Requisitos :
- Java & Mysql
- Netbeans 7.2
- spring-3.2.0.M2
- Ter lido :
Posts Anteriores :
JSNBTut - Lesson 1 - introdução ao Spring
JSNBTut - Lesson 2 - introdução ao gerenciamento de dependências no Spring
1- Crie um banco de dados Mysql : chamarei de springlessons, logue como root em um banco Mysql e crie o usuario e o banco :
CREATE USER 'springlessons'@'%' IDENTIFIED BY 'DHADdSXcDF29WGXy'; GRANT ALL PRIVILEGES ON * . * TO 'springlessons'@'%' IDENTIFIED BY 'DHADdSXcDF29WGXy' WITH GRANT OPTION MAX_QUERIES_PER_HOUR 0 MAX_CONNECTIONS_PER_HOUR 0 MAX_UPDATES_PER_HOUR 0 MAX_USER_CONNECTIONS 0 ; CREATE DATABASE IF NOT EXISTS `springlessons` ; GRANT ALL PRIVILEGES ON `springlessons` . * TO 'springlessons'@'%';
Opcional : arquivo do MysqlWorkBench para criar o banco
springLessons.mwb
2 - Crie as tabela no banco de dados Mysql
 |
| Figura 01 - tabelas do banco |
CREATE TABLE IF NOT EXISTS `springlessons`.`tblOrder` ( `id` INT NOT NULL AUTO_INCREMENT , `customer` VARCHAR(45) NULL , PRIMARY KEY (`id`) ) ENGINE = InnoDB
CREATE TABLE IF NOT EXISTS `springlessons`.`tblOrderItem` (
`id` INT NOT NULL AUTO_INCREMENT ,
`orderId` INT NOT NULL ,
`product` VARCHAR(45) NULL ,
`price` DOUBLE NULL ,
`quantity` DOUBLE NULL ,
PRIMARY KEY (`id`) ,
INDEX `orderItem_order_FK` (`orderId` ASC) ,
CONSTRAINT `orderItem_order_FK`
FOREIGN KEY (`orderId` )
REFERENCES `springlessons`.`tblOrder` (`id` )
ON DELETE NO ACTION
ON UPDATE NO ACTION)
ENGINE = InnoDB
3 - Abra o Netbeans e clique em File -> new Project :
 |
| Figura 02- Novo projeto |
 | |
|
 |
| Figura 04 - projeto SpringLesson03 |
 |
| Figura 05 - Projeto criado pelo wizard |
6 - Adicione as bibliotecas necessárias : Spring e o driver do Mysql
 |
| Figura 06 - Adicione as libs |
no projeto, voce deve estar visualizando isso :
 |
| Figura 07 - Arquivos do projeto |
Agora vamos começar a codificar.
Podemos utilizar o NB p/ facilitar algumas coisas.
7 - vamos criar uma classe que faz parte M do modelo MVC, chamada Order em um package springlesson03.beans
I) Crie o arquivo springlesson03.beans.Order
 |
| Figura 08- Nova classe java |
 | |
|
II) Edite o arquivo springlesson03.beans.Order que usaremos p/ armazenar dados que estiverem na tabela tblOrder
 |
| Figura 10 - Classe Order criada |
Adicione o seguinte código nesse arquivo Order.java
public Integer id;
public String customer;
public List<OrderItem> itens;
ao adicionar a linha private List<OrderItem> itens; o NB fará duas reclamações :
1ª - não conhece o tipo List, adicione a classe java.util.List
 |
| Figura 11 - Sugestão NB |
2ª - não conhece o tipo OrderItem, deixe o NB criar essa classe dentro do mesmo package, que logo editaremos.
 |
| Figura 12 - Sugestão NB |
III) Clique com botão direito e escolha Refactor >> Encapsulate Fields
 |
| Figura 13 - Refatoração Order,java |
 |
