Spring

Struts

MVC – Model-1

· Aplicações complexas, utilizando Model 1 normalmente tem uma grande quantidade de scriptlets com código Java presente nas páginas JSP

Temos problemas com isso
- O Web Designer precisa conhecer Java
- As páginas ficam difíceis de entender
- A manutenção se torna difícil
- Lógica e apresentação acabam se misturando

· Para resolver esses problemas, podemos utilizar JSP Tags Extension(Custom Tags)

Extensão da tecnologia JSP para a criação de novas tags.

· Struts tem um conjunto dessas tags, que são as “tag libraries” para diminuir a quantidade de código Java nos JSPs. (Se possível chegar a 0%).

MVC – Model-2

· Arquiteturalmente falando, o Struts segue o MCV2:

Componentes do Struts

· Aplicações que utilizam Model 2 utilizam Servlets e JSP tirando vantagem das melhores características de cada uma das tecnologias.

Controlador (C)

Um servlet da aplicação, responsável por criar todos os objetos e beans utilizados pelas páginas JSP.
Configurável através de um arquivo XML
Este servlet irá encaminhar as requisições a classes (Action Classes, ou subclasses dela) que devem ser criadas pelo desenvolvedor para realizar o processamento

View (V): normalmente a visão é implementada através de uma página HTML ou JSP.

Model (M): geralmente o modelo é implementado através de um objeto Java (um Javabean).

Classes Auxiliares: Struts oferece um conjunto de classes que auxiliam no desenvolvimento:

FormBeans: utilizada no encapsulamento de dados de formulários HTML , Ligado ao Modelo.

ActionErrors: utilizada no encapsulamento de dados de erros, Ligada ao Modelo.

Tags Personalizadas (Custom Tags): encapsulam a lógica para a apresentação, Ligada à Visão.

Actions: implementam a lógica dos comandos, Ligada ao Controle.

ActionForward : Utilizadas para encasulamento da lógica de redirecionamento.

Tag libraries

Bean tags definir novos beans (em qualquer escopo) a partir de uma variedade de fontes e para imprimir beans e suas propriedades na resposta
- Exemplo: <bean:write name="user" property="fullName"/>
HTML tags para ajudar a montar páginas JSP mais rapidamente, principalmente forms
- Exemplo: montar um Select HTML a partir de uma coleção
  <html:select property="type">
  <html:options collection="serverTypes" property="value"
  labelProperty="label"/>
  </html:select>
Logic tags para fazer um pouco de lógica sem scriptlets, mas apenas através de parâmetros apropriados
- Exemplo: Iterar uma coleção e produzir HTML
<logic:iterate id="subscription" name="user" property="subscriptions">
    <tr>
        <td align="left">
            <bean:write name="subscription" property="host"
                                filter="true"/>
        </td>
        <td align="left">
            <bean:write name="subscription" property="username" filter="true"/>
        </td>
    </tr>
</logic:iterate>

Funcionamento:

1. Usuário clica em um link ou enviar um formulário em uma página HTML

2. Servlet controlador recebe a requisição, verifica as informações de mapeamento em struts-config.xml e encaminha o processamento para uma ação

3. A ação faz um chamado para um serviço da camada de modelo. A ação recebe um objeto do modelo como parâmetro.

4. Faz-se a computação necessária dentro da action.

5. A action retona ao controlador principal um ActionForward dizendo para onde quer ser enviada.

6. O Servlet verifica o mapeamento do recurso solicitado e

encaminha o processamento a página JSP.

7. O arquivo JSP é invocado e enviado ao navegador como HTML.

8. Ao usuário é apresentada uma nova página HTML no navegador.

Exemplo

A primeira coisa a se fazer é baixar o Struts:
- http://jakarta.apache.org/struts
- Ai você vai encontrar informações sobre os jars que devem ir para o classpath e tudo que é preciso para desenvolver aplicações com o Struts
  - Você pode baixar o exemplo usado na disciplina aqui
  - Acompanhe o exemplo da disciplina rodando aqui

Primeira tela

Segunda tela

Terceira tela

Vamos da uma olhada com mais detalhes em nosso exemplo

Primeira página

<%@ include file="headerCode.jsp" %>

<html:html locale="true">

<html:base/>

<head>

<title><bean:message key="application.title"/></title>

<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">

</head>

<body>

<table width="75%" border="1">

