Spring MVC com Annotations – Configurando a Camada de Persistência

Fala pessoal, tudo bem?

Passando para compartilhar mais uma publicação minha no blog da MATERA Systems da série de posts sobre configuração do Spring sem XML.

Neste post, explico como configurar a camada de persistência(sem xml, é claro).

Link: http://www.matera.com/br/2016/10/24/spring-mvc-com-annotations-configurando-a-camada-de-persistencia/

Fico por aqui, espero que gostem e até breve.

 

Spring Framework com Annotations

E ai galera, tudo bem com vocês?

Passando para compartilhar meu ultimo post publicado no blog da MATERA Systems.

Publiquei um  Post há um tempo atrás, falando sobre como podemos usar os benefícios da Injeção de Dependências (DI) e Inversão de Controle (IoC) utilizando o Spring Framework no desenvolvimento de aplicações Java na plataforma SE.

Desta vez, meu novo post explica como utilizar o Spring Framework na plataforma SE sem a necessidade de utilização de arquivos xml para configuração, somente com annotations.

Quer saber como? Acesse o link e confira: Spring Framework com Annotations

Espero que gostem.

Me despeço por aqui e até a próxima.

Projeto Java Desktop com Maven 4º Post

Olá,

Projetinho parado há algum tempo devido a falta de tempo, mais vamos dar sequência para concluir.

Pra inicio, criei um JFrame dando o nome de Principal.

Como o nome já diz, esta será nossa tela principal do sistema, ela que será aberta quando nosso sistema for inicializado.

Para ela não irei fazer nada muito difícil, inseri somente uma barra de menu com dois itens.

Ficando da seguinte forma.

Image

Para a opção Estado do menu, criei um JDialog dando o nome de EstadoForm.

Para ele também nada excepcional, dois campos de texto e um menu com as opções novo, salvar, editar e excluir.

Resumindo nosso formulário ficou da seguinte forma.

Image

Como todos sabem Java é uma linguagem que trabalha com Orientação a Objetos.

Pensando toda nossa tela se torna um objeto assim como cada item da nossa tela também se torna um objeto.

Por enquanto vamos pensar em nossos botões e por sinal temos quatro.

Se cada botão é um objeto, significa que cada um terá um comportamento.

Ps.: Se você pensou que nem todo objeto tem um comportamento, acredite ficar parado sem fazer nada por incrível que pareça é um comportamento.

Em Java, comportamentos são implementados criando-se métodos.

Passo inicial seria pensarmos nas ações que devem ocorrer quando ocorrer um click no botão Novo.

Primeiro passo seria habilitar os campos para preencher e já vamos garantir que estes campos estejam limpos para que nosso usuário preencha com os dados que quiser.

Vamos criar dois métodos separados para executar esta ação.

Se você pensou por que dois métodos separados a explicação mais simples para isto seria a seguinte.

Como estamos utilizando componentes Swing, tais componentes possuem nativos a implementação de um Listener (ouvinte) para eventos, ou seja, um click, o apertar uma tecla, etc.

Para este caso estaremos criando um evento para o click no botão que criamos.

Para fazer isto, click com botão direito do mouse sobre nosso botão > action > actionPerformed.

A ferramenta irá gerar o seguinte método.

private void jButtonActionPerformed(java.awt.event.ActionEvent evt) {  }

Nosso trabalho agora será implementar o comportamento desde método, uma vez que quando o usuário efetuar um click em nosso botão, o Listener saberá que é este método que deve ser executado.

Voltando agora na parte em que disse que criaríamos dois métodos separados para cara ação.

Para as duas ações em específicas que seria habilitar e limpar, e tais ações são bem genéricos e podem ser reutilizadas pra vários outros botões, então dentro dos métodos que indicará qual será a ação de nosso botão, apenas incluímos a chamada para nossos dois métodos, ficando da seguinte forma.

private void jButtonActionPerformed(java.awt.event.ActionEvent evt) {

habilitar(true);

limpar();

//demais métodos

}

Como o foco deste post é somente fazer um exemplo bem simples dando os conceitos básicos para quem esta iniciando com Java encerro por aqui.

