Livro: Aplicações Java para a web com JSF e JPA

 

 

 
Tenho o prazer de anunciar o meu livro “Aplicações Java para a web com JSF e JPA”.  Seguindo a filosofia da Casa do Código, o livro é bem objetivo, menos de 300 páginas, e serve tanto para quem está iniciando quanto para quem já conhece os frameworks. O livro não é uma apostila de exercícios, nem uma referência massante. A ideia é oferecer um bom conteúdo teórico de forma simples e sempre relacionada com a prática. Além de explicar como as coisas funcionam, o livro contém uma série de técnicas para melhorar bastante a performance das aplicações.

 

Mas… por que escrever um livro?

Quando eu iniciei minha participação em fóruns como o GUJ, percebi que as pessoas tinham sempre dúvidas parecidas, e que no geral todos nós temos o costume de seguir sempre o caminho que conhecemos, seja no transito ou no desenvolvimento de sistemas, sem muitas vezes nos perguntar se não haveria um caminho melhor.

Como sempre gostei de estudar as novidades da plataforma Java, muitas vezes passava por problemas que adiantava pouco perguntar em fóruns, porque poucas pessoas estava mexendo com aquilo. Então praticamente a única fonte era a documentação do framework ou a especificação do padrão, como é o caso do JSF e da JPA. Documentação e muito debug de código me ajudou a entender melhor como algumas ferramentas funcionam, e então quando surgiam dúvias nos fóruns muitas vezes eu conseguia respondê-las.

Porém nem tudo que estudamos tem alguém perguntando a respeito, então pode ser útil escrever isso em algum lugar, ajudando quem vier a ter uma dúvida mesmo antes que faça uma pergunta em um fórum. Dessa forma surgiu a ideia de criar este blog. Meu intuito porém nunca tinha sido escrever de forma abrangente, mostrando alguma ferramenta do início ao fim, e sim registrar algo que, pelo menos na época, não fosse possível encontrar na internet. O problema disso é que o conhecimento fica fragmentado, sendo necessário consultar muitas fontes para conseguir um bom resultado na aplicação inteira. Inclusive quando me perguntavam alguma referência para aprender algo eu não podia nem indicar meu blog, pois os posts sempre foram voltados para assuntos mais pontuais, e também era difícil indicar algum livro, pois quase todos são muito extensos para poderem cobrir toda a ferramenta, ou muito superficiais, ensinando como fazer mas não o por que fazer.

Foi então que surgiu o convite do Paulo Silveira, com a proposta de um livro curto, que não tivesse como compromisso cobrir totalmente as ferramentas, e sim abordar com qualidade as partes mais importantes e mais utilizadas no dia a dia. O resultado é este livro, que não tem debug de código, mas explica mais do que o simples “faz assim que funciona”.
Particulamente espero que a leitura seja proveitosa, e que ao final o leitor consiga aplicar no seu cotidiano os conhecimentos adquiridos; e seja qual for o caminho tomado ao desenvolver uma aplicação, que seja consciente. Mesmo que a escolha seja continuar fazendo como fazemos hoje, precisamos escolher continuar nesse caminho, e não fazer isso por não conhecer outro jeito.

 

Conteúdo

1. Introdução
   1. A evolução da integração entre Java e Bancos de dados
   2. Como era a vida com o JDBC?
   3. Diminuição da impedância através do mapeamento
   4. Bibliotecas ORM e o Hibernate
   5. Muitos frameworks ORM, como evitar o vendor lock-in?
   6. O desenvolvimento web com Servlets e o padrão MVC
   7. Tirando HTML do código Java com as JavaServer Pages
   8. Organize seu código com a separação de responsabilidades
   9. O MVC e os frameworks
   10. Por que usar JSF?
   11. O primeiro contato com o JSF
   12. Nos próximos capítulos
2. Primeiros passos com a JPA
   1. Definição do modelo
   2. Configuração básica do persistence.xml
   3. Escolha o dialeto do banco de dados
   4. Automatização da criação e evolução das tabelas
   5. Gravação do primeiro dado no banco de dados
   6. Consultas simples no banco de dados com a JPA
   7. Exclusão de dados com a JPA
   8. O que mais vem pela frente?
