Série Spring: Hello World no Spring

 

olá Pessoal,

Estarei dando inicio a mais uma série aqui no blog e dessa vez é com o Spring framework. No post de hoje veremos como dar um Hello World usando o Spring, parece algo simples e fácil né? Mas, na verdade é. Porém, para quem nunca mexeu com Spring ainda pode achar que é complicado.

O Spring

Sem entrar na teoria pq o que não falta é fonte explicando o que é e pra que serve o framework. Eu digo sempre que o Spring é cara que nos ajuda a não fazer as coisas chatas e repetivas do dia-dia, que normalmente para o cliente não tem valor algum.

 Hello World

Vamos criar um java project, mas não esqueça de ir no site do Spring e baixar a versão mais recente. Estarei usando a versão 3.x.

Development

1. Crie um  java project

2. E os seguintes packages
springhelloworldpackage

3. Agora crie uma classe chamada SpringHelloWorld que terá um método o qual irá imprimir no console a mensagem

“Hello World Spring”.

package br.com.camilolopes.classes;

public class SpringHelloWorld {

                public void showHelloWorld(){

                               System.out.println(“Hello World Spring”);

                }}

4. No package conf  crie um arquivo XML , aqui chamei de springconfiguration.xml. E adicione o código a seguir ao arquivo:

<beans xmlns=“http://www.springframework.org/schema/beans”

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

xsi:schemaLocation=“http://www.springframework.org/schema/beans

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

 <bean  id=“hello” class=“br.com.camilolopes.classes.SpringHelloWorld”/>

</beans>

 

O cabeçalho temos  a configuração do Spring e a versão que estamos o usando. Mas, o essencial está na tag do bean. Ali estamos dizendo ao Spring para ele instanciar um objeto para a classe SpringHelloWorld, sendo assim  na aplicação podemos obter essa instância pelo id do bean e invocar qualquer método disponível da classe. Isso é o mesmo que fazemos

SpringHelloWorld variavelInstancia = new SpringHelloWorld();

Só que agora quem faz isso é o Spring e não nós mais. Veremos a seguir na prática o uso.

5. crie uma classe com o método main. Chamei a minha de Main.

package br.com.camilolopes.main;

import org.springframework.context.ApplicationContext;

import org.springframework.context.support.ClassPathXmlApplicationContext; 

import br.com.camilolopes.classes.SpringHelloWorld;

public class Main {

      public static void main(String[] args) {

//          essa classe é o container

ApplicationContext applicationContext = new ClassPathXmlApplicationContext(

                        “conf/springconfiguration.xml”);

            SpringHelloWorld bean = (SpringHelloWorld) applicationContext.getBean(“hello”);

            bean.showHelloWorld();      }}

 O ApplicationContext é o coração do Spring é através deles que vamos obter o que precisamos para trabalhar. Observe que informei para o ApplicationContext  onde está o arquivo de configuração do Spring que ele precisa se basear.Em seguida tem um .getBean e passei o id do bean que desejo, que é o id que declaramos no xml:

<bean  id=“hello” class=“br.com.camilolopes.classes.SpringHelloWorld”/>

 Ou seja, nesse momento o Spring já fez o new na classe por baixo dos panos, agora podemos fazer o que quiser com o objeto, nesse caso chamei  o único método existente e o resultado foi:

helloworldspringresult

 Simples assim!!. E isso é o básico do Spring.

GitHub

Acesse o repositório no github com todos os projetos da série Spring:  https://github.com/camilolopes/workspacespring

Vou ficando por aqui e espero que tenham gostado do post.

Abraços,

 

 

Review livro: Vire o Jogo com Spring Framework

Olá Pessoal,

 Mais um review de um livro aqui no blog. Dessa vez estava a procura de um livro para comprar aqui para o projeto e ver se era viável ser feito o investimento comprando alguns exemplares para aqueles que não conhecem o framework Spring. Como sempre, o objetivo é apresentar meu ponto de vista com relação ao livro com base no que procurava.

 Lets go…

