SWT und Spring’s @Configurable – Dependency Injection in UI – Komponenten

Keine Kommentare

Gegeben sei der folgende Technologiestack:

– Java Frontend mit dem Standard Widget Toolkit (SWT), geladen und gestartet per Web Start.
– Spring Remoting als Schnittstelle zum Server.
– Spring Webanwendung auf einem Tomcat als Backend.

Das Backend ist Spring-Standard, und wem Spring Remoting nichts sagt, kann hier weiterlesen.
In diesem Blogeintrag soll es um die Kombination von SWT und Spring im Frontend gehen.
Was sind unsere Ziele? Im Prinzip läuft es auf Folgendes hinaus: die UI-Komponenten sollen möglichst dumm sein, da sie etwas schwerer zu testen sind. Die Businesslogik soll sich in einfachen POJOs befinden, mit denen echte Unit-Tests machbar sind. Das Komponentennetz soll durch Dependency Injection zusammengefügt werden, damit keine ServiceLocators die Testbarkeit behindern.

Ich hatte keine SWT-Erfahrung, also war mein erster naiver Gedanke: Okay, dann machen wir halt die UI-Komponenten zu Spring Beans, die Services sind auf Client-Seite Spring Remoting Proxies, und dazwischen ziehen wir eine Schicht von Controllern ein, die jegliche Businesslogik im Frontend übernehmen. Und Spring sorgt dafür, dass alle miteinander reden können.

So einfach war es dann nicht.

Erst einmal haben SWT-UI-Komponenten einen eigenen Lebenszyklus, sie können zu einem beliebigen Zeitpunkt erstellt und zerstört (dispose) und wieder erstellt werden. Der Scope Singleton wäre also in jedem Fall fehl am Platz gewesen, da man dann unter Umständen zerstörte, unbrauchbare UI-Komponenten im ApplicationContext gehabt und natürlich auch unnötig viel Speicher allokiert hätte.

Okay, na dann haben sie halt den Scope Prototype, und wir erzeugen uns eine neue Instanz immer dann, wenn wir sie brauchen.

Auch das ist einfacher gesagt als gemacht. Schauen wir uns doch mal so eine typische UI-Komponente an.

public class SomeListView extends Composite
{
	private TabFolder tabFolder;
	private SomeFilterComponent someFilterComponent;
	private SomeSortableGrid grid;
 
	public SomeListView(Composite parent)
	{
		super(parent, SWT.EMBEDDED);
		setLayout(new GridLayout(1, false));
		someFilterComponent = new SomeFilterComponent(this, SWT.NONE);
		someFilterComponent.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1));
 
		tabFolder = new TabFolder(this, SWT.NONE);
		tabFolder.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 1, 1));
 
		TabItem someListTab = new TabItem(tabFolder, SWT.NONE);
		someListTab.setText("some list");
 
		grid = new SomeSortableGrid(tabFolder, SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL);
		grid.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 1, 1));
		grid.setHeaderVisible(true);
		grid.setSize(this.getSize().x, 400);
		grid.setAutoHeight(true);
		grid.setAutoWidth(true);
 
		campaignListTab.setControl(grid);
	}
}

Diese Komponente stellt eine View mit einer Liste da, die durch eine Filterkomponente gefiltert werden kann. Die Liste ist noch in einem Tabreiter untergebracht. SomeFilterComponent und SomeSortableGrid sind wiederum eigens entwickelte UI-Komponenten. Man sieht, dass die Parent-Komponente immer als Konstruktor-Argument in die Child-Komponente übergeben wird. Wir haben hier eine bidirektionale Abhängigkeit, die Dependency Injection schwer macht: Wollte man SomeFilterComponent in SomeListView injizieren, so müsste vorher SomeListView erzeugt werden, damit es im Konstruktor von SomeFilterComponent verwendet werden kann. Das ginge noch mit Singletons, aber unmöglich wird es, wenn man bedenkt, dass beide Komponenten Prototypes sein müssen.

Fazit: SWT – UI-Komponenten können keine Spring-Beans werden.

Was nun? Doch wieder ServiceLocator-Aufrufe in den UI-Komponenten?