3. Primeiros passos com o JSF
   1. Onde e como defino telas com o JSF?
   2. Criação da tela e dos inputs básicos de dados
   3. commandButton, Managed Beans e a submissão de formulários
   4. Passe dados da tela para o Managed Bean
   5. Como receber os parâmetros direto no método
   6. Gravação do automóvel no banco de dados
   7. Liste os dados com o dataTable
   8. Mas minha listagem está executando várias consultas no banco...
   9. Exclusão de dados e o commandLink
   10. O primeiro CRUD integrado
4. Entendendo a JPA
   1. O padrão de projetos Data Access Object, ou DAO
   2. JPA não é um DAO genérico, é contextual
   3. Ciclo de vida de um objeto na JPA
   4. A JPA vai mais além do que um simples executar de SQLs
5. Como mapear tudo... ou nada!
   1. Definições de entidade
   2. Faça atributos não serem persistidos com o @Transient
   3. Mapeie chaves primárias simples
   4. Mapeie chaves compostas
   5. A anotação @Basic
   6. @Table, @Column e @Temporal
   7. @Version e lock otimista
   8. Relcionamentos muitos para um com @ManyToOne
   9. @OneToOne
   10. Relacionamentos bidirecionais
   11. O que tem a ver o dono do relacionamento com a operação em cascata?
   12. Organize melhor suas entidades e promova reaproveitamento com @Embeddable e @Embedded
   13. Relacionamentos um para muitos com o @OneToMany e @ManyToOne
   14. A importância do Lazy Loading, o carregamento preguiçoso
   15. @Lob
   16. @ElementCollection
   17. Relacionamentos muitos para muitos com o @ManyToMany
   18. Customize as colunas de relacionamentos com @JoinColumn e @JoinColumns
   19. Configure as tabelas auxiliares com @JoinTable
   20. Conclusão
6. Consultas com a JPQL e os problemas comuns na integração com o JSF
   1. Filtre dados com a Java Persistence Query Language - JPQL
   2. Como aplicar funções nas consultas
   3. Onde estão meus joins?
   4. Execute suas consultas e use parâmetros
   5. Utilize funções de agregação
   6. Faça sub-consultas com a JPQL
   7. Agrupamentos e HAVING
   8. Consultas complexas... resultados complexos?
   9. Use o Select New e esqueça os arrays de Object
   10. Organize suas consultas com Named Queries
   11. Execute as Named Queries
   12. Relacionamentos Lazy, N+1 Query e Join Fetch
   13. Evite a LazyInitializationException com o OpenEntityManagerInView
   14. O problema das N+1 consultas e como resolvê-lo
   15. Foi bastante, mas não acabou...
7. Entenda o JSF e crie aplicações web
   1. Se prepare para um mundo diferente, baseado em componentes
   2. A web stateless contra a web stateful
   3. O ciclo de vida das requisições no JSF
   4. Fase 1 - Criar ou restaurar a árvore de componentes da tela (Restore View)
   5. Fase 2 - Aplicar valores do requisição na árvore de componentes (Apply Request Values)
   6. Fase 3 - Converter e Validar (Validate)
   7. Fase 4 - Atualizar o modelo (Update Model)
   8. Fase 5 - Invocar ação da aplicação (Invoke Application)
   9. Fase 6 - Renderizar a resposta (Render Response)
   10. Aja sobre as fases do JSF com os PhaseListeners
   11. Conheça os componentes do JSF
   12. h:form
   13. h:inputText e h:inputTextarea
   14. h:inputSecret
   15. h:inputHidden
   16. h:selectOneMenu, f:selectItem e f:selectItems
   17. h:selectOneRadio
   18. h:selectOneListbox
   19. h:selectManyMenu e h:selectManyListbox
   20. h:selectManyCheckbox
   21. h:selectBooleanCheckbox
   22. Novidade do JSF 2.2: h:inputFile
   23. h:panelGrid
   24. h:panelGroup
   25. h:outputText
   26. h:outputLabel
   27. h:outputFormat
   28. h:outputScript e h:outputStylesheet
   29. h:graphicImage
   30. h:dataTable
   31. ui:repeat
   32. h:commandButton e h:commandLink
   33. A diferença entre Action e ActionListener
   34. Padronização no carregamento de recursos
   35. Entenda os conversores nativos, o f:convertDateTime e o f:convertNumber
   36. Conversores customizados
   37. Conheça os validadores nativos
   38. E quando os validadores nativos não fazem o que eu quero? Crie seus validadores
   39. Novidade: JSF com GET e bookmarkable URLs
   40. h:button e h:link
   41. Regras de navegação
   42. Entenda os escopos e saiba como e quando trabalhar com cada um
   43. A curva de aprendizado do JSF