Abraço e até mais.

O projeto completo ficará disponível no Git Hub.

Projeto Java Desktop com Maven 3º Post

Olá galera,

Para este post estarei criando nossas entidades para damos inicio a parte legal do projeto.

Bom como disse é sistema vai ser algo bem simples e por se tratar de algo que servirá de estudos para iniciantes em programação vamos fazer um cadastro de cidades e estados.

Particularmente não faço este tipo de cadastro em nenhum de meus sistemas, deixar com que o usuário efetue tal tipo de cadastro pode gerar inconsistência no banco de dados, pois, damos ao o usuário o poder de cadastrar cidades e estados que não existem, além de cidades em estados errados. Exemplo claro, o usuário por engano cadastrar Porto Alegre no estado de São Paulo, isto seria um problema e tanto não dando nenhuma credibilidade a informações que nosso sistema fornecerá. Neste caso prefiro inserir cidades e estados diretamente no banco evitando este tipo de problema. Pense pelo seguinte é muito difícil surgir estados e cidades novas do dia pra noite e caso surgir, não é nada fora do comum inserir diretamente no banco um estado e cidade nova. Lembrando opinião particular todo caso gera exceções, por isso analisem bem sua regra de negocio antes de sair criando classes e programando.

Dando sequencia e começando pela entidade estado.

No pacote br.com.meuprimeroprojeto.modelo, vamos criar uma nova classe Java e dar nome a ela de Estado.

Primeiro passo e o mais importante, definir os atributos que nosso estado irá ter. No nosso caso, nome e sigla ficando conforme abaixo.


package br.com.meuprimeiroprojeto.modelo;

/**
*
* @author Fernado
*/

public class Estado {
private Long idEstado;
private String nome;
private String sigla;
}

Feito isso criaremos uma nova classe Java e daremos o nome a ela de Cidade. No caso, somente o nome, porém aqui entra uma coisa interessante. Java é uma linguagem orientada a objetos, para quem não intende orientação a objetos lei este POST, acredito que irá ajudar. Neste caso já possuímos um objeto Estado e se formos pensar, toda cidade fica dentro de um Estado certo?

Neste caso nossa classe cidade ficará da seguinte forma.

package br.com.meuprimeiroprojeto.modelo;

/**
*
* @author Fernado
*/

public class Cidade {
private Long idCidade;
private String nome;
private Estado estado;
}

Bem como o post não ficou extenso vamos fazer o mapeamento objeto relacional das classes pra que o Hibernate crie as tabelas de nosso banco de dados.

Para fazer o mapeamento usaremos algumas Annotations.

Vamos lá:

@Entity: Informa que a classe mapeada é persistente

@Id: Definição de chave primária.

@GeneratedValue: Permite a geração de forma automática para o valor identificador baseados nos mecanismos de geração automática que existem no Hibernate. @GeneratedValue(strategy=”GenerationType.IDENTITY”)  Para este estou utilizando o mecanismo de geranção IDENTITY que é utilizada pra criar colunas identidades na maioria dos bancos de dados, porém existem outros, como SEQUENCE, INCREMENT, AUTO e TABLE, basta escolher o que melhor se aplica ao seu caso.

@ManyToOne: Informa a cardinalidade de muitos para um ao banco de dados. Para mapearmos quando inserimos um objeto dentro de outro é necessário que se informe tal Annotation. Em nosso caso, temos um objeto Estado dentro do objeto Cidade, ao se utilizá-la estamos informando que existem muitas Cidades dentro de um Estado.

Obs: Fiz um breve comentário sobre as Annotations utilizadas neste post, caso queira saber mais recomendo pesquisar algo, existem deversas annotations criadas para facilitar o mapeamento objeto relacional entre outras coisas.

Feito isso basta irmos ao HibernateUtility que se no pacote útil e informar as classes que queremos que o Hibenate mapie para nós deixando o arquivo conforme abaixo.


package br.com.meuprimeiroprojeto.util;

import br.com.meuprimeiroprojeto.modelo.Cidade;
import br.com.meuprimeiroprojeto.modelo.Estado;
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.Configuration;

