Atif ullah Baig - Java Tech Blog

Handling cross cutting concerns with AOP - Spring AspectJ Example

2013-08-09T00:54:00.000-07:00

Cross Cutting Concerns

A cross cutting concern is a concern that is spread over multiple modules. For example logging user activities whenever any operation is performed is a cross cutting concern. To understand this lets say we have a service layer in our application and there are different services on that layer. If we want to log user activity whenever any operation is performed then we would definitely need to embed same logging code into each service class which is obviously code scattering.

The above issue is tackled by AOP (Aspect Oriented Programming) which removes the need for writing redundant code in our application.

AOP (Aspect Oriented Programming)

As the name suggests AOP is based on Aspects. Each Aspect is a module that removes the need to scatter similar code over multiple modules thus AOP modularizes the cross cutting concerns.

Core Concepts

Joinpoint: The point in the execution of an application where you want insert additional logic to be executed.

Pointcut: Expression that select one or more jointpoints.

Advice: Code that will be executed at a jointpoint that has been selected by a pointcut. Following are the types of Advice.

1. Before Advice (this executes before joinpoint)
2. After Advice (this executes after joinpoint)
3. Around Advice (this executes around joinpoint)

Aspect: Module that encapsulate pointcuts and advices.

Spring AspectJ Example

pom.xml

<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
xmlns="http://maven.apache.org/POM/4.0.0" xsi:schemalocation="http://maven.apache.org/POM/4.0.0 
http://maven.apache.org/xsd/maven-4.0.0.xsd">

<modelversion>4.0.0</modelversion>
<groupid>org.atif.demo.aop</groupid>
<artifactid>aop</artifactid>
<version>1.0-SNAPSHOT</version>
<packaging>jar</packaging>
<name>aop</name>
<url>http://maven.apache.org</url>
<properties>
<project .build.sourceencoding="">UTF-8</project>
</properties>
<dependencies>      
<dependency>
<groupid>org.springframework</groupid>
<artifactid>spring-context</artifactid>
<version>2.5</version>
</dependency>
<dependency>
<groupid>aspectj</groupid>
<artifactid>aspectjrt</artifactid>
<version>1.5.4</version>
</dependency>
<dependency>
<groupid>cglib</groupid>
<artifactid>cglib</artifactid>
<version>2.2</version>
</dependency>
<dependency>
<groupid>org.springframework</groupid>
<artifactid>spring-aop</artifactid>
<version>2.5</version>
</dependency>
<dependency>
<groupid>org.aspectj</groupid>
<artifactid>aspectjweaver</artifactid>
<version>1.6.11</version>
</dependency>
<dependency>
<groupid>commons-logging</groupid>
<artifactid>commons-logging</artifactid>
<version>1.1.3</version>
</dependency> 
<dependency>
<groupid>junit</groupid>
<artifactid>junit</artifactid>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
</dependencies>
</project>

Operation.java

package org.atif.demo.aop;

/**
 *
 * @author atif
 */
public enum Operation {
    ADD("Addition"),
    EDIT("Update"),
    DELETE("Delete"),
    VIEW("View");
   
    private String name = null;
   
    Operation(String name) {
      this.name = name;   
    }
   
    public String getName() {
        return this.name;
    }   
}

EventLogger.java

package org.atif.demo.aop;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * @author atif
 *
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface EventLogger {Operation op();
}

EventLoggerAspect.java

package org.atif.demo.aop;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.core.Ordered;

/**
 * Simple Spring AOP aspect, intercepting every method
 * which uses the {@link EventLoggerAspect} annotation.
 *
 * Every method willing to have access checked, needs to declare
 * both the annotation and {@link EventLoggerAspect} as one of its parameters.
 *
 * @author atif
 */
@Aspect
public class EventLoggerAspect implements Ordered {
    private static Log LOG = LogFactory.getLog(EventLoggerAspect.class);
    private int order = 0;

