Relaxed Java Persistence with Ektorp and CouchDB

This repository obviously handles blog posts.

package org.ektorp.sample;

import java.util.*;

import org.ektorp.*;
import org.ektorp.support.*;
import org.springframework.beans.factory.annotation.*;
import org.springframework.stereotype.*;

@Component
public class BlogPostRepository extends CouchDbRepositorySupport<BlogPost> {

        @Autowired
        public BlogPostRepository(@Qualifier("blogPostDatabase") CouchDbConnector db) {
                super(BlogPost.class, db);
                initStandardDesignDocument();
        }

        @GenerateView @Override
        public List<BlogPost> getAll() {
                ViewQuery q = createQuery("all").descending(true);
                return db.queryView(q, BlogPost.class);
        }
        
        @GenerateView
        public List<BlogPost> findByTag(String tag) {
                return queryView("by_tag", tag);
        }

}

View definitions can be embedded within repositories through the @View annotation.

There isn't much to say about the CommentRepository besides that the view used in findByBlogPostId uses the @GenerateView annotation in order to generate the view that describes the Comment's relationship with the BlogPost.

package org.ektorp.sample;

import java.util.*;

import org.ektorp.*;
import org.ektorp.support.*;
import org.springframework.beans.factory.annotation.*;
import org.springframework.stereotype.*;

@Component
@View( name="all", map = "function(doc) { if (doc.blogPostId) { emit(null, doc) } }")
public class CommentRepository extends CouchDbRepositorySupport<Comment> {

        @Autowired
        public CommentRepository(@Qualifier("blogPostDatabase") CouchDbConnector db) {
                super(Comment.class, db);
                initStandardDesignDocument();
        }
        
        @GenerateView
        public List<Comment> findByBlogPostId(String blogPostId) {
                return queryView("by_blogPostId", blogPostId);
        }

}

The BlogController handles all use cases in this application. As this is a very simple application there is no service layer and the controller uses the repositories directly.

Authorization and such is left as an exercise for you, the reader.

package org.ektorp.sample;

import org.joda.time.*;
import org.springframework.beans.factory.annotation.*;
import org.springframework.stereotype.*;
import org.springframework.ui.*;
import org.springframework.web.bind.annotation.*;
import org.springframework.web.servlet.*;

@Controller
public class BlogController {

        @Autowired
        BlogPostRepository blogPostRepo;
        @Autowired
        CommentRepository commentRepo;
        
        @RequestMapping( value = "/posts/", method = RequestMethod.GET)
        public String viewAll(Model m) {
                m.addAttribute(blogPostRepo.getAll());
                return "/posts/index";
        }
        
        @RequestMapping( value = "/posts/new", method = RequestMethod.GET)
        public ModelAndView newPost() {
                return new ModelAndView("/posts/edit", "command", new BlogPost());
        }
        
        @RequestMapping( value = "/posts/", method = RequestMethod.POST)
        public String submitPost(@ModelAttribute("command") BlogPost post) {
                if (post.isNew()) {
                        post.setId(createId(post.getTitle()));
                        post.setDateCreated(new DateTime());
                }
                blogPostRepo.update(post);
                return "redirect:/blog/posts/";
        }
        
        private String createId(String title) {
                return title.replaceAll("\\s", "-");
        }

        @RequestMapping("/posts/{postId}")
        public ModelAndView viewPost(@PathVariable("postId") String postId) {
                ModelAndView model = new ModelAndView("/posts/view");
                model.addObject(blogPostRepo.get(postId));
                model.addObject(commentRepo.findByBlogPostId(postId));
                return model;
        }
        
        @RequestMapping( value = "/posts/{postId}/edit", method = RequestMethod.GET)
        public BlogPost editPost(@PathVariable("postId") String postId) {
                return blogPostRepo.get(postId);
        }
        
        @RequestMapping( value = "/posts/{postId}/comment", method = RequestMethod.POST)
        public String addComment(@PathVariable("postId") String postId, @ModelAttribute("command") Comment comment) {
                comment.setBlogPostId(postId);
                comment.setDateCreated(new DateTime());
                commentRepo.add(comment);
                return "redirect:/blog/posts/" + comment.getBlogPostId();
        }
}

Almost all components in this application are configured through annotations. The few things that need to be configured in xml are the StdCouchDbConnector and its supporting classes StdCouchDbInstance and HttpClient.

The HttpClient is created with the help of org.ektorp.spring.HttpClientFactoryBean that read configuration parameters from couchdb.properties defined below.

Note that in a bigger application, you would want StdCouchDbInstance to be a standalone bean so that it can be referenced by multiple CouchDbConnectors.

<?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:util="http://www.springframework.org/schema/util"
        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
                http://www.springframework.org/schema/util http://www.springframework.org/schema/util/spring-util-3.0.xsd
                http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd">
        
        <!-- Scans within the base package of the application for @Components to configure as beans -->
        <context:component-scan base-package="org.ektorp.sample" />
        
        <util:properties id="couchdbProperties" location="classpath:/couchdb.properties"/>

        <bean id="blogPostDatabase" class="org.ektorp.impl.StdCouchDbConnector">
                <constructor-arg value="blogPosts" />
                <constructor-arg>
                        <bean id="couchDbInstance" class="org.ektorp.impl.StdCouchDbInstance">
                                <constructor-arg>
                                        <bean class="org.ektorp.spring.HttpClientFactoryBean" />
                                </constructor-arg>
                        </bean>
                </constructor-arg>
        </bean>
        
</beans>

If you successfully started the application, your CouchDb instance will contain a new database called blogposts. The new database should contain one design documents: _design/BlogPost the contains the auto generated views .

If you made any posts or comments you should find them here as well.

Now we have covered what a simple application with Ektorp as persistence layer looks like and I hope you will find Ektorp useful for you.