Necessidade

 A necessidade que tinha era encontrar um livro que:

  • Explicasse Spring de maneira direta e prática sem muita frescura (os detalhes o desenvolvedor ia pegando no dia-dia);
  • Fosse em português (mesmo que fosse traduzido), pois nem todos desenvolvedores sabem inglês suficiente para ler um livro em um prazo curto;
  • Fosse mão na massa;
  • Não fosse maior ou igual que o melhor dos melhores Spring in Action 3rd.

Vire o Jogo com Spring Framework

 E foi daí que conheci o livro “Vire o Jogo com Spring framework” e decidi comprar apenas um exemplar e ver se realmente era um livro que poderia servir para um desenvolvedor aqui na equipe que estive precisando aprender Spring no menor tempo possível com qualidade e metendo mão na massa, mesmo que ele quebrasse muito a cabeça no inicio por não conhecer bem os detalhes, mas isso ele ia refinando no dia-dia. Pela descrição do livro, me parece que esse seria o mais indicado e ainda por cima não era tradução, o que eliminou meu risco daquelas traduções sofridas que já conhecemos. Feito, comprei um exemplo e comecei a leitura.

Meu Review

O livro está dividido em duas partes, onde o autor considera que a parte I é apenas os conceitos e a parte II seria mais mão na massa. Eu particularmente não vi diferença nenhuma, pois na parte II não há nada prático, exceto que durante a explicação há trechos de código apenas, mas nada que você tenha que fazer e terminar sozinho. A leitura em alguns pontos é confortável, outros momentos chatas e há trechos muito curtos, que não entendi a existência, se o motivo era só citar sem dar maiores informações. Há mais de um modo de escrita durante o livro, o autor começa bem informal, mas quando começa a tratar os assuntos muda um pouco a abordagem, deixando a leitura mais carregada e cansativa. Eu optaria por manter a mesma informalidade que tem no inicio do livro, dá uma sensação de diálogo que acho muito bom, fora que o uso de “palavras bonitas do português” para livros técnicos só atrapalha, e ser direto com o uso de palavras mais populares acho importante e  no livro não é bem assim em alguns capítulos.

Positivo

 – O livro aborda bem o conteúdo teórico do assunto, e se você tem uma limitação teórica ou não entende nada vai passar a dar uma clareada, porém acho que é informação demais para um iniciante ver em 11 capítulos com prática próximo de zero, mas a teoria eu gostei.

– É um livro pequeno e está bem estruturado. Há organização teórica dos assuntos e links com capítulos passados.

Negativo

 – Não é um livro mão na massa. Se você quer botar mão no código, fazer um exemplo mesmo, esquece! O livro não ajuda nisso.

 – Não percebi a utilidade do exemplo usado no livro, porque o leitor não desenvolve;

 – Não tem exercícios para colocar em prática o que acabou de ser visto no capítulo. Uma coisa é explicar pra que serve o Spring Security e como está estruturado, agora, vamos colocar na prática com um simples “hello spring security” pra ver se rola mesmo? Bem, não tem isso no livro.

 – Há capítulos com uma leitura muito cansativa e chata. Então se prepare para isso e tente superar para conseguir terminar o livro.

Quem pode ler o livro?

Depende do objetivo do leitor. Se este precisa entender o Spring framework e outros módulos Spring, eu indicaria o livro, mas assim, entender na teoria. Mas se você me diz que quer um livro pra ir entendendo os conceitos gradualmente e já ir metendo mão no código fazendo uma aplicação subir com Spring, eu diria que este não é o livro indicado.

Conclusão 

Enfim, a minha expectativa com o livro não foi atingida de maneira prática. Poderia apostar todas minhas fichas que seria um livro prático para iniciantes de verdade com o Spring e poderia adotar aqui no projeto para estagiários, programadores jrs que não conhecem ainda o framework e pudesse levar um exemplar e passar algumas semanas brincado. Porém, na prática não é bem assim, mas ainda indicaria o livro para quem quer entender todo o mundo Spring de maneira teórica.