    /**
     * Logs user operation.
     * An AspectJ annotation declares the pointcut for this aspect.
     *
     * @param joinPoint AOP object which will get automatically injected
     * @param op The EventLogger annotation as extracted from the intercepted method.
     */
    @Before("@annotation(logger)")
    public void logOperationStart(JoinPoint joinPoint, EventLogger logger) {

        Operation operation = logger.op();       

        System.out.println("About to perform " + operation.getName() + " operation.");
    }

    /**
     * Logs user operation.
     * An AspectJ annotation declares the pointcut for this aspect.
     *
     * @param joinPoint AOP object which will get automatically injected
     * @param op The EventLogger annotation as extracted from the intercepted method.
     */
    @After("@annotation(logger)")
    public void logOperationEnd(JoinPoint joinPoint, EventLogger logger) {

        Operation operation = logger.op();       

        System.out.println("Performed " + operation.getName()+ " operation.");
    }

   
    public void setOrder(int order) {
        this.order = order;
    }   
   

    @Override
    public int getOrder() {
        return order;
    }
}

CRUDService.java

package org.atif.demo.aop;

/**
 *
 * @author atif
 */
public class CRUDService {
       
    @EventLogger(op= Operation.ADD)
    public void add() {
        System.out.println("Operation in progress...");
    }
   
    @EventLogger(op= Operation.EDIT)
    public void edit() {
        System.out.println("Operation in progress...");
    }
   
    @EventLogger(op= Operation.DELETE)
    public void delete() {
        System.out.println("Operation in progress...");
    }
   
    @EventLogger(op= Operation.VIEW)
    public void select() {
        System.out.println("Operation in progress...");
    }
}

applicationContext.xml

<beans xmlns:aop="http://www.springframework.org/schema/aop" xmlns:context="http://www.springframework.org/schema/context" 
xmlns:mvc="http://www.springframework.org/schema/mvc" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://www.springframework.org/schema/beans" 
xsi:schemalocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

<aop:aspectj-autoproxy>
</aop:aspectj-autoproxy>

<context:annotation-config/>
<context:component-scan base-package="org.atif.demo.aop"/>
<bean class="org.atif.demo.aop.EventLoggerAspect" id="eventLoggerAspect">
<property name="order" value="0">
</property>
</bean>

<bean class="org.atif.demo.aop.CRUDService" id="crudService">
</bean>
</beans>

App.java

package org.atif.demo.aop;

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

/**
 * AOP Demo
 *
 */
public class App
{
    public static void main( String[] args )
    {     
        ApplicationContext applicationContext;
        applicationContext = new ClassPathXmlApplicationContext("/applicationContext.xml");
        CRUDService crudService = (CRUDService) applicationContext.getBean("crudService");       
        crudService.add();
        crudService.edit();
        crudService.delete();       
        crudService.select();
    }
}

Output

.....

About to perform Addition operation.

Operation in progress...

Performed Addition operation.

About to perform Update operation.

Operation in progress...

Performed Update operation.

About to perform Delete operation.

Operation in progress...

Performed Delete operation.

About to perform View operation.

Operation in progress...

Performed View operation.

BUILD SUCCESSFUL (total time: 2 seconds)

Should I use Servlet Container or Application Server?

2013-02-10T05:20:00.001-08:00

In my very first post I mentioned how tomcat server(which is a Servlet Container) can be installed and in my previous post I discussed about the deployment of EAR file inside glassfish application server along with its installation. Now I think we should put some time in understanding the difference between Servlet Containers and Applications Servers.

Suppose we need to build a simple web application that has fairly simple UI with some basic CRUD functionalities and also transaction management and user management are not of great concern for us. In this case it will be definitely reasonable to use a Servlet Container like Apache Tomcat or Jetty. Does this example imply that we always need Application Servers for more advance features in our Java EE applications? Well it all depends on how we design and develop our application and which features are more useful for it.

