Java Programmer

2012-01-05T21:30:00.001-08:00

Implementing RESTful web services using Spring In Java

2012-01-05T21:30:00.000-08:00


Couple of weeks back my collegue Phil M implemented spring rest implementation in our project and i thought of sharing with everyone.
 
We can use Spring APIs and annotations to build RESTful web services seamlessly.
 
Other alternatives to implement RESTful web service is to use JSR 311(JAX-RS) and its implementation Jersey else we may also use Restlet framework.
 
The Jaxb2Marshaller offers a classesToBeBound property, which allows you to set an array of classes to be supported by the marshaller. 
 
With the representational state transfer (REST) style architecture consists of client and server and requests and responses are built around the transfer of representations of resources. Resources are identified by global IDs that typically use a uniform resource identifier (URI). Client applications use HTTP 
methods (such as GET, POST, PUT, or DELETE) to manipulate the resource or collection of resources. 
 
For example, GET http://host/context/dept/12345 gets the particular department details with the ID 12345. The response representation could be XML or it could be a JSP/HTML page. 
 
 
Annotations such as @RequestMapping and @PathVariable, are used to support resource identification and URI mappings.
 
 
Please Note That I used Spring 3.0.4 Release.
 
 
 
Please find one example below
 
 
Server Side
 
 
demo.domain.address.AddressSearch.java
 
@XmlRootElement(name = "addresses")
public class AddressSearch  implements Serializable {
                
                private List<Address> addresses;
                private String errorMessage;
                private boolean validAddress;
 
...implement get set methods
 
 
demo.domain.address.Address.java
 
@XmlRootElement(name = "address")
public class Address implements Serializable {
                
                private String address1;
                private String address2;
                private String city;
                private String county;
                private String postalCode;
ersion="1.0" encoding="UTF-8"?>
<wls:weblogic-web-app xmlns:wls="http://xmlns.oracle.com/weblogic/weblogic-web-app" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee                                            http://java.sun.com/xml/ns/javaee/ejb-jar_3_0.xsd                                            http://xmlns.oracle.com/weblogic/weblogic-web-app                                            http://xmlns.oracle.com/weblogic/weblogic-web-app/1.2/weblogic-web-app.xsd">
<wls:context-root>addressTEST</wls:context-root>
 
<wls:session-descriptorostalCode, @PathVariable String address1) throws Exception 
                {
                                AddressSearch addressSearch = addressService.getAddress(address1, postalCode);
                                return new ModelAndView(XML_VIEW_NAME, "addresses", addressSearch);
                }
 
 .........
}
 
 
AddressServiceImpl.java
 
@Service
public class AddressServiceImpl implements IQASService {
 
public AddressSearch getAddress(String houseNameOrNumber, String postalCode) {
                                @SuppressWarnings("rawtypes")
                                List addresses = new ArrayList();
                                AddressSearch as = new AddressSearch();
                                
                                try {
                                                addresses = ... your logic left to you how u get the data back maybe bring it from database or user another webservice etc...
                                } catch (Exception e) {
                                }
                                
                                return as; // please note we have some internal logic to populate the list into a business object.
                }
.....
}
 
 
web.xml
 
<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
 ramework.org/senera/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:jaxrs="http://cxf.apache.org/jaxrs"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
       http://www.springframework.org/schema/mvc 
       http://www.springframework.org/schema/mup>1</load-on-startup>
  </servlet>    
  <servlet-mapping>
                <servlet-name>qas</servlet-name>
                <url-pattern>/*</url-pattern>
  </servlet-mapping>
 
 
weblogic.xml
 
<?xml version="1.0" encoding="UTF-8"?>
<wls:weblogic-web-app xmlns:wls="http://xmlns.oracle.com/weblogic/weblogic-web-app" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee                                            http://java.sun.com/xml/ns/javaee/ejb-jar_3_0.xsd                                            http://xmlns.oracle.com/weblogic/weblogic-web-app                                            http://xmlns.oracle.com/weblogic/weblogic-web-app/1.2/weblogic-web-app.xsd">
<wls:context-root>addressTEST</wls:context-root>
 
<wls:session-descriptor>
                <wls:persistent-store-type>replicated_if_clustered</wls:persistent-store-type>
</wls:session-descriptor>
 
</wls:weblogic-web-app>
 
 
 
demo-service.xml
 
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
                   xmlns:context="http://www.springframework.org/schema/context"
                   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                xsi:schemaLocation="
                http://www.springframework.org/schema/beans 
                http://www.springframework.org/schema/beans/spring-beans.xsd
                http://www.springframework.org/schema/context 
                http://www.springframework.org/schema/context/spring-context-3.0.xsd">
 
                <bean id="addressService" class="demo.service.impl.AddressServiceImpl" />
                
                <context:component-scan base-package="demo.service" />
</beans>
 
 
demo-servlet.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:jaxrs="http://cxf.apache.org/jaxrs"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
       http://www.springframework.org/schema/mvc 
       http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
       http://www.springframework.org/schema/context 
       http://www.springframework.org/schema/context/spring-context-3.0.xsd">
      
                <!-- Register the DefaultAnnotationHandlerMapping and AnnotationMethodHandlerAdapter -->
                <mvc:annotation-driven />         
 
                <!-- Component scan for controller classes -->                        
                <context:component-scan base-package="demo.controller" />
 
 
   <!-- Defines the marshaller/unmarshaller that uses JAXB 2 to do the object XML mapping (OXM) -->
                <bean id="jaxbMarshaller" class="org.springframework.oxm.jaxb.Jaxb2Marshaller">
                                <property name="classesToBeBound">
                                                <list>
                                                <value>demo.domain.address.AddressSearch</value>
                                                </list>
                                </property>
                </bean> 
                                
<!-- Defines an XML representation view that utilizes the Jaxb2Mashaller 
                                //XML_VIEW_NAME in controller equals address, which is the view name defined in demo-servlet.xml
 -->
                <bean id="addresses" class="org.springframework.web.servlet.view.xml.MarshallingView">
                                <constructor-arg ref="jaxbMarshaller" />
                </bean>  
                
                <bean id="viewResolver" class="org.springframework.web.servlet.view.BeanNameViewResolver" />
 
   
   <!-- 
                                 REST services can produce different representations according to the request.
                                Spring 3 introduces a new view resolver called ContentNegotiatingViewResolver. 
                                It can switch view resolvers according to request content type (the Accept property in the request header) or URI suffix.
   -->       
                <bean class="org.springframework.web.servlet.view.ContentNegotiatingViewResolver">
                                <property name="mediaTypes">
                                    <map>
                                        <entry key="xml" value="application/xml"/>
                                        <entry key="html" value="text/html"/>
                                    </map>
                                </property>
                                <property name="viewResolvers">
                                    <list>
                                      <!--  Defines a view resolver using the bean name that the user specifies
                                                
                                                    The definition shows support for handling two request content types: application/xml and text/html.
                                                    The code also defines two view resolvers: one BeanNameViewResolver to handle application/xml 
                                                    and one UrlBasedViewResolver to handle text/html.
                                                                                
                                                   When we enter http://<host>:<port>/<appcontext>/addressTEST/getAddress/{postalCode}/{address1} in the browser it requests text/html 
                                                   for the employees. Then UrlBasedViewResolver will take effect and Spring will pick /WEB-INF/jsp/addresses.jsp 
                                                   as its view. 
                                                   When you add the request header Accept:application/xml and invoke the request, the BeanNameViewResolver will take effect.
                                                                                
                                                   Per the code in AddressSearchController.java getAddressPcHouseNoName() method, it will use a view named addresses to represent, 
                                                   which is the JAXB 2 marshaller view that was defined.
                                                                                                                                                                
                                                -->
                                        <bean class="org.springframework.web.servlet.view.BeanNameViewResolver"/>
                                        <bean id="viewResolver" class="org.springframework.web.servlet.view.UrlBasedViewResolver">
                                                                                <property name="viewClass" value="org.springframework.web.servlet.view.JstlView"/>
                                                                                <property name="prefix" value="/WEB-INF/jsp/"/>
                                                                                <property name="suffix" value=".jsp"/>
                                                                </bean>
                                    </list>
                                </property>
                </bean>
 
</beans>
 
 
Please note that all the code described above can be packaged into a seperate war file and make it available in the client side
 
 
JUNIT Client Side  :-
 
 
Now below Junit Class will help us to do some Unit Testing of the Controller.
 
TestAddressSearchController.java
 
public class TestAddressSearchController extends TestBaseController {
                
                @Autowired
                private RestTemplate restTemplate;
                
                private static final String BASE_URL = "http://localhost:7001/addressTEST";
                
                @Override
                public void setUp() throws Exception {
                                super.setUp();
                }
 
                @Test
                public void testGetAddressPcHouseNoName() {
                                String url = BASE_URL + "/getAddress/{postalCode}/{address1}";
                                
                                postalCode = "NE28 9TA";
                                address1 = "165";
                                 A//www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee                                            http://java.sun.com/xml/ns/javaee/ejb-jar_3_0.xsd                                            http://xmlns.oracle.com/weblogic/weblogic-web-app                                            http://xmlns.oracle.com/weblogic/weblogic-web-app/1.2/weblogic-web-app.xsd">
<wls:context-root>addressTEST</wls:context-root>
 
<wls:session-descriptor8String, Class, String...)
HEAD     headForHeaders(String, String...)
OPTIONS             optionsForAllow(String, String...)
POST     postForLocation(String, Object, String...)
PUT        put(String, Object, String...)
 
So to recap getForObject() will perform a GET, convert the HTTP response into an object type of your choice, and returns that object.
*/
                                AddressSearch as = restTemplate.getForObject(url,AddressSearch.class,mapParams);
                                
                                assertTrue(as.getAddresses().size() == 1);
                 }             
...            
}
 
 
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations={
                                "classpath:spring/demo-service.xml",                    
                                "classpath:spring/demo-servlet.xml",
                                "classpath:spring/demo-test-rest.xml"})
 
public class TestBaseController {
                
    protected MockHttpServletRequest request;
    protected MockHttpServletResponse response;
    protected MockHttpSession session;
    
    protected final static String GET = "GET";
    protected final static String POST = "POST";
    
    @Before
    public void setUp() throws Exception {
        this.request = new MockHttpServletRequest();
        this.response = new MockHttpServletResponse();
        this.session = new MockHttpSession();
    }
 
    @After
    public void tearDown() throws Exception {
 
    }
}
 
 
demo-test-rest.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:jaxrs="http://cxf.apache.org/jaxrs"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:mvc="http://www.springframework.org/schema/mvc"
       xsi:schemaLocation="
       http://www.springframework.org/schema/beans 
       http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
       http://www.springframework.org/schema/mvc 
       http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd
       http://www.springframework.org/schema/context 
       http://www.springframework.org/schema/context/spring-context-3.0.xsd">
 
                <!-- Rest Template -->
 
  <!--
                
   The RestTemplate is the central Spring class for client-side HTTP access.
   RestTemplate is thread-safe once constructed, and that you can use callbacks to customize its operations.
   
  -->
   
   <bean id="restTemplate" class="org.springframework.web.client.RestTemplate">  
                                <property name="messageConverters" ref="messageConverter" />
    </bean> 
 
    <!--
      HttpMessageConverters Objects passed to and returned from the methods getForObject(), postForLocation(), and put() and are converted to HTTP requests and from HTTP responses by HttpMessageConverters. 
    -->
 
    <bean id="messageConverter" class="org.springframework.http.converter.xml.MarshallingHttpMessageConverter">
                <property name="marshaller" ref="jaxbMarshaller" />
        <property name="unmarshaller" ref="jaxbMarshaller" />
    </bean>
 
  
</beans>
 
 
Hope this example helps.
 
 
 
 
References 
http://blog.springsource.org/2009/03/27/rest-in-spring-3-resttemplate/
http://www.ibm.com/developerworks/web/library/wa-spring3webserv/
http://static.springsource.org/spring-ws/site/reference/html/oxm.html
http://static.springsource.org/spring/docs/3.0.0.M3/spring-framework-reference/html/ch18s02.html
http://en.wikipedia.org/wiki/Representational_State_Transfer

Working With JUnit And Mock Objects

2011-08-08T11:41:00.000-07:00

 

Introduction: 

 

EasyMock works by implementing the proxy pattern. When you create a mock object, it creates a proxy object that takes the place of the real object. The proxy object gets it's definition from the interface you pass when creating the mock. We will define what methods are called and their returns from within our test method itself.

 

When creating a mock object, there are two types, a mock and a strict mock. In either case, our test will tell the mock object what method calls to expect and what to return when they occur. A basic mock will not care about the order of the execution of the methods. A strict mock, on the other hand, is order specific. Your test will fail if the methods are executed out of order on a strict mock. 

 

In this example, we will be using a strict mock.

 

 

     private LoginServiceImpl service;

     private UserDAO mockDao;

 

	  @Override

	     public void setUp() {

	          service = new LoginServiceImpl();

	          mockDao = createStrictMock(UserDAO.class);

	          service.setUserDAO(mockDao);

	     }

 

	   User results = new User();

           String userName = "testUserName";

           String password = "testPassword";

           String passwordHash =  "someunecryptedpass";

           expect(mockDao.loadByUsernameAndPassword(eq(userName), eq(passwordHash))).andReturn(results);

 

           replay(mockDao);

           assertTrue(service.login(userName, password));

           verify(mockDao);

 

 

expect(<<method name>>)

This is a call to the static method EasyMock.expect. It tells your mock object to expect the method loadByUsernameAndPassword to be called.

 

eq(userName), eq(passwordHash)

 

When EasyMock compares the values passed to the method call, it does and == comparison. The eq comparator in this case will compare the contents of the string using it's .equals method. 

 

.andReturn(results);

This tells our mock object what to return after this method is called.

 

We can as well use expectAndReturn() single method call instead of calling expect() and andReturn() method seperatly.

 

The final three lines are the ones that do the testing work. replay(mockDao); tells EasyMock "We're done declaring our expectations. It's now time to run what we told you". 

 

Finally, verify(mockDao); tells EasyMock to validate that all of the expected method calls were executed and in the correct order.

 

 

Example 1:

 

Let's say we have a PageCachingFilter which will add few response headers to remove caching.

 

 public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException

  {

    HttpServletResponse sResponse = (HttpServletResponse)response;

 

    sResponse.addHeader("Cache-Control","no-cache");

    sResponse.addHeader("Pragma","no-cache");

 

    chain.doFilter(request, response);

  }

 