public class HibernateUtility {

private static final SessionFactory factory;
private static final ThreadLocal sessionThread = new ThreadLocal();
private static final ThreadLocal transactionThread = new ThreadLocal();

public static Session getSession() {
Session session = (Session) sessionThread.get();
if ((session == null) || (!(session.isOpen()))) {
session = factory.openSession();
sessionThread.set(session);
}
return ((Session) sessionThread.get());
}

public static void closeSession() {
Session session = (Session) sessionThread.get();
if ((session != null) && (session.isOpen())) {
sessionThread.set(null);
session.close();
}
}

public static void beginTransaction() {
Transaction transaction = getSession().beginTransaction();
transactionThread.set(transaction);
}

public static void commitTransaction() {
Transaction transaction = (Transaction) transactionThread.get();
if ((transaction != null) && (!(transaction.wasCommitted())) && (!(transaction.wasRolledBack()))) {
transaction.commit();
transactionThread.set(null);
}
}

public static void rollbackTransaction() {
Transaction transaction = (Transaction) transactionThread.get();
if ((transaction != null) && (!(transaction.wasCommitted())) && (!(transaction.wasRolledBack()))) {
transaction.rollback();
transactionThread.set(null);
}
}

static {
try {
factory = new Configuration()
/***POSTGRESQL***/
//                    .setProperty("hibernate.dialect", "org.hibernate.dialect.PostgreSQLDialect")
//                    .setProperty("hibernate.connection.driver_class", "org.postgresql.Driver")
//                    .setProperty("hibernate.connection.url", "jdbc:postgresql://localhost/meuprimeiroprojeto")
//                    .setProperty("hibernate.connection.username", "postgres")
//                    .setProperty("hibernate.connection.password", "postgres")
/***MYSQL***/
.setProperty("hibernate.dialect", "org.hibernate.dialect.MySQLInnoDBDialect")
.setProperty("hibernate.connection.driver_class", "com.mysql.jdbc.Driver")
//CONFIGURAÇÃO DA BASE DE DADOS ** Verificar sempre Username e Password caso necessario alterar.
.setProperty("hibernate.connection.url", "jdbc:mysql://localhost/meuprimeiroprojeto")
.setProperty("hibernate.connection.username", "root")
.setProperty("hibernate.connection.password", "root")

//                    .setProperty("hibernate.connection.datasource", "jdbc/dbSGC") //data source (so pra aplicacao web e tem q configurar no tomcat)
.setProperty("hibernate.hbm2ddl.auto", "update")
.setProperty("hibernate.c3p0.max_size", "10")
.setProperty("hibernate.c3p0.min_size", "2")
.setProperty("hibernate.c3p0.timeout", "5000")
.setProperty("hibernate.c3p0.max_statements", "10")
.setProperty("hibernate.c3p0.idle_test_period", "3000")
.setProperty("hibernate.c3p0.acquire_increment", "2")
.setProperty("show_sql", "true")
.setProperty("use_outer_join", "true")
.setProperty("hibernate.generate_statistics", "true")
.setProperty("hibernate.use_sql_comments", "true")
.setProperty("hibernate.format_sql", "true")
//CLASSES PARA MAPEAMENTO
.addAnnotatedClass(Cidade.class)
.addAnnotatedClass(Estado.class)

.buildSessionFactory();
} catch (RuntimeException e) {
e.printStackTrace();
throw e;
}
}

public static void main(String [] args) {

}

}

Ao termino temos nossas classes com as devidas annotations ficarma da seguinte forma:

Classe Estado


package br.com.meuprimeiroprojeto.modelo;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

/**
*
* @author Fernado
*/
@Entity
public class Estado {

@Id
@GeneratedValue(strategy= GenerationType.IDENTITY)
private Long idEstado;
private String nome;
private String sigla;

//GETTERS E  SETTERS OMITIDOS

}
<pre>

Classe Cidade


package br.com.meuprimeiroprojeto.modelo;

import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.ManyToOne;

/**
*
* @author Fernado
*/
@Entity
public class Cidade {

@Id
@GeneratedValue(strategy= GenerationType.IDENTITY)
private Long idCidade;
private String nome;
@ManyToOne
private Estado estado;

//GETTERS E  SETTERS OMITIDOS
}