A Servlet Container is a Web Server having a concrete implementation of the abstract Servlet API and is able to run Java Servlets. Thus Servlet Container is needed for all Servlets and JSPs that are part of web component of an application. Since application servers are also capable of running Servlets, therefore it is very obvious that every application server has a Servlet Container in it. In other words Servlet Container is a part of Application Server.

Other than running Servlets what are the features that most Application Servers possess yet are not included in Servlet Containers? The first word that comes to mind is EJBs. As most of the Application Servers have EJB Containers therefore with EJBs in our application we can avail a numbers of enterprise services offered by the EJB Containers. But what if we use Embeddable EJB container (OpenEJB) along with Tomcat as Servlet Container. Remember with Embeddable EJB Container we can not fully avail the true power of EJBs. Embeddable containers support only EJB 3.1 Lite which is a scaled down and lighter-weight version of EJB 3.1 that goes hand-in-hand with the Web Profile and is intended for web applications. Thus with Embeddable containers we can put EJBs inside our web module (that is packaged as WAR).

Following snapshot shows Java EE Web Profile APIs.

Following snapshot shows the missing features in EJB Lite.

The point in our EJB discussion here is that we should definitely think of using Application Server if our application needs any feature that is not supported by EJB Lite.

So far we have seen that an Application Server has an EJB Container along with a Servlet Container and we have already discussed briefly about the features provided by both of them. Now other features that most Application Servers possess include support for JMS, JCA, RMI, JTA etc.

We know we can add most of the Java EE features by using standalone implementations. For instance for using JMS in Servlet Container like tomcat we can use OpenJMS as JMS provider. Now the question is why should we use Application Server at all instead of a simple Servlet Container. The main reason behind using Application Servers is to ensure the use of advance Java EE features with least complexity. Using plain Servlet Container for advance features is likely to enhance the complexity of configuration(as we might be forced to use Spring + Third party solutions for adding any new feature) in the longer run. The following table shows the tradeoffs between choosing Spring and EJB 3. (I think we should not be biased and always use the best of both technologies).

Another noticeable difference between Servlet Containers and Application Servers is that, the EAR package is only deployed on Application Servers not on plain Servlet Containers. So it is important to understand the difference between WAR and EAR packages. We all know WAR file can have multiple JARs in it while EAR file can have both JAR and WAR files. So do we only need to package multiple WARs in EAR or is there any better idea behind EAR package? In fact the main reason of EAR package is to simplify the configuration and interaction between different Java EE modules like Web, EJB and Java. Thus the EAR represents a full-fledged and mature Java EE application unlike WAR package that represents only a web application. As an EAR file might have an EJB module in it therefore it is not supported by plain Servlet Containers.

Deploying EAR file inside glassfish on Ubuntu Machine

2013-02-09T09:57:00.001-08:00

In this post we will go through the minimal steps required to deploy EAR file inside glassfish server on Ubuntu linux machine.

Minimal Steps Required

1. Install Sun jdk 1.6 or higher from here if not already installed but first remove any other jdk versions if they were installed previuosly.

2. Download and install glassfish application server with following simple commands.

wget http://download.java.net/glassfish/3.1.1/release/glassfish-3.1.1-unix.sh
sh glassfish-3.1.1-unix.sh

As we can configure glassfish server after its installation therefore we can skip configuring glassfish while its installation.

3. Create a new domain with following simple command.

asadmin create-domain –adminport 4848 –profile developer domain1

where 4848 is default admin port. However in my case admin port was 14889.

4. Next set admin password with following commands (Assuming that glassfish3/bin directory is already added to the PATH variable).

asadmin --user admin
asadmin> change-admin-password --user admin
Enter admin password>[Press Enter key as default is empty value]
Enter new admin password>adminpass
Enter new admin password again>adminpass
Command change-admin-password executed successfully.

5. Now open Glassfish Administration Console and provide the admin user credentials.

6. Once you sign in go to the "Deploy an Application" link under Deployment menu.

7. Now select the EAR file to be deployed and click on OK button.

The EAR file was successfully deployed in the last step and that can be easily tested by accessing our application from the browser.