| Figura 14 - Encapsulamento Order.java |
Conteúdo da classe springlesson03.beans.Order.java
package springlesson03.beans;
import java.util.List;
public class Order {
private Integer id;
private String customer;
private List<OrderItem> itens;
/**
* @return the id
*/
public Integer getId() {
return id;
}
/**
* @param id the id to set
*/
public void setId(Integer id) {
this.id = id;
}
/**
* @return the customer
*/
public String getCustomer() {
return customer;
}
/**
* @param customer the customer to set
*/
public void setCustomer(String customer) {
this.customer = customer;
}
/**
* @return the itens
*/
public List<OrderItem> getItens() {
return itens;
}
/**
* @param itens the itens to set
*/
public void setItens(List<OrderItem> itens) {
this.itens = itens;
}
}
8 - Vamos editar a classe que faz parte M do modelo MVC, chamada OrderItem no package springlesson03.beans
I) Adicione o seguinte código nesse arquivo OrderItem.java
public Integer id;
public Order order;
public String product;
public double price;
public double quantity;
II) E vamos utilizar o atalho Refactor >> Encapsulate Fields
 |
| Figura 16 - Refatoração OrderItem,java |
 | |
|
Conteúdo da classe springlesson03.beans.OrderItem.java
package springlesson03.beans;
class OrderItem {
private Integer id;
private Order order;
private String product;
private double price;
private double quantity;
/**
* @return the id
*/
public Integer getId() {
return id;
}
/**
* @param id the id to set
*/
public void setId(Integer id) {
this.id = id;
}
/**
* @return the order
*/
public Order getOrder() {
return order;
}
/**
* @param order the order to set
*/
public void setOrder(Order order) {
this.order = order;
}
/**
* @return the product
*/
public String getProduct() {
return product;
}
/**
* @param product the product to set
*/
public void setProduct(String product) {
this.product = product;
}
/**
* @return the price
*/
public double getPrice() {
return price;
}
/**
* @param price the price to set
*/
public void setPrice(double price) {
this.price = price;
}
/**
* @return the quantity
*/
public double getQuantity() {
return quantity;
}
/**
* @param quantity the quantity to set
*/
public void setQuantity(double quantity) {
this.quantity = quantity;
}
}
9- Vamos criar o arquivo XML que conterá as definições dos beans, do Spring e da conexão ao banco.
I) Clique com o botão direito no projeto e escolha New >> XML Document. Vamos criar nosso conhecido beans-definitions.xml
 | |
|
 |
| Figura 19 - tipo de arquivo XML |
II) Adicione o seguinte código nesse arquivo beans-definitions.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.xsd
http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd">
<bean id="dataSource" name="dataSource" class="org.springframework.jdbc.datasource.SingleConnectionDataSource">
<constructor-arg index = "0" value = "com.mysql.jdbc.Driver"></constructor-arg>
<constructor-arg index = "1" value = "jdbc:mysql://ns1/springlessons"></constructor-arg>
<constructor-arg index = "2" value = "springlessons"></constructor-arg>
<constructor-arg index = "3" value = "DHADdSXcDF29WGXy"></constructor-arg>
<constructor-arg index = "4" value = "true"></constructor-arg>
</bean>
<bean name="jdbcTemplate" id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<property name="dataSource" ref="dataSource"></property>
</bean>
<bean name="orderDao" id="orderDao" class="springlesson03.dao.OrderDao">
<property name="jdbcTemplate" ref="jdbcTemplate"></property>
</bean>
</beans>
Observe que:
1º criamos um beam chamado dataSource que indica a classe org.springframework.jdbc.datasource.SingleConnectionDataSource que em vez de tags <property></property> utiliza tags <construtor-arg></construtor-arg> com os atributos index e value.
Obs:
index=0 -- Driver
index=1 -- String JDBC de conexão jdbc://<tipoBanco>://<servidorDB>/<nomeBanco>
index=2 -- Usuário / Login do banco
index=3 -- Senha ;
index=4 -- se não colocar esse parametro dá esse erro ao compilar o projeto:
 |