Para concluir, basta abrir MySQL e criarmos um novo schema dando a ele o nome dele de meuprimeiroprojeto.

Com isso termino por aqui e até o próximo post.

Fiz algumas alterações no arquivo POM.xml estarei deixando disponivel o código no GITHUB

Projeto Java Desktop com Maven

Para este post estarei iniciando um projeto de aplicação desktop utilizando o Netbeans, Hibernate e o Maven.

Estarei utilizando neste projeto o padrão de persistência DAO (Data Access Object) por se tratar de algo bem simples. Ao término deste começarei um novo projeto utilizando EntityMannager e SpringFramework algo mais elegante.

Bom por que utilizar o Maven ?

O Maven é um framework que considero muito interessante, ele irá nos proporcionar um certo conforto no desenvolvimento do projeto, uma vez que ele será o responsável por gerenciar nossas dependências, e consequentemente nosso projeto inteiro. Como ele faz isso acho que ficará mais claro no andamento do projeto.
Para iniciar devemos primeiramente configurar o Maven em nossa máquina e no NetBeans, para isso recomendo ler o post do meu amigo Thiago Marques que explica passo a passo como fazer isso.

Próximo passo agora é a criação do projeto no netbeans.
Quem desenvolve projetos desktop está acostumado a criar um projeto simples, porém para utilizar o Maven temos uma pequena diferença.
No menu vamos em Arquivo > Novo Projeto.  Ou pelo atalho CTRL+SHIFT+N.
Iremos selecionar em categorias a opção MAVEN e em Projeto APLICATIVO JAVA.

Ficando como na figura abaixo.

Na próxima tela inserimos algumas informações de nosso projeto ficando da seguinte forma.

Para este projeto, por se tratar de algo bem simples estas informações acima não são de muita importância, mais para projetos futuros que envolvem um pouco mais de complexidade explicarei a importância de tais informações. Já de inicio digo que tais informações estarão incluídas no arquivo POM.xml que é nosso arquivo de configuração do Maven.

Terminado a estrutura de nosso projeto deverá ficar desta forma

Iremos excluir o pacote com.MeuPrimeroProjeto  existente no diretório Pacotes de códigos fonte e Pacote de teste, deixando nosso projeto da seguinte forma.

Ao término teremos nossa estrutura da seguinte forma:
Pacote de códigos-fonte – Onde serão inseridos os pacotes de nosso projeto, classes, interfaces e formulários e etc.
Pacote de testes – Caso utilize testes automatizados tudo relacionado a isso deve ser incluído neste pacote.
Dependências – Onde serão inseridas as bibliotecas do projeto.
Testar Dependências – Onde serão inseridas as bibliotecas de testes caso seja feitos testes automatizados.
Arquivos do Projeto – Onde fica o POM.xml que é nosso arquivo de configuração do Maven, nele serão declaradas nossas dependências do projeto, plugins para compilação e tudo mais. Entrarei em mais detalhes nos próximos posts.

Com isso termino por aqui este primeiro post de inicialização do nosso projeto, para o próximo post iniciarei a criação das classes formulários e interfaces, lembrando que disponibilizarei no GITHUB todo o código quer for gerado neste projeto.
Até mais.

Spring Framework

Olá galera, algum tempo sem postar nada devido a correria neste final de ano na faculdade, Artigos e TCC, axo que sabem como é. Bom resolvi deixar aqui pra vocês um post de um Artigo que fiz para  13º Semana da Informática na Unipar Paranavaí, que é a universidade onde estou concluíndo minha graduação, onde minha orientadora é a Prof. Késsia R. C. Marchi sem dúvida uma das melhores professoras que tive durante minha graduação.  Bom o Spring é uma das ferramentas que utilizo no desenvolvimento do software para meu TCC. O que escrevi é pouco perto da capacidade que esta ferramenta possui, porém o artigo era de 5 pagina então tive que limitar e resumir bastante coisa. Mais espero que gostem. O artigo está disponivel no site do enveto denominado Seinpar onde existem diversos outros artigos do pessoal que está concluíndo a graduação e que são super interessantes. Vale a pena dar uma conferida.

