DANRESA SERVICE DESK INTERNACIONAL

A DANRESA Consultoria de Informática possui excelentes pacotes de serviços para atendimento Service Desk para primeiro nível a usuários de computadores que podem ser planejados sob medida de acordo com as regras de negódios de sua empresa.

Temos atendimento com abrangência nacional e internacional atendendo todo o território brasileiro e países da América do Sul, Estados Unidos, Canadá, Angola, Nigéria, França, dentre outros.

Nosso suporte é 24 horas e pode ser acionado através de nossa ferramamenta web ( própria ) “DANRESA Service Desk Online”, onde os usuários podem abrir chamados de qualquer lugar, desde que tenham acesso a internet ou ao ambiente da DANRESA, ou através de telefonia própria, ou compartilhada.

A central de atendimento localizada nas dependências da DANRESA Consultoria de Informática possui analistas certificados em tecnologias Microsoft, Linux e IBM permitindo alta qualidade técnica no suporte e maior velocidade na solução e encaminhamento dos problemas.

Para descobrir o melhor pacote de serviço de Service Desk para sua empresa basta entrar em contato com um consultor DANRESA e solicitar uma visita técnica ou solicitar o formulário checklist que permite a você responder algumas perguntas que possibiltam aos nossos consultores lhe fornecer uma proposta com melhor custo e benefício.

Se você precisa que os usuários de computadores de sua empresa tenham suporte rápido e eficiente quando ocorrem:
– Problemas gerais com a estação de trabalho ( computador )
– Necessidade de Instalação, Configurações e Acesso aos softwares locais, como por exemplo correio eletrônico ou sistemas da empresa como ERPs, CRMs, etc.
– Necesidade de diagóstico a problemas nos sistemas e na máquina como vírus, defeitos causados por softwares corrompidos.
– Interrupção de acesso a rede, e-mails, lentidão nos acessoa a rede, sistemas, internet.

Nossos atendenres são capacitados para diagnosticar os problemas e resolvê-los imediatamente.

O atendimento pode ser remoto ou local de acordo com o cenário pretendido pela sua empresa.

Com o Serice Desk da DANRESA sua empresa nunca para.

Para saber mais sobre os pacotes de serviços Service Desk DANRESA ligue para um de nossos consultores especializados

– TELEFONE 55 11 4452-6450

Para saber mais sobre a DANRESA Consultoria de Informática acesse nosso web site http://www.danresa.com.br
Para acessar nossa ferramenta DANRESA Service Desk Online http://www.danresa.com.br/servicedesk ( solicite usuário e senha aos nossos consultores )

Com os pacotes de serviços DANRESA SERVICE DESK você tem mais tempo para cuidar dos negócios de sua empresa enquanto nós apoiamos sua área de informática.

Anúncios

Oracle Imp e Exp syntaxe

oracle imp/exp

These tools are used to transfer data from one oracle database to another oracle database. You Export tool to export data from source database, and Import tool to load data into the target database. When you export tables from source database export tool will extracts the tables and puts it into the dump file. This dump file is transferred to the target database. At the target database the Import tool will copy the data from dump file to the target database.
From Ver. 10g Oracle is recommending to use Data Pump Export and Import tools, which are enhanced versions of original Export and Import tools.
The export dump file contains objects in the following order:
1.Type definitions2.Table definitions3.Table data4.Table indexes5.Integrity constraints, views, procedures, and triggers6.Bitmap, function-based, and domain indexes
When you import the tables the import tool will perform the actions in the following order, new tables are created, data is imported and indexes are built, triggers are imported, integrity constraints are enabled on the new tables, and any bitmap, function-based, and/or domain indexes are built. This sequence prevents data from being rejected due to the order in which tables are imported. This sequence also prevents redundant triggers from firing twice on the same data
Invoking Export and Import
You can run Export and Import tool in two modes
Command Line Mode
Interactive Mode
When you just type exp or imp at o/s prompt it will run in interactive mode i.e. these tools will prompt you for all the necessary input. If you supply command line arguments when calling exp or imp then it will run in command line mode
Command Line Parameters of Export tool
You can control how Export runs by entering the EXP command followed
by various arguments. To specify parameters, you use keywords:
Format: EXP KEYWORD=value or KEYWORD=(value1,value2,…,valueN)
Example: EXP SCOTT/TIGER GRANTS=Y TABLES=(EMP,DEPT,MGR)
or TABLES=(T1:P1,T1:P2), if T1 is partitioned table

Keyword Description (Default)
————————————————————–
USERID username/password
BUFFER size of data buffer
FILE output files (EXPDAT.DMP)
COMPRESS import into one extent (Y)
GRANTS export grants (Y)
INDEXES export indexes (Y)
DIRECT direct path (N)
LOG log file of screen output
ROWS export data rows (Y)
CONSISTENT cross-table consistency(N)
FULL export entire file (N)

OWNER list of owner usernames

TABLES list of table names

RECORDLENGTH length of IO record

INCTYPE incremental export type

RECORD track incr. export (Y)

TRIGGERS export triggers (Y)

STATISTICS analyze objects (ESTIMATE)

PARFILE parameter filename
CONSTRAINTS export constraints (Y)
OBJECT_CONSISTENT transaction set to read only during object export (N)

FEEDBACK display progress every x rows (0)

FILESIZE maximum size of each dump file

FLASHBACK_SCN SCN used to set session snapshot back to

FLASHBACK_TIME time used to get the SCN closest to the specified time

QUERY select clause used to export a subset of a table

RESUMABLE suspend when a space related error is encountered(N)

RESUMABLE_NAME text string used to identify resumable statement

RESUMABLE_TIMEOUT wait time for RESUMABLE

TTS_FULL_CHECK perform full or partial dependency check for TTS

TABLESPACES list of tablespaces to export

TRANSPORT_TABLESPACE export transportable tablespace metadata (N)

TEMPLATE template name which invokes iAS mode export

The Export and Import tools support four modes of operation
FULL :Exports all the objects in all schemas
OWNER :Exports objects only belonging to the given OWNER
TABLES :Exports Individual Tables
TABLESPACE :Export all objects located in a given TABLESPACE.

