<!-- 
	Licensed to the Apache Software Foundation (ASF) under one
	or more contributor license agreements.  See the NOTICE file
	distributed with this work for additional information
	regarding copyright ownership.  The ASF licenses this file
	to you under the Apache License, Version 2.0 (the
	"License"); you may not use this file except in compliance
	with the License.  You may obtain a copy of the License at
	
	http://www.apache.org/licenses/LICENSE-2.0
	
	Unless required by applicable law or agreed to in writing,
	software distributed under the License is distributed on an
	"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
	KIND, either express or implied.  See the License for the
	specific language governing permissions and limitations
	under the License.
-->
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">

<beans>


	<!--
		A very simple session example - which creates new sessions and shows the number
		of times a session has been accessed.
		Simply accessing the service will create a new session (if none already exists),
		and display an access count for the current session upon each access.
		Passing the "destroySession" request parameter causes the current session to
		be destroyed
	-->
	<bean name="sessionService"
		class="org.apache.asyncweb.examples.session.SessionExample" />

</beans>