AUMENTO DE PRODUTIVIDADE NO DESENVOLVIMENO DE APLICAÇÕES EM JAVA COM SPRING FRAMEWORK
Fernando S. Godói¹, Késsia R. C. Marchi¹
¹Universidade Paranaense (UNIPAR)
Paranavaí – PR – Brasil
fernandogodoy_18@msn.com, kessia@unipar.br

Resumo. Este artigo traz uma breve descrição do Spring Framework, apresentando sua estrutura e fazendo uma breve descrição dos padrões de Inversão de Controle e Injeção de Dependência, explicando quais benefícios estes padrões proporcionam no desenvolvimento de aplicações em Java. Será aplicado o Spring framework no desenvolvimento de uma aplicação em Java com uso dos padrões de Inversão de Controle e Injeção de Dependência.

1. Introdução
Atualmente o Java é uma linguagem utilizada universalmente, e este sucesso se deu devido ao poder que a linguagem possui possibilitando ao programador trabalhar tanto em baixo quanto em alto nível.
Com o passar dos anos o a linguagem teve uma grande evolução e seguindo este caminho surgiu o J2EE atualmente JEE, com foco em sistemas corporativos. Um dos problemas encontrados na JEE, é que a maior parte dos softwares criados atualmente é de pequeno porte, com isso a utilização de EJBs (Entreprise Java Beans) se tornou inviável devido ao alto nível de complexidade para à implementação. [Calçado 2008]
O Spring framework é uma tecnologia que surgiu para resolver o problema da complexidade encontrada nos EJBs, sendo um framework que implementa os padrões de Inversão de Controle e Injeção de Dependência, juntamente os Patterns de Setter Injection e Constructor Injection, além de prover técnicas de boa programação fornecendo um modelo unificado e simples de programação, isto o tornou um sucesso em meio à comunidade de programadores, sucesso este, foi tão grande que na versão mais nova do JEE, diversas melhorias foram criadas baseadas no Spring. [Calçado 2008; Pacheco 2007]
Este trabalho tem como foco falar sobre o Spring, fazendo uma breve abordagem sobre os padrões de Inversão de Controle e Injeção de Dependência que fizeram do Spring um sucesso junto à comunidade de programadores e utilizar o Spring framework em uma aplicação desenvolvida em Java observando os reais benefícios e facilidade que o Spring proporciona ao programador.

2. Spring
Atualmente mantido pela empresa Interface21, o Spring é um framework que trás diversos benefícios as aplicações, aumentando a produtividade no desenvolvimento de aplicações além de promover um grande aumento de performance em tempo de runtime, e facilitar o trabalho com testes unitários. [Schittini 2011]
O Spring Framework é composto por recursos organizados em cerca de 20 módulos, tais módulos podem ser implementados separadamente ou em conjunto com outros, isto permite ao Spring ser aplicado nos mais variados tipos de aplicações, sendo estas de qualquer porte. [Calçado 2008; Johson 2011]
O Spring implementa dois padrões de grande sucesso na comunidade de programadores que são de Inversão de Controle e Injeção de Dependência, provendo sempre das boas técnicas de programação, sendo estas, baixo acoplamento e alta coesão. Com sua arquitetura baseada em POJOs (Plain Old Java Object), o principal objetivo do Spring é tornar as tecnologias existentes atualmente no mercado fáceis de serem utilizadas.[ Calçado 2008; Schitini 2011]
O Spring possui outro recurso interessante que é o Lazy Inicialization, este recurso permite ao Spring que carregue apenas os Beans solicitados. Desta forma a aplicação ganha em desempenho, pois caso um Bean esteja declarado no Contexto do Spring e não esta sendo utilizado, este não será carregado, sendo carregado somente quando for necessário. [Pacheco 2007]

2.1 Estrutura
A figura 1, apresenta os módulos do Spring framework separadamente, cada um destes módulos pode ser implementado separadamente ou em conjunto com outros.
Figura 1 – Módulos do Spring. (Johson 2011)