<tr>

<td><html:errors/></td>

</tr>

</table>

<html:form action="/cadastroUsuario?metodo=cadastraUsuario" focus="login">

<table>

<tr>

<td>

                    <bean:message key="index.senha"/>:
             </td>
             <td>
                    <html:password property="senha" />
             </td>
       </tr>

<table>

                           <html:submit value="Enviar dados "/>
                    </td>
             </tr>
       </table>

</table>

</html:form>

<logic:present name="lista_usuarios">

<td>E-mail</td>

<td>Opção</td>

</tr>

<logic:iterate id="usuarioCorrente" name="lista_usuarios" indexId="index">

<td><bean:write name="usuarioCorrente" property="mail"/></td>

<td>
<a href='<html:rewrite page="/removeUsuario.do"/>?metodo=removeUsuario&pos=<bean:write name="index"/>'>excluir</a>

</td>
</tr>

</logic:iterate>

</table>

</logic:present>

</body>

</html:html>

A primeira coisa interessante aqui é:

<%@ include file="headerCode.jsp" %>
Isso coloca dentro dessa página o conteúdo da página headerCode.jsp

<%@ taglib uri="/WEB-INF/struts-bean.tld" prefix="bean" %>

<%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html" %>

<%@ tagliburi="/WEB-INF/struts-logic.tld" prefix="logic" %>

O arquivo tld, é onde encontramos as descrições e validações das tags que iremos usar com os prefixos bean, html e logic

Essa tag quando é processada e seu código html é gerado temso o seguinte resultado

<html:html locale="true"> = <html lang="pt">
Essa tag cria um link relativo ao seu local, para que apontadores relativos possam funcionar.

<html:base/>=<base href="http://host:8080/caminho/nome.jsp ">

A seguinte linha é usada para mostrar mensagens internacionalizadas

O servlet de controle já vai ter instanciado um objetos antes de chegar a index.jsp

Um Message Resource (usado com <bean:message ...>)

<bean:message key="application.title"/>

A tag a seguir é uma forma fácil de imprimir todos os erros de uma só vez.

<html:errors/>

Esta tag verifica a configuração da aplicação (que veremos adiante) procurando um bean especial ("Form bean") relacionado com /index.jsp

Neste caso, o tag acha um tal Form bean e verifica se já foi instanciado

Como não foi instanciado, um novo objeto é criado

Quando o form é submetido via HTTP, Struts automaticamente transfere todos os campos do form (no request) para o Form bean

O que você tem que fazer para que isso ocorra:

Definir uma classe para o Form bean (com getters e setters para os campos)

Adicionar a classe à configuração da aplicação

Ligar a classe ao mapeamento da ação, usando o mesmo nome (name="usuarioForm")

<html:form action="/cadastroUsuario?metodo=cadastraUsuario" focus="login">

Esta tag é uma entrada (input) com o nome de login, isso significa que você tem que ter uma propriedade String login no seu bean.(usuarioForm)

<html:text property="login" />

Esta tag envia os dados do formulário para o servlet controlador do Struts

<html:submit value="Enviar dados "/>

Agora vamos ver como encaixar tudo com o arquivo de configuração do struts(struts-config.xml)

<?xml version="1.0" encoding="ISO-8859-1" ?>

<!DOCTYPE struts-config PUBLIC "-//Apache Software Foundation//DTD Struts Configuration 1.1//EN" "http://jakarta.apache.org/struts/dtds/struts-config_1_1.dtd">

<struts-config>

<data-sources />

<form-beans>

<!—Estamos dando um nome ao bean usuarioActionForm -->

<form-bean name="usuarioForm" type="daca.actionform.UsuarioActionForm" />

</form-beans>

<global-exceptions />

<global-forwards>

<forward name="sucesso" path="/sucesso.jsp" />

<forward name="pagina_inicial" path="/index.jsp" />

</global-forwards>

<action-mappings>

</action-mappings>

<message-resources parameter="application" />

<!—diz onde encontrar os arquivos de validação-->

<plug-in className="org.apache.struts.validator.ValidatorPlugIn">

<set-property property="pathnames" value="/WEB-INF/validator-rules.xml, /WEB-INF/validation.xml"/>

</plug-in>

</struts-config>

Web.xml

