domingo, 17 de março de 2013

Hello Spring

UPDATE:
as versões novas do Spring estão todas integradas com maven. Uma versão mais rápida do hello spring pode ser lida direto da página dos caras:

Tirar o pó disso aqui.

Seguinte vamos fazer um hello spring sem compromisso.

Mas antes de começar, por que spring é bacana?

IOC. e DI.

Pronto, isso é tudo. Valendo?

Ingredientes:
  • Windows 7 64 bits
  • Java 7 64 bits
  • Eclipse Juno 4.1 edition (64 bits)
  • Spring 3.2
Comece baixando o java e o eclipse:
A opção correta é a "Java Platform (JDK)"
Pegue o "Eclipse IDE for Java EE Developers", versão 64 bits. Pra não perder o costume.

Agora faça o donwload do Spring:
Clique em "spring-framework-3.2.2.RELEASE-dist.zip" e pronto.

Comece as instalações. É next, next, finnish até não poder mais.
NNF

Já o eclipse não. o Eclipse é um software inteligente, é só descompactar e usar, ;-)
Dica de ouro: nesta versão do windows a política de segurança pode acabar enfiando o pé na sua janta, então descompacte o eclipse no C:\
Adicione no menu para sua comodidade.

Feito isso, vamos descompactar o Spring:

Abra o eclipse e informe como workspace C:\workspace:
Maque o checkbox para sua comodidade.

Crie agora um pequeno projeto java. Chame-o de hello-spring (File>New>Other>Java Project):

Uma tela de alerta pode surgir. apenas marque o checkbox e clique no yes:

Feche a tela de welcome.

Pronto amigão, estamos online! Vá até o projeto hello-spring, que agora você consegue ver claramente. Crie uma nova classe no mesmo (File>New>Class):

Volte à pasta do spring, é hora de copiar as bibliotecas para o projeto:

Cole a pasta no seu projeto eclipse agora:

E, finalmente, selecione os arquivos .jar de dentro da pasta e adicione-os no classpath do projeto:

Com isso poderemos usar dos super poderes do spring sem culpa. Vamos começar modificando a classe que criamos para que ela fique assim:

package hellospring;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {

 /**
  * @param args
  */
 public static void main(String[] args) {
  // TODO Auto-generated method stub
  ApplicationContext ctx = //
  new ClassPathXmlApplicationContext("applicationContext.xml");
  
 }

}

Este código cria o contexto do spring, que cuidará das instâncias dos seus objetos. Entretanto, caso você tente executar, dará um erro:

O spring possui uma dependência no commons-logging da apache. Faça o download do mesmo aqui:


De modo similar ao que fizemos com os .jar do spring, descompate e copie o jars do commons-logging para o projeto:


Em seguida, adicione-os no classpath:

Bacana?

O ajuste seguinte é criarmos o arquivo applicationContext.xml para que o spring saiba como se configurar. Crie o arquivo com o seguinte conteúdo:

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<beans xmlns="http://www.springframework.org/schema/beans"
 xmlns:context="http://www.springframework.org/schema/context"
 xmlns:aop="http://www.springframework.org/schema/aop" 
 xmlns:jee="http://www.springframework.org/schema/jee" 
 xmlns:tx="http://www.springframework.org/schema/tx"
 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xsi:schemaLocation="
 http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-3.2.xsd 
 http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.2.xsd 
 http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.2.xsd 
 http://www.springframework.org/schema/jee http://www.springframework.org/schema/jee/spring-jee-3.2.xsd   
 http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx-3.2.xsd">
 
 <context:annotation-config/>
 <context:component-scan base-package="hellospring.beans"/>
</beans>

Um pouco verborrágico, mas pense que este é um cidadão que você irá mexer pouco quando concluído.

O que ele significa até o momento? além do cabeçalho gigante, temos as duas linhas de configuração de contexto: a primeira orienta o container a procurar anotações nas classes, e a segunda diz qual pacote deve ser escaneado. Vamos criar um bean para testarmos. observe o nome do pacote:

Esta classe ficará assim:

package hellospring.beans;

import org.springframework.stereotype.Component;

@Component
public class SampleBean1 {

 public String sayHello(){
  return "Hello!";
 }

}

Observe a simplicidade da anotação @Component; com ela, estamos orientando o container a manter uma única instância da mesma, sem maiores problemas. Podemos modificar a classe Main para fazemos uso deste bean:

package hellospring;

import hellospring.beans.SampleBean1;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {

 public static void main(String[] args) {
  // spring context
  ApplicationContext ctx = //
  new ClassPathXmlApplicationContext("applicationContext.xml");
  // singleton bean
  SampleBean1 bean = ctx.getBean(SampleBean1.class);
  
  System.out.println(bean.sayHello());
  
 }

}

Simples né?

Podemos ainda fazer com que os beans comuniquem-se uns com os outros. para tanto, basta usar uma anotação chamada @Autowired. Para exemplificar, vamos criar um segundo bean:

package hellospring.beans;

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

@Component
public class SampleBean2 {

 @Autowired
 private SampleBean1 sample1;

 public String sayHello() {
  return sample1.sayHello();
 }
}

Observe a audácia: Se você já programou alguma coisa em java, intuirá que, ao chamar o método sayHello() do SampleBean2, um enorme NullPointerException irá surgir. Mas vamos ver o que acontece.
Torne a modificar o Main.java:

package hellospring;

import hellospring.beans.SampleBean2;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {

 public static void main(String[] args) {
  // spring context
  ApplicationContext ctx = //
  new ClassPathXmlApplicationContext("applicationContext.xml");
  // singleton bean
  SampleBean2 bean = ctx.getBean(SampleBean2.class);
  
  System.out.println(bean.sayHello());
  
 }

}

E a saída do comando:
Mar 17, 2013 1:29:49 AM org.springframework.context.support.AbstractApplicationContext prepareRefresh
INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@68376cc3: startup date [Sun Mar 17 01:29:49 GMT-03:00 2013]; root of context hierarchy
Mar 17, 2013 1:29:49 AM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions
INFO: Loading XML bean definitions from class path resource [applicationContext.xml]
Mar 17, 2013 1:29:49 AM org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons
INFO: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@20dbbc62: defining beans [org.springframework.context.annotation.internalConfigurationAnnotationProcessor,org.springframework.context.annotation.internalAutowiredAnnotationProcessor,org.springframework.context.annotation.internalRequiredAnnotationProcessor,org.springframework.context.annotation.internalCommonAnnotationProcessor,sampleBean1,sampleBean2,org.springframework.context.annotation.ConfigurationClassPostProcessor.importAwareProcessor]; root of factory hierarchy
Hello!

Em resumo, tinha nulo nenhum.

E se você olhar nas mensagens do log, verá na lista de singletons verá sampleBean1 e sampleBean2, :-)

Bom, tem muito mais que pode ser dito, mas por hora chega. Espero que você tenha gostado. Vá estudar/trabalhar agora, rsrs.

Nenhum comentário :

Postar um comentário