2.1.1. Core Container
Neste módulo estão localizadas as funcionalidades padrões do Spring. Nele esta o BeanFactory, sendo este uma implementação do padrão Factory. Este módulo é responsável por aplicar a Inversão de Controle e Injeção de dependência na aplicação. [Balani 2005; Johson 2011]
Fornece também um avançado mecanismo de configuração capaz de gerenciar qualquer tipo de objeto. [Balani 2005; Johson 2011]
No Core Container, fica localizado Context, onde é encontrado o arquivo de configuração do Spring, um arquivo XML denominado ApplicationContext, nele também estão inclusos os serviços como JNDI, EJB, e-mail, validação, funcionalidades de agendamento, internacionalização, entre outros. [Balani 2005; Johson 2011]

2.1.2. Spring AOP e Instrumentation
Este módulo integra as funcionalidades da AOP (Aspect Oriented Programming), podendo esta ser implementada diretamente no Spring. Com isso, permite-se que o gerenciamento de transações passa a ser controlado pelo framework sem necessidade de componentes EJB, além de definição de Pointcuts e Methods Interceptors. [Balani 2005; Carvalho 2006]

2.1.3. Spring Data Acess/Integration
Este módulo implementa uma camada de abstração que possui uma hierarquia simplificada de tratamento erros de exceções lançadas pelo banco de dados, minimizando a quantidade do código criado para interação com banco de dados. [Balani 2005; Carvalho 2006]
Possui também o modulo ORM que implementa a conexão com frameworks para persistência facilitando o trabalho com estes. [Balani 2005; Carvalho 2006]
No módulo Transactions o Spring trata do gerenciamento de transações para classes que implementem interfaces especiais e para todos POJOs existentes na aplicação. [Schitini 2011]

2.1.4. Spring Web
Este módulo tem como base o módulo de contexto de aplicação, desta forma o Spring suportar a integração com o Jakarta Struts, além de facilitar a manipulação multi-parte, pedido e parâmetros de ligação entre objetos, possui também a inicialização do Container IOC (Inverse Of Control) usando Listeners e um arquivo de configuração Web Application Context. [Balani 2005; Johson 2011]
No Spring Servlet se localiza uma implementação do MVC (Model-View-Control) em um padrão altamente configurável por interfaces estratégicas, separando a regra de negócio de paginas Web. [Balani 2005; Johson 2001; Schitini 2011]

2.1.5. Spring Test
O Spring conta com o módulo de testes, dando suporte para o trabalho com componentes JUnit ou TestNG, além de suportar objetos Mock que simulam o comportamento de objetos reais da aplicação, permitindo que seu código seja testado isoladamente. [Johson 2011; Schitini 2011]

3. Inversão de Controle
Inversão de controle é o nome dado a um padrão onde a chamada de métodos que geralmente é efetuada pelo programador passa a ser invertida, ou seja, efetuada por um container ou outro componente que possa tomar o controle sobre a execução, é como se o programador delegasse esta tarefa a um terceiro. [Wikipédia 2008 ; Weissmann 2010]
No Spring os objetos existentes são considerados Beans, e o Container do Spring é que fica responsável por gerenciar os Beans existentes, geralmente estes possuem dependência entre si que são definidas através de meta-dados.[Calçado 2008]
O BeanFactory permite a recuperação de objetos pelo nome, além de gerenciar os relacionamentos entre objetos. Suporta dois modos de objetos, sendo um deles o Singleton que fornece uma instancia compartilhada, e o Prototype que assegura que cada objeto recuperado crie um objeto independente. [Balani 2005]

