<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema"
	attributeFormDefault="unqualified" elementFormDefault="qualified"
	targetNamespace="http://robin.mytechtip.com/springws2example/temperature/schemas">
 
	<xs:element name="GetTemperaturesRequest">
		<xs:complexType>
			<xs:sequence>
				<xs:element name="city" type="xs:string" />
				<xs:element maxOccurs="5" minOccurs="1" name="date" type="xs:date" />
			</xs:sequence>
		</xs:complexType>
	</xs:element>
 
	<xs:element name="GetTemperaturesResponse">
		<xs:complexType>
			<xs:sequence>
				<xs:element maxOccurs="5" minOccurs="1" name="TemperatureInfo">
					<xs:complexType>
						<xs:sequence>
							<xs:element name="min" type="xs:float" />
							<xs:element name="max" type="xs:float" />
							<xs:element name="average" type="xs:float" />
						</xs:sequence>
						<xs:attribute name="city" type="xs:string" use="optional" />
						<xs:attribute name="date" type="xs:date" use="optional" />
					</xs:complexType>
				</xs:element>
			</xs:sequence>
		</xs:complexType>
	</xs:element>
</xs:schema>

package com.mytechtip.robin.springws2example;
 
import java.util.Date;
import java.util.List;
 
public interface TemperatureService {
    public List<TemperatureInfo> getTemperatures(String city, List<Date> date);
}

package com.mytechtip.robin.springws2example;
 
import java.util.ArrayList;
import java.util.Date;
import java.util.List;
import java.util.Random;
 
public class TemperatureServiceImpl implements TemperatureService {
 
	private Random rand = new Random(7);
 
	@Override
	public List<TemperatureInfo> getTemperatures(String city, List<Date> dates) {
		List<TemperatureInfo> temperatures = new ArrayList<TemperatureInfo>();
		// Just return some random data
		for (Date date : dates) {
			temperatures.add(new TemperatureInfo(city, date, rand.nextInt(15),
					rand.nextInt(15) + 15, (rand.nextInt(30) + 15) / 2.0));
		}
 
		return temperatures;
	}
}

 
package com.mytechtip.robin.springws2example;
 
import java.io.Serializable;
import java.util.Date;
 
public class TemperatureInfo implements Serializable {
	private static final long serialVersionUID = 1L;
 
	private String city;
    private Date date;
    private double min;
    private double max;
    private double average;
 
    public TemperatureInfo() {}
 
    public TemperatureInfo(String city, Date date, double min, double max, double average) {
        this.city = city;
        this.date = date;
        this.min = min;
        this.max = max;
        this.average = average;
    }
 
    // Some getter and setter methods
    // ...
 
}

 
package com.mytechtip.robin.springws2example;
 
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Date;
import java.util.List;
 
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.ws.server.endpoint.annotation.Endpoint;
import org.springframework.ws.server.endpoint.annotation.PayloadRoot;
 
import com.mytechtip.robin.springws2Example.temperature.schemas.GetTemperaturesRequestDocument;
import com.mytechtip.robin.springws2Example.temperature.schemas.GetTemperaturesRequestDocument.GetTemperaturesRequest;
import com.mytechtip.robin.springws2Example.temperature.schemas.GetTemperaturesResponseDocument;
import com.mytechtip.robin.springws2Example.temperature.schemas.GetTemperaturesResponseDocument.GetTemperaturesResponse;
 
@Endpoint
public class TemperatureMarshallingEndpoint {
 
	private static final String namespaceUri = "http://robin.mytechtip.com/springws2example/temperature/schemas";
 
	private TemperatureService temperatureService;
 
	@Autowired
	public void setTemperatureService(TemperatureService tempService) {
		this.temperatureService = tempService;
	}
 
	@PayloadRoot(localPart = "GetTemperaturesRequest", namespace = namespaceUri)
	public GetTemperaturesResponseDocument getTemperatures(
			GetTemperaturesRequestDocument request) {
 
		GetTemperaturesRequestDocument requestDoc = request;
		GetTemperaturesRequest in = requestDoc.getGetTemperaturesRequest();
 
		List<Date> dates = new ArrayList<Date>();
		for (Calendar calendar : in.getDateArray()) {
			dates.add(calendar.getTime());
		}
 
		List<TemperatureInfo> infos = temperatureService.getTemperatures(
				in.getCity(), dates);
 
		GetTemperaturesResponseDocument responseDoc = GetTemperaturesResponseDocument.Factory
				.newInstance();
		GetTemperaturesResponse response = responseDoc
				.addNewGetTemperaturesResponse();
 
		for (TemperatureInfo info : infos) {
			GetTemperaturesResponse.TemperatureInfo out = response
					.addNewTemperatureInfo();
 
			out.setCity(info.getCity());
			out.setAverage((float) info.getAverage());
 
			Calendar calendar = Calendar.getInstance();
			calendar.setTime(info.getDate());
			out.setDate(calendar);
			out.setMax((float) info.getMax());
			out.setMin((float) info.getMin());
		}
 
		return responseDoc;
	}
}

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE web-app
    PUBLIC "-//Sun Microsystems, Inc.//DTD Web Application 2.3//EN"
    "http://java.sun.com/dtd/web-app_2_3.dtd">
 