<?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>

  <display-name>Daca</display-name>

  <listener>
    <listener-class>daca.ContextListener</listener-class>
  </listener>

    <!-- Standard Action Servlet Configuration (with debugging) -->

  <servlet>

    <servlet-name>action</servlet-name>

	<servlet-class>org.apache.struts.action.ActionServlet</servlet-class>

    <init-param>
      <param-name>config</param-name>
      <param-value>/WEB-INF/struts-config.xml</param-value>
    </init-param>

    <init-param>
      <param-name>debug</param-name>
      <param-value>2</param-value>
    </init-param>

    <init-param>
      <param-name>detail</param-name>
      <param-value>2</param-value>
    </init-param>

    <load-on-startup>2</load-on-startup>

  </servlet>

	<!-- Spring Servlet-->	
	<servlet>
	   	<servlet-name>SpringContextServlet</servlet-name>
	   	<servlet-class>org.springframework.web.context.ContextLoaderServlet</servlet-class>	  
	  	<load-on-startup>2</load-on-startup>
	</servlet>

    <!-- Standard Action Servlet Mapping -->

  <servlet-mapping>
    <servlet-name>action</servlet-name>
    <url-pattern>*.do</url-pattern>
  </servlet-mapping>

  <welcome-file-list>
    <welcome-file>/index.jsp</welcome-file>
  </welcome-file-list>

   <!-- Struts Tag Library Descriptors -->

  <taglib>
    <taglib-uri>/tags/struts-bean</taglib-uri>
    <taglib-location>/WEB-INF/struts-bean.tld</taglib-location>
  </taglib>

  <taglib>
    <taglib-uri>/tags/struts-html</taglib-uri>
    <taglib-location>/WEB-INF/struts-html.tld</taglib-location>
  </taglib>

  <taglib>
    <taglib-uri>/tags/struts-logic</taglib-uri>
    <taglib-location>/WEB-INF/struts-logic.tld</taglib-location>
  </taglib>

</web-app>

Relembrando o funcionamento

· A implementação do Bean

package daca.actionform;

import java.lang.reflect.InvocationTargetException;

import javax.servlet.http.HttpServletRequest;

import org.apache.commons.beanutils.BeanUtils;

import org.apache.struts.action.ActionError;

import org.apache.struts.action.ActionErrors;

import org.apache.struts.action.ActionForm;

import org.apache.struts.action.ActionMapping;

import org.apache.struts.validator.ValidatorActionForm;

import org.apache.struts.validator.ValidatorForm;

import daca.business.Usuario;

