Solve relative image paths in css used in a JSP file.

I need to use a CSS template for a new project. All background images has been defined in CSS files as relative paths like :

background-image: url('../../images/logo.png');

It was fine if i call an URL : http://www.mydomain.com/console

But i call http://www.mydomain.com/console/create/company , browser can not find the images because it will search this relative path on console/images which does not exist.

I don't want to touch the developer source code and need to find a generic solution. Because if i change the base path. it must also work perfect.

My solution was easy, redirect to an absolute URL depends on context etc. Therefore i wrote a filter to redirect assets into their real paths. Let see in action :)

public class ResourceFilter implements javax.servlet.Filter {

    private static final String ASSETS_FOLDERS = "assets";

    public void doFilter(ServletRequest req, ServletResponse resp, FilterChain chain) throws ServletException, IOException {

        if (req instanceof HttpServletRequest) {
            HttpServletRequest servletRequest = (HttpServletRequest) req;

            String uri = servletRequest.getRequestURI();
            if (uri.contains(ASSETS_FOLDERS)) {

                HttpServletResponse httpResponse = (HttpServletResponse) resp;

                String replaced = uri.substring(uri.lastIndexOf(ASSETS_FOLDERS), uri.length());
                String toRedirect =  servletRequest.getContextPath() + "/" + replaced;

                if (toRedirect.equals(uri)) { // If absolute redirect path equals to uri don't redirect it again. Prevent cycles.
                    chain.doFilter(req, resp);
                    return;
                }
                
                httpResponse.sendRedirect(toRedirect);
                return;
            }
        }
        chain.doFilter(req, resp);
    }

    public void init(FilterConfig config) throws ServletException {}

    public void destroy() {}
}

Spring MVC - Atmosphere Integration

Atmosphere Framework is a most popular push framework for Java EE applications. I integrated framework in Spring Framework. In this simple application you can play a tic-tac-toe with real-time data sharing using push technology.

Git repository :

https://bitbucket.org/masal/tictactoe

Any comments are welcome!

Generic DAO and JPA