Example of Exporting Full Database
The following example shows how to export full database
$exp USERID=scott/tiger FULL=y FILE=myfull.dmp
In the above command, FILE option specifies the name of the dump file, FULL option specifies that you want to export the full database, USERID option specifies the user account to connect to the database. Note, to perform full export the user should have DBA or EXP_FULL_DATABASE privilege.
Example of Exporting Schemas
To export Objects stored in a particular schemas you can run export utility with the following arguments
$exp USERID=scott/tiger OWNER=(SCOTT,ALI) FILE=exp_own.dmp
The above command will export all the objects stored in SCOTT and ALI’s schema.
Exporting Individual Tables
To export individual tables give the following command
$exp USERID=scott/tiger TABLES=(scott.emp,scott.sales) FILE=exp_tab.dmp
This will export scott’s emp and sales tables.
Exporting Consistent Image of the tables
If you include CONSISTENT=Y option in export command argument then, Export utility will export a consistent image of the table i.e. the changes which are done to the table during export operation will not be exported.
Using Import Utility
Objects exported by export utility can only be imported by Import utility. Import utility can run in Interactive mode or command line mode.
You can let Import prompt you for parameters by entering the IMP command followed by your username/password:
Example: IMP SCOTT/TIGER
Or, you can control how Import runs by entering the IMP command followed
by various arguments. To specify parameters, you use keywords:
Format: IMP KEYWORD=value or KEYWORD=(value1,value2,…,valueN)
Example: IMP SCOTT/TIGER IGNORE=Y TABLES=(EMP,DEPT) FULL=N
or TABLES=(T1:P1,T1:P2), if T1 is partitioned table
USERID must be the first parameter on the command line.
Keyword
Description (Default)

USERID
username/password

BUFFER
size of data buffer

FILE
input files (EXPDAT.DMP)

SHOW
just list file contents (N)

IGNORE
ignore create errors (N)

GRANTS
import grants (Y)

INDEXES
import indexes (Y)

ROWS
import data rows (Y)

LOG
log file of screen output

FULL
import entire file (N)

FROMUSER
list of owner usernames

TOUSER
list of usernames

TABLES
list of table names

RECORDLENGTH
length of IO record

INCTYPE
incremental import type

COMMIT
commit array insert (N)

PARFILE
parameter filename

CONSTRAINTS
import constraints (Y)

DESTROY
overwrite tablespace data file (N)

INDEXFILE
write table/index info to specified file

SKIP_UNUSABLE_INDEXES
skip maintenance of unusable indexes (N)

FEEDBACK
display progress every x rows(0)

TOID_NOVALIDATE
skip validation of specified type ids

FILESIZE
maximum size of each dump file

STATISTICS
import precomputed statistics (always)

RESUMABLE
suspend when a space related error is encountered(N)

RESUMABLE_NAME
text string used to identify resumable statement

RESUMABLE_TIMEOUT
wait time for RESUMABLE

COMPILE
compile procedures, packages, and functions (Y)

STREAMS_CONFIGURATION
import streams general metadata (Y)

STREAMS_INSTANITATION
import streams instantiation metadata (N)

Example Importing Individual Tables
To import individual tables from a full database export dump file give the following command
$imp scott/tiger FILE=myfullexp.dmp FROMUSER=scott TABLES=(emp,dept)
This command will import only emp, dept tables into Scott user and you will get a output similar to as shown below
Export file created by EXPORT:V10.00.00 via conventional path
import done in WE8DEC character set and AL16UTF16 NCHAR character set
. importing SCOTT’s objects into SCOTT
. . importing table “DEPT” 4 rows imported
. . importing table “EMP” 14 rows imported
Import terminated successfully without warnings.
Example, Importing Tables of One User account into another User account
For example, suppose Ali has exported tables into a dump file mytables.dmp. Now Scott wants to import these tables. To achieve this Scott will give the following import command
$imp scott/tiger FILE=mytables.dmp FROMUSER=ali TOUSER=scott
Then import utility will give a warning that tables in the dump file was exported by user Ali and not you and then proceed.
Example Importing Tables Using Pattern Matching
Suppose you want to import all tables from a dump file whose name matches a particular pattern. To do so, use “%” wild character in TABLES option. For example, the following command will import all tables whose names starts with alphabet “e” and those tables whose name contains alphabet “d”
$imp scott/tiger FILE=myfullexp.dmp FROMUSER=scott TABLES=(a%,%d%)
Migrating a Database across platforms.
The Export and Import utilities are the only method that Oracle supports for moving an existing Oracle database from one hardware platform to another. This includes moving between UNIX and NT systems and also moving between two NT systems running on different platforms.
The following steps present a general overview of how to move a database between platforms.
1.As a DBA user, issue the following SQL query to get the exact name of all tablespaces. You will need this information later in the process.SQL> SELECT tablespace_name FROM dba_tablespaces;
2.As a DBA user, perform a full export from the source database, for example:> exp system/manager FULL=y FILE=myfullexp.dmp
3.Move the dump file to the target database server. If you use FTP, be sure to copy it in binary format (by entering binary at the FTP prompt) to avoid file corruption.4.Create a database on the target server.5.Before importing the dump file, you must first create your tablespaces, using the information obtained in Step 1. Otherwise, the import will create the corresponding datafiles in the same file structure as at the source database, which may not be compatible with the file structure on the target system.6.As a DBA user, perform a full import with the IGNORE parameter enabled:> imp system/manager FULL=y IGNORE=y FILE=myfullexp.dmp
Using IGNORE=y instructs Oracle to ignore any creation errors during the import and permit the import to complete.
Perform a full backup of your new database.
Posted by Jephe Wu at 1:23 AM Labels: exp, imp, oracle

Você está pronto para o HTML 5 ?

 

Quem acompanhou o começo da web deve lembrar do quanto as primeiras páginas eram feias. O design de páginas com HTML puro era cinza, quadradão, feito na base de frames e tabelas, as animações eram arquivos GIF toscos e restava ao webmaster fazer graça com scripts inúteis. Nesses últimos anos, vários padrões e tecnologias surgiram para ajudar a linguagem, como o CSS, o Flash e o XHTML. Mesmo assim, chegou a hora de mais mudança. A nova versão do padrão HTML está mais sólida, com os principais navegadores suportando suas inovações e facilitando assim a vida do designer, que poderá dispensar bibliotecas e pacotes auxiliares.

Vale lembrar que nem tudo funciona em todos os browsers, já que, na falta de uma especificação definitiva (que está prevista para 2012), os empresas adicionam os recursos do HTML 5 nos navegadores a conta-gotas. Conheça, a seguir, as principais mudanças que já estão aprovadas pela W3C e pelo WHATWG, as entidades que decidem o futuro da linguagem HTML.

Multimídia sem plug-in

O conteúdo em áudio e vídeo na web é refém dos plug-ins, como o Flash, para ser exibido. O HTML 5 prevê uma forma de contornar isso com as tags <video> e <:audio>. Falta ainda definir os tipos de codecs a ser utilizados universalmente com essas tags. Hoje, Chrome e Safari conseguem exibir filmes em H.264 e tocar áudio AAC, encapsulados num arquivo MP4. Já o Firefox, fiel aos padrões abertos, mostra só vídeos Theora e som Vorbis, dentro de um arquivo Ogg. O impasse não preocupa tanto, pois as tags <video> e <:audio> podem receber mais de um arquivo, com o browser selecionando qual é a opção compatível. Para adicionar um vídeo à página, basta usar o código:

<video src="meuvideo.mp4 width="320" height="240" controls></video>

CSS arrumadinho

O novo HTML promete aposentar frames e tabelas das páginas, com o CSS efetivado como responsável para esse fim. Além disso, a versão 5 conta com tags para definir seções dos sites, facilitando a integração com as folhas de estilo. Atualmente, o normal é usar um elemento <div>, com seu nome indicando o tipo de seção. As novas tags são <header>, <footer>, <article>, <section>, <nav> e <aside>. Elas definem o cabeçalho, o rodapé, um artigo, uma seção (de um artigo), a barra de navegação e anotações sobre o conteúdo. Com esses elementos, é criada uma padronização que facilita a localização de conteúdo pelos buscadores e o reaproveitamento dos arquivos CSS.

Gráficos nascidos na web

O elemento <canvas> permite criar desenhos usando JavaScript. Assim é possível, por exemplo, transformar dados do site em gráficos dinâmicos. A tag também serve para usar um texto ou imagem como substituto do desenho, caso o browser não tenha suporte aos gráficos dinâmicos. Nesse caso, o conteúdo alternativo fica entre e <canvas> e </canvas>.

Calendários sem erro

Qual é a data definida por 10/2/2010? Pode ser 10 de fevereiro, no padrão usado no Brasil, e, ao mesmo tempo, 2 de outubro, no modelo americano. O HTML 5 pode contornar essas situações com tags que definem o tipo de dados e sua formatação no texto da página web. A tag <time> marca hora e data e evitaria o problema descrito acima usando o código <timedatetime=”2010-02-10″> </time>, que poderia identificar as informações do navegador e decidir qual seria a data correta, para que ela possa ser exibida no padrão do usuário.

Versão offline

Já ouviu falar no Google Gears? Ele transforma aplicativos web em programas que rodam no browser mesmo em máquinas sem conexão com a web. Essa mágica é feita pelo recurso DOM Storage, que poderá ser usado por qualquer site em HTML 5. Um ponto essencial dessa forma de armazenamento local é que o servidor remoto não pode acessar diretamente o conteúdo (diferentemente dos cookies). Somente o browser e os scripts da página acessada podem modificar o conteúdo offline. Hoje, cada browser usa um limite de espaço. O Firefox aloca no máximo 5 MB por domínio web acessado. Já o Internet Explorer libera 10 MB por base de dados criada, independentemente do domínio.

Muito além dos cliques

Existem várias bibliotecas para habilitar o suporte ao recurso de arrastar e soltar objetos em sites. Mas no HTML 5 a coisa fica bem mais fácil. Basta definir valores para três eventos em JavaScript: dragenter, dragover e drop. Eles indicam, respectivamente, a entrada e a passagem de um elemento sobre outro, além do evento para o momento em que um item é solto. Definir um elemento da página como item que pode ser arrastado é mais fácil ainda. Basta adicionar a definição draggable=”true” a ele.

Fonte: Info

Comentário: O HTML 5 vem pra reorganizar o festival de TAGs que são utilizadas hoje para exibir vídeos, animações ou personalizar nosso layout, criadas a partir da evolução da Internet. Creio que a nova linguagem vai ajudar e muito os desenvolvedores e novatos a criarem seus sites mais facilmente e ao mesmo tempo compatível com a maioria dos navegadores (isto se os usuários atualizarem suas máquinas). 

Spring MVC 3 na Prática com JPA 2

Por Edson Gonçalves

Fonte http://imasters.uol.com.br/artigo/17935

Olá, pessoal, tudo bom?

Este é o segundo artigo da série Spring MVC 3.0. Desta vez iremos trabalhar com a JPA em conjunto com o framework Spring MVC. Como sempre, dúvidas e críticas são bem-vindas.

Para este artigo, vamos utilizar o Tomcat 7.0, ainda em beta. Para baixar o binário do Tomcat 7, vá até o endereço http://tomcat.apache.org/.

O banco de dados utilizado será o MySQL. Você pode baixar a versão 5.1, utilizada no artigo, aqui.

O ambiente de trabalho

A própria empresa responsável pelo Spring Source, divisão da VMware, possui uma ferramenta completa, criada sobre a plataforma Eclipse, chamada de SpringSource Tools Suite. Para baixar o SpringSource Tools Suite, clique aqui, preencha o formulário e faça o Download. Como a ferramenta possui uma opção de instalador, use-a como facilitador se desejare. Na própria página onde baixar o arquivo, haverá a explicação da instalação em cada plataforma, em Installation Instructions.

Criando o projeto

Na view Package Explorer, com o botão direito do mouse, selecione New>Spring Template Project no menu de contexto.

Na caixa de diálogo New Template Project, selecione Spring MVC Project e clique no botão Next.

Ao aparecer a caixa de diálogo Import, clique no botão Yes para permitir que o projeto faça o download das bibliotecas do Spring MVC. No segundo projeto que criar, não haverá necessidade desse download. Falaremos mais adiante sobre esse download e como ele ocorre.

Após o download das bibliotecas, prosseguiremos na criação do projeto. Coloque o nome do seu projeto em Project name e o pacote principal abaixo. Confirme no botão Finish.

Figura 4  definição do nome do projeto e pacote principal

Definição do nome do projeto e pacote principal

O assistente criará, em sua conclusão, um projeto com uma estrutura básica, contendo uma classe, página e arquivos de configurações do framework Spring MVC, como mostra na Figura 5.

Figura 5  estrutura inicial do projeto gerado

Estrutura inicial do projeto gerado

Alterando o projeto base gerado pelo assistente

Além dos arquivos contidos para a execução do projeto, temos o pom.xml, o que denota que o projeto é gerado sobre a estrutura do Maven.

Na view Package Explorer, se expandirmos Maven Dependencies, veremos as bibliotecas que o projeto necessita para ser executado. Nesse momento, o projeto está funcionando tal como foi gerado pelo assistente.

Para compreendermos o que foi gerado, vejam o primeiro artigo que escrevi sobre o Spring MVC, no qual explico a base do framework.

Entretanto, não vamos utilizar alguns dos arquivos criados. Selecione os seguintes diretórios e arquivos do projeto e os remova:

  • WelcomeController.java
  • WelcomeControllerTests.java
  • spring/
  • views/
  • urlrewrite.xml

Adicionando outras bibliotecas ao projeto utilizando o Maven