4. Injeção de Dependência
A Injeção de dependência é um padrão que se relaciona com a Inversão de Controle. É um padrão utilizado quando é necessário manter o baixo acoplamento entre objetos em um sistema. [Schitini 2011]
A forma mais comum de se obter referencia a um objeto é por instanciação direta, isto em Java é feito pelo operado new. O problema de quando se aplica esta forma é quando surge a necessidade de efetuar alterações em um objeto, este tipo de implementação viola o principio do baixo acoplamento entre os objetos. [Calçado 2008]
No conceito da Injeção de Dependência, as dependências não são declaradas na programação como no método tradicional, elas passam a ser injetadas diretamente pelo container, sendo o único trabalho necessário, efetuar a declaração das dependências em um arquivo de configuração.[Calçado 2008; Schitini 2011]
Com Injeção de dependência o código tende a ficar mais limpo, desacoplamento, mais eficaz uma vez que os objetos são fornecidos com suas dependências, tornando-se mais fácil a realização de testes quando as dependências são interfaces ou classes abstratas. [Johson 2011]
O Spring suporta dois tipos de injeção de dependência sendo Constructor Injection e Setter Injection. No Constructor Injection se utiliza do próprio construtor da classe para que se efetue a injeção, podendo este construtor ter quantos parâmetros forem necessários. Para que a injeção seja efetuada basta que o construtor seja anotado com uma annotation @Autowired. Já no Setter Injection, se declara as dependências em métodos Setters, devendo-se utilizar o padrão de nomenclatura correto, e sendo necessário efetuar algumas configurações, podendo ser por XML ou por código. O Setter Injection é o padrão que geralmente é adotado por desenvolvedores. [Fowler 2004; Pacheco 2007]

5. Metodologia
Para este trabalho foi realizada extensa revisão bibliográfica em materiais como livros, artigos e sites da Internet. O passo posterior foi utilizar o Spring framework no desenvolvimento de uma aplicação em Java, observado os reais benefícios que ele oferece ao programador e a aplicação.

6. Conclusão
A utilização de frameworks em projetos de desenvolvimento de softwares se torna uma prática bastante interessante, quando se pratica as boas técnicas de programação. O Spring é um framework com um potencial indiscutível, e sua aplicação em projetos impacta em alto ganho de produtividade, possui módulos bastante completos para desenvolvedores de aplicações, e permite ao programador dedicar-se à implementação da regra de negócio deixando que o Spring se encarregue do resto do trabalho.
Outro pronto interessante do Spring é que ele facilita a criação de teste, e a combinação do Spring com outros frameworks de gerencia de projeto traz benefícios visíveis à aplicação, deixando ela com um código limpo, facilitando manutenções e aumentando o nível de confiabilidade do software.

Referências
Balani, N. (2005) “Introduction to the Spring Framework”. <http://www.ibm.com/developerworks/web/library/wa-spring1/&gt; acesso em 21 de junho 2011.
Calçado, P. (2008) “Curso Spring Framework”. <http://blog.flexdev.com.br/wp-content/uploads/spring/apostila-spring.pdf&gt; acesso em 20 de maio 2011.
Carvalho, M. (2006) “Spring Framework Introdução”. <http://www.imasters.com.br/artigo/4497/java/spring_framework_introducao/&gt; acesso em 19 de junho 2011.
Fowler, M. (2004) “Inversion of Control Containers and the Dependency Injection Pattern”. <http://www.martinfowler.com/articles/injection.html&gt; acesso em 20 de julho 2011.
Johson, R. et Al (2011) “Spring Reference”. <http://static.springsource.org/spring/docs/3.1.x/spring-framework-reference/htmlsingle/spring-framework-reference.html&gt; acesso em 17 de julho de 2011.
Pacheco, D. (2007) “Spring Framework 2.0 para Desenvolvimento de Aplicações em Java”. <http://pt.scribd.com/doc/18517573/Spring-Framework-20-Diego-Pacheco&gt; acesso em 24 de julho 2011.
Schitini, I. et Al. (2011) “Spring Framework”. <http://kenai.com/projects/pos-sistemas-java-jf/sources/pos-java-ufjf-2009-2011/content/02-Daves/SpringFramework.doc?rev=48&gt; acesso em 04 de junho 2011.
Weissmann, L. H. (2010) “Injeção de Dependência com Spring Framework”. <http://www.itexto.net/devkico/?p=859&gt; acesso em 26/07/2011.
Wikipédia. (2008) “Inversão de Controle”. <http://pt.wikipedia.org/wiki/inversao_de_controle/&gt; acesso em 19 de junho 2011.

O Slide da apresentação está diponível no SlideShare neste Link: Slide Apresentação Seinpar