Generic DAO is a design pattern to reduce and prevent code replacing on basic CRUD operations. Hibernate-Generic-DAO (http://code.google.com/p/hibernate-generic-dao/) provides exactly this pattern solution for Hibernate or JPA.

UML Overview of this example:

BaseDAO is an extension of GenericDAO and it must be extended by each DAO class of the project.

JPAGenericDAO is a generic, abstract class to be extended by each concrete DAO class.

Sample code:

1. /**
2.  * @author Hasan Oezdemir
3.  * @since 01.10.2011
4.  *
5.  */
6. public abstract class JPAGenericDAO<T, ID extends Serializable> extends GenericDAOImpl<T, ID> implements
7.         BaseDAO<T, ID> {
9.     private static final Logger logger = LoggerFactory.getLogger(JPAGenericDAO.class);
10.    
11.     @PersistenceContext(unitName="scheduling")
12.     private EntityManager entityManager;
13.    
14.     public JPAGenericDAO(){
15.         super();
16.     }
17.    
18.     @PostConstruct
19.     public void initialized(){
20.         logger.info( "initializing generic dao, setting entity manager: {}", entityManager);
21.         this.setEntityManager(entityManager);
22.         JPASearchProcessor searchProcessor = new JPASearchProcessor(new JPAAnnotationMetadataUtil());
23.         this.setSearchProcessor(searchProcessor);
24.     }
26.     @Override
27.     public T findByExampleUnique(T example) {
28.         Search s = this.createSearch(example);
29.         return searchUnique(s);
30.     }
32.     @Override
33.     public Collection<T> findByExample(T example) {
34.         Search s = this.createSearch(example);
35.         return search(s);
36.     }
37.    
38.     protected Search createSearch(T example) {
39.         Search s = new Search(example.getClass());
40.         s.addFilter(this._getFilterFromExample(example));
41.         return s;
42.     }
43. }

UserDAO extends the BaseDAO :

1. /**
2.  * @author Hasan Oezdemir
3.  * @since 01.10.2011
4.  *
5.  */
6. public interface UserDAO extends BaseDAO<User, Long> {
8. }

and a sample reference implementation of DAOs :

1. /**
2.  * @author Hasan Oezdemir
3.  * @since 01.10.2011
4.  *
5.  */
6. @Singleton
7. public class JPAUserDAO extends JPAGenericDAO<User, Long> implements UserDAO {
9.     public JPAUserDAO(){
10.         super();
11.     }
12. }

We keep basic CRUD operations in our abstract class but we have also seperate interfaces to provide 'Model' specific method and keep them seperate from generic DAO solutions.

Testing with Arquillian and Embedded Glassfish 3.1 - Part 2

We are configured our project to create and run tests with Arquillian. Here i will explain how to create a simple test using Arquillian and JPA.

We have created a data source with JNDI-name "jdbc/sample" in part 1, we will use it for our JPA test, i have used an API to make generic DAOs and hibernate-entity-manager as an entitity manager, needed dependencies therefore :

1. <dependency>
2.     <groupId>org.hibernate</groupId>
3.     <artifactId>hibernate-entitymanager</artifactId>
4.     <version>3.6.7.Final</version>
5.     <exclusions>
6.         <exclusion>
7.             <artifactId>slf4j-api</artifactId>
8.             <groupId>org.slf4j</groupId>
9.         </exclusion>
10.     </exclusions>
11. </dependency>
12. <dependency>
13.     <groupId>org.hibernate</groupId>
14.     <artifactId>hibernate-core</artifactId>
15.     <version>3.6.7.Final</version>
16.     <exclusions>
17.         <exclusion>
18.             <artifactId>slf4j-api</artifactId>
19.             <groupId>org.slf4j</groupId>
20.         </exclusion>
21.     </exclusions>
22. </dependency>
23. <!-- generic DAO dependencies -->
24. <!-- This first dependency includes all the JPA implementations for the DAOs -->
25. <dependency>
26.     <groupId>com.googlecode.genericdao</groupId>
27.     <artifactId>dao</artifactId>
28.     <version>1.0.0</version>
29. </dependency>
30. <!-- This second one includes the Hibernate Entity Manager plugin for the framework -->
31. <dependency>
32.     <groupId>com.googlecode.genericdao</groupId>
33.     <artifactId>search-jpa-hibernate</artifactId>
34.     <version>1.0.0</version>
35. </dependency>
36. <!-- end of generic DAO dependencies -->

I've created a BaseDAO interface and then the a specific interface to provide CRUD operations for users.

1. /**
2.  * @author Hasan Oezdemir
3.  * @since 01.10.2011
4.  *
5.  */
6. public interface BaseDAO<T, ID extends Serializable> extends GenericDAO<T, ID> {
8.     public Collection<T> findByExample(T example);
9.    
10.     public T findByExampleUnique(T example);
11. }

1. /**
2.  * @author Hasan Oezdemir
3.  * @since 01.10.2011
4.  *
5.  */
6. public interface UserDAO extends BaseDAO<User, Long> {
8. }

And an abstract class for JPA implementations :

1. /**
2.  * @author Hasan Oezdemir
3.  * @since 01.10.2011
4.  *
5.  */
6. public abstract class JPAGenericDAO<T, ID extends Serializable> extends GenericDAOImpl<T, ID> implements
7.         BaseDAO<T, ID> {
9.     private static final Logger logger = LoggerFactory.getLogger(JPAGenericDAO.class);
10.    
11.     @PersistenceContext(unitName="sample")
12.     private EntityManager entityManager;
13.    
14.     public JPAGenericDAO(){
15.         super();
16.     }
17.    
18.     @PostConstruct
19.     public void initialized(){
20.          this.setEntityManager(entityManager);
21.         JPASearchProcessor searchProcessor = new JPASearchProcessor(new JPAAnnotationMetadataUtil());
22.         this.setSearchProcessor(searchProcessor);
23.     }
25.     @Override
26.     public T findByExampleUnique(T example) {
27.         Search s = this.createSearch(example);
28.         return searchUnique(s);
29.     }
31.     @Override
32.     public Collection<T> findByExample(T example) {
33.         Search s = this.createSearch(example);
34.         return search(s);
35.     }
36.    
37.     protected Search createSearch(T example) {
38.         Search s = new Search(example.getClass());
39.         s.addFilter(this._getFilterFromExample(example));
40.         return s;
41.     }
42. }

As you remember we are created a persistence-unit named "sample" while injecting the entity-manager at this point, we are used this unit for our DAOs :

1. @PersistenceContext(unitName="sample")
2. private EntityManager entityManager

And a reference implementation for our JPA DAO :

1. /**
2.  * @author Hasan Oezdemir
3.  * @since 01.10.2011
4.  *
5.  */
6. @Singleton
7. public class JPAUserDAO extends JPAGenericDAO<User, Long> implements UserDAO {
9.     public JPAUserDAO(){
10.         super();
11.     }
12. }

We are now ready to implement an Arquillian Test for our JPA class.The most important section to create a static method annotated with @Deployment to build a ShrinkWrap, here is a sample method:

1. /**
2. * Since Arquillian actually creates JAR files under the covers with
3. * ShrinkWrap, the @Deployment is your way of controlling what is included
4. * in that Archive. Note, each class utilized in your test case - whether
5. * directly or indirectly - must be added to the deployment archive.
6. */
7. @Deployment
8. public static Archive<?> createTestArchive() {
9.     return ShrinkWrap
10.         .create(JavaArchive.class, "test.jar")
11.         .addAsResource("arquillian.xml")
12.         .addPackages(true, UserDAO.class.getPackage())
13.         .addAsManifestResource(EmptyAsset.INSTANCE, "beans.xml")
14.         .addAsManifestResource("META-INF/persistence.xml",
15.         ArchivePaths.create("persistence.xml"));
16. }

We must add our arquillian configuration too, otherwise ShrinkWrap reads the default configuration and ignores our configuration.

I've created an abstract class which is extended by all test-classes :

1. /**
2.  *
3.  * @author Hasan Oezdemir
4.  * @since 02.10.2011
5.  *
6.  */
7. public class AbstractJPATest {
9.     /**
10.      * Since Arquillian actually creates JAR files under the covers with
11.      * ShrinkWrap, the @Deployment is your way of controlling what is included
12.      * in that Archive. Note, each class utilized in your test case - whether
13.      * directly or indirectly - must be added to the deployment archive.
14.      */
15.     @Deployment
16.     public static Archive<?> createTestArchive() {
17.         return ShrinkWrap
18.                 .create(JavaArchive.class, "test.jar")
19.                 .addAsResource("arquillian.xml")
20.                 .addAsResource("log4j.xml")
21.                 .addPackages(true, UserDAO.class.getPackage())
22.                 .addAsManifestResource(EmptyAsset.INSTANCE, "beans.xml")
23.                 .addAsManifestResource("META-INF/persistence.xml",
24.                         ArchivePaths.create("persistence.xml"));
25.     }
27.     @Inject
28.     protected UserTransaction userTransaction;
30.     public AbstractJPATest() {
31.         super();
32.     }
34.     /**
35.      * @throws java.lang.Exception
36.      */
37.     @Before
38.     public void setUp() throws Exception {
39.         this.userTransaction.begin();
40.     }
42.     /**
43.      * @throws java.lang.Exception
44.      */
45.     @After
46.     public void tearDown() throws Exception {
47.         try {
48.             this.userTransaction.rollback();
49.         } catch (Exception e) {
50.             throw new Exception(e);
51.         }
52.     }
54.     /**
55.      * @return a test user.
56.      */
57.     protected User createUser() {
58.         User user = new User();
59.         user.setEmail("hasan@hotmail.com");
60.         user.setName("hasan");
61.         user.setPassword("12345");
62.         return user;
63.     }
64. }

Transaction management may be better but this is enought for now :)

We must run our tests with Arquillian.class therefore we should add @RunWith(Arquillian.class) for each our tests-classes, here is a sample :

1. /**
2.  * @author Hasan Oezdemir
3.  * @since 01.10.2011
4.  *
5.  */
6. @RunWith(Arquillian.class)
7. public class JPAUserDAOTest extends AbstractJPATest {
8.    
9.     @Inject
10.     private JPAUserDAO jpaUserDAO;
12.     /**
13.      * Test method for
14.      * {@link com.citecompany.dao.jpa.JPAGenericDAO#findByExampleUnique(java.lang.Object)}
15.      * .
16.      */
17.     @Test
18.     public void testFindByExampleUnique() {
19.         User user = this.createUser();
21.         this.jpaUserDAO.save(user);
22.         User found = this.jpaUserDAO.findByExampleUnique(user);
23.         assertNotNull("Expected user " + user + " is not found in data source.", found);
24.         assertEquals(user.getName(), found.getName());
25.     }
26. }

So our test class is ready to start, you start it either with maven or in eclipse.