| Figura 20 - erro de compilação sem o parametro index=4 |
2º criamos um beam chamado jdbcTemplate que indica a classe org.springframework.jdbc.core.JdbcTemplate e tem uma propriedade name="dataSource" ref="dataSource"
3º criamos um beam chamado orderDao que indica a classe springlesson03.dao.OrderDao (que será criada) e tem uma propriedade name="jdbcTemplate" ref="jdbcTemplate"
10 - Vamos criar o nosso DAO que fará o acesso aos dados no banco. Crie uma Classe chamada OrderDao dentro do package springlesson03.dao para atender as definições de nosso beam orderDao do XML.
<bean name="orderDao" id="orderDao" class="springlesson03.dao.OrderDao">
<property name="jdbcTemplate" ref="jdbcTemplate"></property>
</bean>
Nessa Classe iremos extender a classe JdbcDaoSupport do Spring (org.springframework.jdbc.core.support.JdbcDaoSupport).
Antes de ver o código completo,
I) o que precisamos nesse arquivo ?
- Funções comuns ao DAO como:
- Fazer consultas e atribuir os resultados a Arrays ou Listas de Objetos
- Executar comandos de insert,update,delete
II) o que precisamos saber ?
- que o objeto JdbcTemplate do spring utiliza o metodo getJdbcTemplate() ;
- que o método query desse objeto recebe 3 parâmetros sendo eles:
- param 1- Consulta SQL utilizando como valores de parâmetros o caracter ? ;
- param 2- um objeto prototipado utilizando o objeto nativo Object[]{};
- param 3- a classe que implementa a classe RowMapper (org.springframework.jdbc.core.RowMapper) do Spring (que criaremos adiante)
III) Clique com o botão direito no projeto e escolha New>> Java Class
Vamos criar a classe OrderItemRowMapper que implementa o RowMapper e o package springlesson03.dao
 |
| Figura 21 - Classe OrderItemRowMapper |
Conteúdo do arquivo springlesson03.dao.OrderItemRowMapper.java
package springlesson03.dao;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
import springlesson03.beans.OrderItem;
public class OrderItemRowMapper implements RowMapper{
@Override
public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
OrderItem item = new OrderItem();
item.setProduct(rs.getString("product"));
item.setQuantity(rs.getDouble("quantity"));
item.setPrice(rs.getDouble("price"));
return item;
}
}
IV) Clique com o botão direito no projeto e escolha New>> Java Class
Vamos criar a classe OrderDao
Nessa Classe iremos extender a classe JdbcDaoSupport do Spring (org.springframework.jdbc.core.support.JdbcDaoSupport).
 |
| Figura 22 - Classe OrderDao package springlesson03.dao |
Conteúdo do arquivo springlesson03.dao.OrderDao.java
package springlesson03.dao;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.util.List;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.core.support.JdbcDaoSupport;
import springlesson03.beans.Order;
import springlesson03.beans.OrderItem;
public class OrderDao extends JdbcDaoSupport {
private JdbcTemplate t;
public OrderDao() {
super();
this.t = getJdbcTemplate();
}
public void save(Order order) {
if (order.getId() == null) {
insert(order);
} else {
update(order);
}
}
public List<OrderItem> getOrdemItens(Integer orderId) {
List<OrderItem> myList = null;
String sqlQuery = "SELECT `tblOrderItem`.`id`, `tblOrderItem`.`orderId`,`tblOrderItem`.`product`,"
+ "`tblOrderItem`.`price`,`tblOrderItem`.`quantity` FROM `springlessons`.`tblOrderItem` "
+ " WHERE orderId = ?";
myList = t.query(sqlQuery, new Object[]{orderId}, new OrderItemRowMapper());
return myList;
}
public List<OrderItem> getOrdemItens(Order order) {
List<OrderItem> myList = null;
String sqlQuery = "SELECT `tblOrderItem`.`id`, `tblOrderItem`.`orderId`,`tblOrderItem`.`product`,"
+ "`tblOrderItem`.`price`,`tblOrderItem`.`quantity` FROM `springlessons`.`tblOrderItem` "
+ " WHERE orderId = ?";
myList = t.query(sqlQuery, new Object[]{order.getId()}, new OrderItemRowMapper());
return myList;
}
private void insert(Order order) {
t = getJdbcTemplate();
String sqlInsert = "INSERT INTO `springlessons`.`tblOrder`"
+ "(`id`,`customer`) VALUES (?,?)";
t.update("INSERT INTO `springlessons`.`tblOrder` (`id`,`customer`) VALUES (?,?)", new Object[]{0, order.getCustomer()});
int orderNo = t.queryForInt("SELECT MAX(id) FROM `springlessons`.`tblOrder`");
for (OrderItem item : order.getItens()) {
String sqlInsertItem = "INSERT INTO `springlessons`.`tblOrderItem` "
+ "(`id`,`orderId`,`product`,`price`,`quantity`) "
+ "VALUES(?,?,?,?,?)";
t.update(sqlInsertItem, new Object[]{0, orderNo, item.getProduct(), item.getPrice(), item.getQuantity()});
}
}
private void update(Order order) {
t = getJdbcTemplate();
throw new UnsupportedOperationException("Not yet implemented");
}
// classe implementada no mesmo arquivo apenas por causa da função getOrdemItens
class OrderRowMapper implements RowMapper {
@Override
public Object mapRow(ResultSet rs, int rowNum) throws SQLException {
Order order = new Order();
order.setId(rs.getInt("id"));
order.setCustomer(rs.getString("customer"));
order.setItens(getOrdemItens(order));
return order;
}
}
public List<Order> getOrdens() {
List<Order> myList = null;
String sqlQuery = "SELECT `tblOrder`.`id`, `tblOrder`.`customer` FROM `springlessons`.`tblOrder`";
myList = t.query(sqlQuery, new OrderRowMapper());
return myList;
}
}
A essa altura seu projeto deve estar assim :
 |