Embora boa parte das bibliotecas que precisamos no projeto já estejam disponíveis, precisamos adicionar a biblioteca JDBC do MySQL e as do Hibernate para trabalharmos com a JPA 2.

Abra o arquivo pom.xml, encontrado na view Package Explorer. No canto superior do lado direito, temos o ícone Show Advanced Tabs. Vamos exibir, ao clicar neste ícone, novas tabs que permitirão configurar novos repositórios.

Figura 7  exibindo tabs avançadas do editor visual para o arquivo pom.xml

Exibindo tabs avançadas do editor visual para o arquivo pom.xml

Adicionando um repositório

Na aba Repositories, clique no botão Create. Preencha com JBoss Repo em Id e http://repository.jboss.com/maven2. Esse repositório será necessário para obtermos a última versão do Hibernate, importante para nosso projeto.

Criando propriedades

Caso você não conheça o Maven ainda, já deve ter desconfiado que informamos um endereço para baixarmos as bibliotecas. Entretanto, quais desejamos?

Na aba Overview, em Properties, clique no botão Create. Na caixa de diálogo Add property, preencha como na figura abaixo.

Figura 9  criação da property da versão do hibernate

Criação da property da versão do Hibernate

Adicione outra property preenchendo o diálogo assim:

Figura 10  criação da property da versão da jpa

Criação da property da versão da JPA

Por fim, adicione mais uma property e preencha conforme indicado:

Figura 11  criação da property da versão da biblioteca jdbc do mysql

Criação da property da versão da biblioteca JDBC do MySQL

Criando as dependências

As propriedades foram definidas para informar qual versão desejamos utilizar das bibliotecas que o Maven deverá baixar. Entretanto, precisamos configurar as dependências.

Na aba Dependencies, clique no botão Create e preencha conforme a ilustração:

Figura 12  a dependência do hibernate

A dependência do Hibernate

Crie uma nova dependência e configure assim:

Figura 13  - a dependência da api jpa 2.0

A dependência da API JPA 2.0

Faça o mesmo processo preenchendo conforme abaixo:

Figura 14  a dependência da biblioteca jdbc do mysql

A dependência da biblioteca JDBC do MySQL

E, para a parte de transações do Spring, configure a dependência desta maneira:

Figura 15  a dependência da biblioteca para transações do spring framework

A dependência da biblioteca para transações do Spring Framework

Para trabalhar com banco de dados no Spring, configure a dependência conforme indicado:

Figura 16  a dependência da biblioteca jdbc do spring framework

A dependência da biblioteca jdbc do Spring Framework

Como estamos trabalhando com a JPA, o  Spring precisa da dependência que configuramos no Maven:

Figura 17  a dependência da biblioteca orm do spring framework

A dependência da biblioteca orm do Spring Framework

Ao salvar o arquivo, automaticamente o Maven entrará em ação trazendo as bibliotecas faltantes para o seu projeto. Vemos isso na view Console.

Nota: Detalhes de como o Maven funciona não serão mostrados neste artigo. É importante lembramos que o objetivo não é ensinar a trabalhar com Maven, seja através do arquivo pom.xml ou pelo Eclipse IDE.

Um CRUD com Spring MVC utilizando JPA 2.0

O projeto neste artigo será baseado em apenas uma entidade, suficiente mostrar a você a integração entre as duas tecnologias no desenvolvimento.

Iremos agora modificar o projeto criado automaticamente pelo assistente.

A entidade Contato

Teremos para o exemplo apenas uma entidade, chamada de Contato. Essa entidade trabalhará com uma tabela contato, que possui quatro atributos, sendo o atributo id o único que será gerado automaticamente. A Listagem 1 exibe a entidade que será usada no exemplo.

Listagem 1. A entidade Contato.

package br.com.integrator;

import javax.persistence.*;

@Entity

@Table(name = "contato")

public class Contato {

@Id

@GeneratedValue(strategy = GenerationType.IDENTITY)

@Column(name = "id")

private Long id;

private String nome;

private String email;

private String telefone;

//getters and setters

}

Para fazê-la, clique com o direito do mouse sobre o pacote br.com.integrator e selecione, no menu de contexto, o item New>Class.

Acessando os dados

O acesso aos dados é feito pelo padrão DAO (Listagem 2), com a adição de anotações do Spring Framework. No princípio, adicionamos a anotação @Repository(“contatoDao”), que indica ao Spring Framework que se trata de um DAO. Veremos mais a respeito adiante, na configuração final do Spring.

Utilizamos a anotação @Transactional, para fazer o controle transacional e a anotação @PersistenceContext, permitindo assim com que o Spring injete um EntityManager no serviço quando instanciado. Essa anotação pode ser colocada no atributo ou método setter. Com a essa injeção, temos um comportamento similar ao oferecido pelo EJB 3, incluindo transações, só que sem a necessidade de um contêiner EJB para isso.

Para criar a classe da Listagem 2, crie uma nova classe e coloque o pacote br.com.integrator.dao e preencha o nome da classe como ContatoDAO.

Figura 19  criação da classe contatodao

Criação da classe ContatoDAO

Listagem 2. A classe ContatoDAO.

package br.com.integrator.dao;

import java.util.List;

import javax.persistence.EntityManager;

import javax.persistence.PersistenceContext;

import org.springframework.stereotype.Repository;

import org.springframework.transaction.annotation.Transactional;

import br.com.integrator.Contato;

@Repository("contatoDao")

public class ContatoDAO{

protected EntityManager entityManager;

public ContatoDAO() {

}

@PersistenceContext

public void setEntityManager(EntityManager entityManager) {

this.entityManager = entityManager;

}

public Contato find(Long id) {

return entityManager.find(Contato.class, id);

}

@Transactional

public void persist(Contato contato) {

entityManager.persist(contato);

}

@Transactional

public void merge(Contato contato) {

entityManager.merge(contato);

}

@Transactional

public void remove(Contato contato) {

entityManager.remove(contato);

}

@SuppressWarnings("unchecked")

public List<Contato> findAll() {

return entityManager.createQuery("SELECT c FROM Contato c").getResultList();

}

}

Controlando como o aplicativo funciona

A classe ContatoController, que será criada no pacote br.com.integrator.web, exibida na Listagem 3, lida com as requisições do cliente, controlando o rumo que será dado na chamada a uma determinada view.

Listagem 3. A classe ContatoController.

package br.com.integrator.web;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Controller;

import org.springframework.ui.ModelMap;

import org.springframework.web.bind.annotation.*;

import br.com.integrator.dao.ContatoDAO;

import br.com.integrator.Contato;

@Controller

@RequestMapping("/contato/**")