<web-app>
	<servlet>
		<servlet-name>springws2example</servlet-name>
		<servlet-class>
			org.springframework.ws.transport.http.MessageDispatcherServlet
        </servlet-class>
		<init-param>
			<param-name>transformWsdlLocations</param-name>
			<param-value>true</param-value>
		</init-param>
		<load-on-startup>1</load-on-startup>
	</servlet>
 
	<servlet-mapping>
		<servlet-name>springws2example</servlet-name>
		<url-pattern>/services/*</url-pattern>
	</servlet-mapping>
</web-app>

 
<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"
	xmlns:sws="http://www.springframework.org/schema/web-services"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
  http://www.springframework.org/schema/web-services http://www.springframework.org/schema/web-services/web-services-2.0.xsd
  http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd">
 
	<context:component-scan base-package="com.mytechtip.robin.springws2example" />
 
	<sws:annotation-driven />
 
	<bean class="com.mytechtip.robin.springws2example.TemperatureServiceImpl"></bean>
 
	<bean
		class="org.springframework.ws.server.endpoint.adapter.GenericMarshallingMethodEndpointAdapter">
		<property name="marshaller" ref="marshaller" />
		<property name="unmarshaller" ref="marshaller" />
	</bean>
 
	<bean id="marshaller" class="org.springframework.oxm.xmlbeans.XmlBeansMarshaller">
	</bean>
 
	<sws:dynamic-wsdl id="temperature" portTypeName="TempeatureService"
		locationUri="/services/temperature" >
		<sws:xsd location="/WEB-INF/temperature.xsd" />
	</sws:dynamic-wsdl>
 
</beans>

    // an IndexWriter instance created through method getWriter
    IndexWriter writer = getWriter(dir);
    // The tweak starts here
    MergePolicy mp = writer.getMergePolicy();
    if (mp instanceof LogByteSizeMergePolicy) {
        LogByteSizeMergePolicy lbsmp = (LogByteSizeMergePolicy) mp;
        lbsmp.setNoCFSRatio(1.0);
    }

import java.util.Arrays;
import java.util.Date;
import java.util.List;
 
import com.google.gwt.cell.client.DateCell;
import com.google.gwt.core.client.EntryPoint;
import com.google.gwt.user.cellview.client.CellTable;
import com.google.gwt.user.cellview.client.Column;
import com.google.gwt.user.cellview.client.SimplePager;
import com.google.gwt.user.cellview.client.TextColumn;
import com.google.gwt.user.client.ui.RootPanel;
import com.google.gwt.user.client.ui.VerticalPanel;
import com.google.gwt.view.client.AsyncDataProvider;
import com.google.gwt.view.client.HasData;
 
public class CellTableExample implements EntryPoint {
 
  /**
   * A simple data type that represents a contact.
   */
  private static class Contact {
    private final String address;
    private final Date birthday;
    private final String name;
 
    public Contact(String name, Date birthday, String address) {
      this.name = name;
      this.birthday = birthday;
      this.address = address;
    }
  }
 
  /**
   * The list of data to display.
   */
  @SuppressWarnings("deprecation")
  private static final List<Contact> CONTACTS = Arrays.asList(
      new Contact("John", new Date(80, 4, 12), "123 Abc Avenue"), 
      new Contact("Joe", new Date(85, 2, 22), "22 Lance Ln"), 
      new Contact("Tom", new Date(85, 3, 22), "33 Lance Ln"), 
      new Contact("Jack", new Date(85, 4, 22), "44 Lance Ln"), 
      new Contact("Tim", new Date(85, 5, 22), "55 Lance Ln"), 
      new Contact("Mike", new Date(85, 6, 22), "66 Lance Ln"), 
      new Contact("George", new Date(46, 6, 6),"77 Lance Ln"));
 
  public void onModuleLoad() {
    // Create a CellTable.
    final CellTable<Contact> table = new CellTable<Contact>();
    // Display 3 rows in one page
    table.setPageSize(3);
 
    // Add a text column to show the name.
    TextColumn<Contact> nameColumn = new TextColumn<Contact>() {
      @Override
      public String getValue(Contact object) {
        return object.name;
      }
    };
    table.addColumn(nameColumn, "Name");
 
    // Add a date column to show the birthday.
    DateCell dateCell = new DateCell();
    Column<Contact, Date> dateColumn = new Column<Contact, Date>(dateCell) {
      @Override
      public Date getValue(Contact object) {
        return object.birthday;
      }
    };
    table.addColumn(dateColumn, "Birthday");
 
    // Add a text column to show the address.
    TextColumn<Contact> addressColumn = new TextColumn<Contact>() {
      @Override
      public String getValue(Contact object) {
        return object.address;
      }
    };
    table.addColumn(addressColumn, "Address");
 
    // Associate an async data provider to the table
	// XXX: Use AsyncCallback in the method onRangeChanged
	// to actaully get the data from the server side
    AsyncDataProvider<Contact> provider = new AsyncDataProvider<Contact>() {
      @Override
      protected void onRangeChanged(HasData<Contact> display) {
        int start = display.getVisibleRange().getStart();
        int end = start + display.getVisibleRange().getLength();
        end = end >= CONTACTS.size() ? CONTACTS.size() : end;
        List<Contact> sub = CONTACTS.subList(start, end);
        updateRowData(start, sub);
      }
    };
    provider.addDataDisplay(table);
    provider.updateRowCount(CONTACTS.size(), true);
 
    SimplePager pager = new SimplePager();
    pager.setDisplay(table);
 
    VerticalPanel vp = new VerticalPanel();
    vp.add(table);
    vp.add(pager);
 
    // Add it to the root panel.
    RootPanel.get().add(vp);
  }
}