| Figura 23 - Arquivos do projeto |
11 - Vamos ver como fica a implementação disso tudo :
I) Vamos consultar o banco . Edite o arquivo springlesson03.MainClass e adicione o seguinte código:
package springlesson03;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import springlesson03.beans.Order;
import springlesson03.beans.OrderItem;
import springlesson03.dao.OrderDao;
public class MainClass {
public static void main(String args[]) {
// Iniciando a applicação e o gerenciador de contexto do Spring
ApplicationContext ctx = new ClassPathXmlApplicationContext("beans-definitions.xml");
OrderDao dao = (OrderDao) ctx.getBean("orderDao");
// mostrando os registros cadastrados
List<Order> ordens = dao.getOrdens();
System.out.println("Lista Atual");
for (Order or : ordens) {
System.out.println(or.getId() + "-" + or.getCustomer());
List<orderitem> itens = or.getItens();
for (OrderItem it : itens) {
System.out.println("Product:" + it.getProduct() + "\tQuantidade: " + it.getQuantity() + "\tPreco: " + it.getPrice());
}
// System.out.println(or.getItens()) ; //retorna o endereço do bean
System.out.println("----------------------------------------------------------------");
}
}
}
e Clique no Run Project. Observe que dará um erro. |
| Figura 24 - Erro de compilação , não existem registros no banco |
Isso acontece porque ainda não existem registros no banco, neste momento resolvemos isso pondo dentro de um try/catch :
package springlesson03;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import springlesson03.beans.Order;
import springlesson03.beans.OrderItem;
import springlesson03.dao.OrderDao;
public class MainClass {
public static void main(String args[]) {
// Iniciando a applicação e o gerenciador de contexto do Spring
ApplicationContext ctx = new ClassPathXmlApplicationContext("beans-definitions.xml");
OrderDao dao = (OrderDao) ctx.getBean("orderDao");
// mostrando os registros cadastrados
try {
List<Order> ordens = dao.getOrdens();
System.out.println("Lista Atual");
for (Order or : ordens) {
System.out.println(or.getId() + "-" + or.getCustomer());
List<OrderItem> itens = or.getItens();
for (OrderItem it : itens) {
System.out.println("Product:" + it.getProduct() + "\tQuantidade: " + it.getQuantity() + "\tPreco: " + it.getPrice());
}
// System.out.println(or.getItens()) ; //retorna o endereço do bean
System.out.println("----------------------------------------------------------------");
}
} catch (java.lang.NullPointerException npe) {
System.out.println(npe.getMessage());
System.out.println("Ainda não existem registros no Banco");
}
}
}
Clique no Run Project.Observe o resultado BUILD SUCCESSFUL (total time: 2 seconds) |
| Figura 25 - 1ª compilação do projeto com sucesso, ainda não existem registros no banco |
II) Vamos inserir dados no banco . Edite o arquivo springlesson03.MainClass e troque seu conteúdo pelo seguinte código:
package springlesson03;
import java.util.ArrayList;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import springlesson03.beans.Order;
import springlesson03.beans.OrderItem;
import springlesson03.dao.OrderDao;
public class MainClass {
public static void main(String args[]) {
//criando o Objeto Order e atribuindo valores
Order order = new Order();
order.setCustomer("Mario Cezzare");
//criando o Objeto OrderItem e atribuindo valores
OrderItem item = new OrderItem();
item.setProduct("Product 1");
item.setQuantity(2.0);
item.setPrice(14.37);
// criando lista de objetos OrderItem p/ atibuir ao objeto order
//utilizando o método setItens()
List<OrderItem> itensList = new ArrayList<OrderItem>();
itensList.add(item);
order.setItens(itensList);
System.out.println("Inserido");
// Iniciando a applicação e o gerenciador de contexto do Spring
ApplicationContext ctx = new ClassPathXmlApplicationContext("beans-definitions.xml");
OrderDao dao = (OrderDao) ctx.getBean("orderDao");
// salvando nosso objeto order
dao.save(order);
// mostrando os registros cadastrados
try {
List<Order> ordens = dao.getOrdens();
System.out.println("Lista Atual");
// varrendo as ordens
for (Order or : ordens) {
System.out.println(or.getId() + "-" + or.getCustomer());
System.out.println(or.getItens()) ; //retorna o endereço do bean
System.out.println("----------------------------------------------------------------");
}
} catch (java.lang.NullPointerException npe) {
System.out.println(npe.getMessage());
System.out.println("Ainda não existem registros no Banco");
}
}
}
Clique no Run Project.Observe o resultado :Inserido Sep 19, 2012 12:36:12 AM org.springframework.context.support.AbstractApplicationContext prepareRefresh INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@6791d8c1: startup date [Wed Sep 19 00:36:12 BRT 2012]; root of context hierarchy Sep 19, 2012 12:36:12 AM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions INFO: Loading XML bean definitions from class path resource [beans-definitions.xml] Sep 19, 2012 12:36:13 AM org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons INFO: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@250d593e: defining beans [dataSource,jdbcTemplate,orderDao]; root of factory hierarchy Sep 19, 2012 12:36:13 AM org.springframework.jdbc.datasource.DriverManagerDataSource setDriverClassName INFO: Loaded JDBC driver: com.mysql.jdbc.Driver Sep 19, 2012 12:36:14 AM org.springframework.jdbc.datasource.SingleConnectionDataSource initConnection INFO: Established shared JDBC Connection: com.mysql.jdbc.JDBC4Connection@4edc41c5 Lista Atual 13-Mario Cezzare [springlesson03.beans.OrderItem@5d6ea269]
 |
