Baixe Eclipse e tomcat e outras Notas de estudo em PDF para Informática, somente na Docsity!
Caelum
“Mata o tempo e matas a tua carreira” Bryan Forbes -
Sobre a empresa
A Caelum atua no mercado desde 2002, desenvolvendo sistemas e prestando consultoria em diversas áreas, à luz sempre da plataforma Java. Foi fundada por profissionais que se encontraram no Brasil depois de uma experiência na Alemanha e Itália, desenvolvendo sistemas de grande porte com integração aos mais variados ERPs. Seus profissionais publicaram já diversos artigos nas revistas brasileiras de Java, assim como artigos em eventos acadêmicos, e são presença constante nos eventos da tecnologia. Em 2004 a Caelum criou uma gama de cursos que rapidamente ganharam grande reconhecimento no mercado. Os cursos foram elaborados por ex-instrutores da Sun que queriam trazer mais dinamismo e aplicar as ferramentas e bibliotecas utilizadas no mercado, tais como Eclipse, Hibernate, Struts, e outras tecnologias open source que não são abordadas pela Sun. O material utilizado foi inicialmente desenvolvido enquanto eram ministrados os cursos de verão de java da Universidade de São Paulo em janeiro de 2004 pelos instrutores da Caelum. Em 2006 a empresa foca seus projetos em três grandes áreas: sistemas de gerenciamento de conteúdo para portais, soluções de integração financeira e treinamento com intuito de formação.
Sobre a apostila
Esta é a apostila da Caelum que tem como intuito ensinar Java de uma maneira elegante, mostrando apenas o que é necessário no momento correto e poupando o leitor de assuntos que não costumam ser de seu interesse em determinadas fases do aprendizado. A Caelum espera que você aproveite esse material, e que ele possa ser de grande valia para auto didatas e estudantes. Todos os comentários, críticas e sugestões serão muito bem vindos. O material aqui contido pode ser publicamente distribuído desde que não seja alterado e seus créditos sejam mantidos. Ele não pode ser usado para ministrar qualquer curso, porém pode ser referência e material de apoio. Caso você esteja interessado em usá-lo fins comerciais, entre em contato com a empresa. Atenção: Você pode verificar a data de última atualização da apostila no fim do índice. Nunca imprima a apostila que você receber de um amigo ou pegar por email, pois atualizamos constantemente esse material, quase que mensalmente. Vá até o nosso site e faça o download da última versão! www.caelum.com.br
Caelum - Web 2.0 com VRaptor, Hibernate e Ajax
- Capítulo 1: Como aprender Java.......................................................................... Índice
- 1.1 - O que é realmente importante?................................................................
- 1.2 - Sobre os exercícios..................................................................................
- 1.3 - Tirando dúvidas........................................................................................
- 1.4 - Sobre os autores......................................................................................
- Capítulo 2: O sistema...........................................................................................
- 2.1 - A necessidade do cliente e os testes para aprovação...............................
- 2.2 - Partes do projeto......................................................................................
- 2.3 - Visual.......................................................................................................
- 2.4 - Tecnologias usadas...................................................................................
- 2.5 - Sobre o Vraptor........................................................................................
- 2.6 - Sobre o Hibernate....................................................................................
- 2.7 - Sobre o JQuery
- 2.8 - Criando o projeto.....................................................................................
- Capítulo 3: Controle de usuários..........................................................................
- 3.1 - Primeiros passos......................................................................................
- 3.2 - Preparando o hibernate...........................................................................
- 3.3 - Exercícios.................................................................................................
- 3.4 - Usuário..................................................................................................
- 3.5 - Exercício................................................................................................
- 3.6 - Gerando o banco de dados.....................................................................
- 3.7 - Adicionando...........................................................................................
- 3.8 - Exercícios...............................................................................................
- 3.9 - Dao.........................................................................................................
- 3.10 - Exercício..............................................................................................
- Capítulo 4: Melhorando o sistema e preparando pra Web.................................
- 4.1 - Refatoração............................................................................................
- 4.2 - Melhorando nosso sistema - HibernateUtil............................................
- 4.3 - Melhorando o sistema – DaoFactory.......................................................
- 4.4 - O Dao Genérico......................................................................................
- 4.5 - Testando os refactorings........................................................................
- 4.6 - Colocando na Web..................................................................................
- 4.7 - Instalar o Tomcat...................................................................................
- 4.8 - Configurando o plugin do tomcat no eclipse..........................................
- 4.9 - Configurar nosso projeto no tomcat.......................................................
- Capítulo 5: Cadastro de usuários com Vraptor..................................................
- 5.1 - Lógica do vraptor...................................................................................
- 5.2 - Adicionar usuário...................................................................................
- 5.3 - Exercícios...............................................................................................
- 5.4 - Injetando o DaoFactory com interceptador............................................
- 5.5 - Como configurar o uso dos interceptors................................................
- 5.6 - Exercícios...............................................................................................
- 5.7 - Listando com displaytag.........................................................................
- 5.8 - Exercício................................................................................................
- 5.9 - Redirecionando depois do adiciona........................................................
- 5.10 - Exercícios.............................................................................................
- 5.11 - Removendo usuários............................................................................
- 5.12 - Exercícios opcionais.............................................................................
- Capítulo 6: Cds e músicas.................................................................................. Caelum - Web 2.0 com VRaptor, Hibernate e Ajax
- 6.1 - Menu......................................................................................................
- 6.2 - Exercício................................................................................................
- 6.3 - Entidades...............................................................................................
- 6.4 - Exercício................................................................................................
- 6.5 - CdLogic..................................................................................................
- 6.6 - Exercício................................................................................................
- 6.7 - JSPs para cd...........................................................................................
- 6.8 - Exercício................................................................................................
- 6.9 - MusicaLogic...........................................................................................
- 6.10 - Exercício..............................................................................................
- 6.11 - JSPs para Música..................................................................................
- 6.12 - Exercício..............................................................................................
- 6.13 - Desafio - Exercicios opcionais..............................................................
- Capítulo 7: Autenticação e autorização..............................................................
- 7.1 - Login......................................................................................................
- 7.2 - Exercício - Formulário de login..............................................................
- 7.3 - UsuarioDao............................................................................................
- 7.4 - Exercício................................................................................................
- 7.5 - Lógica....................................................................................................
- 7.6 - Retorno condicional com Vraptor...........................................................
- 7.7 - Logout....................................................................................................
- 7.8 - Exercício................................................................................................
- 7.9 - Interceptador para autorização..............................................................
- 7.10 - Exercício..............................................................................................
- 7.11 - Autorizando lógicas..............................................................................
- 7.12 - Exercício..............................................................................................
- 7.13 - Exercícios opcionais.............................................................................
- Capítulo 8: Validação com Hibernate Validator..................................................
- 8.1 - O Hibernate validator.............................................................................
- 8.2 - Anotações nos beans..............................................................................
- 8.3 - Validando no vraptor..............................................................................
- 8.4 - Exercícios...............................................................................................
- 8.5 - Exercícios opcionais...............................................................................
- 8.6 - Para saber mais: validações personalizadas...........................................
- 8.7 - Para saber mais: validação sem Hibernate Validator..............................
- Capítulo 9: A loja virtual....................................................................................
- 9.1 - Idéia geral..............................................................................................
- 9.2 - Pensando na página - @OneToMany.......................................................
- 9.3 - Exercício................................................................................................
- 9.4 - Página inicial..........................................................................................
- 9.5 - Exercício................................................................................................
- 9.6 - Listar Cds e Musicas..............................................................................
- 9.7 - Exercício................................................................................................
- 9.8 - Exercicio - Futuro carrinho de compras.................................................
- Capítulo 10: Ajax e efeitos visuais......................................................................
- 10.1 - AJAX- Asynchronous JavaScript and XML
- 10.2 - Um pouco de jquery.............................................................................
- 10.3 - Draggables and Droppables.................................................................
- 10.4 - Exercício.............................................................................................. Caelum - Web 2.0 com VRaptor, Hibernate e Ajax
- 10.5 - Gerenciamento do carrinho na Sessão.................................................
- 10.6 - Exercícios.............................................................................................
- 10.7 - Chamando as lógicas com Ajax............................................................
- 10.8 - Exercicio..............................................................................................
- 10.9 - Usando o Firebug para ver o Ajax acontecendo...................................
- 10.10 - Finalizar compra................................................................................
- 10.11 - Exercicios...........................................................................................
- 10.12 - O formulário de finalização da compra...............................................
- 10.13 - Exercícios...........................................................................................
- 10.14 - Usando o Thickbox.............................................................................
- 10.15 - Exercícios...........................................................................................
- Capítulo 11: Apêndice – Melhorando a Loja Virtual...........................................
- 11.1 - Capinhas de mp3..................................................................................
- 11.2 - Exercícios.............................................................................................
- 11.3 - Unicidade das músicas.........................................................................
- 11.4 - Exercício..............................................................................................
- 11.5 - Remoção do carrinho...........................................................................
- 11.6 - Ouvir as musicas..................................................................................
- 11.7 - Formatando moeda..............................................................................
- 11.8 - Listar Vendas........................................................................................
- 11.9 - I18N.....................................................................................................
- 11.10 - Export no displaytaglib......................................................................
- Capítulo 12: Apêndice – Melhorando o login......................................................
- 12.1 - A permissão do Usuario.......................................................................
- 12.2 - Exercícios.............................................................................................
- 12.3 - A anotação...........................................................................................
- 12.4 - Exercícios.............................................................................................
- 12.5 - O interceptador....................................................................................
- 12.6 - Exercícios.............................................................................................
- 12.7 - Desafios................................................................................................
- 12.8 - Para saber mais: Sessão e Usuario.......................................................
- Capítulo 13: Apêndice B – Criando o Ambiente................................................
- 13.1 - Introdução..........................................................................................
- 13.2 - Instalando o eclipse............................................................................
- 13.3 - Instalando o plugin para o tomcat......................................................
- 13.4 - Instalando o plugin para arquivos jsp, html e xml..............................
- 13.5 - Instalando o plugin Hibernate Tools...................................................
- 13.6 - Plugins do eclipse no windows...........................................................
- 13.7 - Firefox e Firebug................................................................................
- 13.8 - Iniciando o projeto.............................................................................
- 13.9 - Preparando o hibernate......................................................................
- 13.10 - Instalando vraptor, jstl e displaytag..................................................
- 13.11 - O web.xml........................................................................................
- 13.12 - O tomcat no windows.......................................................................
- 13.13 - iniciando o tomcat sem plugin..........................................................
- 13.14 - Parando o tomcat sem plugin..........................................................
1 Como aprender Java
“Homens sábios fazem provérbios, tolos os repetem” Samuel Palmer - Como o material está organizado e dicas de como estudar em casa.
1.1 - O que é realmente importante?
Muitos livros, ao passar os capítulos, mencionam todos os detalhes da linguagem juntamente com seus princípios básicos. Isso acaba criando muita confusão, em especial pois o estudante não consegue distinguir exatamente o que é importante aprender e reter naquele momento daquilo que será necessário mais tempo e principalmente experiência para dominar. Se uma classe abstrata deve ou não ter ao menos um método abstrato, se o if só aceitar argumentos booleanos e todos os detalhes de classes internas realmente não devem ser preocupações para aquele que possui como objetivo primário aprender Java. Esse tipo de informação será adquirida com o tempo, e não é necessário até um segundo momento. Neste curso separamos essas informações em quadros especiais, já que são informações extras. Ou então apenas citamos num exercício e deixamos para o leitor procurar informações se for de seu interesse. Algumas informações não são mostradas e podem ser adquiridas em tutoriais ou guias de referência, são detalhes que para um programador experiente em Java pode ser importante, mas não para quem está começando. Por fim falta mencionar sobre a prática, que deve ser tratada seriamente: todos os exercícios são muito importantes e os desafios podem ser feitos quando o curso acabar. De qualquer maneira recomendamos aos alunos estudar em casa, principalmente aqueles que fazem os cursos intensivos.
O curso
Para aqueles que estão fazendo o curso Java e Orientação a Objetos, é recomendado estudar em casa aquilo que foi visto durante a aula, tentando resolver os exercícios que não foram feitos e os desafios que estão lá para envolver mais o leitor no mundo de Java.
Convenções de Código
Para mais informações sobre as convenções de código-fonte Java, acesse:
capítulo 1
Diversos screenshots, remodelamentos e melhorias nos textos foram realizados por Guilherme Moreira e Jacqueline Rodrigues. Agrecimentos a todas as pessoas que costumam enviar erros, bugs e sugestões para a equipe.
2 O sistema
“Explica-se sobretudo o que não se entende..” Jules Barbey D'Aurevilly - Neste capitulo iremos:
- levantar os requisitos do sistema
- escolher as tecnologias utilizadas
2.1 - A necessidade do cliente e os testes para aprovação
Nossa empresa foi contratada por uma pequena gravadora de música que deseja entrar na era da música digital. Contratou nossos serviços para desenvolver uma loja virtual que venda downloads de músicas. Detalhe: urgência máxima no projeto. Fomos chamados para desenvolver uma solução para seus problemas em tempo recorde: somente 20 horas. Suas maiores preocupações é que o sistema seja capaz de suportar qualquer tipo de banco de dados e a interface de iteração com o cliente seja através da web, com muitos recursos visuais e ajax para atrair os compradores. O cliente pediu que o sistema passe pelos seguintes testes para aprovar os gastos com o mesmo:
- permitir listar, cadastrar, e remover um usuário que acessa o sistema
- permitir listar, cadastrar, remover e alterar um cd
- permitir listar, cadastrar, remover e alterar uma música
- sistema de login
- permitir alguém selecionar musicas diversas para comprar
- receber dados de relativos à venda, como nome do cliente, email e cartão de credito
- permitir adicionar e remover musicas do carrinho
2.2 - Partes do projeto
Sendo assim, iremos dividir o projeto em algumas partes:
- criar o ambiente de desenvolvimento
- criar o banco de dados de usuário
- refatorar o sistema para web e dao genérico
- criar sistemas de gerenciamento de Cds e Musicas
- criar o sistema de login
capítulo 2
desenvolvimento ágil e de alta produtividade. Implementa um controlador baseado no padrão Front Controller. É desenvolvido pela Caelum mas disponível para uso geral. Além da própria Caelum, é usado em outros projetos (como o GUJ e o JForum) e por várias empresas.
2.6 - Sobre o Hibernate
O Hibernate é um framework ORM (Object Relational Mapping) que auxilia a camada de persistência de nossa aplicação. Seu objetivo é prover uma interface Orientada a Objetos para nossa programa Java de toda a lógica de persistência em bancos relacionais. O Hibernate cuida dos SQLs e da tradução dos dados entre esses dois modelos, OO e relacional. Traz como um forte benefício a independência de Banco de Dados, além de ser extremamente simples e produtivo. É desenvolvido pela Jboss e possui forte penetração no mercado. Utilizaremos, além do pacote principal do Hibernate, uma extensão chamada Hibernate Annotations que traz muita produtividade ao permitir que utilizemos anotações para configurar o Hibernate. Além disso, usaremos o pacote Hibernate Validator que traz facilidades para a validação de nossos dados.
2.7 - Sobre o JQuery
O JQuery (www.jquery.com) é uma famosa biblioteca Javascript que implementa diversos recursos adicionais ao Javascript usual dos browsers. Possui vários efeitos visuais já implementados e prontos para uso. Além disso, já possui muitas APIs para trabalhar com Ajax de forma simples e produtiva. O JQuery se integra de forma muito fácil ao VRaptor. Utilizamos também três plugins oficiais em cima do JQuery para efeitos de Drag'n'Drop (Interface), janelas não intrusivas (ThickBox) e submit de forms via ajax (AjaxForm).
2.8 - Criando o projeto
Para iniciar, vamos criar nosso projeto no Eclipse.
- Abra o Eclipse
- Vá em File -> Import e selecione Existing projects into Workspace
- Selecione Select archive file e indique o caminho para o zip do projeto ( /caelum/zips/28/projeto.zip ) e selecione o projeto lojavirtual :
3 Controle de usuários
“Os loucos abrem os caminhos que depois emprestam aos sensatos.” Carlo Dossi - Neste capitulo iremos:
- configurar o hibernate
- começar o projeto pelo cadastro de usuários
3.1 - Primeiros passos
Já sabemos o que nosso sistema deve ter. Precisamos agora começar a codificá-lo, mas por onde? Que tal começarmos modelando entidades e seus Daos? Nosso primeiro passo será criar o sistema de controle de Usuários do nosso futuro sistema. Usaremos uma entidade sem relacionamentos e operações básicas de adicionar, remover e listar. Aproveite esse capítulo para entender o funcionamento básico das ferramentas envolvidas no projeto. Nos capítulos posteriores usaremos esse conhecimento na parte mais complexa da aplicação.
3.2 - Preparando o hibernate
Como vamos usar o Hibernate como ferramenta ORM, precisamos primeiro configurá-lo. Os jars necessários já foram copiados quando criamos o projeto. Precisamos apenas configurar o banco de dados.
3.3 - Exercícios
- Precisamos agora configurar o Hibernate para usar o MySQL através do hibernate.cfg.xml. Vá em File -> New -> Create Hibernate Configuration File. Selecione o seu diretório src e o nome de arquivo como hibernate.cfg.xml e clique em Next.
capítulo 3
Na próxima tela, selecione as opções para configurar o MySQL:
- Database dialect: MySQL
- Driver class: com.mysql.jdbc.Driver
- Connection URL: jdbc:mysql://localhost/teste
- Username: root
root true true </session-factory> </hibernate-configuration>
3.4 - Usuário
Para nosso sistema de usuários, é fundamental a existência de alguma classe que modele o que é um Usuário. Criaremos um JavaBean simples para tal, e o usaremos como Entidade do Hibernate.
3.5 - Exercício
- Crie a classe Usuario no pacote br.com.caelum.lojavirtual.modelo. Coloque atributos String para login e senha e um atributo Long (não long) para id: package br.com.caelum.lojavirtual.modelo; public class Usuario { private Long id; private String login; private String senha; } Acrescente outros atributos se achar necessário.
- Gere os getters e setters pelo Eclipse (menu Source, Generate getters and setters).
- Adicione as anotações da Java Persistence API (JPA) para que o Hibernate saiba persistir nossa classe. Lembre-se de sempre importar do pacote javax.persistence. a) Adicione o @Entity à classe: @Entity public class Usuario { b) Adicione @Id e @GeneratedValue ao id: @Id @GeneratedValue private Long id;
- Configure nossa classe Usuario no hibernate.cfg.xml. Adicione a tag abaixo dentro da tag session-factory logo após as tags property :
3.6 - Gerando o banco de dados
Vamos agora gerar o banco de dados para nossa classe Usuario usando o Hibernate.
- Crie a classe GeraBanco no pacote br.com.caelum.lojavirtual.util que, em seu método main, cria a o banco usando o SchemaExport do Hibernate: public class GeraBanco { public static void main(String[] args) { Configuration conf = new AnnotationConfiguration(); conf.configure(); SchemaExport se = new SchemaExport(conf); se.create( true , true ); } }
- Rode essa classe e veja a saída.
3.7 - Adicionando
Sempre que quisermos usar o Hibernate, precisamos de de uma Session. No Hibernate, ao invés de trabalharmos diretamente com Connections JDBC, utilizamos sessões. As sessões do hibernate são bastante interessantes para a implementação de pool de conexões e outros recursos como cache. Para obter uma sessão do hibernate, precisamos criar uma fábrica de sessões, uma SessionFactory. Desta forma: Configuration conf = new AnnotationConfiguration(); conf.configure(); SessionFactory factory = conf.buildSessionFactory(); Session session = factory.openSession(); O Hibernate também facilita muito o controle de transações, que é necessário para operações de insert/delete/update. E para adicionar algo no banco, basta chamar o método save na session passando o objeto a ser persistido: Usuario u = new Usuario(); u.setLogin("admin"); u.setSenha("admin"); Transaction t = session.beginTransaction(); session.save(u); t.commit();
3.8 - Exercícios
- Crie a classe TestaUsuario no pacote
} public void atualiza (Usuario u) { this .session.merge(u); } public List listaTudo() { return this .session.createCriteria(Usuario. class ).list(); } public Usuario procura(Long id) { return (Usuario) session.load(Usuario.class, id); } }
3.10 - Exercício
- Crie a classe UsuarioDao no pacote br.com.caelum.lojavirtual.dao
- Altere sua classe TestaUsuario para usar o Dao para adicionar e listar. a) Instancie o UsuarioDao passando a Session para ele: UsuarioDao dao = new UsuarioDao(session); f) Adicione um Usuario através do dao: Usuario u = new Usuario(); u.setLogin("admin"); u.setSenha("admin"); dao.adiciona(u); g) Liste todos os usuários do banco e percorra com um for imprimindo seus logins: List lista = dao.listaTudo(); for (Usuario usuario : lista) { System. out .println(usuario.getLogin()); } No final, sua classe deve estar assim: public class TestaUsuario { public static void main(String[] args) { // configura o hibernate Configuration conf = new AnnotationConfiguration(); conf.configure(); SessionFactory factory = conf.buildSessionFactory(); Session session = factory.openSession(); // cria um usuario Usuario u = new Usuario(); u.setLogin("admin"); u.setSenha("admin");
// cria dao UsuarioDao dao = new UsuarioDao(session); // abre transacao e insere Transaction t = session.beginTransaction(); dao.adiciona(u); t.commit(); // lista usuarios List lista = dao.listaTudo(); for (Usuario usuario : lista) { System. out .println(usuario.getLogin()); } session.close(); } }
- Rode o TestaUsuario e veja a saída.