// Associate an async data provider to the table
    AsyncDataProvider<Contact> provider = new AsyncDataProvider<Contact>() {
      @Override
      protected void onRangeChanged(HasData<Contact> display) {
        final int start = display.getVisibleRange().getStart();
        int length = display.getVisibleRange().getLength();
        AsyncCallback<List<Contact>> callback = new AsyncCallback<List<Contact>>() {
          @Override
          public void onFailure(Throwable caught) {
            Window.alert(caught.getMessage());
          }
          @Override
          public void onSuccess(List<Contact> result) {
            updateRowData(start, result);
          }
        };
        // The remote service that should be implemented
        remoteService.fetchPage(start, length, callback);
      }
    };

<bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
  <property name="ignoreResourceNotFound" value="true" />
  <property name="locations">
    <value>file:///etc/app/jdbc.properties</value>
  </property>
  <property name="properties">
    <props>
      <prop key="jdbc.driverClassName">com.mysql.jdbc.Driver</prop>
      <prop key="jdbc.url">jdbc:mysql://localhost:3306/mytechtip</prop>
      <prop key="jdbc.username">jdbc_username</prop>
      <prop key="jdbc.password">xxx</prop>
    </props>
  </property>
 
</bean>
 
<bean id="dataSource" destroy-method="close" 
    class="org.apache.commons.dbcp.BasicDataSource">
  <property name="driverClassName" value="${jdbc.driverClassName}"/>
  <property name="url" value="${jdbc.url}"/>
  <property name="username" value="${jdbc.username}"/>
  <property name="password" value="${jdbc.password}"/>
</bean>

<?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:p="http://www.springframework.org/schema/p"
  xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
    <bean id="entityManagerFactoryCreator" 
    class="com.mytechtip.example.EntityManagerFactoryCreator">
    <property name="persistenceUnitName" value="HRMN_Repository"/>
    <property name="jpaProperties">
      <props>
        <prop key="openjpa.ConnectionURL">the_url</prop>
        <prop key="openjpa.ConnectionDriverName">the_driver_class_name</prop> 
        <prop key="openjpa.ConnectionUserName">the_user_name</prop>
        <prop key="openjpa.ConnectionPassword">the_password</prop>
      </props>
    </property>
  </bean>
</beans>

    // ...
    private Properties jpaProperties;
    //...
    public void setJpaProperties(Properties prop) {
        this.jpaProperties = prop;
    }
    // ...
    public EntityManagerFactory create() {
        return Persistence.createEntityManagerFactory("myPersistenceUnit", prop);
    }

<?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:p="http://www.springframework.org/schema/p"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
 
	<bean id="dbManager" class="com.mytechtip.example.DbManager">
		<property name="jdbcDriver" value="com.mysql.jdbc.Driver"/>
		<property name="jdbcUrl" value="jdbc:mysql://localhost/app"/>
		<property name="jdbcUser" value="app" />
		<property name="jdbcPassword" value="app" />
	</bean>
</beans>

package com.mytechtip.example;
 
import java.sql.Connection;
import java.sql.DriverManager;
 
public class DbManager {
 
	private String jdbcDriver;
	private String jdbcUrl;
	private String jdbcUser;
	private String jdbcPassword;
 
	public String getJdbcDriver() {
		return jdbcDriver;
	}
	public void setJdbcDriver(String jdbcDriver) {
		this.jdbcDriver = jdbcDriver;
	}
 
        // more getters and setters ...
 
	public Connection getConnection() throws Exception {
             Class.forName (getJdbcDriver()).newInstance();
             return DriverManager.getConnection(
                   getJdbcUrl(), getJdbcUser(), getJdbcPassword());
	}
}