Vou ficando por aqui…

 Abraços, see ya!!!

Conectando Jenkins com GitHub

Olá Pessoal,

No post de hoje vamos ver como buildar nossos projetos no jenkis e mantê-lo conectado a um repositório; no nosso caso escolhemos o github por usar o Git. Claro que poderia ser um outro repositório, até mesmo local, mas o Github é o mais popular repositório Git.

Lets go…

Starting

Antes de mais nada, vou considerar que você já conhece um pouco de Git e GitHub, pois não entrarei em detalhes de como cada um funciona, para isso  você precisa ter:

– Um repositório criado no GiHub;

– Git na sua máquina local

Os nossos steps

Basicamente criaremos um projeto e em seguida faremos um push para o GitHub. Tendo o projeto no nosso repositório remoto, vamos configurar o Jenkins para conversar com o GitHub  e poder realizar  “pull” quando o build for inicializado.

Step 1

1      Abra o seu eclipse e crie um Java Project chamado MyBookStore.

2      Feito, envie esse projeto para o GitHub.

Uma vez que o projeto já está no repositório, vamos ao Jenkins fazer as devidas configurações (estou considerando que você já tem o jenkins rodando na sua máquina, onforme o primeiro post da série).

Acesse o Jenkins e vá em Manage Jenkins  e escolha Manage Plugins. Alguns plugins o Jenkins já traz e outros precisamos instalar. Na aba de Installed verifique se o plugin do GitHub Plugin está instalado:

Se não tiver, vá na aba de available e procure pelo plugin. Instale também um plugin chamado Git Plugin. Esse é para que o Jenkins possa rodar os comandos do Git.

Note: use a opção install without restart.

Configurando o Jenkins

Agora vamos configurar o jenkins, portanto em manage jenkins escolha configure system e observe que você deve ter uma Git na lista:

Esses caras servem para configuramos e dizermos ao jenkins como ele deve ser comportar se o projeto que fomos buildar usar  um deles. Não é requerido preencher todos, exceto se você tem N projetos e cada projeto tem que usar uma estrutura diferente, por um usar ant e outro maven, daí vc precisa configurar tanto maven quando o ant nessa parte do Jenkins.

Primeiro vamos configurar o JDK que é requerido para qualquer projeto Java onde precisamos compilar as classes .java.

Coloque o local onde instalou o Java, conforme a imagem a seguir:

Assim dizemos ao jenkins onde está o nosso Java e qual ele deve usar para compilar as nossas classes durante o build

Agora vamos para o Git

Nada de diferente, apenas informamos onde está o Git na nossa máquina.

Deixamos as próximas opções da maneira default. Agora vamos configurar o Git Plugin que contém as informações do usuário que fez o commit.

Observe que estamos configurando o Git e não GitHub.

Essa é uma das partes mais importantes e demorei horas para descobrir, aqui vamos colocar key-gen registrado lá no github:

Em Github web Hook deixei a opção Manually manage hook URLs selecionada. Salve as modificações.

Pronto, jenkins configurado.

Criando Jobs no Jenkins

Agora vamos criar um job no Jenkins para o nosso projeto.

E darei o mesmo nome do projeto:

Ao criar o job, vamos para as configurações que nos interessa:

Precisamos informar onde está o nosso repositório, pode estar localmente ou remoto. No nosso caso está remoto no GitHub, que é o:

https://github.com/camilolopes/myworkspace.git

E deixamos assim. É esse cara que o jenkins fará o clone, por isso que ele precisa da URL.

Feito isso podemos salvar e buildar nosso projeto:

Clique na barra de loading à esquerda para ver o log:

Observe que o jenkins conectou ao github e está trazendo o que temos no repositório, nesse caso MyBookStore.

Resultado

A seguir o resultado:

A nuvem, eu costumo dizer que o projeto passou por algumas turbulências, o solzão está tudo tranquilo, todo time pode ir para praia tranquilo que ninguém vai ligar para incomodar.