| Figura 26 - 2ª compilação do projeto com sucesso, inseriu o 1º cliente com itens e fez uma consulta |
O registro foi inserido e a lista consultada, porém a linha or.getItens contém um array de itens que precisa ser varrido. Para isso vamos fazer mais um for(){} para o array de OrderItens
III) Vamos alterar novamente o arquivo MainClass.java, dessa vez alteremos o nome do cliente order.setCustomer("Cliente 2") para inserir mais um registro no banco e ver o resultado da consulta :
Conteudo final do arquivo MainClass.java /*
* Tutorial implementação Spring em Java
* Author : Mario Cezzare Angelicola Chiodi mcezzare@gmail.com
* Lição 3
* p/ acompanhar o tutorial veja antes http://mcezzare.blogspot.com.br/2012/09/java-spring-netbeans-72.html
*/
package springlesson03;
import java.util.ArrayList;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import springlesson03.beans.Order;
import springlesson03.beans.OrderItem;
import springlesson03.dao.OrderDao;
public class MainClass {
public static void main(String args[]) {
//criando o Objeto Order e atribuindo valores
Order order = new Order();
// order.setCustomer("Mario Cezzare");
order.setCustomer("Cliente 2");
//criando o Objeto OrderItem e atribuindo valores
OrderItem item = new OrderItem();
item.setProduct("Product 2");
item.setQuantity(1.0);
item.setPrice(10.12);
// criando lista de objetos OrderItem p/ atibuir ao objeto order
//utilizando o método setItens()
List<OrderItem> itensList = new ArrayList<OrderItem>();
itensList.add(item);
order.setItens(itensList);
System.out.println("Inserido");
// Iniciando a applicação e o gerenciador de contexto do Spring
ApplicationContext ctx = new ClassPathXmlApplicationContext("beans-definitions.xml");
OrderDao dao = (OrderDao) ctx.getBean("orderDao");
// salvando nosso objeto order
dao.save(order);
// mostrando os registros cadastrados
try {
List<Order> ordens = dao.getOrdens();
System.out.println("Lista Atual");
// varrendo as ordens
for (Order or : ordens) {
System.out.println(or.getId() + "-" + or.getCustomer());
//varrendo os itens das ordens
List<OrderItem> itens = or.getItens();
for (OrderItem it : itens) {
System.out.println("Product:" + it.getProduct() + "\tQuantidade: " + it.getQuantity() + "\tPreco: " + it.getPrice());
}
// System.out.println(or.getItens()) ; //retorna o endereço do bean
System.out.println("----------------------------------------------------------------");
}
} catch (java.lang.NullPointerException npe) {
System.out.println(npe.getMessage());
System.out.println("Ainda não existem registros no Banco");
}
}
}
Inserido Sep 19, 2012 12:47:53 AM org.springframework.context.support.AbstractApplicationContext prepareRefresh INFO: Refreshing org.springframework.context.support.ClassPathXmlApplicationContext@95c083: startup date [Wed Sep 19 00:47:53 BRT 2012]; root of context hierarchy Sep 19, 2012 12:47:53 AM org.springframework.beans.factory.xml.XmlBeanDefinitionReader loadBeanDefinitions INFO: Loading XML bean definitions from class path resource [beans-definitions.xml] Sep 19, 2012 12:47:54 AM org.springframework.beans.factory.support.DefaultListableBeanFactory preInstantiateSingletons INFO: Pre-instantiating singletons in org.springframework.beans.factory.support.DefaultListableBeanFactory@16ba5c7a: defining beans [dataSource,jdbcTemplate,orderDao]; root of factory hierarchy Sep 19, 2012 12:47:54 AM org.springframework.jdbc.datasource.DriverManagerDataSource setDriverClassName INFO: Loaded JDBC driver: com.mysql.jdbc.Driver Sep 19, 2012 12:47:55 AM org.springframework.jdbc.datasource.SingleConnectionDataSource initConnection INFO: Established shared JDBC Connection: com.mysql.jdbc.JDBC4Connection@1395dd5b Lista Atual 13-Mario Cezzare Product:Product 1 Quantidade: 2.0 Preco: 14.37 ---------------------------------------------------------------- 14-Cliente 2 Product:Product 2 Quantidade: 1.0 Preco: 10.12 ---------------------------------------------------------------- BUILD SUCCESSFUL (total time: 3 seconds)
 |