public class ContatoController {

@Autowired

private ContatoDAO contatoDao;

@RequestMapping(value = "/contato/{id}", method = RequestMethod.GET)

public String show(@PathVariable("id") Long id, ModelMap modelMap) {

modelMap.addAttribute("contato", contatoDao.find(id));

return "contato/show";

}

@RequestMapping(value = "/contato", method = RequestMethod.GET)

public String list(ModelMap modelMap) {

modelMap.addAttribute("contatos", contatoDao.findAll());

return "contato/list";

}

@RequestMapping(value = "/contato/{id}", method = RequestMethod.DELETE)

public String delete(@PathVariable("id") Long id) {

contatoDao.remove(contatoDao.find(id));

return "redirect:/contato";

}

@RequestMapping(value = "/contato/form", method = RequestMethod.GET)

public String form(ModelMap modelMap) {

modelMap.addAttribute("contato", new Contato());

return "contato/create";

}

@RequestMapping(value = "/contato", method = RequestMethod.POST)

public String create(@ModelAttribute("contato") Contato contato) {

contatoDao.persist(contato);

return "redirect:/contato";

}

@RequestMapping(value = "/contato/{id}/form", method = RequestMethod.GET)

public String updateForm(@PathVariable("id") Long id, ModelMap modelMap) {

modelMap.addAttribute("contato", contatoDao.find(id));

return "contato/update";

}

@RequestMapping(method = RequestMethod.PUT)

public String update(@ModelAttribute("contato") Contato contato) {

contatoDao.merge(contato);

return "redirect:/contato";

}

}

Introduzida na versão do Spring MVC 2.5, podemos declarar uma classe como sendo a controller do framework simplesmente utilizando a anotação @Controller, de org.springframework.stereotype.Controller. Essa anotação permite que o Spring faça seu “scan” automaticamente através do elemento <context:component-scan>.