Our TestCase will look something like below

 

 public void testCacheHeaders() 

  {

    // Create mock controllers

    MockControl requestControl = MockControl.createControl(HttpServletRequest.class);

    MockControl responseControl = MockControl.createControl(HttpServletResponse.class);

    MockControl filterChainControl = MockControl.createControl(FilterChain.class);

 

    // Create the mock objects

    HttpServletRequest request = (HttpServletRequest)requestControl.getMock();

    HttpServletResponse response = (HttpServletResponse)responseControl.getMock();

    FilterChain filterChain = (FilterChain)filterChainControl.getMock();

    

    // Record the expectation

    response.addHeader("Cache-Control","no-cache");

    response.addHeader("Pragma","no-cache");

    

    try

    {

      filterChain.doFilter(request, response);

    }

    catch(Exception e)

    {

      fail(e.getMessage());

    }

    

    // Stop recording

    requestControl.replay();

    responseControl.replay();

    filterChainControl.replay();

 

    // Execute the test

    Filter filter = new PageCachingFilter();

    try

    {

      filter.init(null);

      filter.doFilter(request, response, filterChain);

      filter.destroy();

    }

    catch(Exception e)

    {

      fail(e.getMessage());

    }

    

    // Verify the expectations against the test

    requestControl.verify();

    responseControl.verify();

    filterChainControl.verify();

  }

 

 

IMPORTANT NOTE 1: Please note that spring helps a bit further and eases mock object creation of HttpServletRequest,Response and FilterChain objects.

 

Hence ideally in a single step we can create the mock object unlike the 2 steps described above.

 

import org.easymock.MockControl;

import org.springframework.mock.web.MockFilterChain;

import org.springframework.mock.web.MockFilterConfig;

import org.springframework.mock.web.MockHttpServletRequest;

import org.springframework.mock.web.MockHttpServletResponse;

 

 

   public void setUp()

  {

    filter = new UserFilter();

    request = new MockHttpServletRequest();

    response = new MockHttpServletResponse();

    session = new MockHttpSession();

    chain = new MockFilterChain();

    

    Principal principal = new Principal() {

      public String getName()

      {

        return "TheName";

      }};

    request.setUserPrincipal(principal);

  }

 

 

IMPORTANT NOTE 2: We can also set the return value of a mock object using setReturnValue() method.

 

Example:

 

    User user = new User();

    user.setName("TheName");

 

MockControl userServiceControl = MockControl.createControl(IUserService.class);

userServiceControl.setReturnValue(user);

 

 

IMPORTANT NOTE 3:

 

Below code will show us how to create a Mock ServletContext which can accept the file names which we normally mention in web.xml as a parameter to get loaded.

 

   servletContext = new MockServletContext();

   String configFiles = "/WEB-INF/config/framework/config.xml ";

 

   servletContext.addInitParameter("CONFIG_FILE", configFiles);

 

Below code will show us how to create a StaticWebApplicationContext and attach it to the created ServletContext.

 

Servlet Context is known can be created from the above code.

 

 

    StaticWebApplicationContext applicationContext = new StaticWebApplicationContext();

    applicationContext.setServletContext(servletContext);

    applicationContext.refresh();

    applicationContext.start();

    

    servletContext.setAttribute(XmlWebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, applicationContext);

 

 

IMPORTANT NOTE 4:   

 

If we want to test spring 3.0 front-end controllers below is sample code

 

 

import org.junit.Test;

import org.springframework.web.servlet.ModelAndView;

 

import static org.junit.Assert.assertNotNull;

 

public class TestHomeController extends BaseTestController {

    private HomeController controller;

    private final static String URI = "/home.html";

 

    @Test

    public void testHomeController() throws Exception {

        request.setRequestURI(URI);

        this.controller = new HomeController();

        ModelAndView view = controller.home(request,response);

        assertNotNull(view);

    }

}

    

 

@RunWith(SpringJUnit4ClassRunner.class)

@ContextConfiguration(locations={    

    "classpath:spring/demo-servlet.xml"})

 

@TransactionConfiguration(transactionManager = "transactionManager")

 

public class BaseTestController {

    protected MockHttpServletRequest request;

    protected MockHttpServletResponse response;

    protected MockHttpSession session;

 

    @Before

    public void setUp() throws Exception {

        System.out.println("Doing set-up");

        this.request = new MockHttpServletRequest();

        this.response = new MockHttpServletResponse();

    }

 

    @After

    public void tearDown() throws Exception {

        System.out.println("Doing tearDown");

    }

}

 

 

demo-servlet.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:mvc="http://www.springframework.org/schema/mvc" 

	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd

		http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd">property name="maxUploadSize" value="10000000"/> 

  	</bean> 

  

	....

	

  </beans> 

 

 

 

References

 

httstrong> 

    	<!-- Maximum file size in bytes. --> 

    	<property name="maxUploadSize" value="10000000"/> 

  	</bean> 

  

	....

	

  </beans> 

 

 

 

References

 

http://www.michaelminella.com/testing/unit-testing-with-junit-and-easymock.html

http://www.easymock.org/Downloads.html

http://easymock.org/api/easymock/2.4/index.html?org/easymock/MockControl.html

IMPLEMENTING AJAX FUNCTIONALITY USING JQUERY + JSON FRAMEWORK

2011-08-03T11:17:00.000-07:00

In our old project we are using json framework to achieve ajax functionality.

PLEASE DOWNLOAD THE REQUIRED JSON JAR FILE . WE ARE USING "json-rpc-1.0.jar" JAR FILE.

I want to share the code which can be useful for the readers.

Let us say we want to re-populate the select option dropdown when user changes a value in the existing dropdown.

In the html form contains below code:

<select id="demoSelect" name="demoSelect">
<option value="1">One</option>
<option value="2">Two</option>
</select>

JavaScript Code implementing json looks like below

$("select[name^='demoSelect']").bind('change', function(event)
{
//var e = document.getElementById("demoSelect"); //Get the actual element
var id = event.target.id; //Get the id of the LOV that was changed
var e = document.getElementById(id); //Get the actual element
var i = e.selectedIndex;
var t = e.options[i].text; //Get the text
alert("came here...." + t);

var frmdata = {taskStatusTypeName : t} ;
var myurl = 'demoServlet';
alert(myurl);
var options = {
type: 'GET',
url: myurl,
data: frmdata,
cache: false,
dataType: 'json',
error: function(xhr, textStatus,errorThrown){
alert('An error occurred! ' + errorThrown) ;
},
success: function(data,textStatus){
alert("came here..........success");
var elName = '#demoSelect';
var reasonSelect = $(elName).children().remove().end() ;
for (var i=0;i<data.length;i++){
if (i==0){
reasonSelect.append('<option value="' + data[i].key + '" selected="true">' + data[i].value + '</option>') ;
/* var noteName = '#newNote_' + index ;
var noteVal = data[i].value ;
$(noteName).val(noteVal) ;
*/
}
else{
reasonSelect.append('<option value="' + data[i].key + '">' + data[i].value + '</option>') ;
}
}
$(elName).focus(); //Set focus to the new note input
}
} ;
$.ajax(options) ;

});

As correctly observed it tries to call the underlying backend servlet to fetch the data.

Our servlet code goes like this and donot forget to add the entries in web.xml !

import java.io.IOException;
import java.util.Iterator;
import java.util.List;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.log4j.Logger;
import org.json.JSONArray;
import org.json.JSONObject;

public class DemoJsonServiceServlet extends HttpServlet{

private static final String CONTENT_TYPE = "application/json" ;

public DemoJsonServiceServlet() {
}

private static Logger _logger = Logger.getLogger(DemoJsonServiceServlet.class);

public void init(ServletConfig config) throws ServletException
{
super.init(config);
}

public void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException
{
String taskStatusTypeName = request.getParameter("taskStatusTypeName");
response.setContentType(CONTENT_TYPE) ;
response.setHeader("Cache-Control","no-cache") ;
response.getWriter().write(getJson(request,taskStatusTypeName)) ;
}

private String getJson(HttpServletRequest request,String taskStatusTypeName) throws ServletException {

if (_logger.isDebugEnabled()){
_logger.debug("Task status type " + taskStatusTypeName) ;
}

try {
JSONArray jsonKeyValues = new JSONArray() ;
for(int i=0;i<10;i++) {
JSONObject jsonObj = new JSONObject() ;
jsonObj.put("key","key" +i) ;
jsonObj.put("value","value" +i) ;
jsonKeyValues.put(jsonObj) ;
}
return jsonKeyValues.toString() ;
} catch (Exception e) {
_logger.error("Error in Json service" + e.getMessage()) ;
throw new ServletException(e);
}
}

}

Hope this explanation helps.

Handling Forbidden Pages in SpringMVC3.0 using annotations

2011-07-21T08:06:00.000-07:00

@Controller
@RequestMapping(value = "/Login/**")
public class LoginController extends CommonController {
public static final String loginError = "/Login/LoginError";

@RequestMapping(value="/Login.html")
public String login() {
return Globals.login;
}

@RequestMapping(value="/LoginError.html")
public String loginError() {
return loginError;
}

}

Tiles Definition For "/accessDenied"

<definition name="/accessDenied" extends="base">
<put-attribute name="subtitle" value="Login Error" />
<put-attribute name="menu" value="/WEB-INF/tiles/templates/loginMenu.jsp" />
<put-attribute name="body" value="/WEB-INF/jsp/accessDenied/showAccessDenied.jsp" />
</definition>

showAccessDenied.jsp

<p>
Access to the specified resource has been denied.

<br />
Click <a href="<c:url value=''/>"><b><u>here</u></b></a> to try again.

</p>



Hope this explanation helps.

Spring Security3.5 Authorisation Cache Problem

2011-07-06T11:26:00.000-07:00

In Our project We are using spring security 3.5 for authorisation purpose only.

We use j2ee container for authentication and donot rely on spring for authentication and logout purposes.

Today we faced a cache problem with regards to authentication details.

For the first time if user A logs in his authentication details i.e his associated roles(granted authorities) are correctlly populated.

