Skip to main content

Spring’s AOP with Struts

Using Spring’s AOP with your Struts Application:

To tackle cross-cutting you can use Spring interceptors
To use Spring’s AOP in your Struts Applications you need to :

1. Create the interceptor.
2. Registor the interceptor.
3. Delclare interceptors.

For example
A sample logging interceptor
  
package net.champ.example1.employee.interceptors;

import org.springframework.aop.MethodBeforeAdvice;
import java.lang.reflect.Method;

public class LoggingInterceptor implements MethodBeforeAdvice {

public void beforeMethod(Method method, Object[] objects, Object o) throws Throwable {
System.out.println("logging before intersection");
}
}

This interceptor will execute the beforeMethod() before every intersection (We are using MethodBeforeAdvice). Here we are just printing a line but we can use it for anything we like. Next let us register the interceptor.
Registering the interceptor in the Spring config file
  
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN"
"http://www.springframework.org/dtd/spring-beans.dtd">

<beans>
<bean id="empSearchService" class="net.champ.example1.employee.business.EmpSearchServiceImpl">
<bean name="/submitSearch"
class="net.champ.example1.employee.actions.SubmitSearch">
<property name="empSearchService">
<ref bean="empSearchService">
</property>
</bean>

<!-- Interceptors -->
<bean name="logger"
class="net.champ.example1.employee.interceptors.LoggingInterceptor"/>
<!-- AutoProxies -->
<bean name="loggingAutoProxy"
class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">
<property name="beanNames">
<value>/submitSearch>/values>
</property>
<property name="interceptorNames">
<list>
<value>logger>/value>
</list>
</property>
</bean>

</beans>

Explanation:
First we have to register the interceptor:
 
<bean name="logger"
class="net.champ.example1.employee.interceptors.LoggingInterceptor"/>

Now we need to define the intersections, we will use autoproxy:

<bean name="loggingAutoProxy"
class="org.springframework.aop.framework.autoproxy.BeanNameAutoProxyCreator">

Now we have to register the Struts action’s that will be intercepted.

<property name="beanNames">
<value>/submitSearch>/values>
// <value>/otherBeans>/values>
</property>

Apply interceptors to the beanNames:

<property name="interceptorNames">
<list>
<value>logger>/value>
</list>
</property>

Comments

Popular posts from this blog

Sorting an List in Java

// Create a list String[] strArray = new String[] {"z", "a", "C"}; List list = Arrays.asList(strArray); // Sort Collections.sort(list); // C, a, z // Case-insensitive sort Collections.sort(list, String.CASE_INSENSITIVE_ORDER); // a, C, z // Reverse-order sort Collections.sort(list, Collections.reverseOrder()); // z, a, C // Case-insensitive reverse-order sort Collections.sort(list, String.CASE_INSENSITIVE_ORDER); Collections.reverse(list); // z, C, a

Hibernate

Best sites which are very much useful for assist in Hibernate related problems * Hibernate main site * Hibernate Tutorial * Hibernate Forum * Hibernate Wikipedia * Popular Hibernate Books * Hibernate Materials * Relational Persistence for Idiomatic Java

JSF Lifecycle Phases

JSF Lifecycle Phases JSF follows MVC design pattern to handle request-response process. Basically JSF handles three types of requests. Non-Faces Request Generates Faces Response Faces Request Generates Non-Faces Response Faces Request Generates Faces Response In another case of course non-jsf to non-jsf is there but in this case there is no involvement of JSF action here, so this is not a part of jsf lifecycle process. A JavaServer Faces page is represented by a tree of UI components, called a view . When a client makes a request for the page, the life cycle starts. During the life cycle, the JavaServer Faces implementation must build the view while considering state saved from a previous submission of the page. When the client submits a page, the JavaServer Faces implementation must perform several tasks, such as validating the data input of components in the view and converting input data to types specified on the server side. The JavaServer Faces implementation performs a...