Nein, mit ein bisschen AspectJ-Magie gibt es eine elegante Lösung, die erstaunlich wenig Aufwand benötigt. Hier die drei Schritte zur Lösung:


1. Einbinden des Maven-AspectJ-Plugins für compile-time-weaving in unsere pom
2. Verwendung von @Configurable und @Autowired in unseren UI-Komponenten-Klassen
3. Aktivierung der Dependency Injection in der application-context.xml

Auf diese Art und Weise können wir Spring-Beans in ganz normale Klassen (unsere UI-Komponenten) injizieren, die per Konstruktor erzeugt werden.

Hier die Schritte im Einzelnen:

1. Einbinden des Maven-AspectJ-Plugins für compile-time-weaving in unsere pom

<build>
	<plugins>
		<plugin>
			<groupId>org.codehaus.mojo</groupId>
			<artifactId>aspectj-maven-plugin</artifactId>
			<version>1.4</version>
			<configuration>
				<source>1.6</source>
				<target>1.6</target>
				<complianceLevel>1.6</complianceLevel>
				<Xlint>ignore</Xlint>
				<aspectLibraries>
					<aspectLibrary>
						<groupId>org.springframework</groupId>
						<artifactId>spring-aspects</artifactId>
					</aspectLibrary>
				</aspectLibraries>
			</configuration>
			<executions>
				<execution>
					<goals>
						<goal>compile</goal>
						<goal>test-compile</goal>
					</goals>
				</execution>
			</executions>
			<dependencies>
				<dependency>
					<groupId>org.aspectj</groupId>
					<artifactId>aspectjrt</artifactId>
					<version>1.6.11</version>
				</dependency>
				<dependency>
					<groupId>org.aspectj</groupId>
					<artifactId>aspectjtools</artifactId>
					<version>1.6.11</version>
				</dependency>
			</dependencies>
		</plugin>
	</plugins>
</build>

Diese Konfiguration bewirkt, dass die Aspekte aus spring-aspects in die Klassen eingewoben werden. Interessant ist da für uns nur der AnnotationBeanConfigurerAspect, der bei jeder Klasse eingewoben wird, die mit @Configurable annotiert ist und der bewirkt, dass in diesen Klassen die @Autowired – Annotation verwendet werden kann, um Abhängigkeiten zu injizieren. Das führt uns direkt zum nächsten Schritt.

2. Verwendung von @Configurable und @Autowired in unseren UI-Komponenten-Klassen:

@Configurable(preConstruction = true)
public class SomeListView extends Composite
{
	private TabFolder tabFolder;
	private SomeFilterComponent someFilterComponent;
	private SomeSortableGrid grid;
	@Autowired
	private SomeController someController;
 
	public SomeListView(Composite parent)
	{
		super(parent, SWT.EMBEDDED);
		setLayout(new GridLayout(1, false));
		someFilterComponent = new SomeFilterComponent(this, SWT.NONE);
		someFilterComponent.setLayoutData(new GridData(SWT.FILL, SWT.CENTER, true, false, 1, 1));
 
		tabFolder = new TabFolder(this, SWT.NONE);
		tabFolder.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 1, 1));
 
		TabItem someListTab = new TabItem(tabFolder, SWT.NONE);
		someListTab.setText("some list");
 
		grid = new SomeSortableGrid(tabFolder, SWT.BORDER | SWT.H_SCROLL | SWT.V_SCROLL);
		grid.setLayoutData(new GridData(SWT.FILL, SWT.FILL, true, true, 1, 1));
		grid.setHeaderVisible(true);
		grid.setSize(this.getSize().x, 400);
		grid.setAutoHeight(true);
		grid.setAutoWidth(true);
 
		campaignListTab.setControl(grid);
		someController.doSomething();
	}
}

Durch @Configurable sagen wir AspectJ, dass der AnnotationBeanConfigurerAspect in dieser Klasse eingewoben werden soll. ‚preConstruction = true‘ ist eine Zusatzangabe, die dazu führt, dass Abhängigkeiten sogar vor dem Aufruf des Konstruktors gesetzt werden, deswegen kann SomeController auch schon im Konstruktor verwendet werden. Abhängigkeiten, die injiziert werden sollen, müssen mit @Autowired annotiert werden, wie das hier mit dem SomeController geschieht.

