I was playing around with creating a Twitter clone, in my opinion the "Hello World" of graph databases, and I started out with the following simple service.

Spring configurating:

 
<beans ... >
	<context:annotation-config />
 
	<bean id="neo" class="org.neo4j.api.core.EmbeddedNeo"
		destroy-method="shutdown">
		<constructor-arg>
			<value>var/neo</value>
		</constructor-arg>
	</bean>
 
	<bean id="indexService" class="org.neo4j.util.index.NeoIndexService"
		destroy-method="shutdown">
		<constructor-arg ref="neo" />
	</bean>
 
	<bean id="twitterService"
		class="com.jayway.twitter.neo.NeoBasedTweetService">
<property name="neo" ref="neo" />
<property name="indexService" ref="indexService" />
	</bean>
 
	<!-- Transactions -->
	<tx:annotation-driven />
        ...
</beans>
 

The service:

 
public class NeoBasedTweetService implements TweetService {
 
	protected NeoService neo;
	protected IndexService indexService;
 
	//Setters for neo and indexService
 
	@Transactional
	public Tweet createTweet(User user, String tweet) {
		UserNode userNode = new UserNode(indexService.getSingleNode(
				TwitterIndexConstants.INDEX_USER, user.getUserName()));
		TweetNode tweetNode = new TweetNode(neo.createNode());
		tweetNode.setKvitt(tweet);
		userNode.createRelationshipTo(tweetNode, KvittRelationships.KVITTRAT);
		return tweetNode;
	}
 
	//Services to create User and more
 
}
 

This doesn't feel very DDD. I would really want to do the User to be responsible for creating the Tweet. Like this:

 
public class NeoBasedTweetService implements TweetService {
 
	protected NeoService neo;
	protected IndexService indexService;
 
	//Setters for neo and indexService
 
	@Transactional
	public Tweet createTweet(User user, String tweet) {
		UserNode userNode = new UserNode(indexService.getSingleNode(
				TwitterIndexConstants.INDEX_USER, user.getUserName()));
		return userNode.createTweet(tweet);
	}
 
	//Services to create User and more
 
}
 

The TweetNode and UserNode would look like this:

 
public class TweetNode extends NodeDelegate implements Tweet {
 
	TweetNode(Node underlyingNode) {
		super(underlyingNode);
	}
 
	//Methods for doing Tweet-stuff
 
}
 

 
public class UserNode extends NodeDelegate implements User{
 
	UserNode(Node underlyingNode) {
		super(underlyingNode);
	}
 
	//Methods for doing User-stuff
 
	public Tweet createTweet(String kvitt) {
		//Here comes a problem! I need a new Node
		//from the NeoService to create the TweetNode
		TweetNode tweetNode = new TweetNode(null);
		tweetNode.setTweet(tweet);
		createRelationshipTo(tweetNode, TwitterRelationships.TWEETED);
		return tweetNode;
	}
}
 

NodeDelegate, extended by both User- and TweetNode implements the Neo4j interface Node and delegates all the method calls to the underlying node ( for more on this, see my previous post) :

 
public class NodeDelegate implements Node {
 
	private Node delegate;
 
	protected NodeDelegate(Node underlyingNode) {
		delegate = underlyingNode;
	}
 
	//Methods for delegating all Node methods to the Node delegate
}
 

As you see I have a problem here. In the first version my NeoService is injected into NeoBasedTweetService and used when I create the new TweetNode. In the re-made, more DDD-style example I create the new TweetNode in the UserNode, where I don't have access to my NeoService. How do we solve this?

One alternative that I instinctively dislike is to inject the NeoService into the UserNode. The reason for me disliking this is that my UserNode IS a Node, and it feels very tangled if a Node holds a reference to its container. But I came to think of another solution thanks to a talk I did a while back together with Henrik Reinhold on what was new in Spring 2.5.

In Spring 2.5 load-time weaving (LTW) capabillites was introduced, and with LTW you can manipulate objects in load-time, as opposed to runtime weaving that is proxy based. This, combine it with @Configurable and @Autowired, proves to be very helpful when the Spring context is not in charge of creating the objects in question, as in the example above...

To enable LTW we add one tag in the Spring configuration:

 
<context:load-time-weaver />
 

After that we have to inform the Spring container of how we want thing done. To do we edit the TweetNode and NodeDelegate like this:

 
//Annotate the class with @Configurable so that Spring can find it.
@Configurable
public class TweetNode extends NodeDelegate implements Tweet {
 
	TweetNode(Node underlyingNode) {
		super(underlyingNode);
	}
 
	//Add a default constructor both in the TweetNode
	//and the NodeDelegate, it is new:able without a Node.
	public TweetNode() {
		super();
	}
 
	//Add a setter for the underlaying Node and annotate it with @Autowired.
	@Autowired
	public void setNode(Node nodeDelegate) {
		super.setNode(nodeDelegate);
	}
 
	//Tweet-methods as before
 
}
 

 
public class NodeDelegate implements Node {
 
	private Node delegate;
 
	protected NodeDelegate(Node underlyingNode) {
		delegate = underlyingNode;
	}
 
	protected NodeDelegate() {
	}
 
	protected void setNode(Node nodeDelegate) {
		if (delegate == null) {
			delegate = nodeDelegate;
		}
	}
 
	//Methods for delegating all Node methods to the Node delegate
 
}
 

Now Spring only has to be able to create Nodes. To do that we create a simple NodeFactory, like this:

 
public class NodeFactory implements FactoryBean{
 
	private NeoService neo = null;
 
	public void setNeo(NeoService neo) {
		this.neo = neo;
	}
 
	@Transactional
	public Object getObject() throws Exception {
		return neo.createNode();
	}
 
	public Class getObjectType() {
		return Node.class;
	}
 
	public boolean isSingleton() {
		return false;
	}
 
}
 

... and add it to the configuration, like this:

 
	<bean id="node" class="com.jayway.neo.utils.NodeFactory">
<property name="neo" ref="neo" />
	</bean>
 

The result of this is that Spring now has a NodeFactory that returns a new node for every request, I have annotated the TweetNode so that Spring knows of it (@Configurable) and what to do with it (@Autowired on setNode) and I've enabled load-time weaving in order to get the a new Node woven into a TweetNode every time a new instance of it is created in the code.

In UserNode I really don't have to make any changes. "setNode(Node)" will get a new Node after the instantiation of a TweetNode, even if the constructor that takes a Node is called. For clarity I still changed the UserNode as follows:

 
public class UserNode extends NodeDelegate implements User{
 
	UserNode(Node underlyingNode) {
		super(underlyingNode);
	}
 
	//Methods for doing User-stuff
 
	public Tweet createTweet(String kvitt) {
		//This TweetNode will get a Node set by Spring
		TweetNode tweetNode = new TweetNode();
		tweetNode.setTweet(tweet);
		createRelationshipTo(tweetNode, TwitterRelationships.TWEETED);
		return tweetNode;
	}
}
 

The problem I had when trying to make the UserNode responsible for creating its TweetNode's was that I needed to inject something that could create Nodes into the UserNodes. By using load-time weaving and instructing Spring of how to wire a TweetNode I don't have to pass my NeoService around to all the UserNodes created in my code. Instead I can rely on Spring to inject what is needed, when it's needed.