Category Archives: Spring

Spring Security – Como validar se o usuário está realmente autenticado

E ai galera, hoje estava fazendo meu TCC e precisei fazer uma validação no JSF para ver se o usuario estava logado, ai dando uma olhada nos métodos que o spring nos disponibiliza, achei o seguinte método:

SecurityContextHolder.getContext().getAuthentication().isAuthenticated();

A princípio achei que os meus problemas estavam solucionados, porém, quando nenhum usuário se autenticou ele continua retornando true…. pesquisando descobri que ele considera que existe alguém logado do tipo Anonymous … ¬¬

então para termos um método que funciona realmente temos que fazer da seguinte maneira:

public void isAuthenticated(){
      Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
     return authentication != null && !(authentication instanceof AnonymousAuthenticationToken) && authentication.isAuthenticated();
}

Porém não sei se é a melhor maneira, pelo menos funciona 😀

Fonte: StackOverflow – noushy

Spring Data JPA Avançado – Epecificações e queryDSL

Neste post eu gostaria de mergulhar dentro de alguns recursos e como eles poderiam lhe ajudar a simplificar a implementação da camada de acesso a dados ainda mais. A abstração do repositório Spring Data consiste de um modelo de programação baseado em interface, algumas classes de fábrica e um Spring namespace para facilmente configurar a infraestrutura. Uma interface de repositório típica se parece com isso:

public interface CustomerRepository extends JpaRepository<Customer, Long> {

Customer findByEmailAddress(String emailAddress);
List<Customer> findByLastname(String lastname, Sort sort);
Page<Customer> findByFirstname(String firstname, Pageable pageable);

}

O primeiro método simplesmente espera encontrar um único cliente com um determinado endereço de email, o segundo método retorna todos os clientes com um determinado sobrenome e aplica-se a ordenação determinada ao resultado, enquanto o terceiro método retorna uma página de clientes. Para mais  detalhes dê uma olhada neste artigo (inglês)

Embora essa abordagem seja realmente conveniente (você não precisa escrever uma única linha de implementação de código para ter as queries executadas) temos 2 desvantagens nisso: primeira, o número de métodos de consultas pode crescer para grandes aplicações por causa disso – e esse é o segundo ponto, as consultas definem um conjunto fixo de criterias. Para evitar essas 2 desvantagens, não seria legal se você pudesse chegar com um conjunto de atributos atômicos que você pudesse combinar dinamicamente para construir uma consulta?

Se você é uma usuário de JPA a muito tempo, você pode responder: não é pra isso que a API Criteria serve? Correto, então vamos dar uma olhada como se parece um exemplo de implementação de regra de negócio utilizando a API Criteria JPA. Esse é o caso de uso: nos aniversários deles nós queremos enviar um voucher para todos cliente de longa data. Como recuperaríamos aqueles com essa combinação?

Nós praticamente temos 2 partes para o predicate (atributo/predicado): o aniversário assim como o que nós chamamos de cliente-de-longa-data. Vamos assumir que isso significa que a criação da conta do cliente foi a pelo menos 2 anos atrás. Assim é como se pareceria a implementação utilizando a API Crieria JPA:

LocalDate today = new LocalDate();

CriteriaBuilder builder = em.getCriteriaBuilder();
CriteriaQuery<Customer> query = builder.createQuery(Customer.class);
Root<Customer> root = query.from(Customer.class);

