Notice: This Wiki is now read only and edits are no longer possible. Please see: https://gitlab.eclipse.org/eclipsefdn/helpdesk/-/wikis/Wiki-shutdown-plan for the plan.
Using Spring with XWT
Contents
- 1 Introduction
- 2 CLR Class
- 3 Overview - Spring support for XWT
- 4 How test Spring support for XWT?
- 5 Using Spring with XWT
- 6 Using Spring with XWT - Spring DI
- 7 Using Spring with XWT - Spring DI - @Inject
- 8 Using Spring with XWT - Default factory
- 9 Using Spring Dynamic Module (OSGi) with XWT
- 10 Using Spring Dynamic Module (OSGi) with XWT - Spring DI
- 11 Using Spring Dynamic Module (OSGi) with XWT - Spring DI - @Inject
- 12 Using OSGi Fragment to configure SpringCLRFactory
- 13 Advanced features
Introduction
Work is underway to integrate XWT with Spring and Spring Dynamic Module to declare with Spring bean, the CLR class used into XWT file with XML Spring file.
See (for the moment) Bug 320405. Attached to this bug are zips containing bundles:
- org.eclipse.e4.xwt.springframework: bundle of Spring support for XWT.
- org.eclipse.e4.xwt.springframework.tests : Tests (Main/JUnit) of Spring support for XWT.
Samples with NO OSGi context :
- org.eclipse.e4.xwt.springframework.sample1 : simple sample which declare CLR as Spring bean.
- org.eclipse.e4.xwt.springframework.sample2 : sample which declare CLR as Spring bean which use Spring DI to use a service.
- org.eclipse.e4.xwt.springframework.sample3 : sample which declare CLR as Spring bean which use Spring DI to use a service with @Inject.
- org.eclipse.e4.xwt.springframework.sample4 : sample which use default CLR factory.
Samples with OSGi context :
- org.eclipse.e4.xwt.springframework.osgi.sample1 : simple sample to declare CLR as Spring bean.
- org.eclipse.e4.xwt.springframework.osgi.sample2 : simple sample to declare CLR as Spring bean which use Spring DI + Spring DM to use a service.
- org.eclipse.e4.xwt.springframework.osgi.sample3 : simple sample to declare CLR as Spring bean which use Spring DI + Spring DM to use a service width @Inject.
- org.eclipse.e4.xwt.springframework.osgi.services : bundle which provides IHelloService interface.
- org.eclipse.e4.xwt.springframework.osgi.services.impl : bundle which publish as OSGi service the HelloService implementation.
- org.eclipse.e4.xwt.springframework.osgi.sample4 : sample which use OSGi fragment to configure SpringCLRFactory.
- org.eclipse.e4.xwt.springframework.osgi.sample4.config.springclrfactory : OSGi fragment which configure SpringCLRFactory.
- org.eclipse.e4.xwt.springframework.config.log4j : OSGi fragment which configure Log4j.
- spring-target-platform : Simple Eclipse project which contains the (Spring) target plaform and (OSGi) launch of the samples.
CLR Class
Before explaining Spring support for XWT, it's interesting to understand how CLR Java class are managed with x:Class and x:ClassFactory.
CLR with x:Class
The Event Handling sample show you how XWT file can be linked to a Java CLR (Common Language Runtime) class to manage for instance event handler of the UI with Java code by using x:Class attribute :
<Shell xmlns="http://www.eclipse.org/xwt/presentation" xmlns:x="http://www.eclipse.org/xwt" x:Class="ui.EventHandler"> <Shell.layout> <GridLayout/> </Shell.layout> <Button text="Click Me!" SelectionEvent="clickButton"> </Button> </Shell>
The declaration x:Class="ui.EventHandler" means that the UI is linked to the Java class ui.EventHandler :
package ui; import org.eclipse.swt.widgets.Event; import org.eclipse.swt.widgets.Button; public class EventHandler { protected void clickButton(Event event) { Button button = (Button )event.widget; button.setText("Hello, world!"); } }
When the button gets selected, the method clickButton is invoked to change the Button text to "Hello, world!":
CLR with x:ClassFactory
You can do the same thing (link a CLR class with XWT) with CLR factory :
<Shell xmlns="http://www.eclipse.org/xwt/presentation" xmlns:x="http://www.eclipse.org/xwt" x:ClassFactory="ui.EventHandlerFactory"> <Shell.layout> <GridLayout/> </Shell.layout> <Button text="Click Me!" SelectionEvent="clickButton"> </Button> </Shell>
The x:ClassFactory="ui.EventHandlerFactory" declaration means that the UI is linked to the Java class which is created by the CLR factory ui.EventHandlerFactory :
package ui; import org.eclipse.e4.xwt.ICLRFactory; public class EventHandlerFactory implements ICLRFactory { public Object createCLR(String args) { return new ui.EventHandler(); } }
This CLR factory implements org.eclipse.e4.xwt.ICLRFactory which returns an instance of ui.EventHandler which is the CLR class described below.
Overview - Spring support for XWT
The bundle org.eclipse.e4.xwt.springframework is the Spring support for XWT which implements org.eclipse.e4.xwt.ICLRFactory to declare CLR Class with bean Spring. It's possible to use this Spring support :
- into a "application" Java context. Please see Using Spring with XWT section for more information.
- into an OSGi context. Please see Using Spring Dynamic Module (OSGi) with XWT section for more information.
Spring support for XWT is very easy to use if you know Spring and Spring DM (for OSGi). Next sections will explain more how configure/use Spring/Spring DM than Spring support for XWT. This support will be explained by using provided samples.
Application Java context
Into application Java context, x:ClassFactory follow this syntax :
x:ClassFactory="<MySpringCLRFactory> bean=<myBean>"
where :
- <MySpringCLRFactory> is the Spring CLR factory which load and use Spring XML file ApplicationContext to create an instance of the CLR bean.
- <myBean> : is the bean ID of the CLR bean declared into the Spring XML file ApplicationContext.
OSGi context
Into application Java context, x:ClassFactory follow this syntax :
x:ClassFactory="org.eclipse.e4.xwt.springframework.SpringCLRFactory.INSTANCE bean=<myBean> bundle=<myBundle>"
where :
- <myBean> is the bean ID of the CLR bean declared into the Spring ApplicationContext.
- <myBundle> is the symbolic name of the bundle which contains the Spring XML file ApplicationContext which declare the CLR bean.
How test Spring support for XWT?
Before explaining Spring support for XWT, please follow the explained steps to try the samples of this Spring support. Samples are using Spring 3.0.3 and Spring DM 1.2 but it was tested too with Spring old version (2.5).
Download Eclipse E4
XWT belongs to Eclipse E4 project. To use XWT, download it.
Get last version of XWT from CVS
Today (09/09/2010) Eclipse E4 doesn't contains the ICLRFactory from XWT. Get org.eclipse.e4.xwt from the CVS :
- Host: dev.eclipse.org
- Repository Path: /cvsroot/eclipse
- Module: e4/org.eclipse.e4.xwt/bundles/org.eclipse.e4.xwt
Import Spring support for XWT projects+samples
Unzip org.eclipse.e4.xwt.springframework.zip and import the whole projects into your workspace. Your workspace should look like this :
Your workspace contains a lot of Compilation error because Spring (and Spring DM) is not included to the Default Target Platform.
Set Spring Target Platform
To resolve compilation problems, open the target platform spring-target-platform/Spring Target Platform.target and click on "Set As Target Platform" :
Your workspace should be recompiled and errors should disappear.
For your information spring-target-platform contains :
- the Spring 3.0.3 and Spring DM 1.2.1 bundles required.
- a maven pom.xml which was used to download thoses bundles.
- spring-target-platform\launch-mvn\Install Spring Target Platform.launch is a m2eclipse launch that you can use to get the Spring JARs. Once you have launched it, refresh the project and spring-target-platform\target\targetPlatform\plugins folder must appears with the JARs downloaded.
- several OSGi launch for each samples.
Using Spring with XWT
org.eclipse.e4.xwt.springframework.sample1 is a basic sample which show you how declare CLR class with bean Spring (no OSGi context) :
Here steps that it was done to create this project:
Add JAR/Dependencies
XWT Dependencies :
- org.eclipse.swt;bundle-version="3.6.0",
- org.eclipse.e4.xwt;bundle-version="0.9.1",
- org.eclipse.e4.xwt.springframework;bundle-version="0.9.1",
- com.ibm.icu;bundle-version="4.2.1"
Spring JAR :
- com.springsource.org.apache.commons.logging-1.1.1.jar
- com.springsource.org.apache.log4j-1.2.16.jar
- org.springframework.asm-3.0.3.RELEASE.jar
- org.springframework.beans-3.0.3.RELEASE.jar
- org.springframework.context-3.0.3.RELEASE.jar
- org.springframework.core-3.0.3.RELEASE.jar
- org.springframework.expression-3.0.3.RELEASE.jar
Here Commons Logging (not SLF4J) was used to configure logs for Spring. But Spring recommend to use SLF4J. Please read Spring Logging section.
Configure Log4j
Create log4j.properties into src folder :
log4j.rootLogger=info, con log4j.appender.con=org.apache.log4j.ConsoleAppender log4j.appender.con.layout=org.apache.log4j.PatternLayout log4j.appender.con.layout.ConversionPattern=%-4r [%t] %-5p %c %x - %m%n
Declare Spring bean CLR
Declare CLR class with bean into XML file Spring. To do that create a XML Spring file ui-context.xml into ui package like this :
<?xml version="1.0" encoding="UTF-8"?> <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-3.0.xsd"> <bean name="myUI" class="ui.EventHandler" scope="prototype"> </bean> </beans>
You will notice that:
- http://www.springframework.org/schema/beans/spring-beans-3.0.xsd is used because the sample is based on Spring 3.0.3.
- scope attribute is filled with prototype value in order to create an instance of EventHandler each time XWT must create the CLR class (when XWT file is opened).
Implements Spring CLRFactory
Spring CLR factory is implemented with ui.MySpringCLRFactory class which extends org.eclipse.e4.xwt.springframework.AbstractSpringCLRFactory. This abstract class require to implement the abstract method :
protected abstract ApplicationContext createApplicationContext(IArguments arguments)
which must returns an instance of Spring ApplicationContext which contains CLR bean declared :
package ui; import org.eclipse.e4.xwt.ICLRFactory; import org.eclipse.e4.xwt.springframework.AbstractSpringCLRFactory; import org.eclipse.e4.xwt.springframework.CLRFactoryParameters; import org.springframework.context.ApplicationContext; import org.springframework.context.support.ClassPathXmlApplicationContext; public class MySpringCLRFactory extends AbstractSpringCLRFactory { public static final ICLRFactory INSTANCE = new MySpringCLRFactory(); @Override protected ApplicationContext createApplicationContext(IArguments arguments) { return new ClassPathXmlApplicationContext("ui/ui-context.xml"); } }
To avoid loading XML Spring file ui-context.xml each time that XWT need to create CLR, MySpringCLRFactory define a singleton (INSTANCE) which it must use into x:ClassFactory.
Set the x:ClassFactory
XWT file ui.xwt stored into ui package declare the Spring CLR factory like this :
<Shell xmlns="http://www.eclipse.org/xwt/presentation" xmlns:x="http://www.eclipse.org/xwt" x:ClassFactory="ui.MySpringCLRFactory.INSTANCE bean=myUI"> <Shell.layout> <GridLayout/> </Shell.layout> <Button text="Click Me!" SelectionEvent="clickButton"> </Button> </Shell>
You can notice that x:ClassFactory is used to define the Spring Factory :
- ui.MySpringCLRFactory.INSTANCE define the CLR Spring factory singleton to use.
- bean=myUI define the bean of the CLR.
Test and run it
Create UI Java Class test which open the ui.xwt file :
package ui; import java.net.URL; import org.eclipse.e4.xwt.IConstants; import org.eclipse.e4.xwt.XWT; public class UI { public static void main(String[] args) { URL url = UI.class.getResource(UI.class.getSimpleName() + IConstants.XWT_EXTENSION_SUFFIX); try { XWT.open(url); } catch (Exception e) { e.printStackTrace(); } } }
Run this Main class, UI opens and if you click on button, it call the bean EventHandler :
Using Spring with XWT - Spring DI
At this step, we have seen how declare CLR Class as bean Spring. It's not very interesting compare to use CLR class with x:Class. But Spring is very powerful and it give you for instance Dependency Injection capability. In this section we will use Spring Dependency Injection to use a service into the CLR.
This section will explain the Java project org.eclipse.e4.xwt.springframework.sample2 :
At this step we change the label button when user click on it :
public class EventHandler { protected void clickButton(Event event) { Button button = (Button) event.widget; button.setText("Hello, world!"); } }
In real application CLR class use generally service. Here we will call an HelloService to get the message "Hello, world!".
Define HelloService
Create an interface ui.IHelloService like this :
package services; public interface IHelloService { String hello(); }
Create the IHelloService implementation like this :
package services.impl; import services.IHelloService; public class HelloService implements IHelloService { public String hello() { return "Hello, world!"; } }
Use HelloService into CLR
Modify EventHandler like this to consume the IHelloService :
package ui; import org.eclipse.swt.widgets.Button; import org.eclipse.swt.widgets.Event; import services.IHelloService; public class EventHandler { private IHelloService helloService; public void setHelloService(IHelloService helloService) { this.helloService = helloService; } protected void clickButton(Event event) { Button button = (Button) event.widget; button.setText(helloService.hello()); } }
The service will be filled with Spring Depency Injection.
Declare and use bean service
Declare into the ui-context.xml file the helloService :
<bean name="myService" class="services.impl.HelloService" > </bean>
Here the declaration don't use scope="prototype", because the service is a singleton. Use Dependency Injection to set the service to the CLR class like this :
<bean name="myUI" class="ui.EventHandler" scope="prototype"> <property name="helloService" ref="myService" /> </bean>
Here the ui-context.xml modified :
<?xml version="1.0" encoding="UTF-8"?> <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-3.0.xsd"> <bean name="myUI" class="ui.EventHandler" scope="prototype"> <property name="helloService" ref="myService" /> </bean> <bean name="myService" class="services.impl.HelloService" > </bean> </beans>
You can launch the Java UI test to check that IHelloService is consumed by clicking on button.
Using Spring with XWT - Spring DI - @Inject
It's interesting to use Spring 3.x because it provides the using of the @Inject(JSR-330) annotation to inject your service. (you can do teh same thing with @Autowired). The org.eclipse.e4.xwt.springframework.sample3 is a sample which inject the IHelloService with @Inject :
Use @Inject
package ui; import javax.inject.Inject; import org.eclipse.swt.widgets.Button; import org.eclipse.swt.widgets.Event; import services.IHelloService; public class EventHandler { @Inject private IHelloService helloService; protected void clickButton(Event event) { Button button = (Button) event.widget; // Use the hello service button.setText(helloService.hello()); } }
You can notice that EventHandler#setHelloService(IHelloService helloService) doesn't exists. XML Spring file is modified like this:
Declare <context:annotation-config/>
<?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-3.0.xsd http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd"> <bean name="myUI" class="ui.EventHandler" scope="prototype"> </bean> <bean name="myService" class="services.impl.HelloService" > </bean> <context:annotation-config/> </beans>
You can notice that :
- <property name="helloService" ref="myService" /> doens't exist more.
- <context:annotation-config/> is declared to use @Inject (or @Autowired).
Using Spring with XWT - Default factory
At this step xwt file declare the Spring factory like this :
x:ClassFactory="+ bean=myUI"
x:ClassFactory="ui.MySpringCLRFactory.INSTANCE bean=myUI">
But you can ommit the factory declaration by using '+' character like this :
x:ClassFactory="+ bean=myUI">
XWT.setCLRFactory(MySpringCLRFactory.INSTANCE)
You must after set the factory which must be used by default by calling :
XWT.setCLRFactory(MySpringCLRFactory.INSTANCE);
package ui; import java.net.URL; import org.eclipse.e4.xwt.IConstants; import org.eclipse.e4.xwt.XWT; public class UI { public static void main(String[] args) { XWT.setCLRFactory(MySpringCLRFactory.INSTANCE); URL url = UI.class.getResource(UI.class.getSimpleName() + IConstants.XWT_EXTENSION_SUFFIX); try { XWT.open(url); } catch (Exception e) { e.printStackTrace(); } } }
PAY ATTENTION!!!! The XWT.stCLRFactory must be called into teh same Thread than SWT Display (wich is used by XWT#open).
Using Spring Dynamic Module (OSGi) with XWT
Bundle org.eclipse.e4.xwt.springframework.osgi.sample1
ui.xwt
<Shell xmlns="http://www.eclipse.org/xwt/presentation" xmlns:x="http://www.eclipse.org/xwt" x:ClassFactory="org.eclipse.e4.xwt.springframework.SpringCLRFactory.INSTANCE bean=myUI bundle=org.eclipse.e4.xwt.springframework.osgi.sample1"> <Shell.layout> <GridLayout/> </Shell.layout> <Button text="Click Me!" SelectionEvent="clickButton"> </Button> </Shell>
spring/ui-context
<?xml version="1.0" encoding="UTF-8"?> <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-3.0.xsd"> <bean name="myUI" class="ui.EventHandler" scope="prototype"> </bean> </beans>
Launch sample1
You can find spring-target-platform/sample1.launch
Spring DM (Extender) must be selected.
Launch sample1_no_auto_start
You can find spring-target-platform/sample1_no_auto_start.launch
Auto start to false. You must set start to true for :
- org.eclipse.e4.xwt.springframework
- org.eclipse.e4.xwt.springframework.osgi.sample1
- org.springframework.osgi.extender
Using Spring Dynamic Module (OSGi) with XWT - Spring DI
Bundle services
See the org.eclipse.e4.xwt.springframework.osgi.services bundle.
services-context.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" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"> <bean name="myService" class="services.impl.HelloService" > </bean> </beans>
services-osgi-context.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:osgi="http://www.springframework.org/schema/osgi" xsi:schemaLocation="http://www.springframework.org/schema/osgi http://www.springframework.org/schema/osgi/spring-osgi-1.0.xsd http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"> <osgi:service ref="myService" interface="services.IHelloService" /> </beans>
Bundle org.eclipse.e4.xwt.springframework.osgi.sample2
spring/ui-context.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" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"> <bean name="myUI" class="ui.EventHandler" scope="prototype"> <property name="helloService" ref="myService" /> </bean> </beans>
spring/ui-osgi-context.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:osgi="http://www.springframework.org/schema/osgi" xsi:schemaLocation="http://www.springframework.org/schema/osgi http://www.springframework.org/schema/osgi/spring-osgi-1.0.xsd http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd"> <osgi:reference id="myService" interface="services.IHelloService" timeout="1000" cardinality="0..1" /> </beans>
cardinality="0..1" is very important. Indeed by default it's cardinality="1..1" which means that service is required and the UI will display only if service is available.
Launch sample2
You can find spring-target-platform/sample2.launch
Launch sample1_no_auto_start
You can find spring-target-platform/sample1_no_auto_start.launch
Auto start to false. You must set start to true for :
- org.eclipse.e4.xwt.springframework
- org.eclipse.e4.xwt.springframework.osgi.sample1
- org.springframework.osgi.extender
and
- org.eclipse.e4.xwt.springframework.osgi.services.impl
Using Spring Dynamic Module (OSGi) with XWT - Spring DI - @Inject
Bundle org.eclipse.e4.xwt.springframework.osgi.sample3
- Use @Inject
- Import package javax.inject
Using OSGi Fragment to configure SpringCLRFactory
Bundle org.eclipse.e4.xwt.springframework.osgi.sample4
x:ClassFactory="org.eclipse.e4.xwt.springframework.SpringCLRFactory.INSTANCE bean=myUI">
org.eclipse.e4.xwt.springframework.osgi.sample4.config.springclrfactory
springclrfactory .properties :
org.eclipse.e4.xwt.springclrfactory.timeout = 4000 org.eclipse.e4.xwt.springclrfactory.bundle = org.eclipse.e4.xwt.springframework.osgi.sample4
Use the fragment org.eclipse.e4.xwt.springframework.osgi.sample4.config.springclrfactory
Advanced features
ICLRFactoryAware
See tests.
If you wish get args or CLRFactory instance frm the CLR class, your CLR class can implements ICLRFactoryAware :
package org.eclipse.e4.xwt.springframework; import org.eclipse.e4.xwt.ICLRFactory; public interface ICLRFactoryAware { void setCLRFactory(ICLRFactory factory, IArguments args); }
Where IArguments is the args parsed :
package org.eclipse.e4.xwt.springframework; import org.eclipse.e4.xwt.ICLRFactory; public interface IArguments { // Default separator String DEFAULT_NAME_SEPARATOR = " "; String DEFAULT_VALUE_SEPARATOR = "="; /** * Returns the original source coming from * {@link ICLRFactory#createCLR(String)} which was used to build this * arguments. * * @return */ String getSource(); /** * Returns the value of the args name. * * @param name * @return */ String get(String name); }
Example :
public class CLR implements ICLRFactoryAware { private ICLRFactory factory; private IArguments args; public void setCLRFactory(ICLRFactory factory, IArguments args) { this.factory = factory; this.args = args; }
If you have
x:ClassFactory="org.eclipse.e4.xwt.tests.clrfactory.CLRFactory bean=myCLR"
args.getSource() will return "bean=myCLR".
args.get("bean") willl return "myCLR"
XWT.setCLRFactory
Configuration
configure timeout
to track the ApplicationContext
configure default bundle
With JVM parameters
With fragments
Fragment linked to org.eclipse.e4.xwt.springframework which contaisn springclrfactory.properties into src folder. Ex :
org.eclipse.e4.xwt.springclrfactory.timeout = 4000 org.eclipse.e4.xwt.springclrfactory.bundle = org.eclipse.e4.xwt.springframework.osgi.sample1
You can find fragment sample which configure SpringCLRFactory into the org.eclipse.e4.xwt.springframework.config.springclrfactory fragment .
Debug
You can debug the org.eclipse.e4.xwt.springframework bundle with standard OSGi Trace.
Launch an dOSGi console display :
[SpringCLRFactory] BEGIN Activator#start [SpringCLRFactory] Property <org.eclipse.e4.xwt.springclrfactory.timeout>=4000 [from springclrfactory.properties]. [SpringCLRFactory] Property <org.eclipse.e4.xwt.springclrfactory.bundle>=org.eclipse.e4.xwt.springframework.osgi.sample4 [from springclrfactory.properties]. [SpringCLRFactory] Property <org.eclipse.e4.xwt.springclrfactory.lazy>=false [from DEFAULT]. [SpringCLRFactory] END Activator#start
And :
[SpringCLRFactory] BEGIN SpringCLRFactory#createCLR("bean=myUI") [SpringCLRFactory] bean parameter=myUI (from Arguments) [OK]. [SpringCLRFactory] bundle parameter=org.eclipse.e4.xwt.springframework.osgi.sample4 (from Default) [OK]. [SpringCLRFactory] OSGi Bundle <org.eclipse.e4.xwt.springframework.osgi.sample4> founded [OK]. [SpringCLRFactory] OSGi Bundle <org.eclipse.e4.xwt.springframework.osgi.sample4> started [OK]. [SpringCLRFactory] Searching Spring ApplicationContext from the OSGi Bundle=<org.eclipse.e4.xwt.springframework.osgi.sample4> with timeout=<4000(ms)>... [SpringCLRFactory] Spring ApplicationContext founded [OK]. [SpringCLRFactory] END SpringCLRFactory#createCLR("bean=myUI") [OK].