Creating user events on certain actions. What is recommended solution?

This question regards how one can effectively create and persist event domain objects on certain system or user triggered events which themselves may or may not persist changes to the database.

Im creating a system where a user can tag some object, and when tagging occurs i should create a UserTagEvent which holds the object that was tagged, the tag that was applied or removed, and the user that tagged the object. (EDIT: This is not the actual TAG object, just a log of a tagging event)

The relationship of such a taggable object is one-to-many (a taggable object has many tags)

As far as i can see i have three alternatives.

1. Inline code in the controller/service which does the tagging (don't wanna do this as it mixes two different business processes.)
2. Use hibernate listeners pre-collection-update and post-collection-update to fetch the necessary information and create and persist a new UserTagEvent
3. Use AOP.

Do i have any other alternatives? Has anyone done something similar to this? Wha开发者_如何学Ct do you guys think i should do? Any help is appreciated.

It is not 100% clear if the UserTagEvent represents the actual tag or if it just acts as a log for a tag event.

Use hibernate listeners pre-collection-update and post-collection-update to fetch the necessary information and create and persist a new UserTagEvent

If the UserTagEvent is your tag the hibernate listeners would not make much sense because they would only get fired when you create a UserTagEvent and add it to the object by yourself and then you won nothing.

Inline code in the controller/service which does the tagging (don't wanna do this as it mixes two different business processes.)

I would start by creating a TagService that is responsible for tagging/tag-logging. You could use it either from a controller or by using it from aop but you should encapsule the functionality like: tagService.createTag(tag, object, user)

This could be handy especially when you later want to use a different technology to store the events like some nosql solution.

The following is what i learned when exploring my options:

1) Inline code in the controller/service which does the tagging (don't wanna do this as it mixes two different business processes.)

Didnt give this alternative a try

2) Use hibernate listeners pre-collection-update and post-collection-update to fetch the necessary information and create and persist a new UserTagEvent

This turned out to be very difficult, inefficient, and problematic for several reasons.

For example, you are working with a collection of items which may or may not be lazy initialized. In order to detect changes in the collection i had to listen for collection initialization event, get a cloned collection, store it to a field variable, then listen for a update collection event, get a cloned collection and compare with the collection previously stored.

In addition these events got fired for ALL hibernate events, not just for the domain objects i was interested in. So this was a "no go"...

3) Use AOP.

I was originally very optimistic about this solution, and after a few tries i soon came to realize that this wasn't as simple as i first thought. There were very few guides on the web describing Grails AND AOP, and those existed were rather old.

There was a lot more work involved than i originally thought. My overall impression is that grails seems to have a lot of bugs assosciated with AOP integration, and i also didn't like the fact that i had to add bean definitions to resources.groovy for each aspect that i created. I tried to make aspects be autoloaded through annotations (auto-proxy), but with no luck.

In addition i never got the pointcut to work outside the main project. As my tagging solution is defined as a grails plugin it seems that AOP can't be applied on classes of the plugin (even if it is a inplace plugin).

So this turned out to be a "no go" aswell

So drum roll please.

What i ended up with was using the observer pattern to fire off an event whenever a new tag was added or removed. This involved making changes to my tagger plugin where i could specify listeners through spring beans (whicn implemented a TagEventListener interface) and have the tagger plugin fire off events on the spring beans upon the addTag and removeTag method calls.

Overall im pretty happy with this solution, it involves one or two more method calls then what would be necessary if i had just inlined as described in option 1. But this way I have cleaner code, and i don't mix business processes. So i think the extra 1ns overhead is worth it.