3. Aktivierung der Dependency Injection in der application-context.xml:

Dass der Aspekt eingewoben ist, heißt noch nicht, dass er aktiv werden kann. AspectJ-Aspekte sind üblicherweise static, also müssen wir unseren ApplicationContext static an einer Stelle bekannt machen, an der der Aspekt nachsehen kann. Das übernimmt Spring für uns transparent, in dem wir Folgendes in unsere ApplicationContext-xml-Datei einfügen:

<context:spring-configured/>

Damit das Autowiring per Annotationen funktioniert, brauchen wir auch noch folgenden Eintrag:

<context:annotation-config/>

Das war’s. Jetzt können wir SomeListView per Konstruktor erzeugen und die Abhängigkeiten werden direkt injiziert. Kein ServiceLocator, kein Gluecode. Alles, was irgendwie nach Businesslogik riecht, wird in einen Controller (oder wie man es auch immer nennen möchte) ausgelagert, der injiziert wird. Die UI-Komponenten bleiben so dumm wie möglich.

Nachtrag zur Testbarkeit

Wenn man sich den Code zur SomeListView noch einmal ansieht, merkt man schnell, dass dort immer ein Nullpointer fliegen wird, wenn man den Konstruktor aufruft ohne einen ApplicationContext entsprechend konfiguriert zu haben. Wir haben einfach akzeptiert, dass man SWT-UI-Komponenten in Standard-Unit-Tests nicht gut testen kann (das geht auch ohne Spring nicht wirklich, schließlich sind die Komponenten durch Konstruktorenaufrufe eng verwoben). Für den Test einer UI-Komponente nutzen für folgende Basis-Klasse:

@ContextConfiguration("classpath:conf/some-config-test.xml")
@RunWith(SpringJUnit4ClassRunner.class)
@DirtiesContext
public abstract class AbstractViewTest
{
	protected Shell shell;
 
	@Autowired
	protected SomeController someControllerMock;
 
	@Before
	public void setUp() throws Exception
	{
		assertNotNull(someControllerMock);
 
		shell = new Shell(Display.getDefault(), SWT.NONE);
	}
}

Die some-config-test.xml sieht so aus:

<bean class="org.mockito.Mockito" factory-method="mock" >
	<constructor-arg value="de.codecentric.client.controller.SomeController"/>
</bean>

<context:annotation-config/>
<context:spring-configured/>

Eine konkrete Testklasse kann dann so aussehen:

public class SomeListViewTest extends AbstractViewTest
{
	private SomeListView someListView;
 
	@Before
	public void setUp() throws Exception
	{
		super.setUp();
		SomeObject something = new SomeObject();
 
		when(someControllerMock.doSomething()).thenReturn(something);
		someListView = new SomeListView(shell);
	}
 
	@Test
	public void testSomeListView()
	{
		Control[] children = someListView.getChildren();
		assertEquals(2, children.length);
 
		assertTrue(children[0] instanceof SomeFilterComponent);
		assertTrue(children[1] instanceof TabFolder);
 
		TabFolder tabFolder = (TabFolder) children[1];
		Control[] tabFolderChildren = tabFolder.getChildren();
		assertEquals(1, tabFolderChildren.length);
		assertTrue(tabFolderChildren[0] instanceof SomeSortableGrid);
 
	}
}

Es wird also automatisch der someControllerMock in die someListView injiziert, wenn diese per Konstruktor erzeugt wird, und jegliche Prüfungen können dann auf dem Mock stattfinden.

Tobias Flohre

Tobias Flohre arbeitet als Senior-Softwareentwickler/Architekt bei der codecentric AG. Seine Schwerpunkte sind Java-Enterprise-Anwendungen und Architekturen mit JEE/Spring. Er ist Autor diverser Artikel und schreibt regelmäßig Blogbeiträge zu den Themen Architektur und Spring. Zurzeit beschäftigt er sich mit Integrations- und Batch-Themen im Großunternehmen sowie mit modernen Webarchitekturen.

Share on FacebookGoogle+Share on LinkedInTweet about this on TwitterShare on RedditDigg thisShare on StumbleUpon

Kommentieren

Deine E-Mail-Adresse wird nicht veröffentlicht. Erforderliche Felder sind mit * markiert.