8. Validações simplificadas na JPA e no JSF com a Bean Validation
   1. Trabalhe com os validadores e crie sua própria validação
   2. Organize grupos de validação
   3. A integração entre Bean Validation e JPA
   4. A integração entre Bean Validation e JSF
9. Enriquecendo nossa aplicação JSF
   1. Combos em cascata e commands em dataTable
   2. Mostre mensagens com h:message e h:messages
   3. Internacionalizando nossa aplicação
   4. JSF e Ajax
   5. Organize o código das telas com templates
   6. Composite Components: criando nossos próprios componentes a partir de outros
   7. Criar um jar com componentes customizados
10. Truques que podem aumentar a escalabilidade e perfomance da sua aplicação
   1. Utilize o cache de segundo nível da JPA
   2. Faça cache de consultas
   3. Colhendo estatísticas da nossa camada de persistência
   4. Relacionamentos extra-lazy
   5. Paginação virtual e real de dados
   6. Utilizando Pool de conexões
   7. Tornando o JSF mais leve com uso inteligente de AJAX
   8. Quando possível, manipule componentes JSF no lado do cliente
   9. Considerações finais sobre otimizações
11. Conclusão

 

Onde comprar?

O livro está disponível no site da Casa do Código, nas versões impressa, e-book, e combo, que inclui o e-book e a versão impressa. A vantagem deste último é que você tem a comodidade da versão impressa enquanto a versão eletrônica dá acesso a atualizações ou correções do livro.

 