But when we try to logout user A and make user B to login due to some cache problem user A authentication details i.e his associated roles(granted authorities) are getting displayed when user B login in :-(

It means for spring though user B is logged in it still assumes user A is logged in which means the logout functionality went for a toss and we are not properly implemented the logout functionality.

As said earlier we are not replying on spring for built-in logout functionality.

We have resolved the problem by mimcing the spring builtin logout functionality and changing code when required especially "filterProcessesUrl" variable in LogoutFilter class. Initially it will have value something like "j_securitycheck_logout" but we changed to our project specific logout URL.

Just pasting code for the benefit of other developers.

spring security.xml

<?xml version="1.0" encoding="UTF-8"?>



<b:beans xmlns="http://www.springframework.org/schema/security"
xmlns:b="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-3.0.xsd">

<global-method-security pre-post-annotations="enabled">
</global-method-security>

<http auto-config="true" use-expressions="true" access-denied-page="/accessDenied/showAccessDenied.html">
</http>



<b:bean id="filterChainProxy" class="org.springframework.security.web.FilterChainProxy">
<filter-chain-map path-type="ant">
<filter-chain pattern="/**" filters="exceptionTranslationFilter,securityContextPersistenceFilter,j2eePreAuthFilter,fsi,logoutFilter"/>
</filter-chain-map>
</b:bean>

<b:bean id="securityContextPersistenceFilter" class="org.springframework.security.web.context.SecurityContextPersistenceFilter">
<b:property name="forceEagerSessionCreation" value="true"/>
</b:bean>

<b:bean id="logoutFilter" class="demo.LogoutFilterWrapper">
</b:bean>

<authentication-manager alias="authenticationManager">
<authentication-provider ref='preAuthenticatedAuthenticationProvider'/>
</authentication-manager>

<b:bean id="preAuthenticatedAuthenticationProvider" class="org.springframework.security.web.authentication.preauth.PreAuthenticatedAuthenticationProvider">
<b:property name="preAuthenticatedUserDetailsService" ref="preAuthenticatedUserDetailsService"/>
</b:bean>

<b:bean id="preAuthenticatedUserDetailsService"
class="org.springframework.security.web.authentication.preauth.PreAuthenticatedGrantedAuthoritiesUserDetailsService"/>

<b:bean id="j2eePreAuthFilter" class="org.springframework.security.web.authentication.preauth.j2ee.J2eePreAuthenticatedProcessingFilter">
<b:property name="authenticationManager" ref="authenticationManager"/>
<b:property name="authenticationDetailsSource" ref="authenticationDetailsSource"/>
<b:property name="continueFilterChainOnUnsuccessfulAuthentication" value="false"/>
</b:bean>

<b:bean id="authenticationDetailsSource" class="org.springframework.security.web.authentication.preauth.j2ee.J2eeBasedPreAuthenticatedWebAuthenticationDetailsSource">
<b:property name="mappableRolesRetriever" ref="j2eeMappableRolesRetriever"/>
<b:property name="userRoles2GrantedAuthoritiesMapper" ref="j2eeUserRoles2GrantedAuthoritiesMapper"/>
</b:bean>

<b:bean id="j2eeMappableRolesRetriever" class="org.springframework.security.web.authentication.preauth.j2ee.WebXmlMappableAttributesRetriever">

</b:bean>

<b:bean id="webXmlResource" class="org.springframework.web.context.support.ServletContextResource">
<b:constructor-arg ref="servletContext"/>
<b:constructor-arg value="/WEB-INF/web.xml"/>
</b:bean>

<b:bean id="servletContext" class="org.springframework.web.context.support.ServletContextFactoryBean"/>

<b:bean id="j2eeUserRoles2GrantedAuthoritiesMapper" class="org.springframework.security.core.authority.mapping.SimpleAttributes2GrantedAuthoritiesMapper">
<b:property name="attributePrefix" value="dummy"/>
</b:bean>





<b:bean id="httpRequestAccessDecisionManager" class="org.springframework.security.access.vote.AffirmativeBased">
<b:property name="allowIfAllAbstainDecisions" value="false"/>

<b:property name="decisionVoters">
<b:list>
<b:ref bean="roleVoter"/>
<b:ref bean="webExpressionVoter"/>
</b:list>
</b:property>
</b:bean>


<b:bean id="roleVoter" class="org.springframework.security.access.vote.RoleVoter"/>
<b:bean id="webExpressionVoter" class="org.springframework.security.web.access.expression.WebExpressionVoter"/>

<b:bean id="fsi" class="org.springframework.security.web.access.intercept.FilterSecurityInterceptor">
<b:property name="authenticationManager" ref="authenticationManager"/>
<b:property name="accessDecisionManager" ref="httpRequestAccessDecisionManager"/>
<b:property name="securityMetadataSource">
<filter-invocation-definition-source use-expressions="true">


</filter-invocation-definition-source>
</b:property>
</b:bean>



<b:bean id="exceptionTranslationFilter" class="org.springframework.security.web.access.ExceptionTranslationFilter">
<b:property name="authenticationEntryPoint" ref="authenticationEntryPoint"/>
<b:property name="accessDeniedHandler" ref="accessDeniedHandler"/>
</b:bean>

<b:bean id="authenticationEntryPoint" class="org.springframework.security.web.authentication.LoginUrlAuthenticationEntryPoint">
<b:property name="loginFormUrl" value="/login.jsp"/>
</b:bean>

<b:bean id="accessDeniedHandler"
class="org.springframework.security.web.access.AccessDeniedHandlerImpl">
<b:property name="errorPage" value="/accessDenied/showAccessDenied.html"/>
</b:bean>

<b:bean id="securityContextHolderAwareRequestFilter" class="org.springframework.security.web.servletapi.SecurityContextHolderAwareRequestFilter"/>

</b:beans>

LogoutFilterWrapper.java

import java.io.IOException;
import javax.annotation.PostConstruct;
import javax.servlet.Filter;
import javax.servlet.FilterChain;
import javax.servlet.FilterConfig;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.log4j.Logger;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.web.DefaultRedirectStrategy;
import org.springframework.security.web.RedirectStrategy;
import org.springframework.security.web.authentication.logout.LogoutHandler;
import org.springframework.security.web.authentication.logout.LogoutSuccessHandler;
import org.springframework.security.web.authentication.logout.SecurityContextLogoutHandler;

public class LogoutFilterWrapper implements Filter {

public static final Logger LOGGER = Logger.getLogger(LogoutFilterWrapper.class);

private String logoutSuccessfulUrl="/Login/Login";

private String logoutSuccessfulInactivityUrl="/Login/Login";

private LogoutFilter filter;

protected void initialize() {
LOGGER.debug("LogoutFilterWrapper:Entered into initialize method");
final SecurityContextLogoutHandler context = new SecurityContextLogoutHandler();
context.setInvalidateHttpSession( true );
this.filter =new LogoutFilter( new CustomLogoutSuccessHandler(), new LogoutHandler[] { context } );
}

public void setLogoutSuccessfulUrl(String inUrl ) {
this.logoutSuccessfulUrl = inUrl;
}

public void setLogoutSuccessfulUrlInactivity(String inUrl ) {
this.logoutSuccessfulInactivityUrl = inUrl;
}

@Override
public final void init(FilterConfig inFilterConfig ) throws ServletException {
LOGGER.debug("LogoutFilterWrapper:Entered into init method");
initialize();
this.filter.init(inFilterConfig);
}

@Override
public void destroy() {
this.filter.destroy();
}

@Override
public void doFilter(ServletRequest arg0, ServletResponse arg1,
FilterChain arg2) throws IOException, ServletException {
LOGGER.debug("LogoutFilterWrapper:Entered into doFilter method");

if(this.filter==null) {
initialize();
}
this.filter.doFilter( arg0, arg1, arg2 );

}

/**
* Success Handler
*/
private class CustomLogoutSuccessHandler implements LogoutSuccessHandler {

private RedirectStrategy redirectStrategy = new DefaultRedirectStrategy();

@Override
public void onLogoutSuccess(HttpServletRequest request,
HttpServletResponse response, Authentication authentication)
throws IOException, ServletException {

String targetUrl = "";

SecurityContextHolder.getContext().setAuthentication(null);

request.getSession().removeAttribute(Globals.USER);
request.getSession().invalidate();

redirectStrategy.sendRedirect( request, response, targetUrl );

}
}
}

LogoutFilter.java

import java.io.IOException;
import java.util.Arrays;
import java.util.List;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.apache.log4j.Logger;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.web.authentication.logout.LogoutHandler;
import org.springframework.security.web.authentication.logout.LogoutSuccessHandler;
import org.springframework.security.web.authentication.logout.SimpleUrlLogoutSuccessHandler;
import org.springframework.security.web.util.UrlUtils;
import org.springframework.util.Assert;
import org.springframework.util.StringUtils;
import org.springframework.web.filter.GenericFilterBean;

/**
* Logs a principal out.
* <p>
* Polls a series of {@link LogoutHandler}s. The handlers should be specified in the order they are required.
* Generally you will want to call logout handlers <code>TokenBasedRememberMeServices</code> and
* <code>SecurityContextLogoutHandler</code> (in that order).
* <p>
* After logout, a redirect will be performed to the URL determined by either the configured
* <tt>LogoutSuccessHandler</tt> or the <tt>logoutSuccessUrl</tt>, depending on which constructor was used.
*
* @author Ben Alex
*/
public class LogoutFilter extends GenericFilterBean {

public static final Logger LOGGER = Logger.getLogger(LogoutFilter.class);

//~ Instance fields ================================================================================================

private String filterProcessesUrl = "/LogOut.html";
private List<LogoutHandler> handlers;
private LogoutSuccessHandler logoutSuccessHandler;

//~ Constructors ===================================================================================================

/**
* Constructor which takes a <tt>LogoutSuccessHandler</tt> instance to determine the target destination
* after logging out. The list of <tt>LogoutHandler</tt>s are intended to perform the actual logout functionality
* (such as clearing the security context, invalidating the session, etc.).
*/
public LogoutFilter(LogoutSuccessHandler logoutSuccessHandler,LogoutHandler... handlers) {
Assert.notEmpty(handlers, "LogoutHandlers are required");
this .handlers = Arrays.asList(handlers);
Assert.notNull(logoutSuccessHandler,
"logoutSuccessHandler cannot be null");
this .logoutSuccessHandler = logoutSuccessHandler;
}

public LogoutFilter(String logoutSuccessUrl,LogoutHandler... handlers) {
Assert.notEmpty(handlers, "LogoutHandlers are required");
this .handlers = Arrays.asList(handlers);
Assert.isTrue(!StringUtils.hasLength(logoutSuccessUrl)
|| UrlUtils.isValidRedirectUrl(logoutSuccessUrl),
logoutSuccessUrl + " isn't a valid redirect URL");
SimpleUrlLogoutSuccessHandler urlLogoutSuccessHandler = new SimpleUrlLogoutSuccessHandler();
if (StringUtils.hasText(logoutSuccessUrl)) {
urlLogoutSuccessHandler
.setDefaultTargetUrl(logoutSuccessUrl);
}
logoutSuccessHandler = urlLogoutSuccessHandler;
}

//~ Methods ========================================================================================================

public void doFilter(ServletRequest req, ServletResponse res,
FilterChain chain) throws IOException, ServletException {
HttpServletRequest request = (HttpServletRequest) req;
HttpServletResponse response = (HttpServletResponse) res;

LOGGER.debug("LogoutFilter doFilter entered");

if (requiresLogout(request, response)) {

Authentication auth = SecurityContextHolder.getContext()
.getAuthentication();

LOGGER.debug("Logging out user '" + auth + "' and transferring to logout destination");

for (LogoutHandler handler : handlers) {
handler.logout(request, response, auth);
}

logoutSuccessHandler.onLogoutSuccess(request, response,auth);

return;
}

chain.doFilter(request, response);
}

/**
* Allow subclasses to modify when a logout should take place.
*
* @param request the request
* @param response the response
*
* @return <code>true</code> if logout should occur, <code>false</code> otherwise
*/
protected boolean requiresLogout(HttpServletRequest request,
HttpServletResponse response) {
String uri = request.getRequestURI();
return uri.endsWith(request.getContextPath() + filterProcessesUrl);
}

public void setFilterProcessesUrl(String filterProcessesUrl) {
Assert.isTrue(UrlUtils.isValidRedirectUrl(filterProcessesUrl),
filterProcessesUrl + " isn't a valid value for"
+ " 'filterProcessesUrl'");
this .filterProcessesUrl = filterProcessesUrl;
}

protected String getFilterProcessesUrl() {
return filterProcessesUrl;
}
}

For logout we use common spring action calls

our jsp contain the call :

<a href="<c:url value='/LogOut.html'/>">Log Out</a>

@RequestMapping(value="/LogOut.html")
public ModelAndView logOut(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {

SecurityContextHolder.getContext().setAuthentication(null);

request.getSession().removeAttribute(Globals.USER);
request.getSession().invalidate();
return new ModelAndView(Globals.login);
}

Spring Security3.0.x Authorisation Only using J2eeBasedPreAuthenticatedWebAuthenticationDetailsSource

2011-06-23T12:53:00.000-07:00

We have a requirement in which we use weblogic container for authentication and we are planning to use spring security for authorisation only.

We are using weblogic11g app server and spring security 3.5 for achieving the same.

Below code can help to map j2ee user roles to Spring GrantedAuthorities.

I even posted my question in below website to clear off my doubts.

http://forum.springsource.org/showthread.php?110397-How-to-achieve-Spring-Security3.5-for-authorisation-only-and-not-for-authentication

-------------------------------------------------------------------------------------------------------------------------------------------------
Main things required in your web.xml
-------------------------------------------------------------------------------------------------------------------------------------------------

<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="WebApp_ID" version="2.5">

<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>
/WEB-INF/applicationContext-security.xml
/WEB-INF/servlets.xml
/WEB-INF/views.xml

</param-value>
</context-param>

<servlet>
<servlet-name>springSecurityPreAuth</servlet-name>
<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
<init-param>
<param-name>contextConfigLocation</param-name>
<param-value>
/WEB-INF/servlets.xml
/WEB-INF/views.xml
</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>springSecurityPreAuth</servlet-name>
<url-pattern>*.html</url-pattern>
</servlet-mapping>

<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

<filter>
<filter-name>springSecurityFilterChain</filter-name>
<filter-class>org.springframework.web.filter.DelegatingFilterProxy</filter-class>
</filter>

<filter-mapping>
<filter-name>springSecurityFilterChain</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>

<security-constraint>
<web-resource-collection>
<web-resource-name>Secure TestWeb Access</web-resource-name>
<url-pattern>*</url-pattern>
</web-resource-collection>
<auth-constraint>
<role-name>testWebApp</role-name>
</auth-constraint>
<user-data-constraint>
<transport-guarantee>NONE</transport-guarantee>
</user-data-constraint>
</security-constraint>
<login-config>
<auth-method>BASIC</auth-method>
</login-config>
<security-role>
<role-name>testWebApp</role-name>
</security-role>

-------------------------------------------------------------------------------------------------------------------------------------------------
weblogic.xml
-------------------------------------------------------------------------------------------------------------------------------------------------

<?xml version="1.0" encoding="UTF-8"?>
<wls:weblogic-web-app xmlns:wls="http://xmlns.oracle.com/weblogic/weblogic-web-app" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/ejb-jar_3_0.xsd http://xmlns.oracle.com/weblogic/weblogic-web-app http://xmlns.oracle.com/weblogic/weblogic-web-app/1.2/weblogic-web-app.xsd">
<wls:weblogic-version>10.3.4</wls:weblogic-version>
<wls:context-root>commonloginweblogic</wls:context-root>

<wls:security-role-assignment>
<wls:role-name>testWebApp</wls:role-name>
<wls:principal-name>testWebApp</wls:principal-name>
</wls:security-role-assignment>

</wls:weblogic-web-app>

-------------------------------------------------------------------------------------------------------------------------------------------------

Your applicationContext-security.xml code goes like this
-------------------------------------------------------------------------------------------------------------------------------------------------

<?xml version="1.0" encoding="UTF-8"?>



<b:beans xmlns="http://www.springframework.org/schema/security"
xmlns:b="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/security http://www.springframework.org/schema/security/spring-security-3.0.xsd">

<global-method-security pre-post-annotations="enabled">
</global-method-security>

<http auto-config="true" use-expressions="true">
</http>

<b:bean id="filterChainProxy" class="org.springframework.security.web.FilterChainProxy">
<filter-chain-map path-type="ant">
<filter-chain pattern="/**" filters="j2eePreAuthFilter"/>
</filter-chain-map>
</b:bean>

<authentication-manager alias="authenticationManager">
<authentication-provider ref='preAuthenticatedAuthenticationProvider'/>
</authentication-manager>

<b:bean id="preAuthenticatedAuthenticationProvider" class="org.springframework.security.web.authentication.preauth.PreAuthenticatedAuthenticationProvider">
<b:property name="preAuthenticatedUserDetailsService" ref="preAuthenticatedUserDetailsService"/>
</b:bean>

<b:bean id="preAuthenticatedUserDetailsService"
class="org.springframework.security.web.authentication.preauth.PreAuthenticatedGrantedAuthoritiesUserDetailsService"/>

<b:bean id="j2eePreAuthFilter" class="security.SsoUserJ2eePreAuthenticatedProcessingFilter">
<b:property name="authenticationManager" ref="authenticationManager"/>
<b:property name="authenticationDetailsSource" ref="authenticationDetailsSource"/>
<b:property name="continueFilterChainOnUnsuccessfulAuthentication" value="false"/>
</b:bean>

<b:bean id="authenticationDetailsSource" class="org.springframework.security.web.authentication.preauth.j2ee.J2eeBasedPreAuthenticatedWebAuthenticationDetailsSource">
<b:property name="mappableRolesRetriever" ref="j2eeMappableRolesRetriever"/>
<b:property name="userRoles2GrantedAuthoritiesMapper" ref="j2eeUserRoles2GrantedAuthoritiesMapper"/>
</b:bean>

<b:bean id="j2eeMappableRolesRetriever" class="org.springframework.security.web.authentication.preauth.j2ee.WebXmlMappableAttributesRetriever">
</b:bean>

<b:bean id="j2eeUserRoles2GrantedAuthoritiesMapper" class="org.springframework.security.core.authority.mapping.SimpleAttributes2GrantedAuthoritiesMapper">
<b:property name="attributePrefix" value="test"/>
</b:bean>

</b:beans>

-------------------------------------------------------------------------------------------------------------------------------------------------
Our class extending J2eePreAuthenticatedProcessingFilter code goes like this
-------------------------------------------------------------------------------------------------------------------------------------------------

package security;
import java.security.Principal;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

import org.apache.log4j.Logger;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.GrantedAuthority;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.web.authentication.preauth.j2ee.J2eePreAuthenticatedProcessingFilter;

import domain.User;

import view.SessionState;

/**
* This filter implementation hooks into the Spring Security authentication
* mechanism and ensures that the additional SSO secrity details are loaded and
* made available in the session.
*/
public class SsoUserJ2eePreAuthenticatedProcessingFilter extends J2eePreAuthenticatedProcessingFilter {

/**
* Log.
*/
private static final Logger LOG = Logger.getLogger(SsoUserJ2eePreAuthenticatedProcessingFilter.class);

protected void successfulAuthentication(HttpServletRequest request, HttpServletResponse response, Authentication authResult) {
LOG.debug("successfulAuthentication()");

// There may be unauthenticated threads all requesting for the same session
// at the same time so synchronisation must be achieved.
//
// To minimise contention, this implementation synchronises on the session
// object itself.
//
// Since this is only a session startup issue, there is no further
// contention, bottle-neck or performance impact.

HttpServletRequest req = (HttpServletRequest) request; //principal is set ed()) {LOG.debug("user=" + user);}

if(user != null) {
LOG.debug("Got user data");

//final Authentication authenticatcation()" + authentication);

HttpSession session = request.getSession();
synchronized(session) {
SessionState sessionState = (SessionState)session.getAttribute(SessionState.NAME);

if(sessionState == null) {
LOG.debug("Create new application session state for the newly authenticated user");

// Create new session state for this user
sessionState = new SessionState();

request.getSession().setAttribute(SessionState.NAME, sessionState);

// Load the additional user data for this user
Principal principal = request.getUserPrincipal();
String username = principal.getName();
if(LOG.isDebugEnabled()) {LOG.debug("username=" + username);}

User user=new User();
user.setUsername(username);
if(LOG.isDebugEnabled()) {LOG.debug("user=" + user);}

if(user != null) {
LOG.debug("Got user data");

//final Authentication authentication2 = SecurityContextHolder.getContext().getAuthentication();
if (authentication != null) {
for (GrantedAuthority authority : authentication.getAuthorities()) {
LOG.debug("roles retrieved From Spring=" + authority.getAuthority());
}
}
//
sessionState.setUser(user);
}
else {
// TODO throw exception?
LOG.warn("User authenticated but no user data available for '" + username + "'");
}
}
}

super.successfulAuthentication(request, response, authResult);
}
}

-------------------------------------------------------------------------------------------------------------------------------------------------

In our jsp's finally we can authorise the user based on role

<sec:authorize access="hasRole('testWebApp')">
You are a Junior Developer
</sec:authorize>
-------------------------------------------------------------------------------------------------------------------------------------------------

We can also access the role information in our java code.

SecurityContextHolderAwareRequestWrapper requestWrapper=new SecurityContextHolderAwareRequestWrapper(request,"test");
boolean testRole=requestWrapper.isUserInRole("Webapp");
LOGGER.debug("HomeController.handleRequest testRole()." + testRole);

-------------------------------------------------------------------------------------------------------------------------------------------------

If you want to restrict the user acccess to various links in the web application then we need to add the fsi filter as well

<b:bean id="filterChainProxy" class="org.springframework.security.web.FilterChainProxy">
<filter-chain-map path-type="ant">
<filter-chain pattern="/**" filters="j2eePreAuthFilter,fsi"/>
</filter-chain-map>
</b:bean>

<b:bean id="httpRequestAccessDecisionManager" class="org.springframework.security.access.vote.AffirmativeBased">
<b:property name="allowIfAllAbstainDecisions" value="false"/>
<b:property name="decisionVoters">
<b:list>
<b:ref bean="roleVoter"/>
<b:ref bean="webExpressionVoter"/>
</b:list>
</b:property>
</b:bean>

<b:bean id="roleVoter" class="org.springframework.security.access.vote.RoleVoter"/>
<b:bean id="webExpressionVoter" class="org.springframework.security.web.access.expression.WebExpressionVoter"/>

<b:bean id="fsi" class="org.springframework.security.web.access.intercept.FilterSecurityInterceptor">
<b:property name="authenticationManager" ref="authenticationManager"/>
<b:property name="accessDecisionManager" ref="httpRequestAccessDecisionManager"/>
<b:property name="securityMetadataSource">
<filter-invocation-definition-source use-expressions="true">
<intercept-url pattern="/secure/extreme/**" access="hasRole('testRoleExtreme')"/>
<intercept-url pattern="/secure/**" access="hasRole('testRoleSecure')"/>
<intercept-url pattern="/**" access="hasRole('testRole')"/>
</filter-invocation-definition-source>
</b:property>
</b:bean>
-------------------------------------------------------------------------------------------------------------------------------------------------
Now if you want to implement a proper error page whenever any security related interceptors like FilterSecurityInterceptor throws exceptions then we need to add below tags in our security.xml

If you don't add then you may face below stack trace

Error 500--Internal Server Error
org.springframework.security.access.AccessDeniedException: Access is denied
at org.springframework.security.access.vote.AffirmativeBased.decide(AffirmativeBased.java:71)
at org.springframework.security.access.intercept.AbstractSecurityInterceptor.beforeInvocation(AbstractSecurityInterceptor.java:203)

Below code should work and will resolve the issue

<b:bean id="filterChainProxy" class="org.springframework.security.web.FilterChainProxy">
<filter-chain-map path-type="ant">
<filter-chain pattern="/**" filters="exceptionTranslationFilter,j2eePreAuthFilter,fsi"/>
</filter-chain-map>
</b:bean>

<b:bean id="exceptionTranslationFilter" class="org.springframework.security.web.access.ExceptionTranslationFilter">
<b:property name="authenticationEntryPoint" ref="authenticationEntryPoint"/>
<b:property name="accessDeniedHandler" ref="accessDeniedHandler"/>
</b:bean>

<b:bean id="authenticationEntryPoint" class="org.springframework.security.web.authentication.LoginUrlAuthenticationEntryPoint">
<b:property name="loginFormUrl" value="/login.jsp"/>
</b:bean>

<b:bean id="accessDeniedHandler"
class="org.springframework.security.web.access.AccessDeniedHandlerImpl">
<b:property name="errorPage" value="/accessDenied/showAccessDenied.html"/>
</b:bean>

Remember in our jsp page add below code compulsory if you are relying on I.E and also want to redirect to user-defined error page rather than the typical I.E forbidden page.

<% response.setStatus(200); %>

Refer to this article for more details
http://www.coderanch.com/t/365499/Servlets/java/web-xml-error-page-not

For more information please refer to below url

http://static.springsource.org/spring-security/site/docs/3.0.x/reference/core-web-filters.html

-------------------------------------------------------------------------------------------------------------------------------------------------

Hope this article helps.

Working With Custom Oracle Object Types In IBatis

2011-04-28T12:50:00.000-07:00
Today we got a requirement for working With Custom Oracle Object Types In IBatis.

One of our stored procedure takes a "table of object type" as one of the parameter.

Our requirement is to call this stored proceudure from IBatis.

I would like to thank the original author found in below link as i found solution only after following his instructions.

http://mail-archives.apache.org/mod_mbox/ibatis-user-java/200802.mbox/%3C8B243E70CE6BFB438E3CDE03E1E4F698925024@zil01exm62.ds.mot.com%3E

create or replace TYPE JOB_MEASURES_OBJ_TYPE AS OBJECT
(
MEASURE_ID NUMBER,
SERVICE_CODE VARCHAR2(30 BYTE),
QUANTITY NUMBER,
RECEIPT_DATE DATE,
COUNTER NUMBER,
JOB_ID NUMBER,
ERROR_MSG VARCHAR2(4000 BYTE),
CREATION_DATE DATE,
CREATED_BY VARCHAR2(30 BYTE),
LAST_UPDATE_DATE DATE,
LAST_UPDATED_BY VARCHAR2(30 BYTE)
);

create or replace TYPE JOB_MEASURES_TAB_TYPE AS TABLE OF JOB_MEASURES_OBJ_TYPE;

PROCEDURE pr_insert_job_measures_row
(
pi_tbl_rec IN JOB_MEASURES_TAB_TYPE,
po_message_type OUT NUMBER,
po_message OUT VARCHAR2
) IS

v_rec_index PLS_INTEGER;

BEGIN

v_rec_index := pi_tbl_rec.FIRST;

FOR v_rec_index IN pi_tbl_rec.FIRST .. pi_tbl_rec.LAST LOOP

INSERT INTO dummy
JOB_ID,
)
values
(
pi_tbl_rec(v_rec_index).JOB_ID,
);

END LOOP;
END;

IBatis Xml file entries goes like this

<typeAlias type="JobMeasuresTypeHandler" alias="JobMeasuresTypeHandler" />

<parameterMap id="insertJobMeasuresProcParameters" class="java.util.Map">
<parameter property="jobMeasuresTableRec" typeHandler="JobMeasuresTypeHandler" mode="IN" />
<parameter property="messageType" jdbcType="NUMERIC" javaType="int" mode="OUT"/>
<parameter property="message" jdbcType="VARCHAR" javaType="java.lang.String" mode="OUT"/>
</parameterMap>

<procedure id="insertJobMeasuresProc" parameterMap="JobMeasures.insertJobMeasuresProcParameters">
{call pr_insert_job_measures_row(?,?,?)}
</procedure>

Our Java Code goes like this

JobMeasureOracleDomainObject.java

public class JobMeasureOracleDomainObject implements ORAData,ORADataFactory {

private Long measureId;
private String serviceCode;
private Long quantity;
private Date receiptDate;
private Long counter;
private Long jobId;
private String errorMsg;
private Date creationDate;
private String creationBy;
private Date lastUpdatedDate;
private String lastUpdatedBy;

public static final String _SQL_NAME = "JOB_MEASURES_OBJ_TYPE";
public static final int _SQL_TYPECODE = OracleTypes.STRUCT;
protected MutableStruct _struct;

static int[] _sqlType = {OracleTypes.NUMBER, OracleTypes.CHAR,OracleTypes.NUMBER,OracleTypes.DATE,OracleTypes.NUMBER
,OracleTypes.NUMBER,OracleTypes.CHAR,OracleTypes.DATE,OracleTypes.CHAR,OracleTypes.DATE};

static ORADataFactory[] _factory = new ORADataFactory[11];

static final JobMeasureOracleDomainObject _JobMeasureFactory = new JobMeasureOracleDomainObject();
// logger (if you wish)
//private final Log log = LogFactory.getLog(JobMeasureOracleDomainObject.class);

private static final long serialVersionUID = -7710368639791237838L;

/* constructor */
protected JobMeasureOracleDomainObject(boolean init) {
if (init) {
_struct = new MutableStruct(new Object[11], _sqlType,_factory);
}
}

public JobMeasureOracleDomainObject() {
this(true);
}

/* ORAData interface */
public Datum toDatum(Connection conn) throws SQLException {
System.out.println("Calling method toDatum...");
Datum d = _struct.toDatum(conn, _SQL_NAME);
return d;
}

/* ORADataFactory interface */
public ORAData create(Datum d, int sqlType) throws SQLException {
return create(null, d, sqlType);
}

protected ORAData create(JobMeasureOracleDomainObject o, Datum d, int sqlType) throws SQLException {
System.out.println("Calling method create...");
if (d == null) {
return null;
}
if (o == null) {
o = new JobMeasureOracleDomainObject(false);
}
o._struct = new MutableStruct((STRUCT) d, _sqlType, _factory);
return o;
}

public static ORADataFactory getORADataFactory() {
return _JobMeasureFactory;
}

public Long getMeasureId() throws SQLException {
return (Long) _struct.getAttribute(0);
}
public void setMeasureId(Long measureId) throws SQLException{
this.measureId = measureId;
_struct.setAttribute(0, this.measureId);
}
........
}

JobMeasuresTypeHandler.java

public class JobMeasuresTypeHandler implements TypeHandlerCallback
{

private static final String JOB_MEASURES_TAB = "JOB_MEASURES_TAB_TYPE";
private static final String JOB_MEASURES_REC = "JOB_MEASURES_OBJ_TYPE";

static {
JdbcTypeRegistry.setType(JOB_MEASURES_REC, OracleTypes.STRUCT);
JdbcTypeRegistry.setType(JOB_MEASURES_TAB, OracleTypes.ARRAY);
};

@SuppressWarnings("unchecked")
public void setParameter(ParameterSetter setter, Object parameter) throws SQLException {
System.out.println("calling setParameter..." + parameter);
System.out.println("calling setParameter..." + parameter.getClass());
try {
List<JobMeasureOracleDomainObject> jobMeasuresList = (List<JobMeasureOracleDomainObject>) parameter;
// System.out.println("Converting list to array...");
JobMeasureOracleDomainObject[] recArray = new JobMeasureOracleDomainObject[jobMeasuresList.size()];
for (int i = 0; i < recArray.length; i++) {
recArray[i] = jobMeasuresList.get(i);
}
System.out.println("Converted list to array.");
Connection conn = setter.getPreparedStatement().getConnection();
if (conn instanceof DelegatingConnection) {
DelegatingConnection dcon = (DelegatingConnection) conn;
conn = dcon.getInnermostDelegate();
}
conn = (OracleConnection) conn;
//ARRAY array=createJobMeasuresDataARRAY(conn);
ArrayDescriptor arrayDescriptor =ArrayDescriptor.createDescriptor(JOB_MEASURES_TAB, conn);
ARRAY array = new ARRAY(arrayDescriptor, conn, recArray);
setter.setArray(array);
} catch (SQLException sqle) {
System.out.println("SQLException: " + sqle);
throw sqle;
}
}

public Object getResult(ResultGetter getter) throws SQLException {
System.out.println("calling getResult..." + getter.getObject());
return getter.getObject();
}

/**
* Nothing here can help us anyway...
*/
public Object valueOf(String arg0) {
System.out.println("calling valueOf..." + arg0);
if (arg0 == null) {
return new ArrayList<JobMeasureOracleDomainObject>();
}
return arg0;
}
}

ObjectTypeArraysJobMeasuresTest.java

public class ObjectTypeArraysJobMeasuresTest {

public static void main(String[] args) throws SQLException, IOException, ClassNotFoundException {

new ObjectTypeArraysJobMeasuresTest().insertJobMeasuresProcParameters();
}

private void insertJobMeasuresProcParameters() throws IOException, SQLException, ClassNotFoundException {
//Connection conn = null;
Reader reader = Resources.getResourceAsReader("SqlMapConfig.xml");
SqlMapClient sqlMap = SqlMapClientBuilder.buildSqlMapClient(reader);

List<JobMeasureOracleDomainObject> jobMeasuresList=new ArrayList<JobMeasureOracleDomainObject>();
JobMeasureOracleDomainObject jobMeasureOracleDomainObject=new JobMeasureOracleDomainObject();
jobMeasureOracleDomainObject.setJobId(999L);
jobMeasureOracleDomainObject.setMeasureId(999L);
jobMeasuresList.add(jobMeasureOracleDomainObject);

Map parameterMap = new HashMap();
parameterMap.put("jobMeasuresTableRec", jobMeasuresList);
sqlMap.update("JobMeasures.insertJobMeasuresProc", parameterMap);

Integer resultCode = (Integer) parameterMap.get("messageType");
String resultMessage = (String)parameterMap.get("message");
System.out.println(resultCode + ":" + resultMessage);
}
}

Alternative to SimpleFormController And Using Annotations In Spring3.0

2011-04-18T11:50:00.000-07:00
Previously in our project we were using Deprecated SimpleFormController class for handling all our web server side requests.

Thanks to spring latest releases there is no need to implement any Controller classes and to use un-necessary XML tags floating in the project.

1)

JSP:

<form id="uploadForm" enctype="multipart/form-data" action="<c:url value='/importdata/upload.html' />" method="POST" >
<input type="file" id="file" name="file" size="100" maxlength="500" />
<input type="submit" id="uploadButton" value="Upload File" onclick="document.getElementById('uploadButton').disabled='true';try{document.getElementById('uploadForm').submit();}catch(Exception e){document.getElementById('uploadButton').disabled='true'}" />
....
</form>

Our jsp will infact remains the same and for submission it refers to the URL it wants to navigate.

2) Remove the previous declared xml configurations in the corresponding xml file.

