I have a singleton bean definition like this:
<bean id="exampleBean" class="com.examples.ExampleBean">
<property name="exampleBean2">
<bean class="com.examples.ExampleBean2" />
</property>
</bean>
where ExampleBean could be:
public class ExampleBean {
private ExampleBean2 exampleBean2;
public ExampleBean() { }
public ExampleBean2 getExampleBean2() { return exampleBean2; }
public void setExampleBean2(ExampleBean2 exampleBean2) { this.exampleBean2 = exampleBean2; }
}
The problem is that, in certain conditions, the com.examples.ExampleBean2 class might not exist at runtime witch will cause an error when the IoC tries to instantiate exampleBean.
What I need is to ignore this error from IoC and allow the exampleBean to be created but leaving the exampleBean2 property null.
So the question is: is this possible in any way?
Thanks for all your help.
If you use autowire, what you wish to achieve is possible.
<bean class="com.examples.ExampleBean" autowire="byType" />
<bean class="com.examples.ExampleBean2" />
Or via annotations
#Autowired(required=false)
ExampleBean2 exampleBean2;
Is it an option to declare an init-method on your ExampleBean, and in this init-method check if the class ExampleBean2 exists, and if so setting it?
<bean id="exampleBean" class="com.examples.ExampleBean" init-method="init"/>
Maybe a better way of doing things here would be to use some form of the NullPattern, where you always provide an implementation of ExampleBean2, even if it only is its 'null' value.
If I got it right ExampleBean2 isn't loaded when Spring tries to instantiate the beans. Is this correct? In that case I don't thing you could do much with Spring's built in capabilities.
Perhaps you could create a container class that will always be present. This class will check if ExampleBean2 is loaded and if yes, it will instantiate an instance of it. The container class will have an Object property that could either be null or the instance of the ExampleBean2.
maybe lazy-init will do it, but i think spring will at least check if the bean implementation class is available at creation of the application context
Perhaps this will work:
public class NullFactoryBean implements FactoryBean {
#Override
public Object getObject() throws Exception {
return null;
}
#Override
public Class<?> getObjectType() {
return Object.class;
}
#Override
public boolean isSingleton() {
return false;
}
}
And then...
public class ClassNotFoundPostProcessor implements BeanFactoryPostProcessor {
#Override
public void postProcessBeanFactory(ConfigurableListableBeanFactory beanFactory) throws BeansException {
String[] beanDefinitionNames = beanFactory.getBeanDefinitionNames();
for (String beanDefinitionName : beanDefinitionNames) {
BeanDefinition beanDefinition = beanFactory.getBeanDefinition(beanDefinitionName);
String beanClassName = beanDefinition.getBeanClassName();
try {
Class.forName(beanClassName);
} catch (ClassNotFoundException e) {
beanDefinition.setBeanClassName(NullFactoryBean.class.getName());
}
}
}
}
And then...
<beans>
<bean id="exampleBean" class="com.examples.ExampleBean">
<property name="exampleBean2">
<bean class="com.examples.ExampleBean2" />
</property>
</bean>
<bean class="ClassNotFoundPostProcessor" />
</beans>
EDIT: Sorry about that, it appears that this did not catch the inner beans. I missed this detail when I tested it. It only catches top-level beans. By the way, com.examples.ExampleBean probably won't load anyway because it itself depends directly upon the ExampleBean2 class, which the virtual machine won't find, causing an Error
Related
I have a work class :
public class WorkClass implements ApplicationContextAware {
... // has access to ApplicationContext
}
Have some useful interface :
public interface UsefulInterface {
void doUseful();
}
Have some impl class that can do much more:
public class CanDoAlmostEverything implements UsefulInterface {
...
}
I want to provide UsefulInterface implementation (via CanDoAlmostEverything) to WorkClass using Spring, but NOT to access any other CanDoAlmostEverything methods exept "doUseful"
In other words I want to declare my bean[s] like :
<bean id="workerA" interface="UsefulInterface" class="CanDoAlmostEverything"/>
<bean id="workerB" interface="UsefulInterface" class="AnotherUsefulImpl"/>
WorkClass will know about interface impl only during runtime and code must look like:
String todayWorker = getWorkerNameFromDataBase();
UsefulInterface worker = appCtx.getBean(todayWorker, UsefulInterface.class);
worker.doUseful();
Is it possible? And how it must look like?
I don't recommend you to use getBean this way. In the Spring documentation, it is written that it could be bad for performance.
http://docs.spring.io/spring/docs/1.0.2/api/org/springframework/beans/factory/BeanFactory.html#getBean%28java.lang.String%29
Return an instance (possibly shared or independent) of the given bean
name. Provides a measure of type safety by throwing an exception if
the bean is not of the required type.
Note that callers should retain references to returned objects. There
is no guarantee that this method will be implemented to be efficient.
For example, it may be synchronized, or may need to run an RDBMS
query.
Will ask the parent factory if the bean cannot be found in this
factory instance.
It really depends of what do you want to do. Did you tought that you Workclass could be a bean ?
public class WorkClass implements ApplicationContextAware {
private UsefulInterface workerA;
private UsefulInterface workerB;
public void setWorkerA(UsefulInterface workerA) {
this.workerA = workerA;
}
public void setWorkerB(UsefulInterface workerB) {
this.workerB = workerB;
}
public void work() {
UsefulInterface workerToUse;
if(condition) {
workerToUse = workerA;
} else {
workerToUse = workerB;
}
// treatment
}
}
Here the configuration file :
<bean id="workerA" interface="UsefulInterface" class="CanDoAlmostEverything"/>
<bean id="workerB" interface="UsefulInterface" class="AnotherUsefulImpl"/>
<bean id="mainWorker" class="package.of.WorkClass">
<property name="workerA" ref="workerA" />
<property name="workerB" ref="workerB" />
</bean>
Your main class will have to call getBean, but only one time to get the instance of WorkClass.
Is it a good practice to have objects specific to some implementation as member variables in a factory class ?
For e.g., in the code below, s1 and s2 are required for constructing OneChannel and secondChannel objects respectively. Is it a good practice to declare these as member variables inside the factory ? If not, what can e the other alternative.
public class CommunicationChannelFactoryImpl {
#Autowired
SomeClass s1;
#Autowired
SomeOtherClass s2;
public CommunicationChannel getCommunicationChannel(String channel, Map<String, String> channelProperties) {
if(channel.equals("ONE") {
return new OneChannel(s1);
}
if(channel.equals("TWO") {
return new SecondChannel(s2);
}
}
}
Please note that s1 ad s2 are singleton beans
Since you need those beans for constructing those particular channel implementations, I think you can keep them as properties in that particular factory implementation. You are injecting the required components, so you have the flexibility to change the implementations later if you need.
Also, it will be better if SomeClass and SomeOtherClass are some abstractions/interfaces/super type. In this way if you ever need to provide different implementations for building those channel objects in the future, you'll be able to do so pretty easily.
Why don't let Spring create OneChannel() and SecondChannel() object using BeanFactoryAware?
public class CommunicationChannelFactoryImpl implements BeanFactoryAware {
FactoryBean factoryBean;
public void setBeanFactory(FactoryBean factoryBean) {
this.factoryBean = factoryBean;
}
public CommunicationChannel getCommunicationChannel(String channel, Map<String, String> channelProperties) {
if(channel.equals("ONE") {
return this.factoryBean.getBean("oneChannel");
}
if(channel.equals("TWO") {
return this.factoryBean.getBean("secondChannel");
}
}
}
and define your XML (or JavaConfig, but I'm not using it) as:
<bean id="oneChannel" scope="prototype">
<constructor-arg index="0" ref="s1" />
</bean>
<bean id="secondChannel" scope="prototype">
<constructor-arg index="0" ref="s2" />
</bean>
<bean id="s1" class="path.to.SomeClass" />
<bean id="s2" class="path.to.SomeOtherClass" />
I am having one method and it contains some business logic like , creating the protocols using some domain specific servers and so.I need to run the method once when my application starts.
How can I achieve my below requirement ?
This is what I have already did. I created the bean for a business class and also for controller in applicationContext.xml and inject the business class bean in the controller .
My applicationContext.xml will be,
<bean id="configInfo" class="com.pointel.Agent_Chat.ServerInfo.ConfigServerInfo">
<property name="configurationServer_name" value="${CS_NAME}"></property>
<property name="configurationServer_host" value="${CS_IPADDRESS}"></property>
</bean>
<bean id="config_con" class="com.pointel.Agent_Chat.ServerConnection.ConfigServerConnection" >
<property name="info" ref="configInfo"></property>
</bean>
<bean id="init_Server" class="com.pointel.Agent_Chat.Initialiser.Initialize_Servers">
<property name="connection" ref="config_con"></property>
</bean>
<bean id="initCon" class="com.pointel.Agent_Chat.controllers.InitServerController">
<property name="init_Server" ref="init_Server"></property>
</bean>
My Controller will be,
#Controller
public class InitServerController {
public static int count = 0;
private Initialize_Servers init_Server;
public InitServerController(){
count++;
System.out.println("Init Controller "+count+" time");
}
public void setInit_Server(Initialize_Servers init_Server) {
this.init_Server = init_Server;
initializeServers();
}
private void initializeServers() {
ServerStatus.config_status = init_Server.initialize_Config_Server();
System.out.println("config_status : "+ServerStatus.config_status);
}
}
My Business class will be ,
public class Initialize_Servers {
private ConfigServerConnection connection;
private InteractionServerConnection interConnection;
private UCSConnection ucsConnection;
public Initialize_Servers(){
System.out.println("Initialize_Servers class instance was created !");
}
public ConfigServerConnection getConnection() {
return connection;
}
public void setConnection(ConfigServerConnection connection) {
this.connection = connection;
}
public boolean initialize_Config_Server(){
try{
ConfServerProtocol protocol = connection.getConnection();
if(protocol != null){
System.out.println("Config server Protocol is not null");
return true;
}
}catch(Exception e){
return false;
}
}
}
Is this the right way ? or any other perfect way to do this ?
Good answers are definitely appreciated.
You can set the bean in the xml file to have an init method using the init-method attribute on the bean XML element, like so:
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
<bean id="myBean" class="com.myjunk.MyBean"
init-method="myInit" >
</bean>
</beans>
This would call the myInit() method on MyBean after the bean was initialized. This happens after the properties were wired together. If you are using Annotations to wire stuff, there are annotations you can use as well, but I don't know them off the top of my head. The method must take no parameters.
The other option is to implement ApplicationContextAware, which provides hooks into getting the application context during the wiring process. Again, this happens after the properties are set on the object.
private final ExecutorService executorParsers = Executors.newFixedThreadPool(10);
public void parse(List<MyObjInt> objs) {
//... bunch of elided stuff ....
CompletionService<AsupParseObj> parserService = new ExecutorCompletionService<AsupParseObj>(executorParsers);
for (final AsupStoreObj obj : objs) {
parserService.submit(new ParseThread(obj));
}
}
I would like to DI the "ParseThread" but surely there has to be a better way to do this than burying a call to getBean on a prototype scoped bean and as I am new to Spring I figured I would ask...
Here is the full configuration using lookup-method (see 3.4.6.1 Lookup method injection):
<bean id="executorParsers" class="java.util.concurrent.Executors"
factory-method="newFixedThreadPool"
destroy-method="shutdownNow">
<constructor-arg value="10"/>
</bean>
<bean id="parserService" class="java.util.concurrent.CompletionService">
<constructor-arg ref="executorParsers"/>
</bean>
<bean id="foo" class="Foo">
<lookup-method name="createThread" bean="parseThread"/>
</bean>
<bean id="parseThread" class="ParseThread" scope="prototype" lazy-init="true"/>
And the Java code:
abstract class Foo {
#Autowired
CompletionService parserService;
protected abstract ParseThread createThread();
public void parse(List<MyObjInt> objs) {
for (final AsupStoreObj obj : objs) {
ParseThread t = createThread();
t.setObject(obj);
parserService.submit(t);
}
}
}
Unfortunately you cannot pass any parameters to lookup-method (see SPR-7431 and my article Creating prototype Spring beans on demand using lookup-method), hence the need for artificial setObject().
If you don't like abstract methods/classes, lookup method can be non-abstract no-op method or (better) the default implementation can throw an exception. Spring will override the implementation at runtime, effectively calling getBean() for you.
Bonus: I translated Executor/CompletionService to Spring managed beans as well. Note that Spring supports these out-of-the-box: Task Execution and Scheduling.
Well, I am not sure what you think Spring is going to buy you here, but I would inject a factory of some sort that spits out Runnable/Callable's.
private final ExecutorService executorParsers = Executors.newFixedThreadPool(10);
#Autowired
private CallableFactory myCallableFactory = new MyCallableFactory(); //create this factory
public void parse(List<MyObjInt> objs) {
//... bunch of elided stuff ....
CompletionService<AsupParseObj> parserService = new ExecutorCompletionService<AsupParseObj>(executorParsers);
for (final AsupStoreObj obj : objs) {
parserService.submit(myCallableFactory.createCallable(obj));
}
}
You could also inject the ExecutorService with Spring too.
I have a scenario where I need to inject values to the Arraylist in a class that does not have the setter I believe in this scenario I need to do a get on the list in the POC class and then do a add:
public class POC {
private ArrayList<String> beheaviour=new ArrayList<String>();
public ArrayList<String> getBeheaviour() {
return beheaviour;
}
}
Here is the xml mapping code :
<bean id="poc" class="outBoundocument.factory.POC">
<property name="beheaviour">
<list>
<value>temp1</value>
<value>temp2</value>
<value>temp3</value>
<value>temp4</value>
<value>temp5</value>
</list>
</property>
</bean>
the following code returns :
Error setting property values; nested exception is org.springframework.beans.NotWritablePropertyException: Invalid property 'beheaviour' of bean class [outBoundocument.factory.POC]: Bean property 'beheaviour' is not writable or has an invalid setter method. Does the parameter type of the setter match the return type of the getter?
I have no control over the POC class as its a external vendor provided class and I cant do a constructor injection to it as the only way to add values to it is in the following way :
POC poc=new POC();
poc.getBeheaviour().add("some Stuff")
You could write a custom FactoryBean which adds the items.
Something like this in Java:
public class POCFactoryBean implements FactoryBean<POC> {
private POC poc = new POC();
public void setBeheavior(List<String> items) {
poc.getBehavior().addAll(items);
}
public POC getObject() {
return poc;
}
public Class<?> getObjectType() {
POC.class;
}
public boolean isSingleton() {
return true;
}
}
Corresponding XML:
<bean id="poc" class="some.package.POCFactoryBean">
<property name="beheaviour">
<list>
<value>temp1</value>
<value>temp2</value>
<value>temp3</value>
<value>temp4</value>
<value>temp5</value>
</list>
</property>
</bean>
As far as I know, Spring will not be able to help you here (if you do not have access to the code). Spring only allows you to work with closed-source classes as beans if you define it in XML, which in turn makes it impossible to do attribute injection.
If you are not tied to Spring, you can do what you need with Java Reflection.
UPDATE
Apologies, it seems you can autowire via XML. Have a look here.