42 thoughts on “Livro: Aplicações Java para a web com JSF e JPA

  1. Cara esse seu livro ensina a fazer uma aplicação? ou so fala sobre jsf e jpa? pq falar sobre tem varios tutorias na net….interessante seria criarem um livro desenvolvendo uma aplicação completa com essa plataforma…é o unico livro que ja faiz isso foi o livro “Programação Java para a Web” da novatec

  2. Olá @Gustavo,
    O livro não é centrado na aplicação, e sim nas tecnologias. Porém desde o início é apresentada uma aplicação bem simples e depois adicionamos mais coisas, mas no final não temos uma aplicação complexa; ela continua simples, porém muito é discutido no livro sobre cada tecnologia.

    Concordo com vc em relação a encontrar tudo na internet, inclusive minha bibliografica principal é a especificação, então é só baixar os PDFs, de graça, e ler (JSRs 314, 317 e 303). Porém tutorial na internet, em sua grande maioria, apenas mostra como fazer determinadas coisas. Obviamente não é algo ruim, nos ajuda a fazer rapidamente uma coisa ou outra, mas na grande maioria dos casos só mostra a receita de bolo, não te ensina a criar suas próprias receitas.

    Já ministrei dezenas de treinamentos e ja trabalhei com dezenas de pessoas, e a quantidade de pessoas que não precisa mais de um tutorial para fazer as tarefas do dia a dia é até alta, mas o número baixa bastante quando procuramos quem realmente entende o que está acontecendo por baixo dos panos, e é nessa parte que um livro se difere de “tutoriais”.

    Obviamente existem posts na internet que também não são apenas receita de bolo, eu mesmo sempre procuro escrever algo mais útil do que um simples “tutorial”. Mas o problema disso é a pulverização do conteúdo. Tanto que quando me perguntavam uma referência eu respondia “a internet”: ou seja, muito complicado de encontrar o conteúdo.

    Eu sempre comento que saber fazer as coisas é muito bom para dar empregabilidade, mas se você quiser ter um salário bom, ser valorizado, vai ter que saber mais do que fazer, vai ter que entender o porque das coisas funcionarem de determinada maneira. Conseguir “prever” comportamentos de algo que você nunca implementou porque conhece o framework o suficiente para isso. Mas claro que previsão é sempre uma previsão.

    Porém ler um único livro nunca te dará esse conhecimento da noite para o dia, o caminho é mais longo que isso. Meu objetivo com esse livro foi dar uma ajuda para quem está iniciando ou quem quer passar de “fazedor” para “entendedor”.

    Escrevi bastante, mas não com o intuito de defender o meu livro, e sim um conhecimento mais aprofundado do que os que a maioria dos tutoriais oferecem.

    Obrigado pelo comentário.
    Abraço.

  3. Olá Gilliard Cordeiro,

    Acessei o “Casa do Código” e acessei a página do seu livro, me parece muito bom, lendo sua resposta ao Gustavo me motivou mais ainda a comprar o livro.
    Porém, não tem outra forma de comprar além do PayPal?
    Se tivesse uma forma de pagar com débito ou boleto seria tão bom =D

    Obrigado e parabéns pelo livro.

  4. Olá Gilliard Cordeiro.

    Gostei da abordagem do livro, estou motivado a comprar.
    Porém gostaria da opção pra pagar com boleto.

    Obrigado.

  5. Livro bom não se discute, se lê! Parabéns pelo livro. Acabei de adquiri-lo e já fiquei curioso: qual o software utilizado para as ilustrações? Percebi que parece ser o mesmo software utilizado na edição do livro de Larman Craig. Procede? Mais uma vez parabéns pelo excelente livro. Apenas os leitores que sabem de que se trata é que poderão compreender a grandiosidade da obra.

  6. Gilliard, vc tem algum interesse disponobilizar os fonte do livro? Como vc mesmo fala:
    “-O livro não é centrado na aplicação, e sim nas tecnologias.”, achei interessante a linguagem de bom nivel. Acredito q vá fazer uma ajuda para os marinheiros de primeira viagem. Abraço.

  7. Olá Guilliard, adquiri seu livro JSF e JPA, gostaria de saber se você tem como disponibilizar o código completo da aplicação. Quero parabenizá-lo pelo belo trabalho, um dos mais didáticos que eu já li.
    Abço

  8. Oi @Wilker ,
    Fico muito feliz que tenha gostado. Eu publiquei o código mas faltou um update no post, vou fazer isso agora. O link é este: https://github.com/gscordeiro/faces-motors
    Algumas partes do código eu mudei depois de colocar no livro, então não está exatamente igual, mas é esse o projeto.
    Tem uns bugs que tenho que resolver (provenientes dessas alterações depois que estava funcionando), mas qualquer coisa cria uma issue no proprio projeto no github.
    Um abraço!

  9. Olá Gilliard, estou no 4º semestre de Análise de Sistemas na FACOM – UFMS, este ano comecei estudar Java por conta própria já estudei JSE, um pouco de Servlets, e atualmente estou lendo o livro “Core Java Server faces”. Estou pensando em adquirir seu livro, mas eu gostaria de saber se após a leitura e implementação dos exemplos estarei em capacidade de arrumar um bom estágio em desenvolvimento web utilizando JSF 2.0 + JPA 2.0, e quais empresas aqui em Campo Grande que utilizam essas tecnologias.

    Até mais.

  10. Oi @Douglas Arantes, a ideia do livro é justamente essa, deixar você preparado para desenvolver usando essas tecnologias. Só de você ler um livro sobre esses assuntos (seja o meu ou não), já estará um passo a frente da galera que fica só nos tutoriais.
    Sei sim de empresas em Campo Grande que usam essas tecnologias (te mandei por email), mas mesmo que vc ainda não seja “fera” nelas, acho que você tem que correr atrás de estagiar pois é aí que você vai aprender de verdade: nada como praticar.

    Até++;

  11. Oi Gilliard,

    Comprei o livro faz uma semana eu acho, porém só comecei a ler hoje.

    Quero avisar sobre um possível erro em Agradecimentos:

    “Um agradecimento muito especial à minha namorada, quase esposa, Dantiele
    de Freitas Queiróz …”

    Dantiele? Não seria Daniele?

    Eu estou com a versão 15.2.30

  12. Oi @Jorge,
    que bom que está gostando. Dá trabalho mas vale a pena quando vejo que estão gostando :)
    E o nome da minha namorada é esse mesmo, casalzinho de nome diferente né? hehehe
    Um abraço e obrigado pelo feedback.

  13. Olá Gilliard, boa noite!

    Poderia explicar um pouco a parte que você diz que JPA não é DAO Genérico, que ele é Contextual? Fiquei com medo, pois, programei um sistema utilizando DAO genérico com JPA (rsrs).

    Muito obrigado.

    Obs.: se achar melhor eu posso postar meu DAO pra você avaliar.

  14. Oi @Filipe, boa tarde!

    A tua dúvida foi depois de ler o livro ou vendo o índice? É que no livro explico certinho o que é isso.
    Não sei como está tua implementação e como teu sistema lida com ela, mas já projeto onde trataram um DAO genérico feito com Hibernate/JPA da mesma forma que tratavam um feito com JDBC e problemas “misteriosos” aconteceram.

    Mas “mistérios” costumam acontecer mais quando não entendemos como as coisas funcionam. Entendendo como o contexto funciona, tudo fica claro.

    Um abraço.

  15. Pois é @Jair,

    por enquanto está tendo só paypal e transferência bancária. Mas sei que o pessoal está estudando colocar novas opções de pagamento.

    Quem sabe uma dessas duas sirva pra você.

    Um abraço e valeu pelo interesse.

  16. Ola irmão, parabéns ai pelo livro. Tô no inicio dele ainda, mas gostei da sua forma de escrever, simples e objetiva.

    Só uma dúvida, para a modelagem DER do banco que tem logo no começo do livro, qual ferramenta tu usou?

  17. Gilliard, comprei o teu livro sobre “Aplicações Java para a web com JSF e JPA”, estou tentando fazer os Primeiros passos com a JPA do capítulo 2, já escrevi tudo, mas está apresentando um erro que não sei como resolver, já recorri a alguns colegas, mas ninguém soube me dizer do que se trata. Falaram que era ausência de alguns .jar na pasta WEB-INF/lib pesquisei na Internet coloquei vários deles, mas o erro persiste. Sendo assim peço-lhe que me ajude, agradecido.

    Marcos Prado

    Abaixo meu código e o erro:

    package br.com.integrator;

    import javax.persistence.Entity;
    import javax.persistence.GeneratedValue;
    import javax.persistence.Id;

    @Entity
    public class Automovel {

    @Id
    @GeneratedValue
    private Long id;
    private String marca;
    private String modelo;
    private Integer anoFabricacao;
    private Integer anoModelo;
    private String observacoes;

    public Long getId() {
    return id;
    }
    public void setId(Long id) {
    this.id = id;
    }
    public String getMarca() {
    return marca;
    }
    public void setMarca(String marca) {
    this.marca = marca;
    }
    public String getModelo() {
    return modelo;
    }
    public void setModelo(String modelo) {
    this.modelo = modelo;
    }
    public Integer getAnoFabricacao() {
    return anoFabricacao;
    }
    public void setAnoFabricacao(Integer anoFabricacao) {
    this.anoFabricacao = anoFabricacao;
    }
    public Integer getAnoModelo() {
    return anoModelo;
    }
    public void setAnoModelo(Integer anoModelo) {
    this.anoModelo = anoModelo;
    }
    public String getObservacoes() {
    return observacoes;
    }
    public void setObservacoes(String observacoes) {
    this.observacoes = observacoes;
    }

    }

    package br.com.main;

    import javax.persistence.EntityManager;
    import javax.persistence.EntityManagerFactory;
    import javax.persistence.EntityTransaction;
    import javax.persistence.Persistence;

    import br.com.integrator.Automovel;

    public class Pagina31 {

    public static void main(String[] args) {
    EntityManagerFactory emf = Persistence.createEntityManagerFactory(“default”);
    EntityManager em = emf.createEntityManager();

    Automovel auto = new Automovel();
    auto.setAnoFabricacao(2010);
    auto.setModelo(“Ferrari”);
    auto.setObservacoes(“Nunca foi batido”);

    EntityTransaction tx = em.getTransaction();
    tx.begin();
    em.persist(auto);
    tx.commit();

    em.close();
    emf.close();
    }

    }

    br.com.integrator.Automovel

    Exception in thread “main” javax.persistence.PersistenceException: No Persistence provider for EntityManager named default
    at javax.persistence.Persistence.createEntityManagerFactory(Persistence.java:56)
    at javax.persistence.Persistence.createEntityManagerFactory(Persistence.java:34)
    at br.com.main.Pagina31.main(Pagina31.java:13)

  18. Gilliard,
    Então já li uma boa parte do livro e anotei alguns erros que aparece na Versão: 15.2.30

    1) Página 21 arquivo pdf: ” Enquanto a muitos desenvolvedores utilizavam o Hibernate …” não seria “Enquanto muitos ….”?
    2)Página 144 subtítulo: “Aja sobre as fases” não seria “Ajax sobre as fases…”?
    3)Pagina 117: “anotar algumas diferenças…” não seria “notar algumas diferenças”?
    4)Página 124: “que não é faz parte do nosso modelo” não seria “que não faz parte do nosso modelo”?
    5)Página 113: “mapeamentos do Hibernate,” não seria “mapeamentos do JPA,”
    6)Página 117: “a JPQL nos permite usar algumas funções:” não seria “a JPQL nos permite usar algumas funções.” detalhe (ponto e vírgula para ponto)
    7)Página 133: “não teremos haverá mais LazyInitializationException,…” para “teremos” ou “haverá”

    O livro é bom, porém eu tenho estudado em outros livros também e por isso ainda não terminei de ler o seu livro. Tenho vontade de comprar os outros livros da casa do código, mas o problema é tempo para estudar.

  19. Valeu @Jorge, vou corrigir esses erros de digitação, e então disponibilizarão em breve uma versão corrigida.

    Os livros da casa do código são muito bons, eu recomendo. Vai estudando no seu tempo, o importante é não deixar a correria nos fazer parar de estudar.

    Tem muita gente boa no mercado, mas também tem bastante gente meio acomodada, se vc continuar estudando, mesmo com pouco tempo, vai acabar se destacando (se é que isso já não acontece).

    Abraço.

  20. Gilliard, comprei o teu livro e mais alguns da casa do código. É um dos livros em português mais recentes lançados para aplicação JPA, JSF e Hibernate.
    Gostaria de agradecer a você pelo empenho e te daria uma sugestão, de deixar umas dicas dos pontos que dão mais problema na prática ao fazer uma aplicação usando os frameworks que você citou.
    Eu segui os exemplos do teu livro, e se não fosse a experiência e muita pesquisa muitos deles seriam bem difíceis de darem certo. Se você citar as versõs dos jars que você usou, do contâiner, do JDK e dos frameworks já elucidará mutos problema, pois pode haver erros de versão, além de citar os diretórios onde colocar os API’s e os jars da aplicação. Por exemplo, para que roda o Tomcat, é imprescindível colocar as jars na lib dele, isto já evita muitos problemas. Vejo que muitos têm dúvida da diferença de onde colocar o persistence.xml, já que há diferença quanto à IDE e quanto o tipo de aplicação (desktop ou web).
    Por fim, volto a agradecer e recomendo o livro, já que outros livros nacionais (mesmo que traduzidos) sempre vêm com tecnologia defasada, versões antigas, etc). Parabéns.

  21. Boa tarde,

    Comprei o seu livro na casa do código e baixei o fonte e fiz a “instalação” no eclipse, mas quando subo a aplicação, recebe erros pois não consigo popular as tabelas, pois não tenho as tabelas com dados. Teria como fornecer o script sql para gerar o banco.

    Atenciosamente,

  22. Oi @Adam,
    Obrigado pelos parabéns e pelo feedback. Vou dar uma olhada ali no capítulo onde eu falo da configuração básica pra ver como está a explicação dessa parte que vc comentou. Aí adiciono as informações que estiverem faltando para que quem estiver começando não tenha essa dificuldade que vc relatou.

    Sobre onde colocar os jars, temos que ter em mente que em apps web, o local é o WEB-INF/lib do arquivo war ou pasta da aplicação. Não vai pela cabeça da IDE não, principalmente se for o netbeans que mascara muito esses caminhos. O que importa é que no final os jars precisam estar nesse caminho. O legal do eclipse é que basta jogar o jar nessa pasta que automaticamente vai pro path. No netbeans vc precisa adicionar explicitamente mesmo colocando nessa pasta. Cada IDE tem prós e contras, mas procure focar no que o JavaEE define, e não nas IDEs.

    Se você estiver com dúvidas sobre versões, dê uma olhada no projeto no github, mas especificamente no arquivo do ivy que define as dependências. Para facilitar coloquei essas versões no readme do projeto no github, então vale dar uma conferida: https://github.com/gscordeiro/faces-motors.

    E mais uma dica sobre local de jars, só coloque os jars na pasta lib do servidor se tiver muita certeza do que está fazendo. Pode parecer uma boa ideia no começo, pois todas as apps terão a biblioteca à disposição. Mas como fica se daqui uns anos vc for fazer uma nova aplicação usando JPA 3 e no seu servidor tem a lib da JPA 2? Vai dar problema, pode ter certeza… aí você vai chingar o tomcat, a jpa, o java, todo mundo que tiver perto, mas o problema na verdade foi a estratégia utilizada ;)

    Então evite colocar coisas no path global do servidor. Agora se estiver usando um JBoss 7 ou superior, ou um GlassFish (que não conheço em produção), aí sim tem como vc separar as libs que simplesmente estão disponíveis no server, ou que efetivamente entram no path das aplicações.

    Espero não ter complicado mais do que respondido à sua sugestão, mas é que você tocou em pontos interessantes e importantes, então é bom analisar bem.

    Abração!!

  23. Oi @marcio,
    Não precisa de script nenhum, basta vc criar o banco vazio que a JPA cria a estrutura pra vc. Só checa se o banco está criado corretamente e se o usuário e senha que vc está passando conseguem conectar e alterar a estrutura do banco.

    Para fazer o teste, pegue um cliente de banco genérico como o squirrel e use os mesmos dados que vc está usando na aplicação para conectar por lá. Se der certo e a aplicação não conseguir conectar, pode me mandar a stacktrace que eu te ajudo. Mas aí pra não deixar muito longo aqui no post, coloca na lista de discussões do livro: https://groups.google.com/forum/#!forum/jsf-jpa

    Abração!

  24. Ola Gilliard…
    vai a minha opinião sobre o seu livro.
    adquirir o ebook e já o finalizei, o livro é realmente bom e bem esclarecedor.
    Seguindo os exemplos de inicio parece ser legal, mas depois se torna um pouco confuso ao decorrer em alguns exemplos.
    A mistura esta no nível de conhecimento do Java para quem vai seguir os exemplos, falo se alguém esta começando a aprender e segue os exemplos acaba ficando perdido, isso pq alguns métodos não vão executar da forma como o livro aborda.(não falei que esta errado, só que se seguir igual igual como esta no livro não funciona corretamente).
    Falo a respeito pq tive que fazer modificações para os resultados do CRUD dar certo, mas vendo por outro lado isso força o leitor iniciante no Java a pesquisar mais pq o livro e só inicio de uma ajuda.
    A leitura é muito muito clara e de um bom entendimento.
    Gostei muito da parte de JPA e do uso da interface EntityManager me ajudou bastante a mudar o jeito de desenvolvimento.
    Parabéns pelo livro e ate mais outro livro.

  25. Obrigado pelo feedback @Francisco.

    Fico muito feliz que mesmo você tendo encontrado problemas no livro, tenha gostado no geral, especialmente da clareza. Pode ter certeza que esse foi um objetivo alcançado, o que me deixa feliz.

    Sobre os erros, apesar de você ter visto o lado positivo, obviamente não foram propositais. Algumas pessoas foram relatando os problemas encontrados na lista de discussões do livro, e assim que conseguia reproduzir o erro eu corrigia e uma nova versão do livro era disponibilizada com as correções. Talvez o erro que você encontrou passou batido pelo restante do pessoal da lista, ou então até já tenha saído atualização corrigindo esses problemas.

    Se tiver interesse, dá uma passada lá na lista e detalha mais suas sugestões de melhoria, que com certeza vou correr atrás para deixar o mais bacana possível.

    Abraço.

  26. Gilliard, o livro aborda alguma coisa do PrimeFaces? No site casadocodigo diz que sim, porém no índice do livro não encontrei nada a respeito.
    Outra pergunta: você explica os conceitos de forma mais clara (“entendível”) ou de uma forma mais técnica?
    Mais uma: após estudar seu livro, ou tendo ele como um guia de consulta, terei conhecimento para criar uma aplicação mais complexa além das aplicações de exemplo que o livro implementa? O livro me dá essa base?

    Desde já, obrigado.

  27. Oi @Jonas

    No livro tem um pouco de primefaces, mas não foquei nisso porque componente muda toda hora. O que abordo no livro é onde o primefaces realmente faz algo interessante, que é a parte da paginação real. A grande maioria dos demais componentes são só formas diferentes de apresentar os mesmo componentes padrão. Um exemplo é o suggestionbox, que nada mais é do que um combo.

    A explicação está bem entendível, pelo menos é o feedback que tenho recebido. A ideia é vc saber como fazer, mas saber principalmente o porquê. Então vai te dar base sim pra fazer fazer outras aplicações. Além disso, qualquer dúvida tem a lista do livro onde eu estou sempre respondendo as dúvidas sobre os assuntos do livro.

    Se ainda tiver alguma dúvida é só falar.

    Abraço

  28. Caro Gilliard !

    Como iniciante em JSF/JPA/Primefaces adquiri o seu livro e gostaria de parabenizá-los pela clareza e didática.Com certeza está me ajudando em muito em meu trabalho.
    Porém surgiu-me uma dúvida e gostaria de pedir a sua ajuda na seguinte situação:

    Digamos que preciso fazer a seguinte entrada de dados, onde preciso lançar as vendas de uma determinada revenda, (serão vários carros vendidos). É uma relação 1-n. Como poderia fazer a entrada , utilizando uma DATATABLE, onde eu digitaria por exemplo o Codigo da Venda , o codigo da revenda e abriria a Datatable na tela, na qual apresentaria todos os carros , e eu selecionaria os que comporão aquela venda (Tipo caixa dropBox). No momento que eu confirmar as escolhas dos carros/modelos, a rotina geraria todos os registros corespondentes. ( Id Venda x, Id Revenda x, Carro1 ,Id Venda x, Id Revenda x, Carro2,.. Id Venda x , Id Revenda x, Carro N)

    Não sei se fui claro ? Ficaria muito grato se pudesse contar com o teu auxilio.Obrigado

    Agnaldo

  29. Oi Agnaldo, primeiramente muito obrigado, fico feliz que esteja gostando do livro, e estou aqui pra tentar ajudar mesmo.

    Não sei se entendi 100%, mas vou tentar ajudar.

    Essa revenda seria uma loja de carros, certo? Quem vai lançar as vendas vai mesmo ter acesso a várias lojas? Senão vc poderia “fixar” a revenda com base em qual usuário está logado no momento (até poderia ter a opção de trocar via um combo, por exemplo).
    Na hora de fazer a vonda você quer poder listar os carros e selecionar quais vão fazer parte da venda, certo? Para isso você pode usar a dataTable selecionavel do primefaces.
    Esse componente é bem simples, é um selectManyChackbox apresentado como uma dataTable. Dele vc recupera quais os carros foram selecionados, coloca dentro do objeto venda, e se o cascade estiver configurado corretamente, a propria JPA vai inserir tudo certinho.
    Pra essa parte do banco dar certo além do cascade, você tem que dar uma olhada na parte do livro que eu falo do “lado dono do relacionamento”.

    Se não entendi bem, ou se precisar de mais alguma coisa é só mandar.

    Abraços

Leave a Reply

Your email address will not be published. Required fields are marked *

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>