3) Now Our Controller class will use the annotations.

@Controller
@RequestMapping(value = "/importdata/**")
public class DoImportController {

private ILookUpService lookupService;
String successView="/importdata/viewImportSpreadsheetSummary";
String formView="/importdata/viewImportSpreadsheet";

@Autowired
public DoImportController(ILookUpService lookupService) {
this.lookupService = lookupService;
}

@RequestMapping(value = "/upload.html", method = RequestMethod.POST)
public ModelAndView onSubmit(HttpServletRequest request,HttpServletResponse response,@RequestParam("utility") String utility,@RequestParam("file") MultipartFile file)
throws ServletException, IOException, Exception {
.......
return new ModelAndView(successView, "importResult", data);
}
...

}

Using our own log4j.xml file with each WAR files - Log4j RepositorySelector

2010-10-02T04:27:00.000-07:00
Today i came across this below article which helps us to have separate log4j files for each web application.

http://community.jboss.org/wiki/Log4jRepositorySelector

I tried to test in tomcat and it is working fine and ideally it should work for weblogic and other application server as well.

Final Part - Implementing Multi Threaded Batching Framework In Java

2010-08-24T01:45:00.000-07:00

Part 2 - Implementing Multi Threaded Batching Framework In Java

2010-08-24T01:44:00.000-07:00

