JspWiki and Spring Integration

Top Announcement: 22-Apr-2008 EmForge-0.23 available for download! See News for details.

EmForge is using JspWiki Project for Wiki-Implementation. And JspWiki plays key role in project - since it is used not only for displaying wiki-pages, but for storing any textual information.

JspWiki is very flexible. Most functional parts are separated into modules and WikiEngine (central class of JspWiki) communicates with them via defined interfaces. Concrete implementations are specified in WikiEngine constructor via set of parameters.

For example - WikiEngine is used PageProvider for accessing wiki-pages. JspWiki by default include several implementations of PageProvider: file-system based, RCS-based. It is possible to implement any other page-provider to store wiki=pages there you need (For example EmForge is used two own implementations of PageProvider: MemoryBasedPageProvider used for tests, and Subversion-based to store wiki pages and their history in subversion repository).

From another side, EmForge is used Spring Framework for integrating several parts of project. In this case we need not only integrate JspWiki into Spring-Based project to use WikiEngine in many other beans (for example via FactoryBean) - but also we had a task to integrate different components, used by JspWiki (like own implementation of PageProvider) into Spring Context.

For Example in EmForge we are using Subversion-Based PageProvider. This provider should use SVNRepository object (from SVNKit) for accessing subversion repository. In EmForge we have special bean - RepositoryFactory - responsible for creation SVNRepository depending from project-wide settings.

In Spring these things resolved easily: we defining two beans: RepositoryFactory and SubversionPageProvider - and set RepositoryFactory as property for SubversionPageProvider. Since Spring's IoC is responsible for creation of beans and linking beans references - it will create SubversionPageProvider then it will required, will create (if it will not be yet created RepositoryFactory) and set RepositoryFactory as property to SubversionPageProvider.

But here is one problem: WikiEngine class (that will use this provider) is received only class-name in arguments, and created PageProvider by itself. So, since it's create it by itself - Spring's IoC is not involved into creation process - and provider will not receive required RepositoryFactory object as property...

Wrapper's based solution

Here is different ways to solve this problem: for example initially we changed code of JspWiki (since it is open-source project we has access to sources) to add methods like setPageProvider to allow WikiEngine receive PageProviders not only in properties (via class-names) - but also by Spring-way (via setting properties). But this way produced us a lot of problems with merging with newst versions of JspWiki.

Anyway, solution, allowed us to integrate JspWiki into Spring-based project without changing JspWiki code will be much better. And we did it via wrapper-classes.

Idea is followed:

1. Implement Factory bean to make JspWiki Engine (implementation of factory you may found here. This factory is responsible for creation of JspWiki WikiEngine and placing Spring Context into properties
2. implement special wrapper-class, supported required by JspWiki interface (for example PageProvider).
   1. JspWiki will create this wrapper
   2. during creation this wrapper will get Spring Context stored by factory from settings and get bean-name also from settings
   3. It will request bean, really implemented whole logic from Context by specified name
   4. All methods, implemented interface just redirect calling to the bean
   5. Implementation of Wrapper for PageProvider you can find here

Example of JspWiki bean configuration in Spring Context:

    <bean id="wikiEngine" class="ru.emdev.EmForge.wiki.JspWikiEngineBean">
    	<property name="wikiProperties">
            <props>
				<prop key="jspwiki.applicationName">EmForge</prop>
				<prop key="jspwiki.usePageCache">true</prop>
				<prop key="jspwiki.encoding">UTF-8</prop>
				<prop key="jspwiki.translatorReader.allowHTML">false</prop>
				<prop key="jspwiki.breakTitleWithSpaces">false</prop>
				<prop key="jspwiki.translatorReader.matchEnglishPlurals">true</prop>
				<prop key="jspwiki.translatorReader.inlinePattern.1">*.jpg</prop>
				<prop key="jspwiki.translatorReader.inlinePattern.2">*.jpeg</prop>
				<prop key="jspwiki.translatorReader.inlinePattern.3">*.png</prop>
				<prop key="jspwiki.translatorReader.inlinePattern.4">*.svg</prop>
				<prop key="jspwiki.translatorReader.camelCaseLinks">true</prop>
				<prop key="jspwiki.templateDir">default</prop>
				<prop key="jspwiki.translatorReader.useOutlinkImage">true</prop>
				<prop key="jspwiki.lockExpiryTime">60</prop>
				
				<prop key="jspwiki.pageProvider">ru.emdev.EmForge.wiki.beanwrapper.PageProviderWrapper</prop>
				<prop key="jspwiki.spring.pageProvider">memoryPageProvider</prop>
				<prop key="jspwiki.attachmentProvider">ru.emdev.EmForge.wiki.beanwrapper.AttachmentProviderWrapper</prop>
				<prop key="jspwiki.spring.attachmentProvider">memoryAttachmentProvider</prop>
				
				
				<prop key="jspwiki.searchProvider">LuceneSearchProvider</prop>
				<prop key="jspwiki.specialPage.FindPage">Search.htm</prop>
				<prop key="jspwiki.specialPage.UserPreferences">UserPreferences.htm</prop>
				<prop key="jspwiki.interWikiRef.JSPWiki">http://www.jspwiki.org/Wiki.jsp?page=%s</prop>
				<prop key="jspwiki.interWikiRef.Edit">edit.faces?page=%s</prop>
				<prop key="jspwiki.interWikiRef.WikiWikiWeb">http://c2.com/cgi/wiki?%s</prop>
				<prop key="jspwiki.interWikiRef.TWiki">http://twiki.org/cgi-bin/view/TWiki/%s</prop>
				<prop key="jspwiki.interWikiRef.MeatballWiki">http://usemod.com/cgi-bin/mb.pl?%s</prop>
				<prop key="jspwiki.interWikiRef.Wikipedia">http://www.wikipedia.com/wiki/%s</prop>
				<prop key="jspwiki.interWikiRef.Google">http://www.google.com/search?q=%s</prop>
				<prop key="jspwiki.interWikiRef.Doc">http://doc.jspwiki.org/2.2/Wiki.jsp?page=%s</prop>
				<prop key="jspwiki.interWikiRef.notes">notes:%s</prop>
				<prop key="jspwiki.rss.generate">false</prop>
				<prop key="jspwiki.rss.fileName">rss.rdf</prop>
				<prop key="jspwiki.rss.interval">3600</prop>
				<prop key="jspwiki.rss.channelDescription">Channel Description here</prop>
				<prop key="jspwiki.rss.channelLanguage">en-us</prop>
				
				<prop key="jspwiki.security">jaas</prop>
				<prop key="jspwiki.authorizer">ru.emdev.EmForge.wiki.security.AuthorizerImpl</prop>

            </props>
        </property>
        <property name="initWikiPagesFolder" value="classpath:ru/emdev/EmForge/wiki/pages"/>
    </bean> 

    <!-- Testing Memory-Based Page Providers -->
    <bean id="memoryPageProvider" class="ru.emdev.EmForge.wiki.providers.mapprovider.MapPageProvider"/>
    <bean id="memoryAttachmentProvider" class="ru.emdev.EmForge.wiki.providers.mapprovider.MapAttachmentProvider"/>

Conclusion

As result - we easily integrated JspWiki into Spring Context, using Factory Bean to create Wiki Engine, and may use providers (and other modules), defined as Spring Bean (so, may reference to other beans) but still may be easily be used from Wiki Engine via it's standard way of initialization.