/**

* @author marcos

* Classe que recebe os dados do usuário enviados de um formulário

public class UsuarioActionForm extends ValidatorForm {

private String login="";

private String senha="";

private String mail="";

/**

* @return Returns the login.

public String getLogin() {

return login;

}

/**

* @param login The login to set.

public void setLogin(String login) {

this.login = login;

}

/**

* @return Returns the mail.

public String getMail() {

return mail;

}

/**

* @param mail The mail to set.

public void setMail(String mail) {

this.mail = mail;

}

/**

* @return Returns the senha.

public String getSenha() {

return senha;

}

/**

* @param senha The senha to set.

public void setSenha(String senha) {

this.senha = senha;

}

/**

* cria um usuario do model

* @return usuario, o usuário criado com os dados do form

public Usuario createUsuarioBussiness(){

//TODO usar uma factory, tirar os printStackTrace

Usuario u = new Usuario();

try {

BeanUtils.copyProperties(u, this);

} catch (IllegalAccessException e) {

e.printStackTrace();

} catch (InvocationTargetException e) {

e.printStackTrace();

}

reset();

return u ;

}

/* (non-Javadoc)

* @see org.apache.struts.action.ActionForm#reset(org.apache.struts.action.ActionMapping, javax.servlet.http.HttpServletRequest)

public void reset() {

setLogin("");

setMail("");

setSenha("");

}

/* (non-Javadoc)

* @see org.apache.struts.action.ActionForm#validate(org.apache.struts.action.ActionMapping, javax.servlet.http.HttpServletRequest)

public ActionErrors validate(ActionMapping arg0, HttpServletRequest arg1) {

ActionErrors errors = super.validate(arg0, arg1);

if (getLogin().equals("login")) {

errors.add("login.invalido", new ActionError("login.invalido"));

}

return errors;

}

package daca.service;


import java.util.List;
import daca.business.Usuario;


public interface PersistenteIF {	


	public void save(Usuario usuario);
	public void remove(String id);
	public List selectTodos();	


}

package daca.service;


import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.List;
import org.springframework.jdbc.datasource.DriverManagerDataSource;
import daca.business.Usuario;


public class GerenteBanco implements PersistenteIF{


	private DriverManagerDataSource dataSource;	


	public GerenteBanco(){	
	}


	/* (non-Javadoc)
	 * @see daca.service.PersistenteIF#save(daca.business.Usuario)
	 */
	public void save(Usuario usuario) {		
		try {
			Connection conn = dataSource.getConnection() ;		
			PreparedStatement statement = conn.prepareStatement("insert into usuario (login,senha,mail) values  (?,?,?)");
			statement.setString(1,usuario.getLogin());
			statement.setString(2,usuario.getSenha());
			statement.setString(3,usuario.getMail());
			statement.execute();
			conn.close();
		} catch (SQLException e) {
			e.printStackTrace();
		}		
	}


	/* (non-Javadoc)
	 * @see daca.service.PersistenteIF#remove(java.lang.String)
	 */
	public void remove(String id) {
		try {			
			Connection conn = dataSource.getConnection();
			PreparedStatement statement = conn.prepareStatement("delete from usuario where id=?");
			statement.setString(1,id);			
			statement.execute();
			conn.close();
		} catch (SQLException e) {
			e.printStackTrace();
		}		
	}


	/* (non-Javadoc)
	 * @see daca.service.PersistenteIF#selectTodos()
	 */
	public List selectTodos() {
		Connection conn = null;
		List lista = new ArrayList();
		try {			
			conn = dataSource.getConnection();
			ResultSet rs = conn.createStatement().executeQuery("select * from usuario");
			while(rs.next()){
				Usuario u = new Usuario();
				u.setId(rs.getInt(1));
				u.setLogin(rs.getString(2));				
				u.setSenha(rs.getString(3));
				u.setMail(rs.getString(4));
				lista.add(u);
			}
			conn.close();
		} catch (SQLException e) {
			e.printStackTrace();
		}
		
		return lista;
	}


	/**
	 * @return Returns the dataSource.
	 */
	public DriverManagerDataSource getDataSource() {
		return dataSource;
	}


	/**
	 * @param dataSource The dataSource to set.
	 */
	public void setDataSource(DriverManagerDataSource dataSource) {
		this.dataSource = dataSource;
	}


}

package daca.service;


import org.springframework.context.ApplicationContext;
import org.springframework.web.context.support.WebApplicationContextUtils;
import daca.util.Util;


public  class ServiceLocator {	

	private static ServiceLocator self = null;	


	//the persistence service bean name
	private static final String PERSISTENT_SERVICE_BEAN_NAME = "servicoPersistencia";	

	//the Spring application context
	private ApplicationContext appContext;	


	//the cached user service
	private PersistenteIF servicoUsuario;	


	/**
	 * Construtor.
	 * <p>
	 * Cria um objeto chamado de WebApplicationContext a partir de um contexto guardado na classe Util
	 */
	private ServiceLocator() {		
		this.appContext = WebApplicationContextUtils.getRequiredWebApplicationContext(Util.singleton().getContext());		
		servicoUsuario = (PersistenteIF) lookupService(PERSISTENT_SERVICE_BEAN_NAME);		
	}	


	public static ServiceLocator singleton(){
		if (self == null) {
			self = new ServiceLocator();
		}
		return self;
	}		


	public PersistenteIF getServicoUsuario() {
		return this.servicoUsuario;
	}


	/**
	 * Socaliza um serviço baseado no nome do bean	 * 
	 * @param serviceBeanName o nome do bean a ser pesquisado
	 * @return o bean de serviço
	 */
	public Object lookupService(String serviceBeanName) {
		return appContext.getBean(serviceBeanName);
	}
}

A action

package daca.action;

import java.io.IOException;

import java.util.ArrayList;

import java.util.List;

import javax.servlet.ServletException;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

import org.apache.struts.action.ActionError;

import org.apache.struts.action.ActionErrors;

import org.apache.struts.action.ActionForm;

import org.apache.struts.action.ActionForward;

import org.apache.struts.action.ActionMapping;

import org.apache.struts.actions.DispatchAction;

import daca.actionform.UsuarioActionForm;