Batch.java

public class Batch
{

private static final String ENFORCE_SINGLE_INSTANCE_PROPERTY_KEY = "enforceSingleInstance";

private static final String ASSUME_JOB_TIMEOUT_MINUTES_KEY = "assumeJobTimeoutMinutes";

private static final String GET_CONTROL_ENTRY_SQL = "SELECT ID, PROCESS_NAME, START_TMS, END_TMS, SYSTIMESTAMP as CURRENT_TIME, TOTAL_ROWS, FAILURE_COUNT FROM BATCHING_FRAMEWORK_CONTROL WHERE PROCESS_NAME = ? FOR UPDATE";

private static final String ADD_CONTROL_ENTRY_SQL = "INSERT INTO BATCHING_FRAMEWORK_CONTROL (ID, PROCESS_NAME, START_TMS, END_TMS, TOTAL_ROWS) VALUES (BFC_ID_SEQ.NEXTVAL, ?, systimestamp, null, 0)";

private static final String END_RUN_CONTROL_ENTRY_SQL = "UPDATE BATCHING_FRAMEWORK_CONTROL SET END_TMS=systimestamp"
+ ", TOTAL_ROWS=?, FAILURE_COUNT=? WHERE PROCESS_NAME=?";

private static final String START_RUN_CONTROL_ENTRY_SQL = "UPDATE BATCHING_FRAMEWORK_CONTROL SET START_TMS=systimestamp, END_TMS=null"
+ ", TOTAL_ROWS=0, FAILURE_COUNT=0 WHERE PROCESS_NAME=?";

/**
* 6 hours timeout assumption
*/
private static final String ASSUME_JOB_TIMEOUT_MINUTES_DEFAULT_VALUE = "360";

private Constructor setConstructor;

private Constructor processorConstructor;

private String processorClassName;

private int threads;

private int metricDelay;

private List<BatchProcessor> processors;

private long startTime;

private long total;

private long count;

private long failureCount;

private boolean BatchSuccessful = true;

private int numProcessors = -1;

private boolean enforceSingleInstance;

private int assumeJobTimeoutMilliseconds;

/**
* The JDBC connection from the datasource
*/
private Connection connection;

public Batch(Class setClass, Class processorClass, int threads, int metricDelay)
{
initialiseConfig(processorClass);

try
{
this.threads = threads;
this.metricDelay = metricDelay;
processors = Collections.synchronizedList(new ArrayList<BatchProcessor>(this.threads));
setConstructor = setClass.getConstructor(new Class[] { Batch.class, });
processorConstructor = processorClass.getConstructor(new Class[] { Batch.class, BatchSet.class, });
processorClassName = processorClass.getName();
}
catch (Exception exception)
{
throw new RuntimeException(errorMsg, exception);
}
}

/**
* Perform property configuration
*/
private void initialiseConfig(Class processorClass)
{

ResourceHandler resourceHandler = ResourceHandler.getInstance();

/**
* Get property to see if we should enforce a single instance of this Batch
* to run at a time
*/
enforceSingleInstance = Boolean.valueOf(resourceHandler.getValue(Batch.class, ENFORCE_SINGLE_INSTANCE_PROPERTY_KEY, "true"));

String subclassEnforceSingleInstance = resourceHandler.getValue(processorClass, ENFORCE_SINGLE_INSTANCE_PROPERTY_KEY, null);
if (subclassEnforceSingleInstance != null)
{
// we've a class specific version of this property, so use this instead
enforceSingleInstance = Boolean.valueOf(subclassEnforceSingleInstance);
}

/**
* Get property for maximum duration a job should run for before we treat it
* as
*/
assumeJobTimeoutMilliseconds = Integer.valueOf(resourceHandler.getValue(Batch.class, ASSUME_JOB_TIMEOUT_MINUTES_KEY,
ASSUME_JOB_TIMEOUT_MINUTES_DEFAULT_VALUE)) * 60000;

String subclassAssumeJobTimeoutMinutes = resourceHandler.getValue(processorClass, ASSUME_JOB_TIMEOUT_MINUTES_KEY, null);
if (subclassAssumeJobTimeoutMinutes != null)
{
// we've a class specific version of this property, so use this instead
assumeJobTimeoutMilliseconds = Integer.valueOf(subclassAssumeJobTimeoutMinutes) * 60000;
}

}

public synchronized void finished(final BatchProcessor processor)
{
if (processors.contains(processor))
{
processors.remove(processor);
}

if (processors.isEmpty())
{
notify();
}
}

public synchronized boolean done()
{

if (processors.isEmpty()) return true;
try
{
wait(metricDelay);
}
catch (InterruptedException interruptedException)
{
}
return false;
}

public void execute()
{

ControlTO controlTO = markJobAsRunning(processorClassName);
if (controlTO.isJobIsRunning())
{
// // Do something meaningful like record this into error table etc
return;
}

RuntimeException firstException = null;

try
{
runProcesses();
}
catch (RuntimeException re)
{
firstException = re;
}
finally
{
try
{
completeControlEntry(processorClassName);
}
catch (RuntimeException re)
{
if (firstException != null)
{
firstException = re;
}
}
}

if (firstException != null)
{
throw firstException;
}

}

/**
* This performs the main functionality of this class, that is, get the set of
* data to work on an then dish out this work to each thread. This code will
* only run if this is the only instance of this process running
*
*/
private void runProcesses()
{
BatchSet set;
set = null;
try
{
try
{
set = (BatchSet) setConstructor.newInstance(new Object[] { this, });
set.open();
total = set.total();
for (int i = 0; i < threads; i++)
{
final BatchProcessor processor = (BatchProcessor) processorConstructor.newInstance(new Object[] { this, set, });
processors.add(processor);
}
}
catch (Exception e)
{
throw new RuntimeException("Error constructing Batch", e);
}

startTime = System.currentTimeMillis();
List<BatchProcessor> toStart = new ArrayList<BatchProcessor>(processors.size());
toStart.addAll(processors);

numProcessors = processors.size();

for (BatchProcessor processor : toStart)
{
(new Thread(processor)).start();
}

do
{
if (done())
{
break;
}

count = set.count();
}
while (true);

// output final stats
}
catch (RuntimeException re)
{
// ensure we catch this and log it as we DO NOT want any missing messages
logger.logMessage(Logger.LEVEL_ERROR, "An exception occurred during the Batch run:", re);

// this Batch hasn't worked correctly...
setBatchSuccessful(false);

// throw to client - this may cause another version of the message
throw re;
}
finally
{
if (set != null)
{
set.close();
}
}

/**
* One or more rows being processed have failed so throw a RuntimeException
* to inform the user of this.
*/
if (!isBatchSuccessful())
{
throw new RuntimeException("An error occurred when processing 1 or more of the rows in the set");
}
}

/**
* Has the Batch ran successfully?
*
* @return
*/
public boolean isBatchSuccessful()
{
return BatchSuccessful;
}

/**
* Set whether the Batch ran successfully or not
*
* @param BatchSuccessful
*/
public synchronized void setBatchSuccessful(boolean BatchSuccessful)
{
this.BatchSuccessful = BatchSuccessful;

if (!BatchSuccessful)
{
// increment the number of failures we've had
failureCount++;
}
}

/**
* Get the number of failures that have occurred.
*
* @return
*/
public long getFailureCount()
{
return failureCount;
}

private ControlTO markJobAsRunning(String processName)
{

Connection conn = null;
RuntimeException firstException = null;

ControlTO controlTO = null;

if (!enforceSingleInstance)
{
return new ControlTO();
}

try
{
conn = getConnection();

controlTO = getControlEntry(conn, processName);

if (controlTO == null)
{
// this is the 1st time we've encountered this, so add new entry in the
// control table
Long maxBatchingId=getMaxBatchingControlID(conn);
controlTO = newControlEntry(conn,maxBatchingId,processName);
}
else
{
// calculate whether we think this job has been assumed to have timed
// out
if (controlTO.getElapsedRuntime() > assumeJobTimeoutMilliseconds)
{
String duration = DurationFormatUtils.formatDurationWords(controlTO.getElapsedRuntime(), true, true);
String overrideDuration = DurationFormatUtils.formatDurationWords(assumeJobTimeoutMilliseconds, true, true);

String warningMesssage = "markJobAsRunning(" + controlTO.getProcessName()
+ ") - job has timed out. Running anyway. Job has been running for " + duration + " and timeout period is " + overrideDuration;
logger.logMessage(Logger.LEVEL_WARN, warningMesssage);

RuntimeException dummyException = new RuntimeException("BatchingFramework Warning: " + controlTO.getProcessName() + " " + warningMesssage);

}
else
{
if (controlTO.getEndTimestamp() == null)
{
if (logger.isDebugEnabled())
{
logger.logMessage(Logger.LEVEL_DEBUG, "markJobAsRunning() returned " + true);
}
conn.rollback();

controlTO.setJobIsRunning(true);

return controlTO;
}
}

updateControlEntry(conn, controlTO, false);
}

conn.commit();
}
catch (Exception e)
{
firstException = new RuntimeException(e);
}
finally
{
try
{
closeConnection();
}
}
return controlTO;
}

/**
* Mark the job as complete
*/
private void completeControlEntry(String processName)
{

if (!enforceSingleInstance)
{
return;
}

Connection conn = null;
RuntimeException firstException = null;

try
{
conn = getConnection();

ControlTO controlTO = getControlEntry(conn, processName);
controlTO.setTotalRows(total);
controlTO.setFailureCount(failureCount);

updateControlEntry(conn, controlTO, true);

conn.commit();
}
catch (Exception e)
{

}
finally
{
try
{
closeConnection();
}
catch (Exception e)
{

}
}
}

/**
* Get the control data for a process
*
* @param conn
* @param processName
* @return
*/
private ControlTO getControlEntry(Connection conn, String processName)
{

Exception firstException = null;

ControlTO controlTO = null;

PreparedStatement ps = null;
ResultSet rs = null;

ps = conn.prepareStatement(GET_CONTROL_ENTRY_SQL);
ps.setString(1, processName);

// TODO continue writing code and execute the prepared statement and store all the values in ControlTO

return controlTO;
}

private Long getMaxBatchingControlID(Connection conn)
{

Exception firstException = null;

Long maxId=null;

PreparedStatement ps = null;
ResultSet rs = null;
ps = conn.prepareStatement(GET_MAX_ID_SQL);

// TODO continue writing code and execute the prepared statement

return maxId;
}

/**
* Add a new control entry for a process
*/
private ControlTO newControlEntry(Connection conn, Long maxBatchingId,String processName)
{

RuntimeException firstException = null;

PreparedStatement ps = null;

ps = conn.prepareStatement(ADD_CONTROL_ENTRY_SQL);

//TODO continue writing code and execute the prepared statement

// now read it back
ControlTO controlTO = getControlEntry(conn, processName);

return controlTO;
}

/**
* Update new control entry for a process
*/
private ControlTO updateControlEntry(Connection conn, ControlTO controlTO, boolean endJob)
{
RuntimeException firstException = null;

PreparedStatement ps = null;
try
{
if (endJob)
{
// we're ending job, so mark end_tms with timestamp and add a few
// metrics

Calendar cal = Calendar.getInstance();
java.sql.Date jsqlD = new java.sql.Date( cal.getTime().getTime() );

ps = conn.prepareStatement(END_RUN_CONTROL_ENTRY_SQL);
ps.setDate(1,jsqlD);
ps.setLong(2, controlTO.getTotalRows());
ps.setLong(3, controlTO.getFailureCount());
ps.setString(4, controlTO.getProcessName());
}
else
{

Calendar cal = Calendar.getInstance();
java.sql.Date jsqlD = new java.sql.Date( cal.getTime().getTime() );

// we're starting a job, so set new start time and mark end time as null
// to indicate it's running + reset metrics
ps = conn.prepareStatement(START_RUN_CONTROL_ENTRY_SQL);
ps.setDate(1,jsqlD);
ps.setString(2, controlTO.getProcessName());
}

ps.execute();
}
catch (SQLException e)
{
}
finally
{
try
{
ps.close();
}
catch (SQLException e)
{
}
}

return controlTO;
}

/**
* Get a database connection from the datasource
*/
private Connection getConnection()
{
// Write code to return java.sql.Connection
return connection;
}

/**
* Return the connection to the datasource
*/
private void closeConnection()
{
// Write code to close Connection
}

private static class ControlTO
{
private Long id;

private String processName;

private Date startTimestamp;

private Date endTimestamp;

private Date currentTimestamp;

private Long totalRows;

private Long failureCount;

private boolean jobIsRunning;

// TODO Add get set methods for all fields

public long getElapsedRuntime()
{
if (getEndTimestamp() != null)
{
// this is a job which has finished
return getEndTimestamp().getTime() - getStartTimestamp().getTime();
}

// this is a job which is still running
return getCurrentTimestamp().getTime() - getStartTimestamp().getTime();
}
}
}

.. TO Be Continued In next article

Part 1 - Implementing Multi Threaded Batching Framework In Java

2010-08-24T01:42:00.000-07:00
In our project we have currently a requirement to migrate(upgrade) data In Some Olden Version Of Release To Latest Version.

In olden version our schema and design of database tables are quite different when compared to current release.

So as various releases have progressed our java code has also been changed quite drastically.