| Figura 27 - Resultado Final |
E assim concluímos nossa lição 03.
Resumo : o que foi feito ?
- Criamos um banco no Mysql
- Configuramos uma conexão com um banco de dados utilizando jdbc através da classe org.springframework.jdbc.core.JdbcTemplate;
- Utilizamos a classe ApplicationContext p/ gerenciar o contexto de nossa App. Informamos a ela que as definições dos serviços estão em um arquivo XML, através do objeto ClassPathXmlApplicationContext.
- Utilizamos a classe OrderDao extendendo a classe org.springframework.jdbc.core.support.JdbcDaoSupport e implementando a classe org.springframework.jdbc.core.RowMapper e vimos os métodos query e update do objeto JdbcTemplate (org.springframework.jdbc.core.JdbcTemplate).
- Com isso demos carga nos Objetos (Model)
- Aprendemos mais recursos do NetBeans
Download do projeto NB
SpringLesson03
Esse arquivo zip contém :
- O projeto do NB
- o arquivo do MysqlWorkBench p/ sincronizar a criação e manutenção do banco
Se você nunca utilizou o mysqlwb , ao baixar e abrir o arquivo fornecido no zip crie uma nova conexão , clicando em new Connection :
 |
| Figura 28 - Criando uma conexão no MysqlWorkBench |
 |
| Figura 29 - Criando uma conexão no MysqlWorkBench, clique em Store in KeyChain p/ salvar a senha |
 |
| Figura 30 -Clique em Test Connection , o resultado deve ser esse |
Dúvidas, Contribuições, Sugestões? Poste..
Grato,
Até a próxima.
Nenhum comentário:
Postar um comentário