Pronto temos, nosso projeto  sendo construído pelo Jenkins.

Falha no Jenkins

Vamos simular uma falha e ver o que acontece, e para isso precisamos alterar a classe para que o código não compile:

Daí podemos mandar essa alteração para o GitHub. Uma vez com o código alterado no github:

Precisamos configurar o maven, então vá em manage jenkins e na parte do maven deixe assim:

Esquecemos de configurar no Job como será o build, então vá no job que criamos e depois em configure e deixe assim o build:

Clique em advanced do build

No eclipse Clique com o botão direito no projeto e adicione Maven >> e habilite o maven.

Agora commit e manda as alterações para o github.

Agora vamos mandar o Jenkins buildar nosso projeto e ver o que acontece:

Vamos tentar arrumar isso corrigindo o código, altere o código e mande para o GitHub.

E agora vamos buildar pra ver. O que acontece:

Pronto! Assim concluímos essa parte. Pouco cansativo na primeira vez devido a configurações, mas depois fica mais fácil. No próximo post veremos como automatizar, ou seja, uma mudança no nosso repositório remoto e automaticamente o build começa. Ou seja, Fez push para o github, o build  começa a validar.

Abraços, see  ya!!

Novo curso: Desenvolvimento de Aplicações JEE Utilizando Frameworks

olá Pessoal, 
 
O post de hoje tem como objetivo apresentar para vocês um novo curso que lançei recentemente pelo IMasterPro. O objetivo é para aqueles iniciantes no mundo JEE  usando frameworks possam ter a oportunidade de colocar mão na massa usando aqueles frameworks que mais ouvimos no dia-dia tais como “Hibernate, JSF, SpringSecurity etc”. A seguir apresento um pouco sobre o curso.
 
Lets go.. 
 
 
Sobre Curso 
 
O curso tem como objetivo de ser prático com exercícios e explicações mão na massa, pois acredito que só aprende praticando, afinal de contas você não vai aprender a dirigir se ler um manual de como dirigir ou apenas como dar partida no carro, isso não é o suficiente para você falar que sabe dirigir, é preciso praticar dia-dia para se tornar um melhor motorista, foi com esse conceito que o criei o curso. 
 
 
O que veremos? 
 
Ahh coloquei um pouco de tudo, Hibernate, SpringSecurity, JSF, Mysql 5.x etc. Vamos misturando um pouco daqui e dali, criando pequenas aplicações e evoluindo a cada aula o aprendizado.
 
O que NÃO é o objetivo do curso 
 
Este não tem como objetivo torná-lo especialista em cada framework, até porque é impossível se tornar especialista em tantas tecnologias em algumas horas apenas. Não tenha essa expectativa. A idéia aqui é para quem quer sair do 0x0.
 
Publico Alvo
Eu digo que é iniciante no mundo JEE e não iniciantes em Java. Se você é iniciante no mundo Java, favor não faça o investimento agora.  Na página do curso eu falo dos requisitos esperados que tenha antes de fazer o investimento.
Mais detalhes do curso
 
Vou ficando por aqui… 
 
abracos, see ya!!!!

Série Git na Prática:Descartando alterações no working directory

Olá Pessoal,

No post de hoje veremos como descartar alterações quando ainda estamos no working directory.

Lets go..

 Starting…

Algo muito comum é você fazer alteração no arquivo e depois ver que não seria necessário mais aquela alteração e quer descartar. Mas, o que fazer? Ao modificar o arquivo o git vai informar assim:

Então antes de ir para o INDEX queremos descartar as mudanças feitas e deixar o arquivo como antes. Como proceder?

Simples! Basta executarmos o seguinte comando:

git checkout <nome do arquivo>

Se executarmos novamente o git status veremos que não há nada alterado e se abrirmos o arquivo, ele estará como antes.

Só isso. Simples, não? Não é. O git que é fácil.  🙂

See ya!! Abraços.