Now recently we had one requirement to write a Java API which when given a application number will convert the data for the application number from older version to latest version schema tables.

As there are 1000's of applications which need to be converted hence we are told to write a multi-threaded batching framework which will run the conversion at once.

Now let us look into how we implemented in our project.

Firstly thanks to Our Developer Roy Harrington who has implemented this framework.

Batching Framework contains 4 primary classes

a) Batch.java
b) BatchProcess abstract class
c) BatchProcessor abstract class
d) BatchSet abstract class

Code and the description for each method is given as below.

BatchSet.java

public abstract class BatchSet
{
private Batch batch;

private boolean finished;

private long count;

public BatchSet(Batch batch)
{
this.batch = batch;
finished = false;
}

public abstract void open();

public abstract void close();

public abstract long total();

protected abstract Object nextRow();

/**
* Returns the next object from the BatchSet
*
* @return
*/
public synchronized Object next()
{
try
{
if (finished) return null;
Object row = nextRow();
if (null == row)
finished = true;
else
count++;
return row;
}
catch (RuntimeException re)
{
// things are screwed if this has happened, so mark as finished
batch.setBatchSuccessful(false);
finished = true;

return null; // indicate nothing more
}
}

/**
* Returns the total number of rows processed so far
*
* @return
*/
public synchronized long count()
{
return count;
}

}

BatchProcessor.java

public abstract class BatchProcessor implements Runnable
{
private Batch batch;

private BatchSet set;

public BatchProcessor(Batch batch, BatchSet set)
{
this.batch = batch;
this.set = set;
}

public void run()
{
Object next = null;

try
{
try
{
begin();
}
catch (Exception e)
{
// mark batch as having an error
batch.setBatchSuccessful(false);

recordError(e);

return;
}

while (null != (next = set.next()))
{
try
{
execute(next);
continue;
}
catch (Throwable t)
{
// mark batch as having an error
batch.setBatchSuccessful(false);

recordError(t);
}
}

try
{
end();
}
catch (Exception e)
{
// mark batch as having an error
batch.setBatchSuccessful(false);
return;
}
}
finally
{
batch.finished(this);
}

}

public abstract void begin() throws Exception;

public abstract void execute(Object obj) throws Exception;

public abstract void end() throws Exception;

}

BatchProcess.java

public abstract class BatchProcess
{
private static final String METRIC_DELAY_KEY = "metricDelay";

private static final String METRIC_DELAY_DEFAULT = "5000";

private static final String THREADS_KEY = "threads";;

private static final String THREADS_DEFAULT = "5";

/**
* Must implement this to do the work
*
*/
protected abstract void goProcess();

/**
* Get the metric delay for the class
*
*/
protected final int getMetricDelay()
{
try
{
ResourceHandler resourceHandler = ResourceHandler.getInstance();

return Integer.valueOf(resourceHandler.getValue(getClass(), METRIC_DELAY_KEY, METRIC_DELAY_DEFAULT).trim()).intValue();
}
catch (NumberFormatException e)
{
return 5000;
}
}

/**
* Get the maximum number of threads for this class
*
*/
protected final int getMaxThreads()
{
try
{
ResourceHandler resourceHandler = ResourceHandler.getInstance();
return Integer.valueOf(resourceHandler.getValue(getClass(), THREADS_KEY, THREADS_DEFAULT).trim()).intValue();
}
catch (NumberFormatException e)
{
return 5;
}
}

/**
* Check for the process running, write an entry to say we are running, call
* goProcess() on subclass, clear down process table
*/
public final void go()
{
String processName = getClass().getName();

try
{
// Execute actual Process
goProcess();
}
catch (RuntimeException re)
{
System.exit(1);
}
}
}

.. TO Be Continued In next article

How to allow users to save a local copy of the current form

2010-08-20T05:15:00.001-07:00
In our project we have a requirement that a user need not complete filling of the pretty large form at once but rather can save a local copy and can upload it later and continue working on that form.

So when user hits 'Save Draft Form' in our page we do below things in our Beehieve Controller

//Set the save form attribute to hide the buttons that are not allowed on saved forms, and show the "upload" button

HttpServletRequest req = this.getRequest();
req.setAttribute("SAVE","TRUE");
getResponse().setHeader("Content-Disposition","attachment;filename=OneDraft.htm");

In Our Jsp We Have This Condition To Allow "Upload" Button To Display Only For Locally Saved Html Files

<% boolean localFile;

String save = (String) request.getAttribute("SAVE");
if (save == null || !save.equalsIgnoreCase("TRUE")) {
localFile = false;
} else {
localFile = true;
}
%>

<% if(!localFile) {%>
<netui:button action="saveForm" value="Save Draft Copy" type="submit" alt="Save draft copy" />
<% } else {%>
<netui:button type="submit" value="Upload Form" action="UploadForm" />
<%}
%>

So as we can see javascript code will get executed when user tries to hit "Save draft copy" button and as "SAVE" attribute is already stored in request scope in our Beehieve Controller so "upload" button will get executed.

And once the user hits "upload" button "UploadForm" action gets called in our Beehieve Controller and we load the jsp with the existing form which has few details saved previously.

Hope this explanation helps.

A regular expression to check for prime numbers

2010-07-30T07:54:00.001-07:00
Today i came across this article regarding regular expression to check for prime numbers.

It is really wonderful and i thank Avinash for putting in his blog.

Below code is used in java to achieve the same.

import java.util.regex.Pattern;

public class ArtlTest {

public static void main(String[] args) {

int c =7;

String s = "";

while (c > 0) {
c--;
s+="1";
}

System.out.println(!Pattern.matches("^1?|^(11+?)\\1+", s));
}
}

Few Notes:

if we keenly see what exactly this expression
(11+?)\\1+)
is doing

It matches with "1″ followed by one or more ones minimally. This means that it matches with "11″ initially.

The string obtained initially is bound to the variable
\\1
.

\1+ then matches with whatever has been matched above ("11″ initially) repeated one or more times.

Let’s try to apply it to 9.

"1″ * 9 = "111111111″. (11+?) matches "11″ initially. \\1+ cannot match because there are 7 remaining ones. Backtracking occurs. (11+?) now matches "111″. And here \\1+ matches the remaining 6 remaining ones! Hence, 9 is not prime.

Cool isn't it?

Source: http://www.noulakaz.net/weblog/2007/03/18/a-regular-expression-to-check-for-prime-numbers/

Part 1 - Java Generics FAQ By Angelika Langer

2010-07-16T02:13:00.000-07:00
Couple of months back i started practicing Java Generics FAQ By Angelika Langer.

Great book written by Angelika Langer.

I had already read this book in the past and even spotted 4 bugs from the book.

http://prasanthaboutjava.blogspot.com/2008/03/4-things-i-donot-understand-in.html

I wanted to share few important quotations found from the book from page 1 - 100.

1) Java Generics are a language feature that allows for definition and use of generic types and methods.

2) The compiler translates generic and parameterized types by a technique called type erasure.

3) It is illegal to define generic type that are directly or indirectly derived from class Throwable. Consequently, no parameterized types appear anywhere in exception handling.

4) An instantiation of a generic type where all type arguments are concrete types rather than wildcards is called concrete parameterized type. Examples of concrete parameterized types are List, Map.

5) Parameterized types are not never covariant so

List<Object>

is not a supertype of

List<String>
.

6) Instantiations of different generic types for the same type argument can be compatible.

Example:

void printAll(Collection<Object> c) {
for (Object o : c)
System.out.println(o);
}

List<Object> list = new ArrayList<Object>();
printAll(list); // ok

7) Concrete parameterized types cannot be used in below situations

a) for creation of arrays
b) in exception handling
c) in a class literal
d) in an instanceof expression

Because generic type information will be erased at runtime.

8) Because parameterized type has no exact runtime type representation there is no class literal for concrete parameterized types.

9) A wildcard parameterized type cannot be not a supertype as it is of no use.

10) A place holder for a type argument is called a type parameter.

Example of a parameterized type:

interface Comparable<E> {
int compareTo(E other);
}

The identifier E is a type parameter. Each type parameter is replaced by a type argument when an instantiation of the generic type, such as

Comparable<Object>

or

Comparable<? extends String>

...

11) A type parameter with one or more bounds is called a bounded type parameter. The bounds restrict the set of types that can be used as type arguments and give access to the methods defined by the bounds.

Ex:

TreeMap<Key extends Comparable<Key>,Data>

Specification of a bound has two effects:

a) It gives access to the methods that the bound specifies. In the example, the bound

Comparable<Key>
gives access to the compareTo method that we want to invoke in the implementation of our TreeMap class.

b) Only types "within bounds" can be used for instantiation of the generic type.

12) Primitive types and array types are not permitted as type parameter bounds.

class X0 <T extends int> { ... } // error
class X1 <T extends Object[]> { ... } // error

13) Enum types, such as Thread.State are also permitted as type parameter bound. Thread.State is an example of a nested type used as type parameter bound. Non-static inner types are also permitted.

14) Parameterized types are permitted as type parameter bound, including concrete parameterized types such as List, bounded wildcard parameterized types such as List and Comparablesuper Long>, and unbounded wildcard parameterized types such as Map.Entry. A bound that is a wildcard
parameterized type allows as type argument all types that belong to the type family that the wildcard denotes. The wildcard parameterized type bound gives only restricted access to fields and methods; the restrictions depend on the kind of wildcard.

15) A type parameter can be used as the bound of another type parameter.

Example (of a type parameter used as a type parameter bound):

class Triple<T> {
private T fst, snd, trd;
public <U extends T, V extends T, W extends T> Triple(U arg1, V arg2, W
arg3) {
fst = arg1;
snd = arg2;
trd = arg3;
}
}

16) At most one instantiation of the same generic type can appear in the list of bounds of a type parameter.

Example (of illegal use of two instantiations of the same generic type as bounds of a type parameter):

class ObjectStore<T extends Comparable<T> & Comparable<String>> { // error
private Set<T> theObjects = new TreeSet<T>();
...
public boolean equals(ObjectStore<String> other) {
if (theObjects.size() != other.size()) return false;
Iterator<T> iterThis = theObjects.iterator();
Iterator<String> iterOther = other.theObjects.iterator();
while (iterThis.hasNext() && iterOther.hasNext()) {
T t = iterThis.next();
String string = iterOther.next();
if (t.compareTo(string) != 0) return false;
}
return true;
}
}

17) A bound that is a class type gives access to all its public members except any constructors.

18) The declaration "

Enum<E extends Enum<E>>

" can be decyphered as: Enum is a generic type that can only
be instantiated for its subtypes, and those subtypes will inherit some useful methods, some of which take subtype specific arguments (or otherwise depend on the subtype).

19) We cannot create an object whose type is a type parameter because the compiler does not know how to create objects of an unknown type.

20) Type parameters can appear in throws clauses, but not in catch clauses.

21) Because a type parameter does not have a runtime type representation of its own there is no class literal for a type parameter.

22) The scope of a class's type parameter is the entire definition of the class, except any static members or static initializers of the class. This means that the type parameters cannot be used in the declaration of static fields or methods or in static nested types or static initializers.

Ajax with Direct Web Remoting (DWR)

2010-06-16T07:05:00.000-07:00
I request readers to refer to my wife Sneha's article regarding DWR and its usages with examples.

http://snehaprashant.blogspot.com/2010/06/ajax-with-direct-web-remoting-dwr.html

Handling Concurrent Modification Exceptions in Java Collections

2010-06-11T08:34:00.000-07:00
Today we have faced below problem when trying to remove a object from a list

Exception in thread "main" java.util.ConcurrentModificationException
at java.util.AbstractList$Itr.checkForComodification(AbstractList.java:449)
at java.util.AbstractList$Itr.next(AbstractList.java:420)
at ConcurrentModificationException.removeObjectTwo(ConcurrentModificationException.java:28)
at ConcurrentModificationException.main(ConcurrentModificationException.java:20)

Below is the code

public class ConcurrentModificationException
{

public static void main(String[] args)
{

A a=new A("sneha","prasanth");
A a1=new A("pradeep","hima");
A a2=new A("praveen","subz");

List<A> list=new ArrayList<A>();
list.add(a);list.add(a1);list.add(a2);

B b=new B();
b.setAList(list);

removeObjectTwo(b,a1);

System.out.println(b.getAList());

}

private static void removeObjectTwo(B b,A aToBeRemoved){

for(A a : b.getAList()){
b.removeA(a);
}
}
}

class B {

private List<A> aList=new ArrayList<A>();

public List<A> getAList()
{
return aList;
}

public void setAList(List<A> list)
{
aList = list;
}

public void removeA(A a) {
aList.remove(a);
a.delete();
}
}

class A {

private String firstName;
private String lastName;
private String isDeleted="N";

A(String firstName,String lastName) {
this.firstName=firstName;
this.lastName=lastName;
}

public String getIsDeleted()
{
return isDeleted;
}
public void setIsDeleted(String isDeleted)
{
this.isDeleted = isDeleted;
}
public String getFirstName()
{
return firstName;
}
public void setFirstName(String firstName)
{
this.firstName = firstName;
}
public String getLastName()
{
return lastName;
}
public void setLastName(String lastName)
{
this.lastName = lastName;
}

public void delete() {
this.isDeleted="Y";
}

public String toString() {
return firstName + ":" + lastName;
}

}

Once you have changed the below method it works perfectly

private static void removeObjectTwo(B b,A aToBeRemoved){

List<A> dupA=new ArrayList<A>();

for(A a : b.getAList()){
if(aToBeRemoved.equals(a))
dupA.add(a);
}

for (A a : dupA)
{
b.removeA(a);
}

}
}

Lesson: Never try to do both read/write on the same collection object and better try to take 2 seperate lists and do the way it was done as shown in the above code.

SCJP Sun Certified Programmer By Kathy Sierra and Bert Bates - Final Part

2010-05-11T07:47:00.000-07:00
Couple of months back i started practicing SCJP Sun Certified Programmer for Java 5 Study Guide By Kathy Sierra and Bert Bates.

Great book written by Kathy Sierra and Bert Bates.

I wanted to share few important quotations found from the last chapter.

1) use -d option to change the destination of a class file when it's first generated by the javac command.

2) System properties consist of name=value pairs that must be appended directly behind the -D, for example, Java -Dmyproperty=myvalue.

3) Command-line arguments are always treated as Strings.

4) Default classpaths can be defined by using OS environment variables.

5) In Unix, colons (:) are used to separate the paths within a classpath. In Windows, semicolons (;) are used.

6) In a classpath, to specify the current directory as a search location, use a dot (.)

7) When you include a JAR file in a classpath, you must include not only the directory in which the JAR file is located, but the name of the JAR file too.

8) You can use static imports to create shortcuts for static members (static variables, constants, and methods) of any class.

