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
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.
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:
Maque o checkbox para sua comodidade.
Crie agora um pequeno projeto java. Chame-o de hello-spring (File>New>Other>Java Project):
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