Com a anotação @RequestMapping, encontrada após @Controller, definimos o caminho HTTP que será utilizado na aplicação, sendo mapeada pela classe. Na prática, todas as chamadas na aplicação contendo o “/contato/*” serão analisadas pela classe controller.

O suporte a RESTful foi completamente adicionado no Spring MVC 3, onde determinamos o seu comportamento através também da anotação @ResquestMapping. Agora, o servlet Spring Dispatcher suporta os seguintes métodos HTTP: GET, HEAD, POST, PUT e DELETE.

Para efeitos comparativos, se colocarmos cada um dos métodos HTTP ao lado de um simples aplicativo que executa as quatro operações básicas (CRUD), teríamos o GET como sendo o READ, o POST como CREATE, o PUT como UPDATE e o DELETE como por ele mesmo.

Infelizmente, os navegadores não compreendem nada além de GET e POST em formulários HTML. Ao declarar no formulário do Spring MVC que o método de submissão é o DELETE, por exemplo, este se transformará em um método POST, para que o navegador entenda, só que contendo um campo oculto com o valor DELETE. Infelizmente esse feito não é mágico, e no Spring MVC essa característica só é possível porque configuramos o filtro org.springframework.web.filter.HiddenHttpMethodFilter no arquivo web.xml(veja a Listagem 4).

Ao submeter o formulário, a anotação @ResquestMapping verifica o caminho e o método submetido. Imagine que @ResquestMapping recebe uma chamada HTTP com o caminho “/contato/1”, seria apenas uma visualização do contato número 1 se RequestMethod.DELETE não fosse acionado, disparando automaticamente o método delete(), que tem como objetivo remover o contato. Essa remoção é feita pelo remove() do DAO.

Através de templates URI, a anotação @PathVariable determina a variável que será recebida e transmitida para o método em questão. Se quisermos excluir um determinado contato, enviamos ao navegador o caminho “/contato/1”, mas que será traduzido como “contato?id=1”. Como parâmetro, a variável pode ser convertida para um determinado tipo em sua captura, assim como renomeada.

A conclusão de cada operação no controller pode ser feita através de um redirecionamento, enviando a string “redirect:/caminho” ou simplesmente retornando o caminho que deseja exibir.

A configuração do web.xml

O arquivo web.xml precisa de alguns ajustes, uma vez que ele já possui configurações iniciais para trabalhar com o Spring MVC. A Listagem 4 exibe o arquivo web.xml na íntegra.

Listagem 4. O web.xml.

<?xml version="1.0" encoding="UTF-8"?>

<web-app version="2.5" 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_2_5.xsd">

<display-name>SpringMVC</display-name>

<listener>

<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

</listener>

<servlet>

<servlet-name>ContatoManager</servlet-name>

<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>

</servlet>

<servlet-mapping>

<servlet-name>ContatoManager</servlet-name>

<url-pattern>/</url-pattern>

</servlet-mapping>

<servlet-mapping>

<servlet-name>default</servlet-name>

<url-pattern>/static/*</url-pattern>

</servlet-mapping>

<!-- habilitar o suporte REST do Spring 3.0 -->

<filter>

<filter-name>httpMethodFilter</filter-name>

<filter-class>org.springframework.web.filter.HiddenHttpMethodFilter</filter-class>

</filter>

<!-- Permite colocar um campo oculto para PUT e DELETE -->

<filter-mapping>

<filter-name>httpMethodFilter</filter-name>

<servlet-name>ContatoManager</servlet-name>

</filter-mapping>

<filter>

<filter-name>OpenEntityManagerInViewFilter</filter-name>

<filter-class>

org.springframework.orm.jpa.support.OpenEntityManagerInViewFilter

</filter-class>

</filter>

<filter-mapping>

<filter-name>OpenEntityManagerInViewFilter</filter-name>

<url-pattern>/*</url-pattern>

</filter-mapping>

<session-config>

<session-timeout>10</session-timeout>

</session-config>

<welcome-file-list>

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

</welcome-file-list>

</web-app>

Para o Spring MVC funcionar, utilizamos o servlet org.springframework.web.servlet.DispatcherServlet, configurado no arquivo web.xml da aplicação. Por padrão, o Spring olha beans em arquivos cujo começo possui o mesmo nome do Servlet configurado, seguido de -servlet.xml. Para melhor entendimento, o nome ContatoManager, dado no elemento <servlet-name/>, fará com que o Spring procure por um arquivo chamado ContatoManager-servlet.xml.

Evidentemente ele não é o único item que deve ser configurado no arquivo, já que, se pretendemos trabalhar com REST, como já foi citado anteriormente, precisamos adicionar o filtro pela classe org.springframework.web.filter.HiddenHttpMethodFilter.

Para trabalhar com a JPA, utilizamos o filtro org.springframework.orm.jpa.support.OpenEntityManagerInViewFilter, do Spring. Entretanto, deixarei para falar sobre esse filtro em outra ocasião.

O arquivo persistence.xml

A Listagem 5 mostra o arquivo persistence.xml, que configura como provider o Hibernate.  Esse arquivo deve ser criado dentro do diretório META-INF. Esse diretório será criado em src/main/Java. Veja como ficará em seu projeto:

Figura 20  localização do arquivo persistence.xml dentro de meta-inf

Localização do arquivo persistence.xml dentro de META-INF

Listagem 5. Configuração do arquivo persistence.xml.

<?xml version="1.0" encoding="UTF-8"?>

<persistence version="2.0" xmlns="http://java.sun.com/xml/ns/persistence"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://java.sun.com/xml/ns/persistence

http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd">

<persistence-unit name="ContatoPU" transaction-type="RESOURCE_LOCAL">

<class>br.com.integrator.Contato</class>

<properties>

<property name="javax.persistence.jdbc.url" value="jdbc:mysql://localhost:3306/springmvc"></property>

<property name="javax.persistence.jdbc.user" value="edson"></property>

<property name="javax.persistence.jdbc.password" value="integrator"></property>

<property name="javax.persistence.jdbc.driver" value="com.mysql.jdbc.Driver"></property>

<property name="hibernate.show_sql" value="true" />

<property name="hibernate.format_sql" value="true" />

<property name="hibernate.hbm2ddl.auto" value="create"/>

</properties>

</persistence-unit>

</persistence>

Configurando o Spring

Revisando até o momento em que o criamos, temos um DAO simples que se comunica com o banco de dados através da JPA, utilizando o Hibernate como provider.

Esse DAO será executado pelo Controller do Spring MVC, também já configurado.

Para trabalhar com todas essas informações, dividiremos as configurações em dois arquivos, separando suas responsabilidades.

O primeiro arquivo, chamado de applicationContext.xml (Listagem 6), será o utilizado para a trabalhar com a injeção de dependências na classe DAO, lidando com as características da JPA. Esse arquivo deve ser criado dentro do diretório WEB-INF.

Para criá-lo, clique com o direito do mouse em src/main/webapp/WEB-INF e selecione New>Spring Bean Configuration File no menu de contexto.

Na caixa de diálogo Create a new Spring Bean Definition file, coloque o nome do arquivo de applicationContext e clique no botão Next.

Na segunda etapa, mantenha o beans e mantenha selecionado o item XSD.

Figura 22  seleção do namespace beans

Seleção do namespace beans

Ainda na segunda etapa, mantenha o context e mantenha selecionado o item XSD.

Figura 23  seleção do namespace context

Seleção do namespace context

A última opção que selecionaremos na segunda etapa será o tx; e mantenha selecionado o item XSD. Confirme no botão Finish.

Figura 24  seleção do namespace tx

Seleção do namespace tx

Caso tenhamos esquecido de selecionar algum namespace, não tem importância, pois ao finalizar o assistente, o editor do arquivo de configuração do Spring se abre. Nesse caso, vamos adicionar um último namespace. Clique na aba Namespaces e marque o namespace mvc e selecione o XSD como mostrado abaixo.

Figura 25  seleção do namespace mvc

Seleção do namespace mvc

O conteúdo completo do arquivo applicationContext.xml está na Listagem 6.

Listagem 6. Configuração do arquivo applicationContext.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"

xmlns:context="http://www.springframework.org/schema/context"

xmlns:tx="http://www.springframework.org/schema/tx"

xmlns:mvc="http://www.springframework.org/schema/mvc"

xsi:schemaLocation="http://www.springframework.org/schema/mvc http://www.springframework.org/schema/mvc/spring-mvc-3.0.xsd

http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.0.xsd

http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd">

<bean class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">

<property value="ContatoPU" />

</bean>

<context:component-scan base-package="br.com.integrator"/>

<bean id="transactionManager" class="org.springframework.orm.jpa.JpaTransactionManager">

<property name="entityManagerFactory" ref="entityManagerFactory"/>

</bean>

<mvc:annotation-driven/>

<tx:annotation-driven />

<context:annotation-config />

</beans>

No Spring MVC, para determinar a classe controladora, utilizamos a anotação @Controller. Entretanto, para que seja possível detectar essa anotação, o Spring utiliza o elemento <context:component-scan />, no qual indicamos o pacote em que ele pode verificar. Esse recurso é chamado de Classpath scanning, que permite ao Spring ler as classes encontradas no pacote indicado da aplicação em busca das que estão anotadas. Isso evita que tenhamos de declarar essas classes no XML.

Ao fazer esse “scanning”, as classes são passadas por um filtro e então a definição de um bean é criada para cada uma delas. Evidentemente que esse filtro é determinado pelas anotações, nas quais não existem apenas as anotações que utilizamos neste exemplo, mas de outras mais que temos como referencia para o framework: @Component, @Service, @Controller e @Repository (que foi introduzida no Spring 2.0). Você pode também criar suas próprias anotações e filtros para declarar os componentes.

Para o Spring trabalhar com a JPA, na qual a execução ocorre em ambientes Java EE, utilizamos a factory org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean:

<bean

class="org.springframework.orm.jpa.LocalContainerEntityManagerFactoryBean">

<property name="persistenceUnitName" value="ContatoPU" />

</bean>

Com a propriedade de LocalContainerEntityManagerFactoryBean, especificamos o nome da persistence unit do arquivo persistence.xml. É nesse arquivo que temos as configurações de acesso ao banco de dados pela JPA para realizar as operações de persistência.

Para a configuração do controle transacional em uma aplicação baseada no Spring, é necessário declarar um gerenciador que, nesse caso, será a classe org.springframework.orm.jpa.JpaTransactionManager. Essa classe é utilizada para trabalhar com a JPA, independente de provedor ORM. A declaração da classe é ilustrada no trecho a seguir:

<bean

class="org.springframework.orm.jpa.JpaTransactionManager">

<property name="entityManagerFactory" ref="entityManagerFactory" />

</bean>

JpaTransactionManager precisa de qualquer implementação de javax.persistence.EntityManagerFactory para colaborar com EntityManager produzido pela fabrica, para conduzir transações. A classe JpaTransactionManager é recomendada para aplicações que utilizam apenas uma EntityManager.

Para que não tenhamos que fazer injeção de dependência do EntityManager em todos os nossos DAOs, utilizamos o elemento <context:annotation-config />, que procura todas as classes anotadas com @PersistenceContext, @Autowired (que veremos mais adiante), entre outros, e faz a injeção de dependência automaticamente.

Por termos configurado as transações no DAO, por meio da utilização da anotação @Transactional, o elemento <tx:annotation-driven> foi utilizado.

Como se não bastasse, temos também a parte do Spring MVC, que utiliza o elemento mvc:annotation-driven />, permitindo enviar as requisições das classes que possuem a anotação @Controller.

Configurando o Spring MVC

O segundo arquivo, com o nome de ContatoManager-servlet.xml (Listagem 7), será o responsável por configurar o caminho das views e a tecnologia empregada no projeto do Spring MVC.

Para criá-lo, clique com o direito do mouse sobre o diretório src/main/webapp/WEB-INF e selecione New>Spring Bean Configuration File no menu de contexto.

Na caixa de diálogo Create a new Spring Bean Definition file, coloque o nome do arquivo de ContatoManager-servlet e clique no botão Next.

Na segunda etapa, mantenha apenas o item beans selecionado, como mostrado na Figura 27. Finalize o assistente pelo botão Finish.

Figura 27  seleção do namespace beans

Seleção do namespace beans

A Listagem 7 exibe, na íntegra, o conteúdo do arquivo ContatoManager-servlet.xml.

Listagem 7. Configuração do arquivo ContatoManager-servlet.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">

<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">

<property value="/WEB-INF/jsp/"/>

<property value=".jsp"/>

</bean>

</beans>

O Spring MVC possui um suporte a inúmeros tipos de views, utilizando diversos tipos de tecnologias, como JSP, FreeMarker, JasperReports, Velocity, XML, XSLT e outros. Quando vamos criar um projeto Spring MVC, podemos utilizar uma ou diversas ao mesmo tempo, o que significa que é possível apresentar uma página em HTML gerada pelo JSP contendo os dados vindos do banco de dados através do uso do Spring MVC e também um XML contendo os mesmos dados, com uma pequena alteração de extensão no navegador.

Com a classe org.springframework.web.servlet.view.InternalResourceViewResolver, pré-fixamos o caminho das páginas em “/WEB-INF/jsp/” e damos o sufixo, sendo “.jsp”. Para o conteúdo das páginas, temos InternalResourceViewResolver, uma subclasse de UrlBasedViewResolver, que suporta JSTL e que utilizaremos em nossas views.

Atenção: Como boa prática recomendada pelo Spring, coloque as páginas JSP dentro do diretório WEB-INF, impedindo assim seu acesso direto através da URL.

As views

Criaremos agora três páginas que representarão nosso CRUD. Essas páginas serão criadas dentro de um diretório chamado contato, que ficará dentro de jsp em WEB-INF. Os diretórios jsp e contato ainda não foram criados. Para criá-los, clique com o direito do mouse sobre src/main/webapp/WEB-INF e selecione New>Folder no menu de contexto.

O formulário de cadastro

Se preferir, mude a perspectiva do Eclipse para Java EE, assim será possível clicar com o direito do mouse sobre o diretório e selecionar, no menu de contexto, o item New>JSP File. O assistente de criação de páginas JSP pode lhe ajudar com um template Basico. Por fim, dê o nome de create.jsp no arquivo e coloque o conteúdo similar ao mostrado na Listagem 8.

Listagem 8. A página create.jsp.

<%@ taglib prefix="spring" uri="http://www.springframework.org/tags"%>

<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>

<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>

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

<style type="text/css" media="screen">

@import url("<c:url value="/static/styles/style.css"/>");

</style>

<title>Cadastrar</title>

</head>

<body>

<div id="wrap">

<div>

<%@ include file="/menu.jsp" %>

</div>

<div>

<div>

<c:url var="url" value="/contato" />

<form:form action="${url}" method="POST" modelAttribute="contato">

<div>

<label for="nome">Nome:</label>

<form:input cssStyle="width:250px" maxlength="30" path="nome" size="30"/>

</div>

<br/>

<div>

<label for="email">Email:</label>

<form:input cssStyle="width:250px" maxlength="30" path="email" size="30"/>

</div>

<br/>

<div>

<label for="telefone">Telefone:</label>

<form:input cssStyle="width:250px" maxlength="30" path="telefone" size="20"/>

</div>

<br/>

<div class="submit">

<input value="Criar Contato"/>

</div>

</form:form>

</div>

</div>

</div>

</body>

</html>

Podemos ter uma idéia de como ficará a página create.jsp através da figura abaixo:

Figura 29  a página create.jsp

A página create.jsp

Analisando o web.xml, veremos o elemento <servlet-mapping/>, que define onde a aplicação encontrará os conteúdos estáticos do aplicativo. O Servlet default, utilizado nesse caso, pertence às configurações padrão do Tomcat, responsável por servir conteúdos estáticos de aplicações web. Mesmo que seus arquivos não estejam em um diretório com esse nome, é necessário acrescentá-lo como parte do caminho. Isso inclui imagens e folhas de estilo (podem ser obtidos no projeto completo encontrado no final para download).

Para criar essas páginas, utilizamos tags da biblioteca JSTL e tags do próprio Spring. No caso do Spring, as tags <form/> possibilitam que tenhamos um formulário ligado ao controller. Para utilizar essas tags, devemos acrescentar a seguinte taglib:

<%@ taglib prefix=”form” uri=”http://www.springframework.org/tags/form&#8221; %>

Na construção dos formulários para inserir e atualizar, utilizamos a tag <form:form/> que possui um atributo modelAttribute,  ligando o formulário ao parâmetro do método que executa sua ação. O atributo method indica qual o tipo de ação será feita no controller.

A tag <form:input/> possui o atributo path com o valor correspondente aos atributos existentes no bean Contato.

A página que lista todos os cadastros e permite a exclusão

Para a listagem de todos os cadastros efetuados, criaremos uma página chamada list.jsp, contendo as mesmas informações existentes na Listagem 9.

Junto à listagem, teremos a possibilidade de excluir o cadastro diretamente por essa página.

Listagem 9. A página list.jsp.

<%@ taglib prefix="spring" uri="http://www.springframework.org/tags"%>

<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>

<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>

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

<style media="screen">

@import url("<c:url value="/static/styles/style.css"/>");

</style>

<title>Listar</title>

</head>

<body>

<div>

<div id="menu">

<%@ include file="/menu.jsp" %>

</div>

<div id="main">

<div>

<c:if test="${not empty contatos}">

<table width="600px">

<tr>

<thead>

<th>Id</th>

<th>Nome</th>

<th>E-mail</th>

<th>Telefone</th>

<th>Atualizar</th>

<th>Excluir</th>

</thead>

</tr>

<c:forEach items="${contatos}" var="contato">

<c:url var="url" value="/contato/${contato.id}" />

<tr>

<td>${contato.id}</td>

<td>${contato.nome}</td>

<td>${contato.email}</td>

<td>${contato.telefone}</td>

<td>

<form:form action="${url}/form" method="GET">

<input alt="Atualizar Contato" src="<c:url value="/static/images/update.png"/>" title="Atualizar Contato" value="Atualizar Contato"/>

</form:form>

</td>

<td>

<form:form action="${url}" method="DELETE">

<input alt="Excluir Contato" src="<c:url value="/static/images/delete.png"/>" title="Excluir Contato" value="Excluir Contato"/>

</form:form>

</td>

</tr>

</c:forEach>

</table>

</c:if>

<c:if test="${empty contatos}">Não há contatos cadastrados.</c:if>

</div>

</div>

</div>

</body>

</html>

O Spring MVC gera um Map através de sua classe org.springframework.ui.ModelMap, na qual capturamos os valores retornados pelo método findAll(), de ContatoDAO. Esse Map é capturado pela view, no clássico esquema definido pelo MVC.

No caso da listagem de contatos, esse Map, definido como contatos no método list(), de ContatoController, é varrido por um loop criado pela tag JSTL <c:forEach /> no seguinte trecho:

<c:forEach items=”${contatos}” var=”post”>

Na listagem dos contatos, em uma das tags <form:form/>, vemos em um de seus atributos method o valor DELETE, definido como a ação de exclusão de contatos.

Como os navegadores não reconhecem o envio de formulários além dos métodos POST e GET, precisamos de uma ajuda do Spring Framework para fazer a operação DELETE. O que o Spring MVC fará é traduzir o valor do atributo dessa tag, na geração do HTML, da seguinte forma:

<form method=”post”>

<input type=”hidden” value=”DELETE”/>

Observe que ele criou uma tag oculta HTML na renderização da página com um nome _method e com o valor DELETE. Essa simples adição permitirá a ação de excluir pela classe PostController.

A página de atualização de dados

A última página que teremos no CRUD é a de atualizar (update.jsp), similar ao de adicionar dados, exceto pelo fato de receber os dados vindos do banco de dados para serem exibidos.

Listagem 10. A página update.jsp.

<%@ taglib prefix="spring" uri="http://www.springframework.org/tags"%>

<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>

<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>

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

<style type="text/css" media="screen">

@import url("<c:url value="/static/styles/style.css"/>");

</style>

<title>Atualizar</title>

</head>

<body>

<div id="wrap">

<div>

<%@ include file="/menu.jsp" %>

</div>

<div>

<div>

<c:url var="url" value="/contato/${contato.id}" />

<form:form action="${url}" method="PUT" modelAttribute="contato">

<div>

<label for="nome">Nome:</label>

<form:input cssStyle="width:250px" maxlength="30" path="nome" size="30"/>

</div>

<br/>

<div>

<label for="email">Email:</label>

<form:input cssStyle="width:250px" maxlength="30" path="email" size="30"/>

</div>

<br/>

<div>

<label for="telefone">Telefone:</label>

<form:input cssStyle="width:250px" maxlength="30" path="telefone" size="20"/>

</div>

<br/>

<div class="submit">

<input value="Atualizar Contato"/>

</div>

<form:hidden path="id"/>

</form:form>

</div>

</div>

</div>

</body>

</html>

Similar ao que ocorre com a listagem de contatos, temos no formulário da página de atualização o valor PUT para o atributo method. Novamente, o Spring Framework irá gerar um campo oculto, em HTML, contendo essa informação e transmitindo ao navegador o HTML como ele já o conhece.

As páginas que não fazem parte do CRUD

O menu e a página inicial não fazem parte do CRUD e, portanto, serão apenas apresentadas aqui com seus códigos para completar o exemplo.

A página index.jsp deverá ser criada em  webapps:

Listagem 11. A página index.jsp.

<%@ taglib prefix="spring" uri="http://www.springframework.org/tags"%>

<%@ taglib prefix="form" uri="http://www.springframework.org/tags/form" %>

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>

<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>

<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<html>

<head>

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

<link href="<c:url value="/static/styles/style.css"/>" rel="stylesheet" />

<title>Principal</title>

</head>

<body>

<div id="wrap">

<div>

<%@ include file="/menu.jsp" %>

</div>

<div>

<div>

Aplicação CRUD criada utilizando o Spring MVC 3.0 com suporte a REST.

</div>

</div>

</div>

</body>

</html>

Assim como index.jsp, crie o menu.jsp em webapps.

Listagem 12. A página menu.jsp.

<ul>

<li>

<h2>Contato</h2>

<ul>

<li><a href="<c:url value="/contato"/>">Ver todos</a></li>

<li><a href="<c:url value="/contato/form"/>">Novo Contato</a></li>

</ul>

</li>

</ul>

Figura 32  visão geral de todos os arquivos utilizados na geração do projeto

Visão geral de todos os arquivos utilizados na geração do projeto

O projeto para download

Clique aqui para baixar o projeto completo como feito até o momento.

Considerações finais

Agora que aprendemos a fazer um CRUD com o Spring MVC, podemos criar projetos mais complexos. Caso esteja com pressa de aprender algo mais complexo, a revista JavaMagazine #78 publicou, alguns meses atrás, um artigo meu com o Spring MVC 3 na criação de um blog, passo a passo.

DANRESA Consultoria de Informática, há 10 anos transformando conhecimento e tecnologia em soluções de negócios.

Há 10 anos no mercado, a DANRESA é uma Consultoria de Informática que agrega valores aos negócios de seus clientes por meio de consultoria estratégica e soluções completas envolvendo produtos e serviços de TI.

Hoje são mais de 100 clientes atendidos pela DANRESA com qualidade e eficiência em todo o Brasil.

A DANRESA identifica como as tecnologias de TI existentes no mercado podem ajudar seus clientes a reduzir custos, aumentar a produtividade empresarial, e aumentar seu potencial competitivo, destacando-os de seus concorrentes.

A DANRESA é uma empresa parceira Microsoft Certified e oferece aos seus clientes:

 – Outsourcing, Outtasking e Multisourcing de TI

– Desenvolvimento de Sistemas Client-Server e Web, envolvendo Portais Corporativos, Lojas Virtuais, B2B, B2C, EDI, Integrações de Sistemas. Projetos, Alocações e Fábrica de Software.

– Soluções de Infra-Estrutura, Segurança e Rede, VOIP.

– Inteligência Corporativa ( BI ), SOA, BPM, Colaboração

– Data Management Solutions, Information Worker Solutions, Mobility Solutions, Security Solutions, Licensing Solutions, e-Learning Solutions, Security Solutions.

 Solicite uma visita e/ou um mapeamento de sua Infra-Estrutura de TI com um de nossos consultores e descubra como a DANRESA pode ajudar a sua empresa a alcançar os resultados corporativos desejados com as Soluções Inovadoras de TI da DANRESA.

Saiba mais em http://www.danresa.com.br

Ou ligue para 55 11 4452-6450 e contate um de nossos gerentes comerciais.