SCJP Sun Certified Programmer By Kathy Sierra and Bert Bates - Part9

2010-05-10T06:20:00.000-07:00
Couple of months back i started practicing SCJP Sun Certified Programmer for Java 5 Study Guide By Kathy Sierra and Bert Bates.

Great book written by Kathy Sierra and Bert Bates.

I wanted to share few important quotations found from the nineth chapter.

1) Besides the no-arg constructor and the constructor that takes a Runnable (the target, i.e., the instance with the job to do), there are other overloaded constructors in class Thread.

The constructors we care about are

Thread()

Thread(Runnable target)

Thread(Runnable target, String name)

Thread(String name)

2) The isAlive() method is the best way to determine if a thread has been started but has not yet completed its run() method.

3) The order in which runnable threads are chosen to run is not guaranteed.

4) A thread can be only in one of five states

a) New :- This is the state the thread is in after the Thread instance has been created, but the start() method has not been invoked on the thread.

b) Runnable :- This is the state a thread is in when it's eligible to run, but the scheduler has not selected it to be the running thread. A thread first enters the runnable state when the start() method is invoked, but a thread can also return to the runnable state after either running or coming back from a blocked, waiting, or sleeping state. When the thread is in the runnable state, it is considered alive.

c) Running :- This is the state a thread is in when the thread scheduler selects it (from the runnable pool) to be the currently executing process.

d) Waiting/blocked/sleeping :- The thread is still alive, but is currently not eligible to run. In other words, it is not runnable, but it might return to a runnable state later if a particular event occurs.

e) Dead :- A thread is considered dead when its run() method completes.

5) Threads always run with some priority, usually represented as a number between 1 and 10 (although in some cases the range is less than 10). The scheduler in most JVMs uses preemptive, priority-based scheduling (which implies some sort of time slicing).

6) Although the default priority is 5, the Thread class has the three following constants (static final variables) that define the range of thread priorities:

Thread.MIN_PRIORITY (1)
Thread.NORM_PRIORITY (5)
Thread.MAX_PRIORITY (10)

7) The non-static join() method of class Thread lets one thread "join onto the end" of another thread. If you have a thread B that can't do its work until another thread A has completed its work, then you want thread B to "join" thread A. This means that thread B will not become runnable until A has finished (and entered the dead state).

Thread t = new Thread();
t.start();
t.join();

8) There are three ways a running thread could leave the running state:

a) A call to sleep() Guaranteed to cause the current thread to stop executing for at least the specified sleep duration (although it might be interrupted before its specified time).

b) A call to yield() Not guaranteed to do much of anything, although typically it will cause the currently running thread to move back to runnable so that a thread of the same priority can have a chance.

c) A call to join() Guaranteed to cause the current thread to stop executing until the thread it joins with (in other words, the thread it calls join() on) completes, or if the thread it's trying to join with is not alive, however, the current thread won't need to back out.

Besides those three, we also have the following scenarios in which a thread might leave the running state:

The thread's run() method completes.

A call to wait() on an object

A thread can't acquire the lock on the object whose method code it's attempting to run.

The thread scheduler can decide to move the current thread from running to runnable in order to give another thread a chance to run.

9) We can't guarantee that a single thread will stay running throughout the entire atomic operation.

10) Following are the key points about locking and synchronization:

a) Only methods (or blocks) can be synchronized, not variables or classes.

b) Each object has just one lock.

c) Not all methods in a class need to be synchronized. A class can have both synchronized and non-synchronized methods.

d) If two threads are about to execute a synchronized method in a class, and both threads are using the same instance of the class to invoke the method, only one thread at a time will be able to execute the method. The other thread will need to wait until the first one finishes its method call. In other words, once a thread acquires the lock on an object, no other thread can enter any of the synchronized methods in that class (for that object).

e) If a class has both synchronized and non-synchronized methods, multiple threads can still access the class's non-synchronized methods!

f) If a thread goes to sleep, it holds any locks it has—it doesn't release them.

g) Thread can acquire more than one lock. For example, a thread can enter a synchronized method, thus acquiring a lock, and then immediately invoke a synchronized method on a different object, thus acquiring that lock as well. As the stack unwinds, locks are released again. Also, if a thread acquires a lock and then attempts to call a synchronized method on that same object, no problem. The JVM knows that this thread already has the lock for this object, so the thread is free to call other synchronized methods on the same object, using the lock the thread already has.

h) You can synchronize a block of code rather than a method.

11) Static methods can be synchronized.There is only one copy of the static data we're trying to protect, so we only need one lock per class to synchronize static methods—a lock for the whole class. There is such a lock; every class loaded in Java has a corresponding instance of java.lang.Class representing that class. It's that java.lang.Class instance whose lock is used to protect the static methods of the class (if they're synchronized).

12) wait(), notify(), and notifyAll() must be called from within a synchronized context! A thread can't invoke a wait or notify method on an object unless it owns that object's lock.

13) Note that if the thread calling wait() does not own the lock, it will throw an IllegalMonitorStateException.

14) wait() and notify() or notifyAll(), we should almost always also have a while loop around the wait() that checks a condition and forces continued waiting until the condition is met.

wait() and notify() or notifyAll() are defined on Object class and start(),yield(),sleep() and join() are declared in Thread class.

run() method is declared in Runnable class.

15) The sleep() method is a static method that sleeps the currently executing thread's state. One thread cannot tell another thread to sleep.

SCJP Sun Certified Programmer By Kathy Sierra and Bert Bates - Part8

2010-05-04T07:13:00.000-07:00
Couple of months back i started practicing SCJP Sun Certified Programmer for Java 5 Study Guide By Kathy Sierra and Bert Bates.

Great book written by Kathy Sierra and Bert Bates.

I wanted to share few important quotations found from the eighth chapter.

1) Event handlers are one of the main reasons inner classes were added to the language in the first place.

2) One of the key benefits of an inner class is the "special relationship" an inner class instance shares with an instance of the outer class. That "special relationship" gives code in the inner class access to members of the enclosing (outer) class, as if the inner class were part of the outer class.

3) If we want to Refer the Inner or Outer Instance from within the Inner Class below is the process.

The keyword this can be used only from within instance code which can refer to the inner class.

But what if the inner class code wants an explicit reference to the outer class instance that the inner instance is tied to?

Although normally the inner class code doesn't need a reference to the outer class, since it already has an implicit one it's using to access the members of the outer class, it would need a reference to the outer class if it needed to pass that reference to some other code as follows:

class MyInner {
public void seeOuter() {
System.out.println("Outer x is " + x);
System.out.println("Inner class ref is " + this);
System.out.println("Outer class ref is " + MyOuter.this);
}
}

4) A regular inner class is a member of the outer class just as instance variables and methods are, so the following modifiers can be applied to an inner class:

final

abstract

public

private

protected

static—but static turns it into a static nested class not an inner class.

strictfp

5) Remember that a local class declared in a static method has access to only static members of the enclosing class, since there is no associated instance of the enclosing class. If you're in a static method there is no this, so an inner class in a static method is subject to the same restrictions as the static method. In other words, no access to instance variables.

6) A method-local inner class can be instantiated only within the method where the inner class is defined. In other words, no other code running in any other method—inside or outside the outer class—can ever instantiate the method-local inner class.

However, the inner class object cannot use the local variables of the method the inner class is in unless it is final.

Reason is The local variables of the method live on the stack, and exist only for the lifetime of the method. You already know that the scope of a local variable is limited to the method the variable is declared in. When the method ends, the stack frame is blown away and the variable is history. But even after the method completes, the inner class object created within it might still be alive on the heap if, for example, a reference to it was passed into some other code and then stored in an instance variable. Because the local variables aren't guaranteed to be alive as long as the method-local inner class object, the inner class object can't use them.

7) While an inner class (regardless of the flavor) enjoys that special relationship with the outer class (or rather the instances of the two classes share a relationship), a static nested class does not. It is simply a non-inner (also called "top-level") class scoped within another. So with static classes it's really more about name-space resolution than about an implicit relationship between the two classes.

8) Just as a static method does not have access to the instance variables and non-static methods of the class, a static nested class does not have access to the instance variables and non-static methods of the outer class.

9) Any anonymous interface implementers can implement only one interface.

10) The only modifiers we can apply to a method-local inner class are abstract and final. (Never both at the same time, though.)

11) An anonymous inner class can extend one subclass or implement one interface, Unlike non-anonymous classes (inner or otherwise), an anonymous inner class cannot do both. In other words, it cannot both extend a class and implement an interface, nor can it implement more than one interface.

SCJP Sun Certified Programmer By Kathy Sierra and Bert Bates - Part7

2010-04-29T08:19:00.001-07:00
Couple of months back i started practicing SCJP Sun Certified Programmer for Java 5 Study Guide By Kathy Sierra and Bert Bates.

Great book written by Kathy Sierra and Bert Bates.

I wanted to share few important quotations found from the seventh chapter.

1) The equals() Contract

Pulled straight from the Java docs, the equals() contract says

It is reflexive. For any reference value x, x.equals(x) should return true.

It is symmetric. For any reference values x and y, x.equals(y) should return true if and only if y.equals(x) returns true.

It is transitive. For any reference values x, y, and z, if x.equals(y) returns true and y.equals(z) returns true, then x.equals(z) must return true.

It is consistent. For any reference values x and y, multiple invocations of x.equals(y) consistently return true or consistently return false, provided no information used in equals comparisons on the object is modified.

For any non-null reference value x, x.equals(null) should return false.

2) A hashCode() that returns the same value for all instances whether they're equal or not is still a legal—even appropriate—hashCode() method! For example,

public int hashCode() { return 1492; }

This hashCode() method is horribly inefficient, remember, because it makes all objects land in the same bucket, but even so, the object can still be found as the collection cranks through the one and only bucket—using equals()—trying desperately to finally, painstakingly, locate the correct object. In other words, the hashcode was really no help at all in speeding up the search, even though improving search speed is hashcode's intended purpose!

3) The hashCode() Contract

a) Whenever it is invoked on the same object more than once during an execution of a Java application, the hashcode() method must consistently return the same integer, provided no information used in equals() comparisons on the object is modified. This integer need not remain consistent from one execution of an application to another execution of the same application.

b) If two objects are equal according to the equals(object) method, then calling the hashCode() method on each of the two objects must produce the same integer result.

c) It is NOT required that if two objects are unequal according to the equals(Java.lang.Object) method, then calling the hashCode() method on each of the two objects must produce distinct integer results. However, the programmer should be aware that producing distinct integer results for unequal objects may improve the performance of hashtables.

4) Transient variables can really mess with your equals() and hashcode() implementations. Keep variables non-transient or, if they must be marked transient, don't use then to determine hashcodes or equality.

5) A Vector is basically the same as an ArrayList, but Vector methods are synchronized for thread safety.

6) A Set does not allow for duplicates.A HashSet is an unsorted, unordered Set.

7) Hashtable is the synchronized counterpart to HashMap.Another difference, though, is that while HashMap lets you have null values as well as one null key, a Hashtable doesn't let you have anything that's null.

8) Below table gives more details of the collection classes

Class Map Set List Ordered Sorted
HashMap x No No
HashTable x No No
TreeMap x Sorted By natural order or custom comparison rules
LinkedHashMap x By insertion order or last access order No
HashSet x No No
TreeSet x Sorted By natural order or custom comparison rules
LinkedHashSet x By insertion order No
ArrayList x By index No
Vector x By index No
LinkedList x By index No
PriorityQueue x Sorted By to-do order

9) Unlike basic queue structures that are first-in, first-out by default, a PriorityQueue orders its elements using a user-defined priority. The priority can be as simple as natural ordering (in which, for instance, an entry of 1 would be a higher priority than an entry of 2). In addition, a PriorityQueue can be ordered using a Comparator, which lets you define any ordering you want. Queues have a few methods not found in other collection interfaces: peek(), poll(), and offer().

10) List, which is the wildcard without the keywords extends or super, simply means "any type." So that means any type of List can be assigned to the argument. That could be a List of , , , , whatever. And using the wildcard alone, without the keyword super (followed by a type), means that you cannot ADD anything to the list referred to as List.

11) We cannot use wildcard notation in the object creation.

12) When using a wildcard like List, the collection can be accessed but not modified.

13) When using a wildcard like List, any generic type can be assigned to the reference, but for access only, no modifications.

Writing Testable Code By Isa Goksu, ThoughtWorks

2010-04-27T05:09:00.000-07:00
Readers are requested to read this nice article

http://www.methodsandtools.com/archive/archive.php?id=103

Hope you find above article interesting.

What Next For James Gosling?

2010-04-19T02:46:00.000-07:00
Below blog article is interesting to know what next James Gosling is doing

http://nighthacks.com/roller/jag/entry/next

Also Statistics say that Java Is Far From Dead :-)

http://spikeypillow.com/2010/04/what-programming-languages-are-people-learning/

How To Clear The Logfile When Application Server Is Is Running Mode

2010-03-10T09:46:00.001-08:00
Manytimes i want to clear the log file while the application server is is running mode for analysing problem in better ways as the present log file may get more in size.

We all know we are unable to clear the file when server is in runnning mode.

But thanks to my collegue Sachin Mehta today i came to know how to do it.

Below are the simple steps

1) Open the file which you want to clear in notepad.

2) Clear the contents of the file and save it. Ignore the error message notepad gives while you are trying to save it.Generally we get error message like "Cannot Create the "name of the file" file.Make sure the path and filename are present."

Hope this information helps.

Debugging web applications from eclipse

2010-02-26T04:45:00.000-08:00
Today i came to know debugging web applications from eclipse

Thanks to my collegue Will Byng for helping me a lot in this.

I want to share with my readers

Below are the steps required

1) Download Weblogic Server 923 in official oracle website.

http://download.oracle.com/docs/cd/E15315_04/help/oracle.eclipse.tools.common.doc/html/install.html

2) In startweblogic.cmd

set JAVA_OPTIONS=%SAVE_JAVA_OPTIONS% -DproxyHost=Access2 -DproxyPort=8080 -DnonProxyHosts="10.220.*|localhost" -DproxySet=true

3) From eclipse click "start the server in debug mode" icon available in "Servers" Tab

4) Make sure status icon of the weblogic server in eclipse will show "Debugging".

5) Keep "breakpoint" in the code you want to debug.

Hope this explanation helps.

SCJP Sun Certified Programmer By Kathy Sierra and Bert Bates - Part6

2010-01-26T05:14:00.001-08:00
Couple of months back i started practicing SCJP Sun Certified Programmer for Java 5 Study Guide By Kathy Sierra and Bert Bates.

Great book written by Kathy Sierra and Bert Bates.

I wanted to share few important quotations found from the six chapter.

1) Once you have assigned a String a value, that value can never change.

2) When we make a new instance of the class File, we're not yet making an actual file, we're just creating a filename.

Ex:

File file = new File("fileWrite1.txt");
// Does not create a new file but only creating a filename.

To create a file we need to create it in below way

newFile = file.createNewFile();

3) Basic serialization happens with just two methods: one to serialize objects and write them to a stream, and a second to read the stream and deserialize objects.

ObjectOutputStream.writeObject() // serialize and write

ObjectInputStream.readObject() // read and deserialize

Ex:

import java.io.*;

class Cat implements Serializable {

String name;

Cat(String name) {
this.name=name;
}

public String getName() {
return "Returning name" + name;
}
}

public class SerializationDemo {
public static void main(String[] args) {
Cat c = new Cat("Mimom"); // 2
try {
FileOutputStream fs = new FileOutputStream("testSer.ser");
ObjectOutputStream os = new ObjectOutputStream(fs);
os.writeObject(c); // 3
os.close();
} catch (Exception e) { e.printStackTrace (); }

try {
FileInputStream fis = new FileInputStream("testSer.ser");
ObjectInputStream ois = new ObjectInputStream(fis);
c = (Cat) ois.readObject(); // 4
System.out.println(c.getName());
ois.close();
} catch (Exception e) { e.printStackTrace(); }
}
}

4) Serializable is a marker interface; it has no methods to implement.

5) When you serialize an object, Java serialization takes care of saving that object's entire "object graph." That means a deep copy of everything the saved object needs to be restored.

6) transient modifier will skip serialization of the respective object.

7) When we invoke defaultWriteobject() from within writeObject() we're telling the JVM to do the normal serialization process for this object. When implementing writeObject(), we will typically request the normal serialization process, and do some custom writing and reading too.

8) When it's time to deserialize, defaultReadobject() handles the normal deserialization we'd get if we didn't implement a readobject() method.

9) When an instance of a Serializable class is deserialized, the constructor does not run, and instance variables arc NOT given their initially assigned values! If the constructor were invoked, and/or instance variables were assigned the values given in their declarations, the object we're trying to restore would revert back to its original state, rather than coming back reflecting the changes in its state that happened sometime after it was created.

10) Object references marked transient will always be reset to null, regardless of whether they were initialized at the time of declaration in the class.

11) When superclass is NOT serializable, then any instance variables we INHERIT from that superclass will be reset to the values they were given during the original construction of the object. This is because the non-serializable class constructor WILL run!

Ex:

import java.io.*;
class SuperNotSerial {
public static void main(String [] args) {

Dog d = new Dog(35, "Fido");
System.out.println("before: " + d.name + " "
+ d.weight);
try {
FileOutputStream fs = new FileOutputStream("testSer.ser"};
ObjectOutputStream os = new ObjectOutputStream(fs);
os.writeObject(d);
os.close ();
} catch (Exception e) { e.printStackTrace(); }
try {
FileInputStream fis = new FileInputstream("testSer.ser");
ObjectInputStream ois = new ObjectInputStream(fis);
d = (Dog) ois.readObject();
ois.close();
} catch (Exception e) { e.printStackTrace(); }

System.out.println("after: " + d.name + " "
+ d.weight);
}
}
class Dog extends Animal implements Serializable {
String name;

Dog(int w, String n) {
weight = w; // inherited
name = n; // not inherited
}
}
class Animal { // not serializable !
int weight = 42;
}

which produces the output:

before: Fido 35
after: Fido 42

12) If you serialize a collection or an array, every element must be serializable! A single non-serializable element will cause serialization to fail.

13) Static variables are NEVER saved as part of the object's state…because they do not belong to the object!

14) As simple as serialization code is to write, versioning problems can occur in the real world. If you save a Dog object using one version of the class, but attempt to deserialize it using a newer, different version of the class, deserialization might fail

15) The parse() method in DateFormat class takes a String formatted in the style of the DateFormat instance being used, and converts the String into a Date object.

16) Regular expressions (regex for short) are a kind of language within a language, designed to help programmers with these searching tasks.

Simple Searches

For our first example, we'd like to search through the following source String

abaaaba

for all occurrences (or matches) of the expression

ab

We can see that we have two occurrences of the expression ab: one starting at position 0 and the second starting at position 4.

import java.util.regex.*;
class RegexSmall {
public static void main(String[] args) {
Pattern p = Pattern.compile("ab"); // the expression
Matcher m = p.matcher("abaaaba"); // the source
boolean b = false;
while(b = m.find()) {
System.out.print(m.start() + " ");
}
}
}

This produces

0 4

17) Regex provides a rich set of metacharacters for java.util.regex.Pattern.

\d A digit
\s A whitespace character
\w A word character (letters, digits, or "_" (underscore))

We can also specify sets of characters to search for using square brackets and ranges of characters to search for using square brackets and a dash:

[abc] Searches only for a's, b's or c's

In addition, we can search across several ranges at once. The following expression is looking for occurrences of the letters a - f or A - F, it's NOT looking for an fA combination:

[a-fA-F] Searches for the first six letters of the alphabet, both cases.

18) ? (zero or one) quantifier : Let's say that our job this time is to search a text file and find anything that might be a local, 7-digit phone number. We're going to say, arbitrarily, that if we find either seven digits in a row, or three digits followed by a dash or a space followed by 4 digits, that we have a candidate. Here are examples of "valid" phone numbers:

1234567
123 4567
123–4567

The key to creating this expression is to see that we need "zero or one instance of either a space or a dash" in the middle of our digits:

\d\d\d([-\s])?\d\d\d\d

19) The Predefined Dot

When you see this character in a regex expression, it means "any character can serve here." For instance, the following source and pattern

source: "ac abc a c"
pattern: a.c

will produce the output

3 abc
7 a c

The "." was able to match both the "b" and the " " in the source data.

20) The greedy quantifier does in fact read the entire source data, and then it works backwards (from the right) until it finds the rightmost match. At that point, it includes everything from earlier in the source data up to and including the data that is part of the rightmost match.

? is greedy, ?? is reluctant, for zero or once

* is greedy, *? is reluctant, for zero or more

+ is greedy, +? is reluctant, for one or more

Example:

What happens when we have the following source and pattern?

source: yyxxxyxx
pattern: .*xx

Result

0 yyxxxyxx

The way to think about this is to consider the name greedy. The regex engine looks (greedily) at the entire source data before it could determine that there was an xx at the end.

If we change the pattern to

source: yyxxxyxx
pattern: .*?xx

we're now using the reluctant qualifier *?, and we get the following:

0 yyxx
4 xyxx

James Gosling's tribute to Sun

2010-01-22T02:03:00.000-08:00
Just now i am browsing dzone and found james gosling tribute to sun.

Hatsoff to James Gosling for his excellent work and may god bless him

Hope readers are aware that Oracle's acquisition of Sun is in near approaching.

http://www.goodgearguide.com.au/article/333517

More Information can be found in below website.

http://blogs.sun.com/jag/entry/so_long_old_friend

SCJP Sun Certified Programmer By Kathy Sierra and Bert Bates - Part5

2009-12-11T08:17:00.000-08:00
Couple of weeks back i started practicing SCJP Sun Certified Programmer for Java 5 Study Guide By Kathy Sierra and Bert Bates.

Great book written by Kathy Sierra and Bert Bates.

I wanted to share few important quotations found from the fifth chapter.

1) The general form of the switch statement is:

switch (expression) {
case constant1: code block
case constant2: code block
default: code block
}

2) It's also illegal to have more than one case label using the same value. For example, the following block of code won't compile because it uses two cases with the same value of 80:

int temp = 90;
switch(temp) {
case 80 : System.out.println("80");
case 80 : System.out.println("80"); // won't compile!
case 90 : System.out.println("90");
default : System.out.println("default");
}

3) It is legal to leverage the power of boxing in a switch expression. For instance, the following is legal:

switch(new Integer(4)) {
case 4: System.out.println("boxing is OK");
}

4) We can have only one test expression in a for loop.

Ex: The below code is illegal

for (int x = 0; (x > 5), (y < 2); x++) { } // too many expressions

The compiler will let you know the problem:

TestLong.java:20: ';' expected
for (int x = 0; (x > 5), (y < 2); x++) { }

5) continue statements must be inside a loop; otherwise, you'll get a compiler error. break statements must be used inside either a loop or switch statement. (Note: this does not apply to labeled break statements.).

6) The continue statement causes only the current iteration of the innermost loop to cease and the next iteration of the same loop to start if the condition of the loop is met. When using a continue statement with a for loop, you need to consider the effects that continue has on the loop iteration. Examine the following code:

for (int i = 0; i < 10; i++) {
System.out.println("Inside loop");
continue;
}

The question is, is this an endless loop? The answer is no. When the continue statement is hit, the iteration expression still runs! It runs just as though the current iteration ended "in the natural way."

7) A finally block encloses code that is always executed at some point after the try block, whether an exception was thrown or not. Even if there is a return statement in the try block, the finally block executes right after the return statement is encountered, and before the return executes!

SCJP Sun Certified Programmer By Kathy Sierra and Bert Bates - Part4

2009-11-09T02:26:00.000-08:00
Couple of weeks back i started practicing SCJP Sun Certified Programmer for Java 5 Study Guide By Kathy Sierra and Bert Bates.

Great book written by Kathy Sierra and Bert Bates.

I wanted to share few important quotations found from the fourth chapter.

1) It is legal to test whether the null reference is an instance of a class. This will always result in false, of course. For example:

class InstanceTest {
public static void main(String [] args) {
String a = null;
boolean b = null instanceof String;
boolean c = a instanceof String;
System, out.println (b + " " + c) ;
}
}

prints this: false false

2) Below table summarizes the use of the instanceof operator given the following:

interface Face { }
class Bar implements Face{ }
class Foo extends Bar { }

First Operand (Reference Being Tested) instanceof Operand (Type We're Comparing the Reference Against) Result
null Any class or interface type false
Foo instance Foo, Bar, Face, Object true
Bar instance Bar, Face, Object true
Bar instance Foo false
Foo[] Foo, Bar, Face false
Foo[] Object true
Foo[] Foo, Bar, Face, Object true

3) The || and && operators work only with boolean operands.

4) Difference between short-circuit and non-short-circuit logical operators.

int z = 5;
if(++z > 5 | | ++z > 6) z++; // z = 7 after this code

versus:

int z = 5 ;
if (++z > 5 | ++z > 6) z++; // z = 8 after this code

5) There are six relational operators: >, >=, <, <= , ==, and !=. The last two ( == and ! = ) are sometimes referred to as equality operators.

6) instanceof is for reference variables only, and checks for whether the object is of a particular type.

7) The || does not evaluate the right operand if the left operand is true.

8) The & and | operators always evaluate both operands.

Java Puzzlers By Joshua Bloch, Neal Gafter

2009-11-05T06:27:00.000-08:00
Just now i finished solving puzzles 2nd time from Java Puzzlers book by Joshua Bloch, Neal Gafter.

Oh!! What a book and my comment on the book is same as Guy Steele "I laughed, I cried, I threw up (my hands in admiration)."

Please go fast and get a copy of the book if not till now.

I have already read and practiced the puzzles during May 2008 and below is the link.

http://prashantaboutjava.blogspot.com/2008/05/java-puzzlers-by-joshua-bloch-neal.html

Overriding,Hiding,Overloading,Shadowing,Obscuring

2009-11-04T01:52:00.000-08:00
Overriding

An instance method overrides all accessible instance methods with the same signature in superclasses [JLS 8.4.8.1], enabling dynamic dispatch; in other words, the VM chooses which overriding to invoke based on an instance's run-time type [JLS 15.12.4.4]. Overriding is fundamental to object-oriented programming and is the only form of name reuse that is not generally discouraged:

class Base {
public void f() { }
}

class Derived extends Base {
public void f() { } // overrrides Base.f()
}

Hiding

A field, static method, or member type hides all accessible fields, static methods, or member types, respectively, with the same name (or, for methods, signature) in supertypes. Hiding a member prevents it from being inherited [JLS 8.3, 8.4.8.2, 8.5]:

class Base {
public static void f() { }
}

class Derived extends Base {
public static void f() { } // hides Base.f()
}

Overloading

Methods in a class overload one another if they have the same name and different signatures. The overloaded method designated by an invocation is selected at compile time [JLS 8.4.9, 15.12.2]:

class CircuitBreaker {
public void f(int i) { } // int overloading
public void f(String s) { } // String overloading
}

Shadowing

A variable, method, or type shadows all variables, methods, or types, respectively, with the same name in a textually enclosing scope. If an entity is shadowed, you cannot refer to it by its simple name; depending on the entity, you cannot refer to it at all [JLS 6.3.1]:

class WhoKnows {
static String sentence = "I don't know.";

public static void main(String[] args) {
String sentence = "I know!"; // shadows static field
System.out.println(sentence); // prints local variable
}
}

Although shadowing is generally discouraged, one common idiom does involve shadowing. Constructors often reuse a field name from their class as a parameter name to pass the value of the named field. This idiom is not without risk, but most Java programmers have decided that the stylistic benefits outweigh the risks:

class Belt {
private final int size;

public Belt(int size) { // Parameter shadows Belt.size
this.size = size;
}
}

Obscuring

A variable obscures a type with the same name if both are in scope: If the name is used where variables and types are permitted, it refers to the variable. Similarly, a variable or a type can obscure a package. Obscuring is the only kind of name reuse where the two names are in different namespaces: variables, packages, methods, or types. If a type or a package is obscured, you cannot refer to it by its simple name except in a context where the syntax allows only a name from its namespace. Adhering to the naming conventions largely eliminates obscuring [JLS 6.3.2, 6.5]:

public class Obscure {

static String System; // Obscures type java.lang.System

public static void main(String[] args) {
// Next line won't compile: System refers to static field
System.out.println("hello, obscure world!");
}
}

Source: Java Puzzlers: Traps, Pitfalls, and Corner Cases By Joshua Bloch, Neal Gafter

Class	Map	Set	List	Ordered	Sorted
HashMap	x			No	No
HashTable	x			No	No
TreeMap	x			Sorted	By natural order or custom comparison rules
LinkedHashMap	x			By insertion order or last access order	No
HashSet		x		No	No
TreeSet		x		Sorted	By natural order or custom comparison rules
LinkedHashSet		x		By insertion order	No
ArrayList			x	By index	No
Vector			x	By index	No
LinkedList			x	By index	No
PriorityQueue			x	Sorted	By to-do order

\d	A digit
\s	A whitespace character
\w	A word character (letters, digits, or "_" (underscore))

First Operand (Reference Being Tested)	instanceof Operand (Type We're Comparing the Reference Against)	Result
null	Any class or interface type	false
Foo instance	Foo, Bar, Face, Object	true
Bar instance	Bar, Face, Object	true
Bar instance	Foo	false
Foo[]	Foo, Bar, Face	false
Foo[]	Object	true
Foo[]	Foo, Bar, Face, Object	true