How to configure with Spring an api not based on Spring

HOW TO CONFIGURE WITH SPRING AN
API NOT BASED ON SPRING
Jose María Arranz Santamaría

Madrid (Spain) February 17-18, 2011
1

THE PROBLEM
• Spring was born as a tool to configure and
integrate disparate technologies
• We can not always expect such disparate
technologies be ready to be configured “out of
the box” with Spring
This is the thing Spring was invented for!

3

THE PROBLEM
• ItsNat is a Java web framework
with a custom non-Spring configuration system
• ItsNat configuration is the most powerful and
flexible approach ever invented: Calling methods!
• As of day 0 ItsNat configuration was conceived to
be “overloaded” with higher level configuration
techniques and APIs, for instance… Spring!

4

DO NOT WORRY THIS IS NOT GOING
TO BE AN ItsNat COURSE!


6

WE ARE GOING TO LEARN SOME
Spring TRICKS

7

BUT WE MUST KNOW HOW TO
CONFIGURE A WEB PROJECT BASED
ON ItsNat TO CONFIGURE IT LATER
WITH Spring

We will pick the “core” example in the
ItsNat Reference Manual

8

“PURE” ItsNat EXAMPLE: the servlet
• ItsNat does not define a concrete servlet,
developer must create one (or more)
– Configuration is done in method init
• In this example most of configuration is optional, just
used to show ItsNat configuration options
public class servlet extends HttpServletWrapper
{
public void init(ServletConfig config) throws ServletException
{
super.init(config);
ItsNatHttpServlet itsNatServlet = getItsNatHttpServlet();
ItsNatServletConfig itsNatConfig =
itsNatServlet.getItsNatServletConfig();
ItsNatServletContext itsNatCtx =
itsNatConfig.getItsNatServletContext();

9

• ItsNatHttpServlet, ItsNatServletConfig
y ItsNatServletContext are the roots (and
singletons) of ItsNat configuration
itsNatCtx.setMaxOpenDocumentsBySession(6);

String serverInfo = getServletContext().getServerInfo();
boolean gaeEnabled = serverInfo.startsWith(
"Google App Engine");

itsNatCtx.setSessionReplicationCapable(gaeEnabled);
itsNatCtx.setSessionSerializeCompressed(false);
itsNatCtx.setSessionExplicitSerialize(false);

10

itsNatConfig.setDebugMode(true);
itsNatConfig.setClientErrorMode(
ClientErrorMode.SHOW_SERVER_AND_CLIENT_ERRORS);
itsNatConfig.setLoadScriptInline(true);
itsNatConfig.setFastLoadMode(true);
itsNatConfig.setCommMode(CommMode.XHR_ASYNC_HOLD);
itsNatConfig.setEventTimeout(-1);
itsNatConfig.setOnLoadCacheStaticNodes("text/html",true);
itsNatConfig.setOnLoadCacheStaticNodes("text/xml",false);
itsNatConfig.setNodeCacheEnabled(true);

11

itsNatConfig.setDefaultEncoding("UTF-8");
itsNatConfig.setUseGZip(UseGZip.SCRIPT);
itsNatConfig.setDefaultDateFormat(
DateFormat.getDateInstance(DateFormat.DEFAULT,Locale.US));
itsNatConfig.setDefaultNumberFormat(
NumberFormat.getInstance(Locale.US));
itsNatConfig.setEventDispatcherMaxWait(0);
itsNatConfig.setEventsEnabled(true);
itsNatConfig.setScriptingEnabled(true);
itsNatConfig.setUsePatternMarkupToRender(false);
itsNatConfig.setAutoCleanEventListeners(true);

12

• Now we register in the servlet an ItsNat template
core_example.xhtml and associated document loader
CoreExampleLoadListener
– Just a simple example of HTML page with AJAX
String pathPrefix = getServletContext().getRealPath("/");
pathPrefix += "/WEB-INF/pages/manual/";

ItsNatDocumentTemplate docTemplate;
docTemplate = itsNatServlet.registerItsNatDocumentTemplate(
"manual.core.example","text/html",
pathPrefix + "core_example.xhtml");
docTemplate.addItsNatServletRequestListener(
new CoreExampleLoadListener());

13

• Another example, in this case a page with XML
docTemplate = itsNatServlet.registerItsNatDocumentTemplate(
"manual.core.xmlExample","text/xml",
pathPrefix + "xml_example.xml");
new CoreXMLExampleLoadListener());

• This XML example inserts an ItsNat “template
fragment”
– Template fragments have not “loaders/processors”
ItsNatDocFragmentTemplate docFragTemplate;
docFragTemplate = itsNatServlet.registerItsNatDocFragmentTemplate(
"manual.core.xmlFragExample","text/xml",
pathPrefix + "xml_fragment_example.xml");

14

“PURE” ItsNat EXAMPLE
• <root>/WEB-INF/pages/manual/core_example.xhtml
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
"http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head><title>ItsNat Core Example</title></head>
<body>
<h3>ItsNat Core Example</h3>
<div itsnat:nocache="true"
xmlns:itsnat="http://itsnat.org/itsnat">
<div id="clickableId1">Clickable Elem 1</div>
<br />
<div id="clickableId2">Clickable Elem 2</div>
</div>
</body>
</html>

15

• CoreExampleLoadListener is just a simple
launcher of document processors, called per page
loaded
public class CoreExampleLoadListener
implements ItsNatServletRequestListener
{
public CoreExampleLoadListener() {}

public void processRequest(ItsNatServletRequest request,
ItsNatServletResponse response)
{
ItsNatHTMLDocument itsNatDoc =
(ItsNatHTMLDocument)request.getItsNatDocument();
new CoreExampleDocument(itsNatDoc);
}
}

16

• CoreExampleDocument manages the page
(document) state receiving AJAX events
public class CoreExampleDocument implements EventListener
{
protected ItsNatHTMLDocument itsNatDoc;
protected Element clickElem1;
protected Element clickElem2;

public CoreExampleDocument(ItsNatHTMLDocument itsNatDoc)
{
this.itsNatDoc = itsNatDoc;
load();
}
...

17


18

• <root>/WEB-INF/pages/manual/xml_example.xml
<?xml version='1.0' encoding='UTF-8' ?>
<discs>
<itsnat:include name="manual.core.xmlFragExample"
xmlns:itsnat="http://itsnat.org/itsnat" />
<cdList>
<cd>
<title>Tittle</title>
<artist>Artist</artist>
<songs>
<song>Song Pattern</song>
</songs>
</cd>
</cdList>
</discs>

19

• <root>/WEB-INF/pages/manual/xml_fragment_example.xml

<?xml version='1.0' encoding='UTF-8' ?>
<root>
<title>CD List</title>
<subtitle>in XML</subtitle>
</root>

20

• CoreXMLExampleLoadListener : in this case
(XML page) there is no AJAX events, we do not need a
class wrapping the document. This example includes the
template fragment "manual.core.xmlFragExample"
public class CoreXMLExampleLoadListener
implements ItsNatServletRequestListener
{
public CoreXMLExampleLoadListener() { }

ItsNatServletResponse response)
{
ItsNatDocument itsNatDoc = request.getItsNatDocument();
Document doc = itsNatDoc.getDocument();
Element discsElem = doc.getDocumentElement();
...

21


22

ItsNat Springization

23

OBJETIVES
1. Build a single reused generic servlet :
itsnatspring.itsnatservlet
2. Configuration is fully done in a XML
configuration file of Spring in classpath:
itsnatex/spring.xml
3. The only user defined Java classes will be the
document wrappers/containers:
itsnatex.CoreExampleDocument
itsnatex.CoreXMLExampleDocument

24

CONSEQUENCES
• Besides the generic servlet we will need some
utility classes also generic and reusable for
other ItsNat+Spring projects
• These classes are not completed, just to cover
the needs of this example
– ItsNat has more configuration options

25

THE SERVLET
package itsnatspring;

import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import org.itsnat.core.http.HttpServletWrapper;
import org.itsnat.core.http.ItsNatHttpServlet;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.context.support.GenericApplicationContext;

public class itsnatservlet extends HttpServletWrapper
{
public void init(ServletConfig config) throws ServletException
{
super.init(config);
ItsNatHttpServlet itsNatServlet = getItsNatHttpServlet();
GenericApplicationContext rootContext = new GenericApplicationContext();
ItsNatBeansRegistryUtil.registerSingletons(rootContext, itsNatServlet);
rootContext.refresh();

26

THE SERVLET
String springXMLPath = config.getInitParameter("spring_config");
if (springXMLPath == null)
throw new RuntimeException("spring_config initialization
parameter is not specified in web.xml");
ApplicationContext context =
new ClassPathXmlApplicationContext(
new String[] {springXMLPath},rootContext);
}
}

• ItsNat configuration objects are registered into a
generic ApplicationContext (the root), our
XML with Spring configuration is loaded by
another (child) Spring context

27

ItsNatBeansRegistryUtil
import org.itsnat.core.ItsNatServletConfig;
import org.itsnat.core.ItsNatServletContext;
import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.context.support.AbstractApplicationContext;

public class ItsNatBeansRegistryUtil
{
public final static String itsNatHttpServletBean = "itsNatHttpServlet";
public final static String itsNatServletConfigBean = "itsNatServletConfig";
public final static String itsNatServletContextBean = "itsNatServletContext";

public static ItsNatHttpServlet getItsNatHttpServlet(ApplicationContext context) {
return context.getBean(itsNatHttpServletBean,ItsNatHttpServlet.class);
}
public static ItsNatServletConfig getItsNatServletConfig(ApplicationContext context){
return context.getBean(itsNatServletConfigBean,ItsNatServletConfig.class);
}
public static ItsNatServletContext getItsNatServletContext(ApplicationContext context){
return context.getBean(itsNatServletContextBean,ItsNatServletContext.class);
}
28

ItsNatBeansRegistryUtil
public static void registerSingletons(AbstractApplicationContext context,
ItsNatHttpServlet itsNatServlet)
{
ItsNatServletConfig itsNatServletCofig =
itsNatServlet.getItsNatServletConfig();
ItsNatServletContext itsNatServletContext =
itsNatServletCofig.getItsNatServletContext();

ConfigurableListableBeanFactory beanFact = context.getBeanFactory();
beanFact.registerSingleton(itsNatHttpServletBean,itsNatServlet);
beanFact.registerSingleton(itsNatServletConfigBean,itsNatServletCofig);
beanFact.registerSingleton(itsNatServletContextBean,itsNatServletContext);
}
}

• ItsNat configuration objects are manually
registered as singletons in Spring context

29

web.xml
<?xml version="1.0" encoding="UTF-8"?>
<web-app version="3.0" xmlns="http://java.sun.com/xml/ns/javaee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
<servlet>
<servlet-name>itsnatservlet</servlet-name>
<servlet-class>itsnatspring.itsnatservlet</servlet-class>
<init-param>
<param-name>spring_config</param-name>
<param-value>itsnatex/spring.xml</param-value>
</init-param>
</servlet>
<servlet-mapping>
<servlet-name>itsnatservlet</servlet-name>
<url-pattern>/itsnatservlet</url-pattern>
</servlet-mapping>
<session-config>
<session-timeout>30</session-timeout>
</session-config>
</web-app> 30

spring.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
http://www.springframework.org/schema/util
http://www.springframework.org/schema/util/spring-util-3.0.xsd">

<bean class="itsnatspring.ItsNatServletContextBean">
<property name="maxOpenDocumentsBySession" value="10" />
<property name="sessionReplicationCapable" value="false" />
<property name="sessionSerializeCompressed" value="false" />
<property name="sessionExplicitSerialize" value="false" />
</bean>

31

ItsNatServletContextBean
• This utility class is used as a singleton to save the
specified flags and in the end of bean configuration
they are registered calling methods of
ItsNatServletContext
– Because we need the ApplicationContext
we will implement
ApplicationContextAware
– Because we must to save in ItsNat context our
configuration data in the end of bean
configuration we need to implement
InitializingBean
32


import org.itsnat.core.ItsNatServletContext;
import org.springframework.beans.BeansException;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.context.ApplicationContextAware;

public class ItsNatServletContextBean
implements InitializingBean,ApplicationContextAware
{
protected ApplicationContext context;
protected Integer maxOpenDocumentsBySession;
protected Boolean sessionReplicationCapable;
protected Boolean sessionSerializeCompressed;
protected Boolean sessionExplicitSerialize;

public ItsNatServletContextBean() { }

33

public int getMaxOpenDocumentsBySession() {
return maxOpenDocumentsBySession;
}
public void setMaxOpenDocumentsBySession(int maxOpenDocumentsBySession){
this.maxOpenDocumentsBySession = maxOpenDocumentsBySession;
}
public boolean getSessionReplicationCapable() {
return sessionReplicationCapable;
}
public void setSessionReplicationCapable(
boolean sessionReplicationCapable) {
this.sessionReplicationCapable = sessionReplicationCapable;
}
public boolean getSessionSerializeCompressed() {
return sessionSerializeCompressed;
}
public void setSessionSerializeCompressed(
boolean sessionSerializeCompressed) {
this.sessionSerializeCompressed = sessionSerializeCompressed;
}
34

public boolean getSessionExplicitSerialize() { return sessionExplicitSerialize; }
public void setSessionExplicitSerialize(boolean sessionExplicitSerialize){
this.sessionExplicitSerialize = sessionExplicitSerialize;
}
@Override
public void setApplicationContext(ApplicationContext context) throws BeansException {
this.context = context; }
@Override
public void afterPropertiesSet() throws Exception {
ItsNatServletContext itsNatServletContext =
ItsNatBeansRegistryUtil.getItsNatServletContext(context);
if (maxOpenDocumentsBySession != null)
itsNatServletContext.setMaxOpenDocumentsBySession(maxOpenDocumentsBySession);
if (sessionReplicationCapable != null)
itsNatServletContext.setSessionReplicationCapable(sessionReplicationCapable);
if (sessionSerializeCompressed != null)
itsNatServletContext.setSessionSerializeCompressed(sessionSerializeCompressed);
if (sessionExplicitSerialize != null)
itsNatServletContext.setSessionExplicitSerialize(sessionExplicitSerialize);
}
}
35

spring.xml (cont.)
<bean id="defaultLocale" class="itsnatspring.LocaleBean" >
<property name="language" value="en" />
<property name="country" value="US" />
</bean>

<bean id="defaultDateFormat" class="itsnatspring.DateFormatBean" >
<property name="style" value="2" /> 
<property name="locale">
<bean factory-bean="defaultLocale" factory-method="getLocale"/>
</property>
</bean>

<bean id="defaultNumberFormat" class="itsnatspring.NumberFormatBean" >
<property name="locale">
<bean factory-bean="defaultLocale" factory-method="getLocale" />
</property>
</bean>
... 36

LocaleBean
• This “factory bean” allows configuring a Locale and
made public calling the “factory method”
getLocale()
import java.util.Locale;

public class LocaleBean implements InitializingBean
{
protected String language;
protected String country;
protected Locale locale;

public LocaleBean() { }
public String getCountry() { return country; }
public void setCountry(String country) { this.country = country; }
public String getLanguage() { return language; }

37

LocaleBean
public void setLanguage(String language) { this.language = language; }
public Locale getLocale() { return locale; }

@Override
public void afterPropertiesSet() throws Exception
{
Locale[] availablelocales = Locale.getAvailableLocales();
for(Locale locale : availablelocales)
if (locale.getLanguage().equals(language) &&
locale.getCountry().equals(country))
{
this.locale = locale;
return;
}
this.locale = new Locale(language,country);
}
}

38

• Some other utility classes are very similar to the
previous shown, from now we are just to show
only the most interesting
• From Spring XML you can figure out how they
work under the hood
– ItsNat singletons are got through
ItsNatBeansRegistryUtil and the Spring
ApplicationContext
– This context is got implementing
ApplicationContextAware

39

spring.xml (cont.)
<bean class="itsnatspring.ItsNatServletConfigBean">
<property name="debugMode" value="true" />
<property name="clientErrorMode" value="4" />
<!– ClientErrorMode.SHOW_SERVER_AND_CLIENT_ERRORS -->
<property name="defaultEncoding" value="UTF-8" />
<property name="onLoadCacheStaticNodes"> <!– backed by a Properties attr -->
<value>
text/html=true
text/xml=false
</value>
</property>
<property name="defaultDateFormat">
<bean factory-bean="defaultDateFormat" factory-method="getDateFormat"/>
</property>
<property name="defaultNumberFormat">
<bean factory-bean="defaultNumberFormat" factory-method="getNumberFormat"/>
</property>
</bean>
...
40

spring.xml (cont.)
<bean id="coreExamplePath" class="itsnatspring.WebPathBean">
<property name="relativePath" value="/WEB-INF/pages/manual/core_example.xhtml"/>
</bean>

<bean id="coreExampleDoc" class="itsnatex.CoreExampleDocument" scope="prototype" >

</bean>

<bean id="coreExampleDocTemplate" class="itsnatspring.ItsNatDocumentTemplateBean">
<property name="name" value="manual.core.example" />
<property name="mime" value="text/html" />
<property name="source">
<bean factory-bean="coreExamplePath" factory-method="getAbsolutePath"/>
</property>
<property name="itsNatServletRequestListener" >
<bean class="itsnatspring.ItsNatServletRequestListenerBean" >
<property name="documentBeanName" value="coreExampleDoc" />
</bean>
</property>
</bean>
...

41

ItsNatServletRequestListenerBean
• This “local singleton bean” is very interesting becase it works
like a generic “ItsNat document loader listener”
implementing ItsNatServletRequestListener
• To be generic we must invent a simple interface
ItsNatDocumentInitialize for the document
processors/wrappers:

import org.itsnat.core.ItsNatServletRequest;
import org.itsnat.core.ItsNatServletResponse;

public interface ItsNatDocumentInitialize
{
public void load(ItsNatServletRequest request,
ItsNatServletResponse response);
}

42


import org.itsnat.core.ItsNatServletRequest;
import org.itsnat.core.ItsNatServletResponse;
import org.itsnat.core.event.ItsNatServletRequestListener;
import org.springframework.context.support.AbstractApplicationContext;

public class ItsNatServletRequestListenerBean implements
ItsNatServletRequestListener,ApplicationContextAware,InitializingBean
{
protected AbstractApplicationContext context;
protected String documentBeanName;

public ItsNatServletRequestListenerBean() { }
43

ItsNatServletResponse response) {
ItsNatDocumentInitialize docWrapper =
context.getBean(documentBeanName,ItsNatDocumentInitialize.class);
docWrapper.load(request, response);
}

public String getDocumentBeanName() { return documentBeanName; }

public void setDocumentBeanName(String documentBeanName) {
this.documentBeanName = documentBeanName;
}

44

@Override
public void setApplicationContext(ApplicationContext context)
throws BeansException {
this.context = (AbstractApplicationContext)context;
}
@Override
// Checking correctly defined:
if (documentBeanName == null)
throw new RuntimeException("docBeanName property is mandatory");
if (!context.getBeanFactory().isPrototype(documentBeanName))
throw new RuntimeException("Bean " + documentBeanName +
" must be "prototype" scoped");
}
}

45

ItsNatDocumentTemplateBean
• Finally this bean registers the template and the
associated “ItsNat document loader listener” configured
import org.itsnat.core.event.ItsNatServletRequestListener;
import org.itsnat.core.tmpl.ItsNatDocumentTemplate;

public class ItsNatDocumentTemplateBean
implements InitializingBean,ApplicationContextAware {
protected String name;
protected String mime;
protected Object source;
protected ItsNatServletRequestListener itsNatServletRequestListener;

46

public ItsNatServletRequestListener getItsNatServletRequestListener(){
return itsNatServletRequestListener;
}
public void setItsNatServletRequestListener(
ItsNatServletRequestListener itsNatServletRequestListener) {
this.itsNatServletRequestListener = itsNatServletRequestListener;
}

public String getName() { return name; }
public void setName(String name) { this.name = name; }
public String getMime() { return mime; }
public void setMime(String mime) { this.mime = mime; }
public Object getSource() { return source; }
public void setSource(Object source) { this.source = source; }

@Override
public void setApplicationContext(ApplicationContext context)
throws BeansException {
this.context = context;
}

47

@Override
public void afterPropertiesSet() throws Exception
{
// name, mime and source are mandatory
ItsNatHttpServlet itsNatHttpServlet =
ItsNatBeansRegistryUtil.getItsNatHttpServlet(context);
ItsNatDocumentTemplate docTemplate =
itsNatHttpServlet.registerItsNatDocumentTemplate(name,mime,source);
if (itsNatServletRequestListener != null)
itsNatServletRequestListener);
// More config here...
}
}

48

spring.xml (cont.)
<bean id="coreXMLDocExamplePath" class="itsnatspring.WebPathBean">
<property name="relativePath" value="/WEB-INF/pages/manual/xml_example.xml" />
</bean>
<bean id="coreXMLExampleDoc" class="itsnatex.CoreXMLExampleDocument“
scope="prototype">

</bean>
<bean id="coreXMLExampleDocTemplate"
class="itsnatspring.ItsNatDocumentTemplateBean">
<property name="name" value="manual.core.xmlExample" />
<property name="mime" value="text/xml" />
<bean factory-bean="coreXMLDocExamplePath"
factory-method="getAbsolutePath"/>
</property>
<property name="itsNatServletRequestListener" >
<bean class="itsnatspring.ItsNatServletRequestListenerBean" >
<property name="documentBeanName" value="coreXMLExampleDoc" />
</bean>
</property>
</bean> ...

49

spring.xml (cont.)
<bean id="coreXMLFragExamplePath" class="itsnatspring.WebPathBean">
<property name="relativePath"
value="/WEB-INF/pages/manual/xml_fragment_example.xml" />
</bean>

<bean id="coreXMLExampleFragTemplate"
class="itsnatspring.ItsNatDocFragmentTemplateBean">
<property name="name" value="manual.core.xmlFragExample" />
<property name="mime" value="text/xml" />
<bean factory-bean="coreXMLFragExamplePath"
factory-method="getAbsolutePath"/>
</property>
</bean>

</beans>

50

ItsNatDocFragmentTemplateBean
• With this class the template fragment is registered
...
public class ItsNatDocFragmentTemplateBean
implements InitializingBean,ApplicationContextAware
{
protected String name;
protected String mime;
protected Object source;
...
@Override
// name, mime and source are mandatory
ItsNatHttpServlet itsNatHttpServlet =
ItsNatBeansRegistryUtil.getItsNatHttpServlet(context);
ItsNatDocFragmentTemplate fragTemplate;
fragTemplate = itsNatHttpServlet.registerItsNatDocFragmentTemplate(
name,mime,source);
// More config here...
}
} 51

CONCLUSION
Can you use Spring to configure “any”
API?

52

How to configure with Spring an api not based on Spring

Recomendados

Recomendados

Mais conteúdo relacionado

Mais procurados

Mais procurados (20)

Semelhante a How to configure with Spring an api not based on Spring

Semelhante a How to configure with Spring an api not based on Spring (20)

Último

Último (20)

How to configure with Spring an api not based on Spring