import daca.util.DCConstants;

public class UsuarioAction extends DispatchAction {

/* (non-Javadoc)

* @see org.apache.struts.action.Action#perform(org.apache.struts.action.ActionMapping, org.apache.struts.action.ActionForm, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)

public ActionForward cadastraUsuario(ActionMapping mapping, ActionForm form,

HttpServletRequest request, HttpServletResponse response)

throws IOException, ServletException {

UsuarioActionForm usuario =(UsuarioActionForm) form;

List listaDeUsuario = (List) request.getSession().getAttribute(DCConstants.LISTA_USUARIO);

if (listaDeUsuario == null){

listaDeUsuario = new ArrayList();

request.getSession().setAttribute(DCConstants.LISTA_USUARIO, listaDeUsuario);

}

listaDeUsuario.add(usuario.createUsuarioBussiness());

return mapping.findForward(DCConstants.PAGINA_INICIAL);

}

/* (non-Javadoc)

public ActionForward removeUsuario(ActionMapping mapping, ActionForm form,

HttpServletRequest request, HttpServletResponse response)

throws IOException, ServletException {

String posicao = request.getParameter("pos");

List listaDeUsuario = (List) request.getSession().getAttribute(DCConstants.LISTA_USUARIO);

if (posicao != null) {

try {

listaDeUsuario.remove(Integer.parseInt(posicao));

}catch (Exception e) {

ActionErrors errors = new ActionErrors();

errors.add("erro_parametro_invalido",new ActionError("error.usuario.naoremovido"));

super.saveErrors(request,errors);

}

return mapping.findForward(DCConstants.PAGINA_INICIAL);

}

· Depois da computação feita na action, temos uma coleção na sessão com usuários, mostramos o resultado com a tag iterate

<logic:present name="lista_usuarios">

<tr>

<td>Opção</td>

</tr>

<logic:iterate id="usuarioCorrente" name="lista_usuarios" indexId="index">

<tr>

<td>

<a href='<html:rewrite page="/removeUsuario.do"/>?metodo=removeUsuario&pos=<bean:write name="index"/>'>excluir</a>

</td>

</tr>

</logic:iterate>

</table>

</logic:present>

Essa linha é a responsável por remover um usuário da lista

<a href='<html:rewrite page="/removeUsuario.do"/>?metodo=removeUsuario&pos=

<bean:write name="index"/>'>excluir</a>

rewrite é uma tag para que possamos ficar independente de contexto, http://host:8080/contexto
metodo, diz qual método chamar na classe, lembre do mapeamento que fizemos da action
<bean:write name=”index”/>, imprime o numero corrente da iteração. Assim é possível pegar o índice para excluir o usuário correto
A action /removeUsuario.do, tem funcionamento semelhante ao cadastra, mas não precisa de um form.

Finalmente ...

Struts faz mais do que mostrei aqui, principalmente nas taglibs

Examine a documentação das taglibs aqui

Spring

J2EE

Aplicações J2EE são compostas de componentes
Para nós, um componente é uma unidade autocontida de software que pode ser composta numa aplicação em tempo de design (sem compilação)
Componentes J2EE são escritos em Java

Componentes J2EE na Camada de Apresentação

Os seguintes componentes podem existir na camada de apresentação:

"Application client" (cliente não-Web)
Tipicamente usa Swing como User Interface (UI)
Também chamado "Console Application"
Applets

Componentes J2EE na Camada Web

Componentes da camada Web podem incluir vários módulos, incluindo:
Páginas HTML/XML estáticas
Servlets
Programas em Java que rodam no servidor Web e que processam pedidos gerando respostas dinâmicas
Java Server pages (JSP)
Templates HTML mais fáceis de criar, mas contendo "scriplets" (trechos em Java) para a geração de conteúdo dinâmico
São convertidas em servlets quando acessadas pela primeira vez
JavaBeans
Componentes tradicionais em Java que podem ser usados em servlets e JSPs

Componentes J2EE na Camada de Aplicação

Componentes da camada de aplicação são chamados Enterprise Java Beans (EJB)

Há vários tipos de EJBs:

Session Beans

Representam uma conversação transiente com um cliente

Quando o cliente termina, a session bean some

Entity Bean
- Representam dados persistentes gravados num banco de dados (tipicamente uma linha de uma tabela)
Message-Driven Bean
- Uma combinação de um session bean com um Listener de mensagem Java Message Service (JMS)
- Permite que um componente de aplicação (o message bean) receba mensagens assíncronas
- Isso significa que podemos acoplamento muito fraco entre pedaços da aplicação: importante quando máquinas remotas estão envolvidas e podem nem estar no ar, ou pelo menos, poderão não responder de forma síncrona a chamadas remotas

A camada de dados

Observe que a camada de chamamos "de dados" pode ser um banco de dados ou outra coisa:

Sistema Legado

Containers

A chave da arquitetura J2EE é que muito trabalho normalmente feito pelo programador é poupado, já que é feito automaticamente pelo middleware

O programador se concentra no Business Logic

A entidade que faz essa mágica é o Container

Serviços

Gerenciamento de ciclo de vida
Localização de componentes
Comunicação transparente
Troca de mensagens
Segurança (http://java.sun.com/docs/books/tutorial/security1.2/index.html)
Persistência
Transações
Pool

J2EE é bem mais que EJB?

· Sim, muitas pessoas pensam que se não tivermos EJB não estamos desenvolvendo uma aplicação J2EE. Como vimos acima J2EE é bem mais do que EJB.

Porque desenvolver aplicações sem EJB ?

· Deploy complexo

· Configuração complexa

· Desempenho nem sempre é adequado

· Aprendizagem complicada

· Dificulta a testabilidade

· Acúmulo de funcionalidades que nem sempre são necessárias para a aplicação.

Como implementar os serviços descritos até aqui resolvendo os problemas acima?

· Lightweight container (containers leves).

Serviços embutidos nos lightweight containers

· Gerenciamento do ciclo de vida.

· Localização de componentes

· Dependência de resolução: resolver as dependências de implementação através do seu esquema de configuração(Veja mais detalhes em IOC mais adiante)

Potenciais serviços

· Enterprise service: Gerência de transação ou a declaração de serviços para os objetos que estão “rodando” no container

· Thread management: o container oferece um modelo de threads para acessar e gerenciar os objetos

· Clustering

· Management: gerência de serviços para os objetos que estão “rodando” dentro dele.

· Exposing remoting service: acesso remoto para os objetos que estão rodando no container.

· Consulting remote service: prover acesso transparente para objetos que estão rodando do outro lado do container.

· Customization and extensibility: permite adicionar serviços de forma declarativa aos objetos que estão “rodando” dentro do container.

Entendendo Inversão de controle (Invertion of control- IoC)

· O que queremos com IoC é minimizar dependência

· IoC é uma forma de controlar e desenvolver aplicações de forma que estas sejam mais flexíveis e mais "limpas".

· É um conceito interessante e que facilmente pode ser utilizado para construir códigos muito mais elegantes.

Problema

public class JDBCDataManger {

public void accessData() {

// temos um forte acoplamento aqui

DataSource dataSource = new DataSource();

//access data

...
}
}

Possível solução

Setter Injection
- resolver as dependências em um arquivo, por exemplo:

public class JDBCDataManger {
  private DataSource dataSource;
  
  public void setDataManager(DataSource dataSource {
    this.dataSource = dataSource;
  }
  
  public void getData() {
      //use dataSource for something
  }
}

<bean id="myDataSource" 
  class="org.apache.commons.dbcp.BasicDataSource" >
  <property name="driverClassName">
    <value>com.mydb.jdbc.Driver</value>
  </property>
  <property name="url">
    <value>jdbc:mydb://server:port/mydb</value>
  </property>
  <property name="username">
    <value>root</value>
  </property>
</bean>



<bean id="dataManager" 
  class="example.JDBCDataManger">
  <property name="dataSource">
    <ref bean="myDataSource"/>
  </property>
</bean>

Exemplo comentado:

A primeira página fica praticamente sem mudanças:


<%@ include file="headerCode.jsp" %><html:html locale="true">
<html:base/>
<head>
<title><bean:message key="application.title"/></title>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
</head>
<body>
<table width="75%" border="1">
  <tr>
    <td><html:errors/></td>
  </tr>
</table>
<html:form action="/cadastroUsuario?metodo=cadastraUsuario" focus="login">

<table>	
	<tr>
		<td>
			<bean:message key="index.login"/>	: 
		</td>
		<td>
			<html:text property="login" />
		</td>
	</tr>	
	<tr>
		<td>
			<bean:message key="index.mail"/> : 	
		</td>
		<td>
			<html:text property="mail"/>
		</td>		
	</tr>
	<tr>
		<td>
			<bean:message key="index.senha" />: 
		</td>
		<td>
			<html:password property="senha" />
		</td>		
	</tr>	
	<table>
		<tr>	
			<td>
				<html:submit value="Enviar dados "/> 
			</td>
		</tr>
	</table>	
</table>
</html:form>
<logic:present name="lista_usuarios">
<table width="75%" border="1">
  <tr>
    <td>Nome</td>
    <td>E-mail</td>
    <td>Opção</td>
  </tr>
<logic:iterate id="usuarioCorrente" name="lista_usuarios" indexId="index">
	  <tr>
		<td><bean:write name="usuarioCorrente" property="login"/></td>
		<td><bean:write name="usuarioCorrente" property="mail"/></td>
		<td><a href='<html:rewrite page="/removeUsuario.do"/>?metodo=removeUsuario&

id=<bean:write name="usuarioCorrente" property="id"/>'>excluir</a></td>
	  </tr>    
 </logic:iterate>
</table>
</logic:present>
</body>

A mudança abaixo, é para termos como deletar o registro do banco dados

<bean:write name="usuarioCorrente" property="id"/>

Não temos mudança no struts-config.xml
Não temos mudança em nosso UsuarioForm
Vamos dar uma olhada em o que muda para colocar o Spring em nosso projeto:

Acrescente o servlet dele no web.xml:





	<!-- Spring Servlet-->
	
	<servlet>
	   	<servlet-name>SpringContextServlet</servlet-name>
	   	<servlet-class>org.springframework.web.context.ContextLoaderServlet</servlet-class>	  
	  	<load-on-startup>2</load-on-startup>
	</servlet>

Acrescentar os jars do Spring no classpath
O proximo passo é configurar o beans que iremos usar no arquivo de configuração do Spring (applicationContext.xml)


	

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd"><beans>	
	<!-- ========================= Start of PERSISTENCE DEFINITIONS ========================= -->  	
	<!-- DataSource Definition -->
	<bean id="dataSource"  
    	class="org.springframework.jdbc.datasource.DriverManagerDataSource" destroy-method="close">
		<property name="driverClassName">
			<value>com.mysql.jdbc.Driver</value>
		</property>
		<property name="url">
			<value>jdbc:mysql:///daca</value>
		</property>
		<property name="username">
			<value>root</value>
		</property>
		<property name="password">
			<value></value>
		</property>
	</bean>	
	<!--  PErsistent Service Defintion -->
	<bean id="servicoPersistencia" class="daca.service.GerenteBanco">
		<property name="dataSource"><ref local="dataSource"/></property>
	</bean>
</beans>

A definição desses beans é a forma usada pelo Spring para oferecer serviços e resolver a dependência de implementação;
Quando definimos o bean de id="dataSource" estamos usando o serviço de DAO do Spring, não implementamos nada e possuimos um bean que sabe carregar um Driver, abrir uma conexão etc;
Quando definimos o bean de id="servicoPersistencia" o Spring vai ficar responsável por instanciar as dependencias e te dar a classe pronta para que você possa usar
Vamos acompanhar em nosso exemplo:

 *
 * TODO To change the template for this generated type comment go to
 * Window - Preferences - Java - Code Style - Code Templates
 */
public class GerenteBanco implements PersistenteIF{	
	private DriverManagerDataSource dataSource;	
	public GerenteBanco(){	
	}
	/* (non-Javadoc)
	 * @see daca.service.PersistenteIF#save(daca.business.Usuario)
	 */
	public void save(Usuario usuario) {		
		try {
			Connection conn = dataSource.getConnection() ;		
			PreparedStatement statement = conn.prepareStatement("insert into usuario (login,senha,mail) values  (?,?,?)");
			statement.setString(1,usuario.getLogin());
			statement.setString(2,usuario.getSenha());
			statement.setString(3,usuario.getMail());
			statement.execute();
			conn.close();
		} catch (SQLException e) {
			e.printStackTrace();
		}		
	}
	/* (non-Javadoc)
	 * @see daca.service.PersistenteIF#remove(java.lang.String)
	 */
	public void remove(String id) {
		try {			
			Connection conn = dataSource.getConnection();
			PreparedStatement statement = conn.prepareStatement("delete from usuario where id=?");
			statement.setString(1,id);			
			statement.execute();
			conn.close();
		} catch (SQLException e) {
			e.printStackTrace();
		}		
	}
	/* (non-Javadoc)
	 * @see daca.service.PersistenteIF#selectTodos()
	 */
	public List selectTodos() {
		Connection conn = null;
		List lista = new ArrayList();
		try {			
			conn = dataSource.getConnection();
			ResultSet rs = conn.createStatement().executeQuery("select * from usuario");
			while(rs.next()){
				Usuario u = new Usuario();
				u.setId(rs.getInt(1));
				u.setLogin(rs.getString(2));				
				u.setSenha(rs.getString(3));
				u.setMail(rs.getString(4));
				lista.add(u);
			}
			conn.close();
		} catch (SQLException e) {
			e.printStackTrace();
		}		
		return lista;
	}
	/**
	 * @return Returns the dataSource.
	 */
	public DriverManagerDataSource getDataSource() {
		return dataSource;
	}
	/**
	 * @param dataSource The dataSource to set.
	 */
	public void setDataSource(DriverManagerDataSource dataSource) {
		this.dataSource = dataSource;
	}
}

package daca.action;import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
Import javax.servlet.http.HttpServletResponse;
import org.apache.struts.action.ActionError;
import org.apache.struts.action.ActionErrors;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.actions.DispatchAction;
import daca.actionform.UsuarioActionForm;
import daca.service.ServiceLocator;
import daca.util.DCConstants;
/**
* @author marcos
*
* TODO To change the template for this generated type comment go to
* Window - Preferences - Java - Code Style - Code Templates
*/
public class UsuarioAction extends DispatchAction {
/* (non-Javadoc)
* @see org.apache.struts.action.Action#perform(org.apache.struts.action.ActionMapping, org.apache.struts.action.ActionForm, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
*/
	public ActionForward cadastraUsuario(ActionMapping mapping, ActionForm form,
			HttpServletRequest request, HttpServletResponse 
					response) throws IOException, ServletException {	
		UsuarioActionForm usuario = (UsuarioActionForm) form; 		
		ServiceLocator.singleton().getServicoUsuario().save(usuario.createUsuarioBussiness());
		request.setAttribute(DCConstants.LISTA_USUARIO, ServiceLocator.singleton().getServicoUsuario().selectTodos());
		return mapping.findForward(DCConstants.PAGINA_INICIAL);		
	}	
	/* (non-Javadoc)
	* @see org.apache.struts.action.Action#perform(org.apache.struts.action.ActionMapping, org.apache.struts.action.ActionForm, javax.servlet.http.HttpServletRequest, javax.servlet.http.HttpServletResponse)
	*/
	public ActionForward removeUsuario(ActionMapping mapping, ActionForm form,
				HttpServletRequest request, HttpServletResponse response)
					throws IOException, ServletException {		
		String id = request.getParameter("id"); 
		if (id != null) {
			try {
				ServiceLocator.singleton().getServicoUsuario().remove(id); 
			}catch (Exception e) {
				ActionErrors errors = new ActionErrors();
				errors.add("erro_parametro_invalido",new ActionError("error.usuario.naoremovido"));
				super.saveErrors(request,errors);
			}		
		} 
		request.setAttribute(DCConstants.LISTA_USUARIO, ServiceLocator.singleton().getServicoUsuario().selectTodos());
		return mapping.findForward(DCConstants.PAGINA_INICIAL);
		
	}
}

Módulos

Core: módulo responsável por instanciar e "plugar" as coisas que mudam em sua aplicação.
Context: Módulo que prover um caminho fácil para acessar os beans descritos no arquivo de configuração, também cuida do suporte a menssagens usando resources bundle, progagação de eventos etc.
DAO: Módulo responsável por prover uma camada JDBC, você não precisa fazer classes para carregar Driver ou abrir conexões com algum banco de dados, transações programadas e declarativas.
ORM: Módulo responsável por integrar os frameworks de ORM (mapeamento OO para o mundo relacional)
AOP: suporte para programação orientada a aspactos
WEB: Módulo de integração com aplicações web simples, também prover suporte multipart, internacionalização,
WEB MVC: módulo de integração do Spring com Struts, Faces etc