Predicate hasBirthday = builder.equal(root.get(Customer_.birthday), today);
Predicate isLongTermCustomer = builder.lessThan(root.get(Customer_.createdAt), today.minusYears(2);
query.where(builder.and(hasBirthday, isLongTermCustomer));
em.createQuery(query.select(root)).getResultList();

O que temos aqui? Criamos uma nova LocalDate por conveniência e seguimos com três linhas padrões para estabelecer as instâncias da infraestrutura JPA necessária. Então temos duas linhas construindo os atributos/predicados, uma para concatenar as duas e uma ultima para executar a consulta atual. Estamos usando classes de meta-modelagem introduzidas com JPA 2.0 e geradas pela API de Processamento de Anotações. O principal problema com este código é que os atributos não são fáceis de externalizar e reutilizar porque você precisa configurar o CriteriaBuilder, CriteriaQuery e o Root primeiro. Além da readaptação do código é tão pobre quanto é difícil de deduzir rapidamente a intenção do código à primeira vista.

Especificações
Para estar apto para definir atributos/predicados reutilizáveis nós introduzimos a interface de Especificação que é derivada dos conceitos introduzidos no livro Domain Driven Design de Eric Vans. Ele define uma especificação como um atributo sobre uma entidade a qual é exatamente o que nossa interface de especificação representa. Atualmente consiste em apenas um único método:

public interface Specification<T> {

Predicate toPredicate(Root<T> root, CriteriaQuery query, CriteriaBuilder cb);

}

então agora podemos facilmente utilizar uma classe utilitária como essa:

public CustomerSpecifications {
  public static Specification<Customer> customerHasBirthday() {
    return new Specification<Customer> {
      public Predicate toPredicate(Root<T> root, CriteriaQuery query, CriteriaBuilder cb) {
        return cb.equal(root.get(Customer_.birthday), today);
      }
    };
  }

  public static Specification<Customer> isLongTermCustomer() {
    return new Specification<Customer> {
      public Predicate toPredicate(Root<T> root, CriteriaQuery query, CriteriaBuilder cb) {
        return cb.lessThan(root.get(Customer_.createdAt), new LocalDate.minusYears(2));
      }
    };
  }
}

Reconhecidamente, não é o código mais bonito do mundo, mas fornece nossa necessidade inicial muito bem: podemos nos referir a um conjunto de especificações atômicas. A próxima questão é: como vamos executar essas especificações? Para fazer isso, você simplesmente estende JpaSpecificationExecutor na interface do seu repositório e assim “puxa” uma API para executar especificações:

public interface CustomerRepository extends JpaRepository<Customer>, JpaSpecificationExecutor {
  // Seus métodos de consulta aqui!!!
}

Um cliente pode agora fazer:

customerRepository.findAll(hasBirthday());
customerRepository.findAll(isLongTermCustomer());

A implementação do repositório básico irá preparar o CriteriaQuery, Root e CriteriaBuilder para você, aplique o atributo/predicado criado por uma especificação determinada e execute a consulta. Mas nós não poderiamos apenas ter criado métodos simples de consulta para realizar isso? Correto, mas lembre-se do nossa segunda necessidade inicial. Nós queremos estar aptos para combinar livremente especificações atômicas para criar novos na hora. Para fazer isso nós temos especificações da classe utilitária que fornece os métodos and(…) e or(…) para concatenar especificações anatomicas. Temos também um where(…) que fornece uma doce semântica que faz a expressão mais legível. O exemplo do caso se uso que vimos no começo parece com isso:

customerRepository.findAll(where(customerHasBirthday()).and(isLongTermCustomer()));

Isto fica mais legível, melhorando tanto a legibilidade quanto fornecendo flexibilidade adicional comparado ao uso da API Criteria JPA sozinha. A única ressalva aqui é que subindo com a implementação da especificação requer algum esforço  de codificação.

QueryDSL
Para curar essa dor um projeto open-source chamado Querydsl surgiu com uma abordagem bastante similar mas também diferente. Assim como a API Criteria JPA ela usa um processador de anotações Java 6 para gerar objetos meta-modelos mas produz uma API muito mais acessível. Outra coisa legal sobre o projeto, é que não tem suporte apenas para JPA, mas também aceita consultas Hibernate, JDO, Lucene, JDBC e até coleções simples.

Então para tê-lo instalado e rodando você adiciona o QueryDSL ao seu pom.xml e configura o plugin APT plugin conforme abaixo:

<plugin>
   <groupId>com.mysema.maven</groupId>
   <artifactId>maven-apt-plugin</artifactId>
   <version>1.0</version>
   <executions>
      <execution>
        <phase>generate-sources</phase>
        <goals>
          <goal>process</goal>
        </goals>
        <configuration>
            <outputDirectory>target/generated-sources</outputDirectory>
            <processor>com.mysema.query.apt.jpa.JPAAnnotationProcessor</processor>
        </configuration>
      </execution>
   </executions>
</plugin>

Isso irá fazer o seu build criar classes de consulta especiais – QCustomer dentro do mesmo pacote no nosso caso.

QCustomer customer = QCustomer.customer;
LocalDate today = new LocalDate();
BooleanExpression customerHasBirthday = customer.birthday.eq(today);
BooleanExpression isLongTermCustomer = customer.createdAt.lt(today.minusYears(2));

Este não é apenas o Inglês quase fluente fora da caixa (?), o BooleanExpressions, é mesmo reutilizável sem mais empacotamento do qual nos livra da especificação wrapper adicional (um pouco desagradável de implementar). Um plus adicional é que você tem o auto-complete de código da IDE a cada ponto do lado direito de atribuição, então customer. + CTRL + SPACE listará todas as propriedades. customer.birthday. + CTRL + SPACE listará todas as palavras-chave disponíveis e assim por diante. Para executar os atributos do QueryDSL você simplesmente estende QueryDslPredicateExecutor ao seu repositório:

public interface CustomerRepository extends JpaRepository<Customer>, QueryDslPredicateExecutor {
  // Seus métodos de consulta aqui!!!
}

Os clientes podem simplesmente fazer:

BooleanExpression customerHasBirthday = customer.birthday.eq(today);
BooleanExpression isLongTermCustomer = customer.createdAt.lt(today.minusYears(2));
customerRepository.findAll(customerHasBirthday.and(isLongTermCustomer));

Resumo
A abstração do repositório Spring Data JPA permite a execução de atributos/predicados ou via atributos API Criteria JPA wrapped dentro de um objeto de especificação ou via atributos QueryDSL. Para permitir essa funcionalidade você simplesmente deixa seu repositório extender JpaSpecificationExecutor ou QueryDslPredicateExecutor (você poderia até mesmo usar os 2 se você gostou). Veja que você precisa dos JAR’s do QueryDSL na classe no caso de você decidir pela abordagem do QueryDSL.

Mais uma coisa
Mais uma coisa legal sobre a abordagem do QueryDSL é que ela não está apenas disponível para os nossos repositórios JPA, mas para nosso apoio MongoDB também. A funcionalidade é inclusa apenas no release M2 do Spring Data MongoDB. Além de ambos módulos Mongo e JPA do Spring Data, são suportados na plataforma CloudFoundry. Veja os exemplos em cloudfoundry-samples wiki para iniciar  em Spring Data e CloudFoundry.

Fonte: SpringSource – Oliver Gierke

Integrando JSF 2 e Spring

É muito fácil encontrar material sobre JSF 2 de qualidade na internet, mas não se encontra uma forma fácil de realizar a integração com Spring, e quando encontrada, geralmente a integração é feita via xml. Nesse post será mostrado como fazer a integração entre essas duas ferramentas de uma maneira simples usando anotações e um mínimo de xml.

Para trabalhar com o JSF são necessários dois jars:

compile 'com.sun.faces:jsf-api:2.2.0-m04'
compile 'com.sun.faces:jsf-impl:2.2.0-m04'

Por parte do Spring, são os mesmos jars usados para integração com Struts:

compile 'org.springframework:spring-asm:3.1.1.RELEASE'
compile 'org.springframework:spring-beans:3.1.1.RELEASE'
compile 'org.springframework:spring-context:3.1.1.RELEASE' 
compile 'org.springframework:spring-core:3.1.1.RELEASE'
compile 'org.springframework:spring-expression:3.1.0.RELEASE'
compile 'org.springframework:spring-web:3.1.1.RELEASE'

A configuração no web.xml fica assim:

<web-app version=”2.5″ xmlns=”http://java.sun.com/xml/ns/j2ee&#8221;
<servlet>
<servlet-name>faces</servlet-name>
<servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>faces</servlet-name>
<url-pattern>*.xhtml</url-pattern>
</servlet-mapping>
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
<listener>
<listener-class>
org.springframework.web.context.request.RequestContextListener
</listener-class>
</listener>
</web-app>
view raw web.xml This Gist brought to you by GitHub.

As tags servlet e servlet-name são para o uso “padrão” do JSF. A classe ContextLoaderListener é quem vai subir o contexto do Spring, também uma configuração comum. O que merece atenção aqui é o RequestContextListener, o qual vai expor o request para que o Spring possa manipulá-lo, permitindo assim que ele faça as injeções no momento adequado.

Por fim, há mais uma alteração que deve ser colocada no faces-config.xml:

<application>
<el-resolver>org.springframework.web.jsf.el.SpringBeanFacesELResolver</el-resolver>
</application>

JSF utiliza Expression Language (EL) para determinar a qual classe a página xhtml se refere. Fazendo uso de uma classe chamada ELResolver ele pega a String passada, a interpreta e faz a referência adequada. A classe SpringBeanFacesELResolver proporciona a integração entre os dois frameworks interceptando a requisição e passando-a para o contexto do Spring, o qual a manipula para prover as dependências requeridas pelos ManagedBeans, devolvendo-a em seguida para o ELResolver do próprio JSF.

Para ficar mais claro, vamos ao código. Abaixo, um Dao gerenciado pelo Spring:

@Repository("carroDao")
public class JdbcCarroDao implements CarroDao {

    // métodos aqui
}

Ao utilizar a anotação @Repository, se houver apenas uma implementação para CarroDao, geralmente para o Spring não é necessário que um nome seja especificado, mas ele se faz necessário ao trabalhar com JSF:

@ManagedBean
public class CarroBean {

    @ManagedProperty(name = "dao", value = "#{carroDao}")
    private CarroDao dao;

    public void setDao(final CarroDao dao) {
        this.dao = dao;
    }
}

Agora a anotação @ManagedProperty será usada não apenas para se referir ao que está no escopo web, mas também para lidar com os beans do Spring. A propriedade name é usada para indicar o nome do campo do managedBean, para que o JSF chame o setter adequado, enquanto a propriedade value vai ser usada para referenciar o nome do bean, no caso o carroDao anteriormente especificado.

E é só isso. Fazendo uso do fluxo do próprio JSF, e com algumas poucas configurações, o Spring proporciona uma integração simples e natural, que não altera em nada a forma de trabalhar com JSF.

Fonte: SimpleDev – Juliano Alves

Spring 3, configurando beans com Annotations

Hoje, é muito comum frameworks configuráveis através de annotations. O Spring também possui esse estilo de configuração que é bastante prático e traz produtividade ao desenvolvimento. Você poderá inclusive misturar configuração via XML e Annotations e utilizar qual for mais adequada para cada situação. Nesse tutorial mostraremos como a configuração pode ser feita através de annotations e ainda como pode ser feita a detecção automática dos beans através do classpath scanning.

Esse tutorial é continuação do Hello World com Spring 3 para um projeto WEB, se ainda não tem um projeto Spring configurado, é recomendável ler o outro tutorial antes de prosseguir com esse. Algumas anotações utilizadas nesse capítulo necessitam JEE 5 (como @PostConstruct).

1. Configurando os beans com annotations

Vamos começar configurando beans com Annotations, ao invés de usar a configuração de XML. Como é possível utilizar as duas configurações simultaneamente, a configuração feita através de Annotations é processada antes da configuração via XML. A configuração em XML pode então sobrescrever a configuração feita com Annotations.

Para habilitar a configuração dos beans via annotations, basta adicionar uma tag context:annotation-config no seu arquivo applicationContext.xml (Note a inclusão do namespace context)

<?xml version=”1.0″ encoding=”UTF-8″?>
<beans xmlns=”
http://www.springframework.org/schema/beans”
       xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”
       xmlns:context=”http://www.springframework.org/schema/context”
       xsi:schemaLocation=”http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd>

       <context:annotation-config/>

</beans>

Com essa tag, será possível fazer a configuração dos beans por Annotations.

Vejamos as anotações (alguns dos exemplos mostrados foram retirados da documentação do Spring):

@Required

A anotação @Required é utilizada nos setters das propriedades do bean, veja o exemplo:

public class SimpleMovieLister {

private MovieFinder movieFinder;

    @Required
public void setMovieFinder(MovieFinder movieFinder) {
this.movieFinder = movieFinder;
}
// …
}

Essa anotação indica que essa propriedade deve ser populada na configuração. Caso não haja configuração para essa propriedade uma exceção será lançada pelo container.

@Autowired e @Inject

Como esperado, você pode utilizar a anotação @Autowired em métodos setter. Se estiver utilizando um JAR para o JSR-330 (Injeção de dependencia) poderá utilizar a anotação @Inject. O Spring detecta se o JAR está presente automaticamente. A anotação @Autowired faz a configuração da propriedade de forma automática, buscando na fábrica do Spring algum bean que possa satisfazer a dependencia e então realizando a configuração.

public class SimpleMovieLister {
private MovieFinder movieFinder;
@Autowired
public void setMovieFinder(MovieFinder movieFinder) {
this.movieFinder = movieFinder;
}
// …
}

Propriedade anotadas com @Autowired devem ser obrigatoriamente preenchidas. Você pode alterar esse comportamento através do atributo required, como @Autowired(required=false). A anotação @Inject não tem a mesma definição, sendo o preenchimento opicional.

Também é possível utilizar essa anotação em métodos com nomes aleatórios e com vários argumentos:

public class MovieRecommender {
private MovieCatalog movieCatalog;
private CustomerPreferenceDao customerPreferenceDao;

@Autowired
public void prepare(MovieCatalog movieCatalog, CustomerPreferenceDao customerPreferenceDao) {
this.movieCatalog = movieCatalog;
this.customerPreferenceDao = customerPreferenceDao;
}
// …
}

Você pode usar o @Autowired em construtores e campos:

public class MovieRecommender {
@Autowired
private MovieCatalog movieCatalog;
private CustomerPreferenceDao customerPreferenceDao;
@Autowired
public MovieRecommender(CustomerPreferenceDao customerPreferenceDao) {
this.customerPreferenceDao = customerPreferenceDao;
}
// …
}

@Value

A anotação @Value é utilizada quando temos propriedades que não são outros beans exemplo:

public class MovieCatalog {
@Value(“Comedy”)
String name;

}

@PostConstruct e @PreDestroy

As anotações @PostContruct e @PreDestroy servem para anotar métodos que devem ser chamados quando o container for iniciado e destruido respectivamente. É necessário ter um JAR do JSR-250 para ter disponíveis essas anotações. Se não tiver esse JAR disponível uma alternativa é utilizar os atributos init-method e destroy-method na definição do bean no XML do Spring. Ou o bean implementar as interfaces InitializingBean e DisposeableBean.

2. Contruindo uma aplicação utilizando Annotations

Utilizando uma aplicação que já esteja configurada com o Spring, vamos criar dois beans e utilizar a injeção de dependência através de annotations. Crie duas classes conforme o exemplo:

package org.javaframework.spring;

import javax.annotation.PostConstruct;

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

public class MostraInformacoesSistema {

    @Autowired
Sistema sistema;

    @PostConstruct
public void mostraInformacoes(){
System.out.println(“Sistema: “+sistema.getNome()+
“, versão: “+sistema.getVersao());
}
}

package org.javaframework.spring;

import org.springframework.beans.factory.annotation.Value;

public class Sistema {

    @Value(“Spring com annotations”)
String nome;

@Value(“1.0”)
String versao;

    public String getNome() {
return nome;
}
public String getVersao() {
return versao;
}
public void setNome(String nome) {
this.nome = nome;
}
public void setVersao(String telefone) {
this.versao = telefone;
}
}

A classe Sistema servirá para guardarmos algumas informações que serão mostradas pela classe MostraInformacoesSistema. Foi utilizada a anotação @Autowired no atributo sistema da classe MostraInformacoesSistema, isso indica para o Spring fazer a configuração dessa propriedade automaticamente. A anotação @PostConstruct fará com que o método mostraInformacoes seja chamado assim que o bean esteja completamente configurado.

Agora vamos configurar o XML do Spring para ler essas anotações e fazer a configuração, configure seu arquivo applicationContext.cml conforme o exemplo:

<?xml version=”1.0″ encoding=”UTF-8″?>
<beans xmlns=”http://www.springframework.org/schema/beans”
xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”
xmlns:context=”http://www.springframework.org/schema/context”
xsi:schemaLocation=”http://www.springframework.org/schema/beans 
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

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

<context:annotation-config/>

<bean/>

<beanhttp://static.springsource.org/spring/docs/3.0.x/spring-framework-reference/html/beans.html#beans-annotation-config” target=”_blank”>3.9 Annotation-based container configuration.

Fizemos a configuração do bean por annotations, mas ainda precisamos declarar o bean no XML. Isso porque a tag context:annotation-config apenas lê as anotações e faz a configuração, mas não implica em detectar as classes automaticamente. Para isso precisamos de outra tag, que será mostrada a seguir.

3. Classpath scanning

Classpath scanning é um recurso do Spring que lê o classpath da aplicação e busca classes que possam ser configuradas, isso evita que você tenha que declarar essas classes no XML. Essas classes são passadas por um filtro e então uma definição de um bean é criada para elas. Geralemente esse filtro é alguma anotação que marca que determinada classe deve ser utilizada como um componente. Essas anotações são: @Component, @Service, @Controller e @Repository (que foi introduzida no Spring 2.0). Você pode também criar suas próprias anotações e filtros para declarar os componentes.

A anotação @Component é um tipo genérico para qualquer bean que deve ser gerenciado pelo Spring. @Repository, @Service e @Controller são especializações de @Component e servem para as camadas de persistencia, serviço e apresentação respectivamente. Você pode utilizar @Component para qualquer classe da sua aplicação, mas utilizar uma anotação mais específica ajuda caso deseje criar um filtro, utilizar ferramentas, ou orientação a aspectos. Funcionalmente todas as anotações servem para declarar beans, não existe diferença entre elas a não ser na questão de organização da apliacação e utilidades citadas anteriormente.

Para detectar as classes e gerar beans precisamos de uma outra tag no applicationContext.xml

<?xml version=”1.0″ encoding=”UTF-8″?>
<beans xmlns=”http://www.springframework.org/schema/beans”
xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”
xmlns:context=”http://www.springframework.org/schema/context”
xsi:schemaLocation=”http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.0.xsd”>

<context:component-scan base-package=”org.javaframework”/>

</beans>

Essa tag irá indicar ao Spring para procurar as classes e fazer a configuração dos beans. O atributo base-package indica em qual pacote as classes devem ser lidas, podem ser especificados quantos pacotes desejar, separados por vírgula.

Com essa tag, podemos alterar o applicationContext.xml da aplicação exemplo que criamos, retirando as declarações dos beans. O arquivo applicationContext.xml fica da seguinte forma:

<?xml version=”1.0″ encoding=”UTF-8″?>
<beans xmlns=”http://www.springframework.org/schema/beans”
xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”
xmlns:context=”http://www.springframework.org/schema/context”
xsi:schemaLocation=”http://www.springframework.org/schema/beans 
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd

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

<context:annotation-config/>
<context:component-scan base-package=”org.javaframework”/>

</beans>

As classes devem ter alguma anotação que indique que são componentes, utilizamos a anotação @Service

package org.javaframework.spring;

import javax.annotation.PostConstruct;

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

@Service
public class
MostraInformacoesSistema {

    @Autowired
Sistema sistema;

    @PostConstruct
public void mostraInformacoes(){
System.out.println(“Sistema: “+sistema.getNome()
+”, versão: “+sistema.getVersao());
}
}

package org.javaframework.spring;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

@Service
public class Sistema {

    @Value(“Spring com annotations”)
String nome;

@Value(“1.0”)
String versao;

    public String getNome() {
return nome;
}
public String getVersao() {
return versao;
}
public void setNome(String nome) {
this.nome = nome;
}
public void setVersao(String telefone) {
this.versao = telefone;
}
}

Agora, basta criar as classes e utilizar as anotações para fazer a configuração, contando que as classes estejam no pacote definido em base-package elas serão detectadas e configuradas automaticamente, sem a necessidade de intervenção no XML de configuração do Spring.

Mais informações sobre o classpath scanning podem ser obtidas na documentação do Spring, seção 3.10 Classpath Scanning and Managed Components.

Fonte: JavaFramework

Hello World com Spring 3 para um projeto WEB

Uma das maiores dúvidas na utilização do Spring é como fazer a configuração inicial da aplicação. Nesse tutorial explicaremos como fazer essa configuração. Mostraremos como criar uma aplicação web, quais arquivos necessários, e configurar beans no contexto do Spring. Tudo para uma aplicação WEB.

1. Baixando o Spring

Nesse tutorial foi utilizado o Spring versão 3.0.1, que pode ser baixado no seguinte endereço http://www.springsource.com/download/community. Quando acessar a página, será pedido que preencha um formulário, voce pode preencher ou clicar no link download page na parte de baixo do form onde é dito “I’d rather not fill in the form. Just take me to the download page”. É interessante fazer dois downloads, um é o Spring Framework with Docs, que é o Spring + Documentação. E o Spring Framework Dependencies, que são as dependencias do Spring.
http://s3.amazonaws.com/dist.springframework.org/release/SPR/spring-framework-3.0.1.RELEASE-A-dependencies.zip
http://s3.amazonaws.com/dist.springframework.org/release/SPR/spring-framework-3.0.1.RELEASE-A-with-docs.zip

Extraia os arquivos baixados para um pasta qualquer. No arquivo Spring with Docs existirá uma pasta dist, que contém a distribuição do Spring e uma pasta src com os fontes das biliotecas, essas são as pastas mais importantes. No arquivo dependencies existirá uma pasta que representa cada pacote de dependências do Spring. Você não precisará importar para seu projeto todas as biliotecas, apenas as que for utilizar.

Dica: Quando estiver desenvolvendo com o Spring e encontrar um erro como java.lang.NoClassDefFoundError: org/apache/commons/logging/LogFactory, significa que a classe LogFactory do pacote org.apache.commons.logging não foi encontrada. Repare o pacote org/apache/commons, esse pacote é de uma biblioteca externa (não é org/springframework), você poderá encontrar essa biblioteca no arquivo de dependencies na pasta org.apache.commons. Dentro dessa pasta existirá uma subpasta com.springsource.org.apache.commons.logging o final do pacote condiz com o pacote da classe não encontrada org.apache.commons.logging, logo essa deve ser a biblioteca a ser adicionada.
Se o erro encontrado for algo como java.lang.NoClassDefFoundError: org/springframework/asm/ClassVisitor, repare que o pacote é org/springframework, logo essa é uma classe do Spring. Essa classe estará dentro de algum jar dentro da pasta dist da distribuição do JAR do Spring. Existe um arquivo JAR chamado org.springframework.asm-3.0.1.RELEASE-A.jar repare que o nome do arquivo org.springframework.asm condiz com o pacote da classe, logo esse é o JAR que deve ser adicionado ao seu projeto.

2. Criando o projeto

Vamos criar e preparar um projeto com as bibliotecas do Spring. Crie um projeto WEB no seu ambiente de desenvolvimento. Se estiver utilizando o plugin WTP do eclipse, será um projeto Dynamic Web Project. Escolha um projeto que tenha como versão do servlet 2.4 ou superior e Java 1.5 ou superior.

Copie para o diretório /WEB-INF/lib da sua aplicação os seguintes arquivos JAR (estão na pasta dist do arquivo baixado):

  • org.springframework.asm-3.0.1.RELEASE-A.jar
  • org.springframework.beans-3.0.1.RELEASE-A.jar
  • org.springframework.context-3.0.1.RELEASE-A.jar
  • org.springframework.core-3.0.1.RELEASE-A.jar
  • org.springframework.expression-3.0.1.RELEASE-A.jar
  • org.springframework.web-3.0.1.RELEASE-A.jar

Copie também para o diretório /WEB-INF/lib da sua aplicação o seguinte JAR que está no arquivo de dependencias (pasta org.apache.commons\com.springsource.org.apache.commons.logging\1.1.1):

  • com.springsource.org.apache.commons.logging-1.1.1.jar

Essas são as bibliotecas que utilizaremos nesse tutorial, a medida que for avançando na utilização do Spring, outras bibliotecas podem ser necessárias.

3. Configurando o projeto com o Spring

A configuração do Spring é feita através de um arquivo XML. Vamos criar um arquivo applicationContext.xml na pasta WEB-INF para utilizar como configuração do Spring. Esse arquivo deve ter o seguinte conteúdo:

<?xml version=”1.0″ encoding=”UTF-8″?>
<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”>

</beans>

Por enquanto esse arquivo não terá nenhuma configuração.

Ao iniciar a aplicação será necessário inicializar o container do Spring. Esse container irá ler o applicationContext.xml criado e fará a inicialização da aplicação. Precisamos informar ao container web sobre a inicialização do Spring, fazemos isso com a seguinte configuração no web.xml:

<?xml version=”1.0″ encoding=”UTF-8″?>
<web-app version=”2.5″
xmlns=”
http://java.sun.com/xml/ns/javaee”
    xmlns:xsi=”http://www.w3.org/2001/XMLSchema-instance”
    xsi:schemaLocation=”http://java.sun.com/xml/ns/javaee
http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd”

<!– Bootstrap the root application context as usual using ContextLoaderListener –>
<listener>
<listener-class>
            org.springframework.web.context.ContextLoaderListener
</listener-class>
</listener>

</web-app>

O ContextLoaderListener por padrão irá ler o arquivo applicationContext.xml e fazer a configuração do Spring.

Agora é um momento interessante de se testar a aplicação. Faça o deploy da aplicação, ligue o servidor e verifique se a aplicação é incializada sem erros. Se tudo funcionou perfeitamente, passe para a próxima etapa. Se acontecer algum erro, verifique seu deploy, se as bibliotecas foram colocadas nos locais corretos, e se o arquivo web.xml e applicationContext.xml estão como no exemplo (você poderá utilizar um web.xml com versão de servlet 2.4, o exemplo acima utiliza servlet 2.5).

4. Criando o primeiro bean

No Spring os objetos configurados tem o nome de bean. Você declara vários beans na sua aplicação e o Spring faz a injeção de dependencia, instanciando e configurando os objetos. Vamos criar nosso primeiro bean para testar o Spring. Crie uma classe chamada HelloWorld com o seguinte código:

package org.javaframework.spring;

public class HelloWorld {

String mensagem;
public void setMensagem(String message) {
this.mensagem = message;
}
public void dizerMensagem(){
System.out.println(“Hello World!! “+mensagem);
}
}

É apenas uma classe comum em Java. Iremos configurar agora, um bean no Spring. Como dito anteriormente um bean é um objeto configurado pelo container do Spring. Iremos utilizar o applicationContext.xml para configurar esse bean. Adicione o seguinte trecho no arquivo /WEB-INF/applicationContext.xml:

<bean init-method=”dizerMensagem”>
<property name=”mensagem” value=”Primeiro bean configurado do Spring!!!”/>
</bean>

A tag bean define um bean para a classe org.javaframework.spring.HelloWorld. Configuramos o método que deve ser chamado na inicialização desse bean através do init-method. E configuramos a propriedade mensagem. O Spring irá instanciar um objeto da classe HelloWorld, chamará o método setMensagem com o valor “Primeiro bean configurado do Spring!!!” e por fim invocará o método dizerMensagem. Se fizer a publicação da aplicação e ligar o servidor você verá a seguinte linha no console:

Hello World!! Primeiro bean configurado do Spring!!!

(Procure no console pois não será a última linha impressa)

Espero que tenha sido útil, fique atento ao Java Framework Portal para novos tutoriais.

Veja também: Spring 3, configurando beans com Annotations

Fonte: JavaFramework

Aplicação integrando JSF 2.0 + Spring 3 + Maven 2

Achei na net um código fonte de uma aplicação show de bola 😀 segue a baixo a descrição do autor:

Olá pessoal.
Acabo de colocar no github a APP que gerei aqui integrando os 3 frameowrks, JSF 2.0, Spring 3 e Maven 2.
O endereço é esse: GitHub AutoPecas
Em breve estarei disponibilizando a integração com o Spring Security.
A aplicação é bem trivial, apenas com cadastro de Perfil e Usuário, porém pode ser utilizada como
modelo para a criação de uma aplicação profissional utilizando essa gama de frameworks que permitem uma melhor produtividade.
Fiquem atentos, pois o repositório está sob constante atualização e em breve estarei postando essa nova integração.
Futuramente estarei criando um Post explicando como criar a aplicação passo a passo.
Ah, outro detalhe, juntamente com a aplicação, no pacote “Util” temos o script autopecas.sql que irá gerar um perfil e um usuário para acesso ao sistema.
Abraços e até a próxima,

Fonte: SempreJava – Leandro