PDF Java Full Stack Alex 2021
PDF Java Full Stack Alex 2021
1 – História do Java
Criada em 1995 pela Sun Microsystems e comprada pela Oracle em 2008 pelo valor de $ 7,4 biliões de dólares.
Grande responsável pela disseminação da programação orientada a objetos ou chamada também de POO ou OO.
A maioria das linguagens criadas atualmente são muito parecidas com Java e adotam/copiam sua lista enorme de
conceitos e soluções, como:
Compilado e rodada em cima da JVM máquina virtual Java, essa linguagem tem o poder de rodar em qualquer
lugar.
Relógio, celular, computadores, notebook, carros, torradeiras elétricas, em tudo mesmo desde que o equipamento
aceite a instalação.
O Java tem o grande beneficio de que um sistema escrito em versões anteriores rode sem nenhum problema em
versões mais novas e isso faz com que empresas multinacionais, banco, sistemas do governo, sistemas militares e
grandes corporações se sintam seguras em criar os sistemas usando Java.
E também pela sua enorme segurança nas aplicações com o beneficio de ser compilada gerando bytecode, assim
não é possível um invasor alterar o seu código e mudar o processamento real do sistema o que o torna a escolha
perfeita para empresas de software.
OBS: Precisamos deixar bem claro que JavaScript não é Java, o Java é usado para fazer todo o processamento de
dados do lado do back-end nos servidores web.
O JavaScript é usado no front-end para mostrar os dados na tela e para deixar as telas do sistema interativas com
a pessoa, nos últimos anos também vem sendo possível rodar o JavaScript nos servidores usando por exemplo o
NodeJS (Veja AQUI).
Basicamente em um sistema web completo em Java nós usamos 86% de Java para todo o processamento e 14% de
JavaScript para criação das telas junto com vários frameworks para facilitar o desenvolvimento.
O front-end são as telas do sistema tudo que o usuário vê na tela do computador, sempre é constituído de Html +
Css + JavaScript.
O back-end é toda a parte de estrutura onde realmente acontece todo o processamento de dados e sua
manipulação junto com o banco de dados e sql e código Java, PHP, NodeJS ou alguma outra linguagem Back-End.
Exemplo de um front-end é qualquer tela de um sistema de computador ou celular, alguma tela qualquer.
Abaixo tem a tela de impressão de certificado da minha EAD feito com Bootstrap e Thymeleaf.
Toda a parte de front-end no final quando é interpretado pelo navegador se torna Html + CSS + JavaScript.
Agora na parte de back-end é onde o bicho pega, é onde está 87% do código funcional, é onde está toda a regra
de negócio, é o que fornece os dados para o front-end mostrar, o back-end pode existir sozinho e efetuar
milhares de recursos mas é preciso de uma entrada de dados, esses dados têm que vir de algum lugar e de onde
vêm? De algum front-end, tela de computador, aplicativos, algum sistema web, alguma tela dá esses dados como
entrada, outro de uma forma mais avançada pode haver um equipamento como é o caso da previsão do tempo a
entrada de dados vem de um hardware, mas no final é preciso de front-end para mostrar os dados para nós.
Bem, o back-end não tem como ser mostrado em uma única imagem, mas aqui vai um exemplo do projeto da
Plataforma EAD Jdev Treinamento.
Criado 100% em Java, levei quase 2 anos pra deixar ela no ponto que está com muitos recursos, você pode testar
toda a plataforma realizando o cadastro gratuito clicando AQUI.
O Java é atualmente uma das linguagens mais utilizadas em todo o mundo, em ainda em crescimento nas
empresas, através de novas adoções. Uma coisa que se deve mencionar é que hoje o Java não é apenas uma
linguagem, mas sim uma plataforma de desenvolvimento.
Nos últimos anos o Java vem sendo usado por todo o mundo dentre as características podemos citar as seguintes:
• Aprenda Java e programe em qualquer plataforma e SO: Uma das grandes vantagens do Java é que ele além
de ser uma linguagem é uma plataforma de desenvolvimento. Com ele é possível desenvolver aplicações para
desktop, celular, cartão, web, televisão digital, etc.
• Comunidades: Os grupos de usuários Java são muito fortes em todo o mundo e graças a eles é possível obter
material para estudos de maneira fácil, participar de encontros regionais, palestras e até minicursos. Neles
também é possível trocar experiência com pessoas que já atuam na área a mais tempo e o mais importante
que é obter soluções para qualquer problema.
• Grande número de frameworks: Graças ao investimento das comunidades e também de algumas empresas,
existem hoje uma variedade de frameworks que visam facilitar o trabalho do desenvolvedor.
• O Java não roda somente Java: A máquina virtual Java atualmente roda cerca de 350 linguagens com pontos
interessantes, por exemplo, o Groovy linguagem dinâmica, Scala que é específica para concorrência dentre
outras linguagens como JPython , Python, Jruby e o Ruby.
• Desenvolva em qualquer sistema operacional para qualquer sistema operacional: Quando se compila um
arquivo em Java ele gera um bytecode que é interpretado numa JVM. Bastando que o seu sistema operacional
tenha uma JVM, será possível executar o Java nos sistemas operacionais Windows, GNU/Linux e Mac. Suas
principais IDES, podemos citar o Eclipse e o Netbeans, rodam em Java, ou seja, se pode programar em
qualquer sistema operacional.
2 - Presente no desenvolvimento :
• App Mobile mais conhecido é o Android.
• Sistemas Web e Desktop
• Big Data
• Machine Learning
• IoT
• Sistema Embarcados em equipamentos.
• Inteligência artificial.
O que garante a qualidade dos sistemas criados com a linguagem Java é o poder da orientação a objetos, assim a
manutenção se torna fácil, legível e eficaz com a grande reutilização de código dentro do projetos.
Unimed
Banco Original
Banco Inter
Banco do Brasil
Banco Caixa Econômica Federal
Sicred
Sicoob
Claro
Vivo
Tim
Seguradoras
Spotify
Transportadoras
Farmácias
Mercados
Sistemas de Geolocalização
Sistemas administrativos, financeiros, analíticos e muito mais.
Etc... Etc..
Te faço um desafio, vá para o Google e pesquise pela frase “Vaga para programador Java.”
Você encontrará milhares de vagas em todas as cidades e estados do Brasil, e isso não é brincadeira, a demanda é
realmente enorme.
Muitos reclamam que é difícil se tornar um programador e na verdade quem não consegue é porque estuda da
forma errada, começam atropelando conteúdo, não seguem a sequência de aprendizado e ficam perdidos, pessoas
assim ficam fora do mercado e fica reclamando por aí.
A quantidade de sistemas criados e vagas para trabalhar com Java multiplicaram 10 vezes.
Quem sabe daqui uns 30 anos, a verdade é, você quer ser programador e entrar no mercado com muitas
oportunidades e bom salários o Java é a melhor escolha.
Primeiro, Java possuí vaga em qualquer cidade do Brasil, dúvida… pesquisa no Google e comprove.
A quantidade de sistemas que existem no mercado de trabalho garante emprego para você nos próximos 30 anos.
É robusto e é seguro, quem sabe Java está com o sucesso nas mãos.
E sendo um programador você também tem a oportunidade de criar seu próprio sistema, adquirir clientes e faturar
muito alto sendo empreendedor e programador.
No entanto, para que fossem feitas atualizações recorrentes do produto e fosse oferecido um suporte maior aos
usuários, a empresa resolveu fazer essa alteração no licenciamento. Assim, a Oracle tem implantado melhorias a
cada seis meses, lançando novas funcionalidades. O primeiro desses releases foi publicado em abril de 2019 e o
segundo tem previsão para outubro do mesmo ano.
Essa prática deve seguir sendo realizada até o final de 2020. A maior polêmica em relação às novas regras do Java
é o boato de que todas as versões do software seriam pagas.
Essa conversa começou a rodar os fóruns de TI da internet quando a Oracle comprou a Sun.
Como falado, depois que essa compra foi efetivada, o software seguiu sendo distribuído gratuitamente por um
tempo. No entanto, logo percebeu-se que ele demandava custos, e esses valores precisavam ser repassados aos
usuários para que não houvesse prejuízo. Dessa forma, o objetivo da cobrança é fazer com que mais atualizações
sejam realizadas no produto, bem como prestar um suporte mais eficiente para os usuários.
No entanto, não há motivo para pânico! A versão free do Java continuará existindo , porém, com recursos mais
limitados. As versões chamadas de LTS (Long Term Support), serão pagas, assim como as versões superiores a 11.
Mas ninguém é obrigado a adquiri-la, embora ela seja bastante vantajosa, como falaremos mais adiante.
Então para você aprender a programar e ter o Java em sua máquina você nunca pagará R$ 1 reais por isso.
E também todas as ferramentas para você aprender a programar também são totalmente gratuitas.
Como aumentar seu salário de programador? Ao mesmo tempo que a resposta é superfácil “Aprendendo mais,
lógico”, mas, como? Sabendo exatamente o que estudar e seguindo a sequência correta.
Você deve dominar os melhores e mais usados frameworks Java do mercado, como o melhor e mais famoso Spring
Framework e seu módulo Spring Boot.
A maioria dos treinamento te ensinam por pedaços, ecossistemas separados, mas como sair o júnior e juntar todas
as partes até o nível sênior, esse é meu objetivo com você.
É muito comum ficar perdido no começo porque em cada lugar você encontra respostas diferentes para a mesma
pergunta, qual o caminho correto de estudo para aprender Java e entrar no mercado de trabalho? Eu vou te revelar
o caminho que eu fiz e que ficou comprovado que é eficaz e já está aprovado por mais de 60 mil alunos.
No mínimo você deve saber dominar muito bem o POO e saber fazer um CRUD com banco de dados real.
Domine as principais arquiteturas em Java EE, MVC, DAO, RESTfull, API, Controllers, Services, Modelos e etcs.
Tenha em mente o passo a passo a ser seguido para ser um programado em Java de sucesso.
Fica travado na programação e não consegue desenvolver a lógica pra escrever o código.
Não consegue entender e como ligar os dados e o fluxo dos frameworks e projetos de software, mesmo que seja
um simples CRUD.
Está tendo a impressão que está ficando de fora do mercado por não saber o caminho correto de estudo que o
mercado precisa que você tenha.
É obrigatório que você aprenda a criar no mínimo um CRUD com as arquiteturas mais usadas com Java e se
frameworks de sucesso no mercado.
Você não pode de forma alguma tentar aprender várias linguagens ao mesmo tempo, isso só irá de atrasar cada
vez mais.
Você precisa aprender a olhar os requisitos das vagas de emprego no mercado de trabalho e focar seu estudo nos
assuntos pedidos.
Você precisa HOJE MESMO, aprender a resolver os problemas mais comuns que ocorrem no dia a dia de um
programador.
Perder o medo de alterar o código e testar, e também encontrar as respostas na documentação e ajuda da IDE de
desenvolvimento.
Se você é iniciante sua única oportunidade é estar comigo e aprender com quem está a 14 anos no mercado como
desenvolver/programador Java de sucesso.
Estuda com livros, cursos on-line, tutoriais, Google, Youtube, participa de comunidades, grupos e todo dia mesmo
aprende algo novo.
A empresa corre atrás de programadores que possuem os requisitos citados até esse ponto.
E para isso, para ser esse programador de sucesso você precisa de método presente no meu curso, FORMAÇÃO
JAVA WEB FULL-STACK.
- Mais de 50 módulos.
- 22 certificados válidos.
- 1100 videoaulas passo a passo.
- Acesso vitalicio.
- Garantia de 30 dias.
- Suporte total da equipe para suas dúvidas.
- Atualizações sem custo.
Perfil Profissional
sim! Iniciar o curso agora mesmo
Java Avançado Cursos clique aqui!
Agora eu vou mostrar para Quando falo não pular etapas imagina uma parede
você qual os caminhos de tijolos e se faltar tijolos essa parede desaba ou
Algoritmos
Início:
Verifica se o interruptor está desligado;
Procura uma lâmpada nova;
Pega uma escada;
Leva a escada até o local;
Posiciona a escada;
Sobe os degraus;
Para na altura apropriada;
Retira a lâmpada queimada;
Coloca a lâmpada nova;
Desce da escada;
Então acima acabamos de ver um exemplo de
Aciona o interruptor;
algoritmo escrito em nossa linguagem que falamos,
Se a lâmpada não acender, então:
mas o importante é entender que nesse processo
Retira a lâmpada queimada;
podemos definir como o sistema irá se comportar
Coloca outra lâmpada nova;
e a partir dai transformamos o algoritmo em
Senão
um processo dentro de um sistema com alguma
Tarefa terminada;
Joga a lâmpada queimada no lixo; linguagem que no nosso caso é Java.
Guarda a escada;
Fim;
Calma, tudo de uma vez não dá não, lembre do Aqui vai a verdade nua e crua doa a quem doer,
que já falamos Não pule etapas! para se aprender e dominar muito bem um
frameworks gigantesco como esse é preciso de
Vou citar um exemplo, o Spring Framework é em média 2 anos para se sentir confortável e
o maior framework Java do mundo, ele abrange desenvolver com tranquilidade sem contar o tempo
todos os módulos de desenvolvimento é o para aprender programação básica.
ecossistema completo tendo todas as ferramentas e
módulos que auxiliam o desenvolvedor Java a criar Então é preciso foco, escolher o que aprenderá
aplicações com agilidade, qualidade, performance, levando em consideração o que o mercado mais
mas você deve estar me perguntando onde entra a usa, quantidade de vagas de emprego e qualidade
parte do FOCO. em desenvolvimento, escolhendo as ferramentas
agora entra o foco nos estudos porque nesse
Aqui que está a coisa mais importante, o Spring ponto você já sabe que sendo especialista na
Framework é o mais usado pelas empresas linguagem e nas melhores ferramentas usadas pelo
de desenvolvimento de sistemas, praticamente mercado de trabalho você abrirá as portas para sua
90% das vagas de empregos para Java pedem carreira e se tornando um profissional de verdade
obrigatoriamente conhecimentos aprofundados seguindo uma linha de estudo com muito foco
nele e, com certeza, você não aprende em 1 sabendo onde quer chegar.
semana, 1 mês ou 5 meses.
O foco é mais importante ainda quando em um sistema e olha só, hoje sou especialista e
começamos a se deparar com muitos problemas o estou aqui ensinando tudo a você dê uma forma
que é normal em qualquer linguagem, ferramenta prática, fácil e diferente, entregando todo meu
e framework de desenvolvimento, cabe a você conhecimento passo a passo em cima de todas as
pesquisar, aprender e solucionar, a última coisa dificuldades que já passei e sei que você também
que deve pensar é partir para outro framework passará e com o meu curso tudo ficará mais fácil.
por causa de um problema ou outro, tudo tem
solução você tem que aprender a usar, entender Lembre-se, FOCO, dedicação, paciência, estudo e
o frameworks pra resolver problemas e entregar o assim você terá sucesso como eu.
sistema para o cliente.
Haaaa! E imagina a sorte que você tem por ler esse curso para ensinar todo mundo de uma forma fácil
texto. Eu tive sorte o suficiente pra trabalhar em e do jeito que eu aprendi.
várias empresas do Brasil e pegar projetos em todas
as plataformas do Java e assim nesses mais de 10 Cansei de vasculhar blog, sites e baixar projetos
anos de carreira eu aprendi degrau por degrau os que nunca funcionavam e de repente eu conseguia
pilares para ser programador sênior em Java Web. criar aquele código mas não tinha muito a ver com
as coisas na internet então sempre me vinha a
E eu percebi que a minha dificuldade era a mesma mente que disponibilizaria todo esse conhecimento
de muitos e por influência da vida eu consegui para fazer os outros sofrerem menos nessa carreira.
aprender todos os pilares necessários e sempre tive
em minha mente que um dia criaria meu site (que Olhe esse mapa mental simplificado abaixo:
você pode conhecer CLICANDO AQUI) e um
Momento atual
API REStful e spring REStful Hibernate + Jpa + Ajax
Webservices
Jsf e PrimeFaces Hibernate + Jpa + Ajax Html
O mundo JavaScript
Java Web SQL
Jsp e Spring Mvc Hibernate + Jpa + jQuery Swing
Android
Jsp e Servlets SQL + JDBC
Início
Cada módulo citado acima são arquiteturas Modelo mental → JavaServe Pages
diferentes, estruturas de projetos e (JSP) e Spring MVC
desenvolvimentos e isso influência muito no
modo de pensar em como programar a aplicação
fundamentos da Web/Internet
e como criar as funcionalidades dentro dela e o
Java e orientação a objetos
mais importante ainda como fazer os frameworks
SQL e JDBC básico
se conectarem e trafegarem dados da tela para o
banco de dados e vice-versa. JPA
JSP e Spring MVC Hibernate
Modelo mental → JavaServe spring MVC
Pages (JSP)
Html básico
Fundamentos da Web/Internet Geral
JavaScript básico
JavaServer Pages (JSP)
(Front-end) Java e orientação a objetos
Back-end CSS básico
JSP SQL e JDBC básico
e
Servlets
Html básico
JPA Arquitetura
JSF
Spring MVC PrimeFaces
Html básico
JavaServer Faces
JavaScript básico
Html básico
CSS básico
JavaScript básico
CSS básico
Depoimentos dos
alunos felizes
Linha de estudo
JSP e Frameworks MVC O JavaScript não cria applets ou aplicações
Início CSS
independentes. Na sua forma mais comum, o
JavaScript
JavaScript fica embutido nos documentos HTML e
Java e orientação a objetos
pode fornecer níveis de interatividade para páginas
Escolha sua linguagem !!! ???
Web que não são acessíveis com um HTML simples.
Algorítimos
Lógica de programação
Diferenças-chave entre o Java e o JavaScript:
O código Java precisa ser compilado, ao passo que JavaScript AngularJS e Angular
é a base
os códigos JavaScript estão totalmente em texto para: Node
atuando juntos com o navegador e páginas bem do D3
lado do cliente.
Meteor
Backbone
Com JavaScript sua maior importância é manipular
elementos html e acessa recursos por POST, GET,
JSON, iterações na página com o cliente, acessar Os mais famosos no mercado são React, JQuery e
RESTful e outros. AngularJs.
JavaScript é a base para que você domine qualquer Existem muitos outros frameworks baseados em
outro frameworks que são baseados em JavaScript JavaScript acima estou citando apenas alum mais
como na imagem abaixo: famosos, mas não se assuste sabendo apenas
um deles você já se da muito bem na carreira de
programador e se quiser ser um programador Full-
Stack CLIQUE AQUI.
CSS Bulma
é a base
para:
Ulkit
Semantic UI
Então não perca tempo e muito menos o valor Com esta técnica, o programador não precisa se
promocional do curso. Clique no botão abaixo: preocupar com os comandos em linguagem SQL;
ele usará uma interface de programação simples
sim! Iniciar o curso agora mesmo que faz todo o trabalho de persistência.
clique aqui!
Não é necessária uma correspondência direta entre
as tabelas de dados e as classes do programa.
Frameworks ORM Hibernate
e JPA A relação entre as tabelas onde originam os dados
e o objecto que os disponibiliza é configurada pelo
Mapeamento objeto-relacional (ou ORM, do programador, isolando o código do programa das
inglês: Object-relational mapping) é uma técnica alterações à organização dos dados nas tabelas do
de desenvolvimento utilizada para reduzir a banco de dados.
impedência da programação orientada aos objetos
utilizando bancos de dados relacionais. A forma como este mapeamento é configurado
depende da ferramenta que estamos a usar. Como
As tabelas do banco de dados são representadas exemplo, o programador que use Hibernate na
através de classes e os registros de cada tabela linguagem Java pode usar arquivos XML ou o
são representados como instâncias das classes sistema de anotações que a linguagem providencia.
correspondentes.
O Hibernate é um framework para o mapeamento Web Service é uma solução utilizada na integração
objeto-relacional escrito na linguagem Java, de sistemas e na comunicação entre aplicações
mas também é disponível em .Net com o nome diferentes. Com esta tecnologia é possível que
NHibernate. novas aplicações possam interagir com aquelas
que já existem e que sistemas desenvolvidos em
JPA → Java Persistence API plataformas diferentes sejam compatíveis.
Java Persistence API (ou simplesmente JPA) é uma Os Web Services são componentes que permitem
API padrão da linguagem Java que descreve uma às aplicações enviar e receber dados.
interface comum para frameworks de persistência
de dados. Cada aplicação pode ter a sua própria
“linguagem”, que é traduzida para uma linguagem
A JPA define um meio de mapeamento objeto- universal, um formato intermediário como XML,
relacional para objetos Java simples e comuns Json, CSV, etc.
(POJOs), denominados beans de entidade.
Os Web Services são utilizados para disponibilizar Abaixo segue uma boa imagem que podemos
serviços interativos na Web, podendo ser acessados representar os web services ilustrando que podem
por outras aplicações usando, por exemplo, o ser acessados por vários sistemas criados com
protocolo SOAP (Simple Object Access Protocol) ou diferentes linguagens e dispositivos diferentes.
hoje em dia JSON mais RESTful.
Java Java
Abaixo segue uma boa imagem que podemos
representar os web services ilustrando que podem
ser acessados por vários dispositivos diferentes. Web services .Net
.Net
PHP PHP
Segurança em aplicações
Java Web
Para lançar aplicativos móveis, aplicações web,
softwares e sistemas de TI confiáveis, as empresas
Banco de dados devem ter um processo de desenvolvimento seguro
para resistir a ataques mal-intencionados. Este
processo envolve práticas seguras em cada fase do
desenvolvimento.
Servidor
Em nosso curso aprenderemos Spring Security que
é o maior e mais usado no mundo inteiro.
Clientes
[email protected]
Alex Fernando Egidio
(45) 9 9979-5800
Desenvolvedor Sênior em Java
(44) 9 8821-2355
Me siga nas redes sociais https://www.javaavancado.com
Cnpj: 26.934.453/0001-89
Rua: Pioneiro Antônio de Ganello
Bairro: Jardim Dias I
Cidade: Maringá/PR
Compartilha esse e-book com seus amigos, OK! Cep: 87025-758
Tchau :)
JSF + PrimeFaces
e Hibernate
Sumário
O que é Java EE?.............................................................................................................................5
O protocolo HTTP...........................................................................................................................6
Desenvolvimento web com Java......................................................................................................8
Containers........................................................................................................................................9
Introdução ao JSF e Primefaces.....................................................................................................10
Desenvolvimento desktop ou web?...............................................................................................11
O desenvolvimento Web e o protocolo HTTP...............................................................................12
Mesclando desenvolvimento Desktop e Web................................................................................13
Características do JSF....................................................................................................................13
Guarda o estado dos componentes.................................................................................................14
Separa as camadas.........................................................................................................................14
Especificação: várias implementações...........................................................................................14
Primeiros passos com JSF..............................................................................................................15
Configuração do controlador do JSF.............................................................................................17
Faces-config: o arquivo de configuração do mundo JSF...............................................................18
O que é ManagedBean?.................................................................................................................18
Principais componentes.................................................................................................................19
O que é o MVC Design Pattern?...................................................................................................20
Ciclo de vida do JSF......................................................................................................................20
Fase 1: Restore View (Restauração da visão)................................................................................22
Fase 2: Apply Request Values (Aplicar valores da requisição).....................................................22
Fase 3: Process Validation (Processar as validações)....................................................................22
Fase 4: Update Model Values (Atualizar valores de modelo)........................................................22
Fase 5: Invoke Application (Invocar aplicação)............................................................................23
Fase 6: Render Response (Renderizar a resposta).........................................................................23
Visão geral.....................................................................................................................................24
Anotações e Escopo.......................................................................................................................24
Estrutura de página JSF.................................................................................................................25
Configurando JSF com Maven......................................................................................................26
Ativando o JSF em nosso projeto..................................................................................................28
Configurando o Persistence.xml....................................................................................................29
Classe Java HibernateUtil..............................................................................................................29
Mapeando nossa entidade Usuário................................................................................................30
Estrutura padrão de um ManagedBean..........................................................................................32
PanelGrid em JSF e EL..................................................................................................................33
JSF – DataTable.............................................................................................................................34
Mensagens com FacesMessage.....................................................................................................34
Exibindo mensagens após redirecionamento.................................................................................35
CommandButton JSF.....................................................................................................................36
Quando usar Action ou ActionListener com JSF...........................................................................37
O Action.........................................................................................................................................37
O ActionListener............................................................................................................................38
O setPropertyActionListener.........................................................................................................39
Utilizando AJAX com JSF de maneira eficiente...........................................................................39
Visão geral do Ajax........................................................................................................................40
Utilizando Ajax com JSF...............................................................................................................41
Usando o FilterOpenSessionInView..............................................................................................42
Declarando Filter no Web.xml.......................................................................................................43
Autor, criador e fundador do Java Avançado Cursos TI. Atua no mercado como
desenvolvedor e engenheiro de sistemas em Java é apaixonado por desenvolvimento
web em Java e pela “mágica” que seus frameworks trazem para o dia a dia de nós
desenvolvedores.
Com mais de 10 anos de experiência ajuda programadores do Brasil todo a se
tornarem profissionais.
O protocolo HTTP
HTTP/1.1 200 OK
Date: Thu, 26 Sep 2013 15:17:12 GMT
Server: Apache/2.2.15 (CentOS)
Content-Type: text/html; charset=utf-8
<html>
<body>
</body>
</html>
Outros códigos de status bastante comuns são o 404, que indica que o recurso não foi
localizado no servidor e o código 500, que indica que houve erro no processamento
da requisição enviada.
Containers
Durante muitos anos, os usuários se habituaram com aplicações Desktop. Este tipo de
aplicação é instalada no computador local e acessa diretamente um banco de dados ou
gerenciador de arquivos.
As tecnologias típicas para criar uma aplicação Desktop são Delphi, VB (Visual
Basic) ou, no mundo Java, Swing. Para o desenvolvedor, a aplicação Desktop é
construída com uma série de componentes que a plataforma de desenvolvimento
oferece para cada sistema operacional.
Esses componentes ricos e muitas vezes sofisticado
estão associados a eventos ou
procedimentos que executam lógicas de negócio. Problemas de validação de dados
são indicados na própria tela sem que qualquer informação do formulário seja
perdida.
De uma forma natural, esses componentes lembram-se dos dados do usuário,
inclusive entre telas e ações diferentes. Nesse tipo de desenvolvimento são utilizados
diversos componentes ricos, como por exemplo, calendários, menus diversos ou
componentes drag and drop (arrastar e soltar).
Eles ficam
associados a eventos, ou ações, e guardam automaticamente seu estado, já
que mantêm os valores digitados pelo usuário.
Para resolver problemas como esse, surgiram as aplicações baseadas na web. Nessa
abordagem há um servidor central onde a aplicação é executada e processada e todos
os usuários podem acessá-la através de um cliente simples e do protocolo HTTP.
Um navegador web, como Firefox ou Chrome, que fará o papel da aplicação cliente,
interpretando HTML, CSS e JavaScript que são as tecnologias que ele entende.
Enquanto o usuário usa o sistema, o navegador envia requisições (requests) para o
lado do servidor (server side), que responde para o computador do cliente (client
side).
Em nenhum momento a aplicação está salva no cliente: todas as regras da aplicação
estão no lado do servidor. Por isso, essa abordagem também foi chamada de cliente
magro (thin client).
E, mais importante ainda, não há mais eventos, mas sim um modelo bem diferente
orientado a requisições e respostas. Toda essa base precisará ser conhecida pelo
desenvolvedor.
Comparando as duas abordagens, podemos ver vantagens e desvantagens em ambas.
No lado da aplicação puramente Desktop, temos um estilo de desenvolvimento
orientado a eventos, usando componentes ricos, porém com problemas de
manutenção e gerenciamento. Do outro lado, as aplicações web são mais fáceis de
gerenciar e manter, mas precisamos lidar com HTML, conhecer o protocolo HTTP e
seguir o modelo requisição/resposta.
Características do JSF
JSF é uma tecnologia que nos permite criar aplicações Java para Web utilizando
componentes visuais pré-prontos, de forma que o desenvolvedor não se preocupe
com Javascript e HTML. Basta adicionarmos os componentes (calendários, tabelas,
formulários) e eles serão renderizados e exibidos em formato html.
Separa as camadas
O JSF ainda tem a vantagem de ser uma especificação do Java EE, isto é, todo
servidor de aplicações Java tem que vir com uma implementação dela e há diversas
outras disponíveis.
A implementação mais famosa do JSF e também a implementação de referência, é a
Oracle Mojarra disponível em http://javaserverfaces.java.net/. Outra implementação
famosa é a MyFaces da Apache Soware
Foundation em http://myfaces.apache.org/.
Cada biblioteca oferece ShowCases na web para mostrar seus componentes e suas
funcionalidades. Você pode ver o showcase do PrimeFaces no endereço
http://www.primefaces.org.
Na sua demo online, podemos ver uma lista de componentes disponíveis, como
inputs, painéis, botões diversos, menus, gráficos
e componentes drag & drop, que vão
muito além das especificações,
ainda mantendo a facilidade de uso:
O que é ManagedBean?
Um sistema de cadastro por exemplo, assim que o usuário terminar de digitar seus
dados e clicar em concluir o managedBeans irá receber estas informações e verificar
se tem algum erro e retornar uma página dizendo que o cadastro foi feito ou irá
retornar uma página informando os erros. O managedBean é o Controller neste caso.
A principal responsabilidade de um managedBean é intermediar a comunicação entre
as páginas (componentes do JSF) e nosso modelo. Escutar eventos, processá-los e
delegar para a camada de negócios são apenas algumas de suas responsabilidades.
A comunicação entre managedBeans não difere da troca de mensagens entre
componentes de software na orientação a objetos. Cada componente (managedBean)
conhece a interface pública do outro componente para que eles possam trocar
mensagens.
ManagedNeans são componentes, em sua grande maioria, intimamente ligados a(s)
página(s) e que deveriam ter apenas o estritamente necessário para representar a GUI.
Dificilmente você terá um managedBean genérico (CRUD não conta) que poderia
funcionar em todo lugar. Você precisa fazer um esforço hercúleo para conseguir isso,
e as vezes parece que não vale a pena.
Todo managedBean é ligado com uma tela diretamente e podemos identificar isso
através da anotação @ManagedBean.
Principais componentes
Um dos fundamentos de maior relevância do JSF é seu ciclo de vida que se dá entre a
requisição e a resposta do servidor de aplicação. São vários os motivos da existência
deste ciclo, dentre estes, temos:
• Manter o controle de estado dos componentes de interface;
Fase 2: Apply Request Values (Aplicar valores da requisição) Nesta fase, cada
componente da visão, criado ou recuperado, passa a ter o seu valor. Nesse contexto,
existem algumas diferenças ocasionadas pelo valor do atributo “immediate” em cada
componente:
• immediate = false: Neste caso, que é o padrão, os valores são apenas
convertidos para o tipo apropriado. Se o valor é um Integer, é convertido para
Integer.
• immediate = true: Os valores são convertidos e validos.
Fase 4: Update Model Values (Atualizar valores de modelo) Os valores enviados pela
requisição e validados pela fase 3, são atualizados em seus respectivos atributos
contidos nos backings beans, onde somente as propriedades enviadas são atualizadas.
É importante dizer que, mesmo após a fase de validação, fase 3, os valores enviados
podem estar inválidos a nível de negócio ou a nível de conversão de tipos, o que pode
ser verificado pelo próprio bean.
Visão geral
Anotações e Escopo
Para usarmos nosso projeto JSF precisamos não apenas do JSF e também precisamos
do Hibernate, PostgreSQL, PrimeFaces e para isso tem que ser baixado uma lista
enorme de bibliotecas o principal beneficio do Maven é isso baixar tudo que precisa
de uma vez e com versões compatíveis.
Pra começar as configurações vou listar abaixo o código XML do pom.xml do
Maven.
Para o nosso projeto Java enxergar o uso do JSF em nosso projeto temo que ativar o
FacesServlet em nosso projeto, essa classe e a principal do JSF.
FacesServlet é um Servlet que gerencia o ciclo de vida de processamento de pedidos
para aplicativos da web que estão utilizando o JavaServer Faces para construir a
interface com o usuário.
Configurando o Persistence.xml
Essa classe é responsável por ler o arquivo persistence.xml e criar a conexão com o
banco de dados e todos as opções configuradas.
Nesta mesma classe que é criado o EntityManagerFactory. Interface usada para
interagir com a fábrica do gerenciador de entidades para a unidade de persistência.
A Java Persistence API (JPA), parte da especificação EJB 3.0 do Java Enterprise
Edition 5, simplifica muito a persistência de Java e fornece uma abordagem de
mapeamento objeto-relacional que permite declarativamente definir como mapear
objetos Java para tabelas de banco de dados relacional de uma maneira padrão e
portátil que funciona tanto dentro de um servidor de aplicativos Java EE 5 quanto
fora de um contêiner EJB em um aplicativo Java Standard Edition 5 (Java SE 5).
Usando o JPA, você pode designar qualquer classe POJO como um JPA entidade -
um objeto Java cujos campos não transitórios devem ser mantidos em um banco de
dados relacional usando os serviços de um gestor da entidade obtido de uma
APP provedor de persistência (dentro de um contêiner EJB Java EE ou fora de um
contêiner EJB em um aplicativo Java SE).
Uma entidade tem as seguintes características:
Todo ManagedBean por mais simples que seja o cadastro possui uma estrutura
padrão para o seu funcionamento.
Abaixo cito e demonstro em código esses pontos principais:
• Objeto de regra de negócio da tela.
• DAO de persistência.
• Lista que carrega os objetos cadastrados.
PanelGrid em JSF e EL
JSF – DataTable
Essa linha vai fazer com que suas mensagens sejam armazenadas no escopo de Flash.
A duração desse escopo vai ser o suficiente para que você consiga exibir as
mensagens adicionadas depois do redirecionamento.
O código completo do método ficaria assim:
CommandButton JSF
Então, para entendermos bem o processo quando clicamos no botão o JSF irá fazer
todas as validações necessários cado haja e enviará os dados para o lado do
managedBean e é nesse momento que os dados da tela são adicionados/setado para o
objeto que representa a tela e após seta o método irá ser chamado.
De acordo com os botões acima pode ver abaixo quais serão os método que serão
chamados.
Basicamente temos duas formas de executar uma ação no managedBean após clicar
em um botão ou link com JSF. Podemos passar uma EL (Expression Language) para
o atributo action ou para o atributo actionListener do componente. Apesar de ambos
os atributos invocarem um método no managedNean, eles possuem uma diferença
sútil que costuma levar a pergunta: quando e qual devo usar?
Não é difícil decidir qual usar. Para isso precisamos antes entender a motivação por
trás de cada um e suas peculiaridades.
O Action
Você deveria usar uma action se sua intenção é executar uma lógica de negócio ou
navegar entre páginas. O método da action pode retornar uma String indicando a
regra de navegação.
Por exemplo, para executar uma lógica de negócio que grava um usuário no banco de
dados teríamos algo como:
Repare que após gravar o usuário o managedBean executa uma regra de navegação
para que o usuário seja redirecionado para a página de listagem de usuários.
Esta regra de navegação é conhecida como outcome. Se o método retorna null ou
possui retorno void, o usuário é mantido na mesma página e o JSF reaproveita a
mesma árvore de componentes.
O mesmo pode ser obtido se uma String vazia é retornada ou o outcome retornado
leve para a mesma página, nesse caso a diferença é que uma nova árvore de
componentes é criada.
O ActionListener
Você deveria usar uma actionListener se o que você quer fazer é executar uma lógica
relacionada a view ou disparar uma ação antes de uma lógica de negócio.
A lógica invocada por uma actionListener está mais ligada a detalhes da tela do que
puramente regras de negócio. Para usá-lo em uma h:commandButton bastaria termos
o código a seguir:
A diferença principal entre o action eu actionListener é que o actionListener não faz
redirecionamento e nem envio do formulário e mesmo assim ainda podermos
executar métodos Java do lado o servidor.
O setPropertyActionListener
Usando o FilterOpenSessionInView
Um problema que todos que estão trabalhando com Hibernate não está livre de se
deparar com ele. É o velho LazyInitializationException que acontece e deixa o pobre
do desenvolvedor estressado.
Pretendo ser menos teórico e mais prático, pois tem muita coisa na net explicando o
porque temos o LazyInitializationException, porém poucos explicaram de forma
prática a solução.
Então aqui vou mostrar como resolver o problema, pois também fui afetado com este
problema e levei umas quase 15 horas para resolver. E agora vejo que era algo
simples, mas eu precisava entender o por que.
Além de resolver muitos problemas em projetos esse filtro resolve um grande
problema na parte de persistência de dados, porque pode estabelecer um ponto único
para abrir a sessão, commitar e dar roolback nas transações com o banco de dados e
isso mantém a consistência dos dados em uma base de dados do nossos sistemas.
Um segundo problema também que conseguimos resolver e que com esse filtro pode
fazer o Hibernate já subir a conexão e todas as configurações quando o servidor
estiver sendo estartado.
Então o que temos que fazer é criar uma classe e implementas a interface Filter, mas
especificamente do pacote javax.servlet.Filter do JavaEE e também anotar com
@WebFilter e por ultimo adicionar a sua declaração no arquivo web.xml para que
seja possível a leitura dele pelo projeto, esse padrão permite interceptar toda
requisição e responta em um único ponto do sistema.
E por último fechamos a sessão. Temos que tratar qualquer erro que venha acontecer
em nosso sistema e para isso o filter que implementamos resolve muito bem qualquer
problema então caso venha acontecer algum erro dentro do Exception damos o
rollback para rever alterações no banco de dados feita na transação atual.
Tags Básicas
Agora na variável action temos o valor passado como parametros para assim definir o
que processar do lado do servidor.
Então todos seguem o mesmo padrão onde em cima é como fica o componente e em
baixo a primeira parte sempre é o código JSF e a segunda parte o código Java do lado
no managedBean (Servidor).
Código ManagedBean:
Classes e objetos usados para criar a estrutura da lista para formar o gráfico são do
próprio PrimeFaces então manual e o showcase se tornam de suma importância para
o aprendizado.
Como já sabemos quando dá uma exceção em uma requisição Ajax temos que
capturar isso na resposta e mostrar para o usuário e quando não é Ajax a página deve
ser recarrega para ser mostrada o erro.
Primeiramente precisamos ter um Dialog do PrimeFaces que irá abrir uma tela para o
usuário e dentro dele temos que desenvolver a rotina para a captação da mensagem de
erro.
A única diferença do que fizemos acima é passar no atributo do nosso botão o Ajax
para ser false, assim, o redirecionamento é feito e será exibido dentro do próprio
navegador a pilha de erro.
Assim a pilha de erro não sendo exibida dentro do Dialog e sim dentro do navegador
teremos um resultado abaixo.
Confirm Dialog
Teremos o seguinte feito, quando clicarmos no botão de excluir ou editar que assim
seja depende do que você quer fazer em seu sistema.
Barcode
Aqui neste exemplo estamos passando o valor fixo mas para tornar isso dinâmico
basta trazer do banco de dados em um objeto controlado com o managedBean e
pronto temos os códigos de barras dinâmicos.
Um recurso muito mas muito bacana mesmo e muito utilizado e executar rotinas em
determinado tempo em um sistema e é claro que o PrimeFaces iria nos surpreender
cada vez mais.
O p:poll faz chamadas Ajax com intervalos de tempo em nossos sistemas, então
vamos supor que queríamos mostrar no canto dos sistemas quantas mensagens não
lidas o usuário tem pra isso essa seria a solução para quem está criando projetos com
PrimeFaces e JSF.
Vou dar um exemplo bem simples que é incrementar um numero automaticamente do
lado do servidor e fazendo apenas isso sabemos que podemos processar qualquer
coisa por vai complexa que seja e retornar na tela o resultado.
Então em um exemplo simples na tela JSF usando o p:poll teríamos o código simples
abaixo.
Growl do PrimeFaces
Referências
https://www.primefaces.org/documentation/
https://www.primefaces.org/showcase/
https://www.tutorialspoint.com/jsf/
https://www.javatpoint.com/jsf-tutorial
Jdbc
Jpa e Hibernate
Spring Data
Sumário
Introdução ao JDBC.........................................................................................................................4
Introdução ao SQL...........................................................................................................................4
Linguagem DDL..............................................................................................................................5
Linguagem DML.............................................................................................................................6
Criando banco de dados...................................................................................................................7
Criando tabela de dados...................................................................................................................7
Componentes JDBC.........................................................................................................................8
Classe de conexão com banco.........................................................................................................9
Interface PreparedStatement..........................................................................................................10
Por que usar o PreparedStatement?...............................................................................................10
A classe de modelo de dados.........................................................................................................10
Padrão DAO...................................................................................................................................11
Inserindo dados no banco de dados...............................................................................................12
Realizando consulta de todos os dados da tabela..........................................................................12
Realizando buscar por ID..............................................................................................................13
Realizando Update de dados..........................................................................................................14
Deletando registro no banco de dados...........................................................................................14
Considerações finais sobre o JDBC...............................................................................................15
O que é JPA?..................................................................................................................................16
História da Especificação JPA.......................................................................................................16
JPA 2.0 (Java Persistence API)......................................................................................................17
Configurando Maven com JPA......................................................................................................18
Arquivo de configuração do JPA...................................................................................................19
Classe de conexão do JPA..............................................................................................................20
Introdução ao EntityManager........................................................................................................20
DaoGeneric JPA.............................................................................................................................21
Anotação @Entity..........................................................................................................................21
Anotação @Id................................................................................................................................22
Anotação @OneToMany e @ManyToOne....................................................................................22
Anotação @OneToOne..................................................................................................................23
Anotação @ManyToMany.............................................................................................................23
Anotação @NaturalId....................................................................................................................25
Anotação @Table...........................................................................................................................25
Anotação @UniqueConstraint.......................................................................................................26
Anotação @Version.......................................................................................................................26
Anotação @Colum.........................................................................................................................27
Anotaçõe @GeneratedValue e @SequenceGenerator...................................................................27
Anotação @GeneratedValue..........................................................................................................28
Anotação @Transient....................................................................................................................28
Anotação @Lob.............................................................................................................................29
Retornando a primary key da entidade..........................................................................................29
Salvando com JPA (Persist)...........................................................................................................30
Save or Update com JPA (Merge)..................................................................................................30
Pesquisar um registro no banco de dados......................................................................................31
Deletando registros........................................................................................................................31
Trazendo lista de dados do banco de dados...................................................................................31
Introdução ao JDBC
Introdução ao SQL
Linguagem DDL
Linguagem DML
Componentes JDBC
Connection: Essa interface com todos os métodos para entrar em contato com um
banco de dados. O objeto de conexão representa o contexto de comunicação, ou
seja, toda a comunicação com o banco de dados é feita apenas por meio do objeto
de conexão.
Statement: Você usa objetos criados a partir dessa interface para enviar as
instruções SQL para o banco de dados. Algumas interfaces derivadas aceitam
parâmetros além de executar procedimentos armazenados.
Dentro desta mesma classe criamos o método responsável por executar a conexão
e retorna a mesma quando necessitamos.
Pra finalizar o padrão Singleton teremos sempre ao final um método estático que
retorna o objeto de conexão com o banco de dados.
Interface PreparedStatement
Como Java é orientado a objetos nada mais correto do que ter um objeto que
representa nosso negócio e também representa a tabela no banco de dados e para
isso já podemos seguir um padrão mais básico e fácil que existe no
desenvolvimento de sistemas que é criar uma classe que tráfega os dados em
todas as camadas do sistema até chegar ao banco de dados e do banco para as
camadas do sistema, então, em uma tabela que possuí id, nome e e-mail a classe
de modelo ficaria como a imagem abaixo:
Padrão DAO
Neste passo já vamos aprender como fazer o método salvar em nossa estrutura
DAO. O salvar já recebe o objeto com os dados, escrevemos o SQL e os
parâmetros são representados pelas interrogações (?, ?) e são setados na mesma
ordem que são escritos na String do SQL;
O que é JPA?
JPA é um framework leve, baseado em POJOS (Plain Old Java Objects) para
persistir objetos Java. A Java Persistence API, diferente do que muitos imaginam,
não é apenas um framework para Mapeamento Objeto-Relacional (ORM - Object-
Relational Mapping), ela também oferece diversas funcionalidades essenciais em
qualquer aplicação corporativa.
Atualmente temos que praticamente todas as aplicações de grande porte utilizam
JPA para persistir objetos Java.
JPA provê diversas funcionalidades para os programadores, como será mais
detalhadamente visto nas próximas seções. Inicialmente será visto a história por
trás da JPA, a qual passou por algumas versões até chegar na sua versão atual.
A versão JPA 2.0 incluiu um grande número de características que não estavam na
primeira versão, especialmente as mais requisitadas pelos usuários, entre elas a
capacidade adicional de mapeamento, expansões para a Java Persistence Query
Language (JPQL), a API Criteria para criação de consultas dinâmicas, entre outras
características.
Entre as principais inclusões na JPA destacam-se:
POJOS Persistentes: Talvez o aspecto mais importante da JPA seja o fato que os
objetos são POJOs (Plain Old Java Object ou Velho e Simples Objeto Java),
significando que os objetos possuem design simples que não dependem da
herança de interfaces ou classes de frameworks externos.
Qualquer objeto com um construtor default pode ser feito persistente sem
nenhuma alteração numa linha de código. Mapeamento Objeto-Relacional com
JPA é inteiramente dirigido a metadados. Isto pode ser feito através de anotações
no código ou através de um XML definido externamente.
Consultas em Objetos: As consultas podem ser realizadas através da Java
Persistence Query Language (JPQL), uma linguagem de consulta que é derivada
do EJB QL e transformada depois para SQL. As consultas usam um esquema
abstraído que é baseado no modelo de entidade como oposto às colunas na qual a
entidade é armazenada.
Configurações simples: Existe um grande número de características de
persistência que a especificação oferece, todas são configuráveis através de
anotações, XML ou uma combinação das duas. Anotações são simples de usar,
convenientes para escrever e fácil de ler. Além disso, JPA oferece diversos valores
defaults, portanto para já sair usando JPA é simples, bastando algumas anotações.
Integração e Teste: Atualmente as aplicações normalmente rodam num Servidor de
aplicação, sendo um padrão do mercado hoje. Testes em servidores de aplicação
são um grande desafio e normalmente impraticáveis.
Efetuar teste de unidade e teste caixa branca em servidores de aplicação não é
uma tarefa tão trivial. Porém, isto é resolvido com uma API que trabalha fora do
servidor de aplicação.
Isto permite que a JPA possa ser utilizada sem a existência de um servidor de
aplicação. Dessa forma, testes unitários podem ser executados mais facilmente.
Abaixo podemos ver a lista enorme de bibliotecas que são baixadas quando
adicionamos as tags xml no pom.xml do Maven, está parte pode ser vista no
projeto.
Quando usamos JDBC tudo era configurado direto em uma classe Java criada do
zero, usando JPA isso é feito de forma mais organizada usando um arquivo de xml
onde são configurados os mesmos parâmetros como url do banco de dados,
usuário do banco, senha do banco de dados e ainda temos muitos outros recursos
como permitir a geração automática das tabelas no banco de dados.
Introdução ao EntityManager
DaoGeneric JPA
Quando trabalhamos com JPA a escrita de SQL é quase zero, o frameworks além
de ter sua própria linguagem que é o HQL ainda possui inúmeros métodos que são
comuns a todo sistema que é criado e então nós programadores apenas
precisamos saber qual método invocar e com apenas uma chamada fazer muito
mesmo no banco de dados, ao invés de escrever linhas e mais linhas de SQL puro
apenas chamamos no caso do JPA o método PERSIST que os dados são
gravados corretamente no banco de dados, o melhor de tudo que o DAO genérico
agora fica muito mais simples e fácil de entender. Ao invés da conexão direta nós
invocamos o EntityManager dentro do DAO.
Anotação @Entity
A anotação @Entity é utilizada para informar que uma classe também é uma
entidade. A partir disso, a JPA estabelecerá a ligação entre a entidade e uma tabela
de mesmo nome no banco de dados, onde os dados de objetos desse tipo poderão
ser persistidos.
Uma entidade representa, na Orientação a Objetos, uma tabela do banco de
dados, e cada instância dessa entidade representa uma linha dessa tabela.
Caso a tabela possua um nome diferente, podemos estabelecer esse mapeamento
com a anotação @Table, a qual será explorada em outra documentação.
Anotação @Id
O relacionamento OneToMany é bem usado, e são poucas vezes que de fato não
precisamos te-lo, então é aquele lance se não precisou até hoje, espere mais um
pouco que essa necessidade vai nascer.
Vamos tirar a vantagem dos annotations e veremos @OneToMany e
@ManyToOne ao invés dos .hbm. Como exemplo há vários cenários para
exemplificar este tipo de relacionamento, tais como: um time de futebol tem vários
jogadores, uma infra-estrutura tem vários servidores, porém um jogador só pode
jogar em um time(ou não depende da regra de negócio, aqui está o pulo do gato),
e um servidor está em uma infra-estrutura.
Anotação @OneToOne
A anotação One-to-One é utilizada para associar duas entidades onde uma não é
componente da outra, ao contrário da definição acima.
Numa associação One-to-One também podemos ter um relacionamento
bidirecional. Nesse caso, um dos lados precisará ser o dono do relacionamento e
ser responsável por atualizar uma coluna com uma chave estrangeira.
Anotação @ManyToMany
Anotação @NaturalId
Anotação @Table
@Tabela é definida no nível da turma; Ele permite que você defina os nomes de
tabelas, catálogos e esquemas para o mapeamento de entidades. Se nenhuma
@Table for definida, os valores padrão serão usados: o nome de classe não
qualificado da entidade.
O elemento @Table contém um esquema e atributos de catálogo, se precisarem
ser definidos. Você também pode definir restrições exclusivas para a tabela usando
a anotação @UniqueConstraint em conjunto com @Table.
Anotação @UniqueConstraint
Anotação @Version
Você pode adicionar capacidade de bloqueio otimista a uma entidade usando a
anotação @Version.
A propriedade version será mapeada para a coluna OPTLOCK e o gerenciador de
entidades a utilizará para detectar atualizações conflitantes (evitando atualizações
perdidas que você poderia ver com a estratégia last-commit-wins).
Anotação @Colum
Vendo todas as opções que temos para as colunas podemos fazer e demonstar
uma regra bem bacana, usando a coluna de cpf como exempo podemos definir as
regras que o cpf é um atributo natural e que sua coluna do banco tem um nome
diferente do atributo e o campo será único no banco de dados e depois de gravado
não poderá ser modificado.
Então criando a sequencia e dando nome a ela nós podemos definir que o ID ou
sendo a primary key usara esse nosso sequenciador.
Anotação @GeneratedValue
Anotação @Transient
Anotação @Lob
Usando JPA toda aquela complexidade se ficar escrevendo SQL na mão e tendo
que a todo momento ficar adicionando novos atributos e gerando manutenção na
parte de persistencia tendo que ir manualmente e adicionar mais SQL a todo
momento, isso não existe com JPA, toda essa complexidade é abstraida e para
salvar basta chamar o método PERSIST.
Para realizar a pesquisa o JPA também tem um método pronto e nós apenas
precisamos passar a classe pra ele saber qual tabela buscar no banco e o ID do
objeto que no caso é o valor da chave única do registro que precisamos trazer.
Deletando registros
Para deletar registro a forma mais prática para evitar problemas de objetos em
memória é fazer o JPA executar um SQL de delete, mas antes disso precisamos
sabe o ID do objeto que desejamos remover, podemos passar direto como
parâmetro ou então fazer de forma bem genérica igual eu criei no método abaixo.
Depois que temos toda a parte de persistência criada, JPA configurado, entidades
criadas e mapeadas e o DAO genérico criado e funcionando corretamente. Agora é
a hora de comer a gravar dados. Primeiramente precisamos chamar nosso DAO
logo em seguida instanciar um objeto e setar os dados do seu atributo e pra
finalizar gravar no banco de dados.
objeto é retornado. Após o retorno passamos nosso objeto para nosso método que
faz o delete/remoção desse registro na base de dados.
No método que estou criando a lista é trazida do banco de dados quando os dados
satisfazem a pesquisa e sua condição, para exemplificar estou passando o meu
nome dentro do HQL dizendo para retornar apenas os dados onde o nome seja
exatamente igual a ‘Egidio’.
Uma consulta nomeada é uma consulta definida estaticamente com uma string de
consulta imutável predefinida. O uso de consultas nomeadas em vez de consultas
dinâmicas pode melhorar a organização do código separando as cadeias de
consulta JPQL do código Java. Ele também reforça o uso de parâmetros de
consulta em vez de embutir literais dinamicamente na cadeia de consulta e resulta
em consultas mais eficientes.
Caso a query tenha parâmetros isso não muda nada no que já aprendemos,
apenas chamamos a query pelo nome e passamos os parâmetros.
A API Criteria é uma API predefinida usada para definir consultas para entidades. É
a maneira alternativa de definir uma consulta JPQL. Essas consultas são seguras,
portáteis e fáceis de modificar, alterando a sintaxe.
Semelhante ao JPQL segue esquema abstrato (fácil de editar esquema) e objetos
incorporados. A API de metadados é mesclada com a API de critérios para modelar
entidades persistentes para consultas de critérios.
A principal vantagem da API de critérios é que os erros podem ser detectados mais
cedo durante o tempo de compilação. Consultas JPQL baseadas em strings e
consultas baseadas em critérios JPA são iguais em desempenho e eficiência.
A API Criteria e o JPQL estão intimamente relacionados e têm permissão para
projetar usando operadores semelhantes em suas consultas.
Ele segue o pacote javax.persistence.criteria para projetar uma consulta. A
estrutura de consulta significa a consulta de critérios de sintaxe.
A consulta de critérios simples a seguir retorna todas as instâncias da classe de
entidade na fonte de dados.
Bean Validation
Hibernate Search
Hibernate Envers
O projeto Envers visa permitir uma auditoria fácil de classes persistentes. Tudo o
que você precisa fazer é anotar sua classe persistente ou algumas de suas
propriedades, que você deseja auditar, com @Audited. Para cada entidade
auditada, será criada uma tabela que conterá o histórico de alterações feitas na
entidade. Você pode recuperar e consultar dados históricos sem muito esforço.
Similarmente ao Subversion, a biblioteca tem um conceito de revisões.
Basicamente, uma transação é uma revisão (a menos que a transação não
modifique nenhuma entidade auditada). Como as revisões são globais, com um
número de revisão, você pode consultar várias entidades nessa revisão,
recuperando uma visão (parcial) do banco de dados nessa revisão. Você pode
encontrar um número de revisão com uma data e, ao contrário, você pode obter a
data em que uma revisão foi confirmada.
A biblioteca funciona com o Hibernate e requer anotações do Hibernate ou
gerenciador de entidades. Para que a auditoria funcione corretamente, as
entidades devem ter identificadores exclusivos imutáveis (chaves primárias). Você
pode usar o Envers onde quer que o Hibernate funcione: independente, dentro do
JBoss AS, com o JBoss Seam ou Spring.
Spring Data
O Spring Data JPA é um framework que nasceu para facilitar a criação dos nossos
repositórios.
Ele faz isso nos liberando de ter que implementar as interfaces referentes aos
nossos repositórios (ou DAOs), e também já deixando pré-implementado algumas
funcionalidades como, por exemplo, de ordenação das consultas e de paginação
de registros.
Ele (o Spring Data JPA) é, na verdade, um projeto dentro de um outro maior que é
o Spring Data. O Spring Data tem por objetivo facilitar nosso trabalho com
persistência de dados de uma forma geral. E além do Spring Data JPA, ele possui
vários outros projetos:
Agora integrando com Spring Frameworks nós apenas vamos configurar o nome
para o persistence-unit do JPA para que seja possível ativar os recursos em nosso
projeto.
A única declaração que teremos que manter nesse arquivo é a declaração para as
entidades persistentes.
Esse arquivo em formato XML é lido pelo Spring quando o projeto é iniciado e suas
configurações adicionadas ao contexto do sistemas rodando no servidor. Neste
arquivo vamos configurar nosso repositórios, nossa injeção de dependência,
nossas configurações com o banco de dados e ativar a integração com JPA +
Hibernate + Spring.
Neste parte iremos configurar a conexão com nosso banco de dados, é igual
configurar com jdbc porém aqui quem vai cuidar dos processos mais complexos é
o Spring.
Nesta parte vamos configurar a conexão criada com DataSource a ligar com o JPA
do Spring Frameworks. Neste ponto vamos configurar nosso persistence unit e
também onde são configurados as propriedades para o hibernate
Interface CrudRepository
Anotação @Repository
Quando se trabalha com Spring Data usamos a interface CrudRepository que nos
dispões de todo o poder de persistencia com métodos prontos e fáceis de usar e
também torna super fácil a implementação de novas queryes para nosso sistemas.
Anotação @Transactional
Anotação @Query
Anotação @Modifying
Então, para evitar uma exceção na transação dos métodos anotados com
@Modifying, é preciso inserir a @Transactional(readOnly = false), para dizer que
esta transação não será para leitura e sim de escrita.
Anotação @Autowired
precisamos da nossa camada de modelo e então para isso nós resgatamos ele da
seguinte forma →usuarioSpringData.get();
Consulta assíncrona
Usando Sort
Auditoria
O Spring Web MVC é o framework web original criado na API Servlet e foi incluído
no Spring Framework desde o início. O nome formal, “Spring Web MVC”, vem do
nome do seu módulo de origem ( spring-webmvc), mas é mais comumente
conhecido como “Spring MVC”.
O Spring MVC, como muitos outros frameworks web, é projetado em torno do
padrão de front controller, onde a central Servlet, the DispatcherServlet, fornece
um algoritmo compartilhado para o processamento de solicitações, enquanto o
trabalho real é executado por componentes delegados configuráveis. Este modelo
é flexível e suporta diversos fluxos de trabalho.
O DispatcherServlet, como qualquer Servlet, precisa ser declarado e mapeado de
acordo com a especificação Servlet usando a configuração Java ou em web.xml.
Por sua vez, o DispatcherServletusa a configuração Spring para descobrir os
componentes delegados necessários para o mapeamento de solicitações, a
resolução da exibição, o tratamento de exceções e muito mais .
Spring RESTful
Cache
Redirecionamento e encaminhamento
Segurança (criptografia e autenticação)
Todos esses são fatores críticos na construção de serviços resilientes. Mas isso
não é tudo. A web é construída a partir de muitas especificações minúsculas, por
isso, tem sido capaz de evoluir facilmente, sem se atolar em "guerras de padrões".
Os desenvolvedores são capazes de utilizar ferramentas de terceiros que
implementam essas diversas especificações e, instantaneamente, têm a tecnologia
de cliente e servidor na ponta dos dedos.
Assim, construindo sobre HTTP, as APIs REST fornecem os meios para construir
APIs flexíveis que podem:
Suportar compatibilidade com versões anteriores
• APIs evolutivas
• Serviços escalonáveis
• Serviços seguráveis
O que é importante perceber é que o REST, por mais onipresente que seja, não é
um padrão, por si só , mas uma abordagem, um estilo, um conjunto de restrições
em sua arquitetura que pode ajudá-lo a construir sistemas em escala da web.
Neste tutorial, usaremos o portfólio do Spring para criar um serviço RESTful,
aproveitando os recursos sem pilha do REST.
Spring Boot
Se você está começando com o Spring Boot, ou “Spring” em geral, comece lendo
esta seção. Ele responde às questões básicas “o quê?”, “Como?” E “por
quê?”. Inclui uma introdução ao Spring Boot, juntamente com instruções de
instalação. Nós, em seguida, orientá-lo através da construção de sua primeira
aplicação Spring Boot, discutindo alguns princípios fundamentais como nós vamos.
Você pode usar o Spring Boot para criar aplicativos Java que podem ser iniciados
usando java -jar ou mais implementações tradicionais de guerra.
• Forneça vários recursos não funcionais que são comuns a grandes classes
de projetos (como servidores incorporados, segurança, métricas,
verificações de integridade e configuração externalizada).
Spring Batch
O Spring Batch é uma estrutura em lote leve e abrangente projetada para permitir
o desenvolvimento de aplicações em lote robustas, vitais para as operações diárias
dos sistemas corporativos.
Conclusão
Vimos várias forma de persistência com banco de dados, vimos a evolução dos
frameworks em Java e como estão se tornando poderosos ajudando toda a
comunidade de programadores pelo mundo.
Todo o conteúdo desde livro é obrigatório para que qualquer desenvolver Java
tenha sucesso e seja um ótimo profissional.
Grande abraços e até mais.
Referências
https://www.javaavancado.com/formacao-java-web-profissional/index.html
https://www.objectdb.com/api/java/jpa
https://docs.jboss.org/hibernate/annotations/3.5/reference/en/html/entity.html
http://docs.jboss.org/hibernate/orm/5.3/quickstart/html_single/
https://docs.spring.io/spring-data/jpa/docs/current/reference/html/
https://docs.spring.io/spring-data/data-jpa/docs/1.4.x/reference/htmlsingle/
https://www.tutorialspoint.com/jdbc/
https://www.tutorialspoint.com/hibernate/
https://www.tutorialspoint.com/spring/
https://www.javaavancado.com