CODEWITHSUNDEEP
springoop
Brandon Yarbrough
Brandon Yarbrough

Reputation: 38399

Spring and the anemic domain model

So, I've noticed that I definitely have a tendency to pattern my Spring/Hibernate stack objects like this:

The problem here is that the Foos don't have any real logic. For example, if an email needs to be sent every time a Foo expires, there's not a call to Foo.expire(). There's a call to FooService.expireFoo(fooId). This is for a variety of reasons:

So for these sorts of reasons, my Spring domain objects tend to be basically glorified structs with some validation logic. Maybe this is okay. Maybe web services are okay as procedural code. Maybe as new features get written, it's acceptable to create new services that deal with the same old objects in new ways.

But I'd like to escape from this sort of design, and I'm wondering what other Spring uses do about it? Do you combat it with fancy tricks like load-time weaving (which I'm not that comfortable with)? Do you have some other trick? Do you think procedural is fine?

Upvotes: 72

Views: 6693

Answers (4)

ptomli
ptomli

Reputation: 11818

You can get Spring to inject your services into your Hibernate instantiated instances, using AOP. You can also get Hibernate to do the same, using Interceptors.

See https://web.archive.org/web/20131209103730/http://www.jblewitt.com/blog/?p=129

Regarding "It's annoying to get a Foo to do several somethings transactionally", I would expect your service implementations would know/care about the transactions, and if you're now using the service interfaces within your domain model, that should now be not quite so annoying.

I suspect that deciding when a domain model should be saved is dependent upon what it is and what you're doing with it.

FWIW I have a tendency to produce just the same sort of anemic structures, but I'm getting there, now I know it's possible to do it a more sensible way.

Upvotes: 12

Elom Atsou Agboka
Elom Atsou Agboka

Reputation: 93

I recommend you the book Use Case Driven Object Modeling with UML by Doug Rosenberg and Matt Stephens. It talks about the ICONIX process a software development methodology that also talks about anemic domain model. It's also a topic developed by Martin Fowler in it's web site https://www.martinfowler.com/bliki/AnemicDomainModel.html . But how do we achieve when using Spring Framework and/or Spring Boot is what I'm also try to figure out.

Upvotes: 0

Sled
Sled

Reputation: 18979

I think that there is a simple refactoring pattern that will solve your problem.

  1. Inject your service into your repository.
  2. Before returning your Foo set its' FooService
  3. Now have your your FooController ask for the appropriate Foo from the FooRepository
  4. Now call the methods you want on you Foo. If it cannot implement them itself, have it call the appropriate method on the FooService.
  5. Now remove all the calls to the FooService through what I like to call "bucket bridge" methods on Foo (it just passes the parameters along to the service).
  6. From now on, whenever you want to add a method add it to Foo.
  7. Only add stuff to the service when you really need to for performance reasons. As always, these methods should be called through the model object.

This will help evolve you towards a richer domain model. It also preserves the Single Responsibility Principle since all your DB-dependent code remains in the FooService implmentations and helps you migrate the business logic from FooService to Foo. In you want to switch your back-end to another DB or in-memory or mock (for testing) you don't need to change anything but the FooService layer.

^ I am presuming that FooService does DB calls that would be too slow to do from an ORM like selecting the most recent Foo that shares property X with a given Foo. That is how most I've seen work.

Example

Instead of: 

class Controller{
    public Response getBestStudentForSchool( Request req ){
        Student bestStudent = StudentService.findBestPupilForSchool( req.getParam( "schlId" ).asInt() );
        ...
    }
}

You'll move towards something like this:

class Controller{
    public Response getBestStudentForSchool( Request req ){
        School school = repo.get( School.class, req.getParam( "schlId" ).asInt() ); 
        Student bestStudent = school.getBestStudent();
        ...
    }
}

Which I will hope you will agree already seems richer. Now you are making another database call, but if you keep the School cached in session the penalty is neglible. I'm afraid that any truly OOP model will be less efficient than the anemic model you are using, but the reduction of bugs through code clarity should be worth it. As always, YMMV.

Upvotes: 6

Kevin Swiber
Kevin Swiber

Reputation: 1556

It sounds like your application is designed around procedural coding principles. This alone will hinder any object-oriented programming you're trying to do.

It's possible that a Foo has no behavior it controls. It's also acceptable to not use a Domain Model pattern if your business logic is minimal. A Transaction Script pattern sometimes just makes sense.

The problem comes in when that logic starts growing. Refactoring a Transaction Script into a Domain Model isn't the easiest thing, but it's certainly not the most difficult. If you have tons of logic surrounding Foo, I'd recommend moving to the Domain Model pattern. The encapsulation benefits make it very easy to understand what's going on and who is involved with what.

If you want to have Foo.Expire(), create an event in your Foo class such as OnExpiration. Wire up your foo.OnExpiration += FooService.ExpireFoo(foo.Id) on object creation, possibly through a factory used by the FooRepository.

Really think about first. It's very possible that everything's already in its right place... for now.

Good luck!

Upvotes: 10

Related Questions