2

In my main() method I create a PersonCollection Object using Spring and then I start to load different Persons objects.

BeanFactory appContext = new ClassPathXmlApplicationContext("cp-beans.xml");
PersonCollection pc = appContext.getBean(PersonCollection.class);
Person aPerson = pc.loadById(1); 
aPerson.doSomething();
aPerson.loadById(1067);
aPerson.doSomething();

In turn PersonCollection.loadById() can load the object from memcached or from Amazon SimpleDB:

public Person loadById(int id) throws ConnectException, NoSuchElementException {
    String memCacheKey = "Person-" + id;
    Person aPerson = (Person) cache.get(memCacheKey);
    if (aPerson != null) {
        return aPerson; //cache hit
    }
    aPerson = loadByIdFromSdb(id); //cache miss, read it from SimpleDB
    cache.set(memCacheKey, aPerson);
    return aPerson;
}

So there are two ways to create a Person, the first is deserializing from memcached, the second will call new Person() and assign all data.

Person has two @Autowired properties and is declared as a @Service and the package is in context:component-scan, however the dependencies are not passed, because the bean is created with new or from the cache and not with the Spring framework.

I could use appContext.getBean() to create the Person Object, however, it would mean to pass around the applicationContext and use getBean() inside the application, which doesn't feel right.

How to solve the problem?

UPDATE: I read the documentation and tried the suggestion of Ryan Stewart and wrote a small example project to try it. It works great, thank you!

https://github.com/stivlo/spring-di

Ultimately, I've refactored my original project, in a way that I don't need this feature anymore, but is a good tool to have in my arsenal.

Improve this question

2 Answers 2

Reset to default
5
  1. Yes, avoid ApplicationContext.getBean() in your (non-infrastructure) code like the plague.
  2. Option one: Don't autowire your POJO-like classes. Pull that out into a "service" object that is tightly coupled to the Person. This is more or less the current mainstream approach, and I hope it goes away because it gets messy.
  3. Option two: Use AspectJ weaving with the @Configurable annotation to make Person autowirable regardless of where it's instantiated. I really like this option, though I haven't used it in a production project yet.
Improve this answer
Sign up to request clarification or add additional context in comments.

7 Comments

Thank you, option two looks very promising: looking into it.
+1 Never stumbled upon option two, it sounds very promising indeed.
Today I had a use case that benefited from @Configurable weaving. I've followed my own source code example, but despite many tests and frustration it wasn't working until I've added <context:load-time-weaver aspectj-weaving="autodetect"/> -- It's weird because I don't have this tag in my test project, and it works anyway.
@stivlo: Did you perhaps use build-time weaving in your test project instead of load-time weaving?
ah I think it would make sense, in that case. However, I set up the project with Roo, so I am not sure, I've looked at applicationContext.xml, but I don't see anything. Maybe you can look? Is a very small project just to test this weaving. github.com/stivlo/spring-di
|
1

You may also want to look into a little oddball utility class called ObjectFactoryCreatingFactoryBean, which is a way of "reusing" the capabilities of the BeanFactory without unduly contaminating your business code with worrying about bean names.

<beans>
   <bean id="PersonCollection " class="com.example.PersonCollection">
       <property name="personMaker" ref="PersonMaker"/>
   </bean>

   <bean id="personPrototype" class="com.example.Person" scope="prototype">
       <!-- Things to inject onto a newly-made person -->
   </bean>

   <bean id="PersonMaker" class="org.springframework.beans.factory.config.ObjectFactoryCreatingFactoryBean">
     <property name="targetBeanName"><idref local="personPrototype"/></property>
   </bean>
</beans>

In this way, your PersonCollection instance doesn't need to know any bean names, but can get a fresh Person (with the specified dependencies injected) via:

Person p = (Person) this.personMaker.getObject();

IMO there are some ways it could be made much more convenient (such as working with an inner bean rather than idref) but that would require some Spring-guru and a custom XML namespace.

Improve this answer

4 Comments

That still has Person objects being instantiated by Spring. The problem here is how to inject instances that are managed by code outside of your control. The prime example is Hibernate.
I think in that case you can change the definition of the PersonPrototype bean to use factory-bean and factory-method... That way it pulls the result from the external source (e.g. Hibernate) but can still apply XML-configured setter-injection onto the object before the object gets used by the rest of the components.
Hibernate doesn't create the objects and hand them off to you like that. They're constructed internally in response to a query or load request. And other frameworks in general aren't always friendly enough to expose a convenient way for you to get your own instances into or out of them. While you could always, theoretically, hack and slash your way in with reflection, that's really just not a viable solution. Sometimes pure Java just doesn't cut it.
Nonetheless this is also another interesting addition to my Spring skills, thanks!

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.