Spring managed components interoperability with JPA/JAXB or others
As Spring is a de-facto standard in creating JEE application, one problem faced commonly is interoperability between Spring managed beans and objects created by other runtimes like JPA or JAXB. As most of the application is using JPA or JAXB we will look into ways to use Spring beans in other objects and injecting other objects in Spring beans. In This article I will refer objects created by other runtime like JAXB or JPA as external object and the classes as external class.
Configuring bean programmatically in Java class:
For configuring beans programmatically Spring provided their <beans> and <bean> equivalent in Java.
packageinterop.config.test;
importorg.springframework.beans.factory.annotation.Value;
importorg.springframework.context.annotation.Bean;
importorg.springframework.context.annotation.Configuration;
@Configuration
publicclassConfigurationClass {
class SampleBean{
}
@Bean(name="sample")
SampleBean getBean(@Value("#{systemProperties['user.dir']}")String param, ServiceClass service){
return new SampleBean();
}
}
1. Annotate the class with @Configuration
2. Annotate method for creating beans with @Bean
Spring will execute this method and register the returned object as bean with name as method name.
Parameters passed into these creator methods are of type any Spring bean or annotated as @Value. If this method requires other objects, then call other bean methods and those returned beans will be available to it.
@Configuration is equivalent to XML configuration and @Bean is equivalent to <bean/> and has all configuration options like Scope, Name etc are available.
Other useful annotations:
@ImportResource – Allows us to import a spring xml file or other @Configuration class for importing beans and resource like XML configuration.
@Value – Use SpEL expressions to inject properties or other bean attributes.
This class must be under component scan.
For more details:
Injecting Spring components (beans) into external classes (instantiated using new operator):
This is useful in using Spring components/services in external classes instantiated using new operator. Spring intercepts the autowired beans in the Configurable class and new calls for the class. There are several strategies for weaving those classes like weaving at compile or load time. Look resource #1.
This can be done using @Configurable class.
This needs following jars:
cglib-2.2.2.jar
asm-all-3.3.1.jar
aspectjrt-1.6.9.jar
aspectjweaver-1.6.9.jar
org.springframework.aspects-<VERSION>.jar
org.springframework.instrument-<VERSION>.jar
Add following in applicatioContext.xml
<context:spring-configured />
<context:load-time-weaver />
Run application with VM argument:
-javaagent:lib/org.springframework.instrument-<VERSION>.jar
Sample Code:
@Configurable class:
packageinterop.config.test;
importinterop.config.test.ConfigurationClass.SampleBean;
importorg.springframework.beans.factory.annotation.Autowired;
importorg.springframework.beans.factory.annotation.Configurable;
@Configurable
publicclassConfigurableClass {
@Autowired
SampleBean sampleBean;
public SampleBean getSampleBean() {
return sampleBean;
}
}
applicationContext.xml
<?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"
xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd">
<context:component-scan base-package="interop.config.test" />
<context:spring-configured />
<context:load-time-weaver />
</beans>
@Configuration class to create the autowired bean is the class described in previous topic.
Issues with @Configurable
Resources:
Injecting external objects in Spring context to use them in Spring components:
Adding objects to application context [singletons]:
Singletons can be added the way described in resources listed #1 and dynamic bean definitions can be added as listed in Resources #2.
Sample code for registering singleton in ApplicationContext:
public class ConfigTest {
public static void main(String[] args) {
ConfigurableApplicationContext context = new ClassPathXmlApplicationContext("/applicationContext.xml");
//registering singleton
context.stop();
ConfigurableListableBeanFactory factory = context.getBeanFactory();
factory.registerSingleton("auto", new Auto("fgfdg", "fgfd"));
context.start();
System.out.println(Arrays.asList(context.getBean("auto")));
}
static class Auto{
String a;
String b;
public Auto(String a, String b) {
this.a=a;
this.b=b;
}
}
}
Now how to register beans in ptototype scope dynamically?
Use Case:
- Application is receiving data from external API (REST or Web Services) in XML format.
- JAXB populates object graph from XML.
- Application has @Service (s) which needs this object graph populated by JAXB. For example, populating data transfer object (DTO) by using SpEL (@Value annotated fields) or the @Service consuming this object graph by any other purpose.
How to make this object graph available to those services (Spring components)?
First of all such Service need to of scope prototype as it depends on data retrieved from external sources (will be different every time, so objects state depends on this data. This object is stateful). A Service can be singleton which is using that data only in a method and by this object graph as argument, but in scenario like populating DTO using SpEL where fields of class is annotated with @Value(<expression>). We will look into prototype scoped bean.
Scope is not necessarily be prototype, can be changed according to requirements.
We need following things:
- A Spring component bean in which we will store our object. This component will be singleton and will be in application context already. This will be annotated with @Component and will have fields for holding data.
packageinterop.config.test;
importjava.util.Map;
importjava.util.TreeMap;
importorg.springframework.stereotype.Component;
@Component
publicclassExternalObjectContainer {
publicMap<String, Object> container= newTreeMap<String, Object>();
publicvoidaddObject(String key, Object value){
container.put(key, value);
}
publicObject getObject(String key){
return container.get(key);
}
}
In this class currently there is only one field of type Map for holding data. This field can be of Object type or some specific JAXB root class type. Also, for concurrent access or storing more objects, data structure and storage methods can be changed as per requirement.
External class:
packageinterop.external;
publicclass Root {
publicCustomer customer;
publicOrder order;
publicObject object;
publicclass Customer{
publicString name;
publicCustomer(String name) {
this.name=name;
}
}
publicclass Order{
publicint quantity;
publicOrder(intquantity) {
this.quantity=quantity;
}
}
}
- The requester of the external API will set the object graph, populated from response received to the singleton component, created in previous step. This needs reference to the component. This reference can be acquired by autowiring the bean to this requester. If this requester is not a spring component then make this @Configurable.
packageinterop.config.test;
importinterop.external.Root;
importorg.springframework.beans.factory.annotation.Autowired;
importorg.springframework.context.ApplicationContext;
importorg.springframework.stereotype.Service;
@Service
publicclassServiceClass {
@Autowired
ExternalObjectContainer container;
@Autowired
ApplicationContext context;
public void service(){
/*
* In real this object will be created by data received from external sources, e.g.
* ReST API response XML converted to object model by JAXB.
*/
Root root = newRoot();
root.customer=root.new Customer("customeR");
root.order=root.new Order(9);
//the container we created has Map to store objects, so put any random key.
//this depends on storage model.
container.addObject("randomKey", root);
/*
* request the consumer of this data, prototype scoped bean from application context.
* This will create new object with all mapped fields populated from external object.
* Cannot autowire because this will instantiate on creation of this service class and will
* not have data or may even fail to inject required dependency.
*/
ExternalObjectConsumerComponent component = (ExternalObjectConsumerComponent) context.getBean("externalObjectConsumerComponent");
//check data populated in the bean
System.out.println(component);
//Doing the same thing with non Spring component, a configurable class.
ExternalObjectConsumerConfigurable configurable = newExternalObjectConsumerConfigurable();
System.out.println(configurable);
}
}
- The @Service class which will populate the DTO from this object graph. This will be a prototype scoped bean as this will have fields annotated with @Value(<SpEL expression>). This is the actual DTO. This bean will be requested only after step #2 is done. Obviously, DTO can be populated only if one have the required data.
One can make this singleton by moving these annotations to other class.
Using this injected external object in Spring component:
packageinterop.config.test;
importorg.springframework.beans.factory.annotation.Value;
importorg.springframework.context.annotation.Scope;
importorg.springframework.stereotype.Service;
@Service
@Scope("prototype")
publicclassExternalObjectConsumerComponent {
@Value("#{externalObjectContainer.container.get('randomKey').customer.name}")
String name;
@Value("#{externalObjectContainer.container.get('randomKey').order.quantity}")
int qty;
@Override
public String toString() {
return super.toString()+"{Name : "+name+", Quantity : "+qty+"}";
}
}
Using this injected external object in external object:
packageinterop.config.test;
importjavax.annotation.PostConstruct;
importinterop.external.Root;
importorg.springframework.beans.factory.annotation.Autowired;
importorg.springframework.beans.factory.annotation.Configurable;
/**
*This example is for using external object injected in Spring component in a non Spring/external object.
*
*This will be useful in using external object in external object but in flow there is Spring services in between.
*/
@Configurable
publicclassExternalObjectConsumerConfigurable {
@Autowired
ExternalObjectContainer container;
String name;
int qty;
/*
* Rather than using SpEL the data can be accessed directly from the bean.
* Put this initialization logic in in method annotated with PostConstruct to populate data
* just after initializing object. This is just an alternative for SpEL and nothing to do with
* it is Spring component or not.
*/
@PostConstruct
public void mapProperties(){
Root root = (Root) container.getObject("randomKey");
name=root.customer.name;
qty=root.order.quantity;
}
@Override
public String toString() {
return super.toString()+"{Name : "+name+", Quantity : "+qty+"}";
}
}
Resources:
Testing all this:
importinterop.config.test.ConfigurableClass;
importinterop.config.test.ServiceClass;
importorg.springframework.context.ApplicationContext;
importorg.springframework.context.support.ClassPathXmlApplicationContext;
publicclass Main {
public static void main(String[] args) {
ApplicationContext context = newClassPathXmlApplicationContext("/applicationContext.xml");
System.out.println("\n\n\n");
//check sample bean is configured through @Configuration class
System.out.println(context.getBean("sample"));
System.out.println("\n\n\n");
//check Spring components injected in external objects through @Configurable class
ConfigurableClass configurable = newConfigurableClass();
System.out.println("\n\n\n");
System.out.println(configurable.getSampleBean());
System.out.println("\n\n\n");
//Test injecting external objects into Spring components
ServiceClass service = (ServiceClass)context.getBean("serviceClass");
service.service();
System.out.println("\n\n\n");
}
}
Running this with java agent:
In Eclipse configure Run Configuration like this:
Project overview:
Injecting prototype scoped bean into Singleton bean such that every time singleton bean is requested it will have new instance of prototype scoped bean.
It can be achieved using proxy scoped bean. In @Scope annotation parameter set proxyMode parameter. For details look.
Alternatively, method injection can be used.
Get project codeand add Spring framework libraries as in eclipse projects classpath.
