Arquivo de dezembro, 2014

Ruby – Classes – Linux

Publicado: 27 de dezembro de 2014 em Ruby on Rails

Programação orientada a objetos representa o mundo real. Na programação orientada a objetos, implementa-se um conjunto de classes que definem os objetos presentes no sistema de software. Em orientação a objetos, uma classe é uma estrutura que abstrai um conjunto de objetos com características similares. Uma classe define o comportamento de seus objetos através de métodos e os estados possíveis destes objetos através de atributos. Em outros termos, uma classe descreve os serviços providos por seus objetos e quais informações eles podem armazenar.

Porque Usar Classes?

No mundo real, muitas vezes você vai encontrar muitos objetos individuais todos da mesma espécie. Pode haver milhares de outros bebês na existência, todos parecidos. Cada bebê foi construído a partir do mesmo conjunto de projetos(DNA) e, portanto, contém os mesmos componentes. Em termos de orientação a objetos, dizemos que o seu bebê é uma instância da classe de objetos conhecidos como bebê. Uma classe é o modelo a partir do qual objetos individuais são criados. Criando a classe bebê teremos um objeto bebê com seus atributos definidos:

Bebê

Bebê

Classes Ruby

Em Ruby tudo é um objeto, então podemos dizer que tudo tem uma classe, deste modo Ruby possui alguns conceitos diferentes de outras linguagens de programação hibridas como por exemplo C++ e Java. Entretanto uma classe escrita em Ruby também possui os conceitos básicos da linguagem orientada a objeto e possui basicamente 3 partes distintas:

  • A Definição da classe  (Nome da classe: Bebe).
  • Os membros da classe (Atributos da classe: nome, peso, tamanho).
  • Construtor da classe (Método: initialize).
Classe - Bebê

Classe – Bebê

Exemplo:

Neste exemplo criamos uma classe chamada Bebe e criamos um construtor para inicializar os valores para cada bebê que for instanciado, e também utilizamos um recurso que nos permite não inicializar valores na classe simulando um construtor Overload, no qual permite instanciar um objeto Bebe com valores ou sem valores definidos podendo alimenta-los através de métodos ou atributos a qualquer hora.

Ruby

#!/usr/bin/env ruby
# Desenvolvimento Aberto
# Classes.rb

class Bebe

   # Define atributos
   attr_accessor :nome, :peso, :tamanho
   
   # Define construtor da classe (Efeito Overload)
   def initialize (nome = nil, peso=nil, tamanho=nil)
     @nome = nome 
     @peso = peso
     @tamanho = tamanho
   end
  
end

# Cria instância do Bebê construtor defindo
b1 = Bebe.new("Daniel", "3.5", "36")

# Cria instância do Bebê construtor overload
b2 = Bebe.new

# Alimenta valores nos atributos publicos
b2.nome="Sabrina"
b2.peso="2.7"
b2.tamanho="32"

# Imprime Bebês
puts "Bebê 1:", "Nome: " + b1.nome, "Peso: " + b1.peso, "Tamanho: " + b1.tamanho + "cm"

puts "\nBebê 2:", "Nome: " + b2.nome, "Peso: " + b2.peso, "Tamanho: " + b2.tamanho + "cm"
Anúncios

Ruby – Methods – Getter e Setter – Linux

Publicado: 27 de dezembro de 2014 em Ruby on Rails

Métodos em sua forma mais simples são sub-rotinas e podem ser tanto um procedimento ou uma função, geralmente estão associados a um objeto, mas podem ser utilizados independente de estarem ou não dentro de uma classe, isto vai depender exclusivamente do paradigma de programação que você vai escolher programar.

Genericamente falando, métodos alimentam e retornam valores, no entanto existem vários tipos de métodos especialmente no paradigma de programação orientada a objeto, os mais comuns são chamados de Getters e Setter, servem especificamente para retornar e alimentar objetos, especificando ou validando alguma regra de negocio entre seu processo.

Ruby - Métodos - Getter e Setter

Ruby – Métodos – Getter e Setter

Exemplo:

Neste exemplo criamos uma simples variável global que é alimentada através do método Setter e retornada através do método Getter, este tipo de método é comumente visto dentro de classes na programação orientada a objeto.

Ruby

#!/usr/bin/env ruby
# Desenvolvimento Aberto
# Métodos.rb

# Define uma variável global 
$meuvalor = 0
 
# Os metodos mais comuns definem e retornam valores

# Retorna valor da variável global
def getValor()
  return $meuvalor
end

# Alimenta valor na variável global
def setValor(valor)
   $meuvalor = valor
end

# método para alimentar valor
setValor(10)

# método para retornar valor
puts "Meu valor é :", getValor()

O SAP .NET Connector 3.0 é a versão atual do ambiente de desenvolvimento da SAP para a comunicação entre os sistemas da plataforma SAP e Microsoft .NET. Este conector suporta RFCs e serviços Web. Ele permite que você escreva aplicações diferentes, na plataforma Web, Windows Form, ou aplicativos de console. Para baixa-lo você precisa ter um usuário na SAP MarketPlace com direitos de download, entretanto existe um projeto Open Source que estende o SAP Connector e disponibiliza a biblioteca do conector da SAP na versão para computadores x86 e x64 compilados para o Microsoft Framework 4.0.

SAP Oficial: SAP .NET Connector 3.0

SAP Connector Library: https://github.com/ion-sapoval/NSAPConnector/tree/master/Libraries

O que é Remote Function Call (RFC)?

Uma chamada de função remota (RFC) é a chamada ou a execução remota de um módulo de função remoto em um sistema externo. No sistema da SAP, estas funções são fornecidas pelo sistema de interface de RFC. O sistema de interface RFC permite chamadas de função entre dois sistemas SAP, ou entre um sistema SAP e um sistema externo. As transações de dados não se limitam a obtenção de dados a partir do servidor, mas também podem inserir dados em registros do servidor. O sistema SAP pode atuar como um cliente ou um servidor em uma chamada RFC.

SAP - .NET Connector - Exportando Dados

SAP – .NET Connector – Exportando Dados

 Usando o SAP .NET Connector 3.0 no Visual Studio

1 – Após baixar a biblioteca adequada para seu sistema operacional, crie um projeto C# Windows Forms e em suas propriedades mude o Target para que seja compilado na versão 4.0 do framework. Ressaltando que estamos utilizando a versão das dlls baixadas do projeto hospedado no Github no link acima. Adicione as três bibliotecas ao seu projeto e para referencia veja a figura abaixo:

Connector - Referencia - Bibliotecas

Referencia – bibliotecas

2 – No Netweaver abra transação SE16, e verifique o conteúdo da tabela de exemplo chamada SCARR no seu ambiente de desenvolvimento, caso não possua os dados do Netweaver em um ambiente de desenvolvimento, veja como configurar um ambiente DEV (200) e alimentar dados à tabela SCARR nos posts anteriores:

Scarr

Scarr

3 – No Visual Studio crie um design simples utilizando painéis, rótulos, caixas de textos e um botão:

Visual Studio - Design Time

Visual Studio – Design Time

Exemplo:

Neste exemplo utilizamos SAP Connector 3.0 e funções RFC do Netweaver para exportar dados contidos no sistema SAP através de chamadas remotas de uma aplicação escrita em C#.

C#

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using SAP.Middleware.Connector;  // SAP .NET Connector

namespace DASapNetConnector3
{
    public partial class Form1 : Form
    {
        public Form1()
        {
            InitializeComponent();
        }

        private void button1_Click(object sender, EventArgs e)
        {
            // Cria parametros de conexão
            RfcConfigParameters meusap = new RfcConfigParameters();

            // Alimenta parametros SAP Logon
            meusap.Add(RfcConfigParameters.Name, textBox1.Text);
            meusap.Add(RfcConfigParameters.AppServerHost, textBox2.Text);
            meusap.Add(RfcConfigParameters.SystemNumber, textBox3.Text);

            // Alimenta parametros SAP GUI
            meusap.Add(RfcConfigParameters.Client, textBox4.Text);
            meusap.Add(RfcConfigParameters.User, textBox5.Text);
            meusap.Add(RfcConfigParameters.Password, textBox6.Text);

            // Cria destino
            RfcDestination meurfc = RfcDestinationManager.GetDestination(meusap);

            try
            {
                if (meurfc != null)
                {
                    // Verifica conexão
                    meurfc.Ping();
                    label1.Text = "SAP - Conectado com sucesso.";

                    // Lê tabela
                    RfcRepository repo = meurfc.Repository;

                    // Define função de exportação de textos
                    IRfcFunction funcaoRT = repo.CreateFunction("RFC_READ_TABLE");

                    // Define parametros da função
                    funcaoRT.SetValue("query_table", "SCARR");
                    funcaoRT.SetValue("delimiter", "|");

                    // Chama função
                    funcaoRT.Invoke(meurfc);

                    // Recupera Dados cru, você precisa trata-los para
                    // que sejam humanamente legivel
                    IRfcTable tabela = funcaoRT.GetTable("DATA");

                    // Recupera texto
                    string dados = tabela.ToString();

                    // Workaround para limpar tabela
                    // Existem métodos mais eficientes
                    // Este é apenas um caminho rápido para exemplo
                    // Também há possibilidades em diferentes funções e BAPis
                    // Converter um set de dados da função em um set de dados .NET
                    dados = dados.Replace("TABLE  [STRUCTURE TAB512 { FIELD WA=","");
                    dados = dados.Replace("[STRUCTURE TAB512 { FIELD WA=", "");
                    dados = dados.Replace("}]", "\n");

                    // alimenta GUI
                    richTextBox1.AppendText(dados.TrimStart());

               }
            }
            catch (Exception ex)
            {
                // Erro ao conectar
                label1.Text = "SAP - Desconectado";
                MessageBox.Show(ex.ToString(), "Erro",
                                MessageBoxButtons.OK, MessageBoxIcon.Error);
            }
        }
    }
}

Eclipse – GlassFish Tools for Eclipse – Java

Publicado: 23 de dezembro de 2014 em Java

O Glassfish Tools é um conjunto de plug-ins para o Eclipse, que complementa o suporte que existe para o Glassfish Server e tecnologias relacionadas na distribuição padrão Eclipse. Você pode instala-lo facilmente através do Eclipse MaketPlace. As ferramentas para o desenvolvimento de aplicações para GlassFish integram-se com Web Tools no Eclipse e suportam tanto o  GlassFish 4.0 e 3.1. Esses recursos também fazem parte do Oracle Enterprise Pack para Eclipse (OEPE).

Instalando o GlassFish Tools for Eclipse

1 – Abra o Eclipse e no menu Help, escolha Eclipse MarkePlace digite Glassfish e clique em pesquisar, escolha a ferramenta com a versão adequada da sua IDE:

GlassFish - Marketplace

GlassFish – Marketplace

2 – Após a instalação, na aba Server adicione um novo servidor adequado a sua versão:

GlassFish - Server

GlassFish – Server

3 – O Glassfish precisa do Java JDK para poder rodar corretamente, por padrão o Eclipse utiliza o JRE, clique no ícone ao lado da opção de configuração do seu caminho para adicionar uma nova opção, um nova janela irá aparecer, escolha Standard VM e adicione o caminho da instalação do seu JDK:

Java - JDK

Java – JDK

4 – Adicione o local da instalação do Glassfish:

GlassFish - Instalação

GlassFish – Instalação

5 – Escolha o domínio e defina o usuário e  senha para sua instancia, a senha é definida em algumas versões quando você inicia o servidor pela primeira vez, caso sua versão não solicite a mudança de senha, para mudar, após iniciar o servidor abra seu navegador utilizando a porta 4848 e no menu Domain escolha Administrator Password e altere sua senha:

GlassFish - Login

GlassFish – Login

6 – Seu servidor foi criado automaticamente, você pode inicia-lo para testar:

GlassFish Server - OK

GlassFish Server – OK

7 – Agora, crie um novo projeto web dinâmico, atente-se para as configurações do projeto, e o mais IMPORTANTE é não esquecer de definir o arquivo web.xml, para isto clique em próximo duas vezes e marque a opção Generate web.xml deployment descriptor:

GlassFish - Projeto

GlassFish – Projeto

8 – Crie uma nova pagina JSP chamada index.jsp e como você pode ver, diferentemente de outros servidores de aplicação o Glassfish possui a marca registrada da Oracle e lhe proporcionará alguns recursos RAD como um preview para facilitar a criação de sua pagina:

GlassFish - HTML Preview

GlassFish – HTML Preview

9 – Altere sua pagina como no código abaixo e clique em RUN para executar o deploy e rodar sua aplicação:

Glassfish - Web App

Glassfish – Web App

Exemplo:

Neste exemplo vamos criar uma simples pagina JSP para testar a instalação do Glassfish Server:

Java

Hello World Glassfish

<?xml version="1.0" encoding="ISO-8859-1" ?>
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
    pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1" />
<title>Desenvolvimento Aberto</title>
</head>
<body>
<h1>Desenvolvimento Aberto</h1>
<h2>Oracle - GlassFish Open Source Edition 4.1</h2>
<h3>Hello World! GlassFish</h3>
</body>
</html>

O GlassFish é a primeira implementação mundial da plataforma Java Enterprise Edition, sendo referência da plataforma e, como tal, suporta EJB, JPA, JSF, JMS, RMI, JSP, servlets, etc. Isto permite aos desenvolvedores criar aplicativos empresariais que são portáteis e escaláveis, e que se integram com tecnologias legadas . Componentes opcionais também podem ser instalados para serviços adicionais.

O GlassFish é baseado em código fonte liberado pelo sistema de persistência TopLink da Sun e Oracle Corporation. Ele usa um derivado do Apache Tomcat como o contêiner Servlet para servir conteúdo Web, com um componente adicional chamado Grizzly que usa Java New I/O (NIO) para escalabilidade e velocidade.

A versão com suporte é chamado o Oracle GlassFish Server. O GlassFish é um software livre, com regido sob duas licenças de software livre: o Common Development and Distribution License (CDDL) e da Licença Pública Geral GNU (GPL).

Glassfish OpenSource Edition: https://glassfish.java.net/download.html

Oracle Glassfish Server: http://www.oracle.com/technetwork/middleware/glassfish/overview/index.html

Instalando o Glassfish Open Source Edition

Antes de baixar o Glassfish verifique se já não o possui pois ele é instalado através de vários pacotes Java EE, inclusive com o a IDE NetBeans, ele está localizado na pasta arquivos de programas.

1 – Caso não o possua você deve efetuar o download e descompacta-lo na pasta de sua preferencia:

Glassfish - Open Source Edition

Glassfish – Open Source Edition

2 –  O Glassfish roda na porta 8080, caso já possua um servidor rodando nesta mesma porta, você precisa reconfigurar a portar para o glassfish. No diretório de sua instalação glassfish\domains\domain1\config abra o arquivo domain.xml e mude as portas, utilize a imagem abaixo para referencia. Caso não tenha nenhum outro servidor utilizando a porta 8080 ignore este passo:

Glassfish - Porta

Glassfish – Porta

3 – Na pasta glassfish\bin utilize este comando para iniciar o servidor: asadmin start-domain:

Inicia Servidor

Inicia Servidor

4 – Para testar abra o seu navegador e insira o endereço do servidor local com a porta que você definiu:

Glassfish - Localhost:9080

Glassfish – Localhost:9080

Pronto! Seu servidor Glassfish já esta funcionando corretamente, você pode instalar as ferramentas para o Eclipse e criar suas aplicações. Para saber como instalar o Glassfish Tools for Eclipse clique aqui.

Eclipse – JBoss Tools for Eclipse – Java

Publicado: 21 de dezembro de 2014 em Java

O JBoss Tools é um conjunto de plug-ins para o Eclipse, que complementa o suporte que existe para o JBoss e tecnologias relacionadas na distribuição padrão Eclipse. Você pode instala-lo facilmente através do Eclipse MaketPlace.

Instalando o JBoss Tools for Eclipse

1 – Abra o Eclipse e no menu Help, escolha Eclipse MarkePlace digite JBoss e clique em pesquisar, escolha a ferramenta com a versão adequada da sua IDE:

Eclipse MarketPlace

Eclipse MarketPlace

2 – Após a instalação, na aba Server adicione um novo servidor adequado a sua versão:

Novo Servidor

Novo Servidor

3 – A configuração padrão já comtempla um servidor local, clique em próximo:

Servidor Local

Servidor Local

4 – Você deve apontar a pasta que contem a instalação do seu servidor JBoss e a versão do seu JRE:

JBoss - Servidor e JDK

JBoss – Servidor e JRE

5 – Após o servidor ser configurado você pode inicia-lo para testar:

JBoss - Servidor

JBoss – Servidor

6 – Crie um novo projeto dinâmico para Web e atente-se se está utilizando as configurações adequadas para o servidor JBoss, use a imagem abaixa para referencia:

Projeto - Web - JBoss

Projeto – Web – JBoss

7 – Utilize o código abaixo e rode sua aplicação, selecione o servidor JBoss e clique em finish:

Selecione o Servidor

Selecione o Servidor

8 – Pronto sua aplicação web está rodando utilizando o JBoss Enterprise Application  Platform:

Aplicação - JBoss Enterprise Platform

Aplicação – JBoss Enterprise Platform

Para saber mais sobre JBoss Enterprise Application Platform você pode utilizar a documentação oficial:

JBoss EAP: https://access.redhat.com/documentation/en-US/JBoss_Enterprise_Application_Platform/

Exemplo:

Neste exemplo vamos criar um simples Servlet para testar a instalação do JBoss EAP:

Java

Hello World JBoss

package org.desenvolvimento.aberto;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet("/HelloWorldJBoss")
public class HelloWorldJBoss extends HttpServlet {
	private static final long serialVersionUID = 1L;

	public HelloWorldJBoss() {
		super();
	}

	protected void doGet(HttpServletRequest request,
			HttpServletResponse response) throws ServletException, IOException {

		// Cria Página HTML Dinâmica
		response.setContentType("text/html");

		PrintWriter html = response.getWriter();

		html.println("<html>");
		html.println("<body>");
		html.println("<h1>Desenvolvimento Aberto - Java</h1>");
		html.println("<h2>JBoss Application Server Platform</h2>");
		html.println("<h3>Redhat - Instalação: Standalone</h3>");
		html.println("</form>");
		html.println("</body>");
		html.println("</html>");
	}

}

JBoss Enterprise Application Platform – Java

Publicado: 21 de dezembro de 2014 em Java

O JBoss Enterprise Application Platform é uma plataforma de código aberto baseada em Java EE de execução do servidor de aplicativos baseado em assinatura usado para criação, implantação e hospedagem de aplicações e serviços Java altamente transacionais.  O JBoss Enterprise Application Platform é parte do portfólio JBoss Enterprise Middleware de software. Como é baseado em Java, o servidor de aplicações JBoss opera em varias plataformas e pode ser utilizado em qualquer sistema operacional que suporte Java. O JBoss Enterprise Application Platform foi desenvolvido pela JBoss, atualmente uma divisão da Red Hat.

JBoss Enterprise Application Platform: http://jbossas.jboss.org/downloads

Instalando e testando o JBoss EAP

1 – Baixe o JBoss EAP e descompacte-o em uma pasta de sua preferencia:

JBoss - EAP -Download

JBoss – EAP -Download

2 – O JBoss EAP roda na porta 8080, caso já possua um servidor rodando nesta mesma porta, você precisa reconfigurar a portar para o JBoss. No diretório de sua instalação standalone\configuration abra o arquivo standoalone.xml e mude as portas, utilize a imagem abaixo para referencia. Caso não tenha nenhum outro servidor utilizando a porta 8080 ignore este passo:

Reconfigurando porta

Reconfigurando porta

3 – Na pasta bin do seu servidor rode o arquivo standalone.bat através da linha de comando:

JBoss: Instancia StandAlone

JBoss: Instancia StandAlone

4 – Abra o seu navegador e use digite o endereço do servidor local na porta que você configurou:

JBoss - Localhost:5080

JBoss – Localhost:5080

Pronto! Seu servidor JBoss já esta funcionando corretamente, você pode instalar o JBoss Developer Studio ou as ferramentas para o Eclipse e criar suas aplicações. Para saber como instalar o JBoss Tools for Eclipse clique aqui.

O Apache Maven é uma ferramenta de gerenciamento de projetos e compressão indispensável no gerenciamento de projetos de todos os tamanhos. O Maven também torna o trabalho do desenvolvedor muito mais fácil quando você precisa utilizar frameworks e bibliotecas diversas que não estão incluídos por padrão no pacote Java que você utiliza. Para começar a fazer uso dos recursos que o Maven nos proporciona vamos utilizar o framework Hibernate e uma biblioteca de acesso a dados da Oracle para criar uma simples aplicação web com o servidor de aplicação Tomcat.

O que é Hibernate?

O Hibernate é um framework para o mapeamento objeto-relacional escrito na linguagem Java, que facilita o mapeamento dos atributos entre uma base tradicional de dados relacionais e o modelo do objeto de uma aplicação, mediante o uso de arquivos (XML) ou anotações Java.

Hibernate: http://hibernate.org/

Configurando o Eclipse e o Maven para criar uma aplicação Web

Nosso foco principal é mostrar como utilizar o Maven para adicionar dependências e mostrar como funciona os pacotes que o Maven utiliza sem que tenhamos que baixa-los e instala-los e também como configurar o Eclipse para que o Tomcat consiga trabalhar em conjunto com o Maven. Não se preocupe em entender todo o código abaixo pois não focaremos em como utilizar o Hibernate agora, futuramente teremos vários outros posts que o contemplarão.

1 – Crie um projeto Maven com o artefato maven-archetype-webapp e o configure adicionado o servidor Tomcat ao Build Path, caso não saiba como fazer isto veja nosso post anterior sobre como utilizar o Maven e o Tomcat clicando aqui.

  • Com o projeto criado, clique com o botão direito no seu projeto e escolha Maven->Add Dependency.
  • Digite a palavra hibernate e encontre org.hibernate hibernate-core.
  • Expanda e selecione sua ultima versão final.
Hibernate Core

Hibernate Core

2 – Por padrão os downloads estão desabilitados, precisamos habilita-los para podermos utilizar outras dependências. No menu Window->Preferences digite “maven” e posicione o cursor no tópico Maven e marque os tópicos como na figura abaixo e aguarde o download, talvez precise reinicializar o Eclipse:

Maven - Preferencias

Maven – Preferencias

3 – Após o carregamento completo das configurações do Eclipse, continue a adicionar mais dependências, desta vez escolha hibernate-validator:

Hibernate Validator

Hibernate Validator

4 – Em seguida adicione hibernate Entity-manager:

Hibernate Entity Manager

Hibernate Entity Manager

5 – Por ultimo adicione Oracle ojdbc14:

Oracle - ojdbc14

Oracle – ojdbc14

6 – Agora abra seu arquivo chamado pom.xml e constatará que ocorreu um erro ao adicionar o driver da Oracle, isto porque o Maven não consegue baixa-lo. Você precisa de um Login gratuito da Oracle para baixar o driver e precisa instala-lo manualmente no Maven, utilize o link abaixo para baixar o arquivo:

ojdbc14: http://www.oracle.com/technetwork/database/enterprise-edition/jdbc-10201-088211.html

Para instalar utilize a linha de comando abaixo, atente-se as versões no arquivo pom.xml:

mvn install:install-file -DgroupId=com.oracle -DartifactId=ojdbc14  -Dversion=10.2.0.4.0 -Dpackaging=jar -Dfile=ojdbc14.jar -DgeneratePom=true

Use a imagem abaixo para referencia de como instalar a dependência:

Oracle - ojdbc14

Oracle – ojdbc14

Após instalar com sucesso volte ao Eclipse, clique com o botão direito no seu projeto e escolha Maven->Update Project o erro deve desaparecer.

7 – O Tomcat por padrão não consegue utilizar as dependências que o Maven possui, você precisa mudar a configuração. Com o botão direito no seu projeto escolha propriedades e Deployment Assembly:

  • Clique em Add.
  • Escolha Java Build Path Entries.
  • Escolha Maven Dependencies e finalize.
Web Deployment Assembly

Web Deployment Assembly

8 – Crie os arquivos para cada código abaixo e rode sua aplicação utilizando o Hibernate para ler um registro do banco de dados:

Maven - Tomcat - Hibernate - Oracle

Maven – Tomcat – Hibernate – Oracle

Exemplo:

Neste exemplo utilizamos o Maven para localizar as dependências necessárias para nosso projeto sem que precisássemos instala-las manualmente. Crie cada arquivo com seu respectivo tipo, utilize a imagem acima para verificar como fica a arvore do seu projeto. Rode o Servlet chamado HelloWorldHibernate.java.

Oracle

-- Cria tabela de funcionários
create table Funcionarios(
  ID_Funcionario  NUMBER(5),
  Nome            VARCHAR2(30),
  Sobrenome       VARCHAR2(70),
  Cargo           VARCHAR2(30),
  Salario         NUMBER(9,2));

-- Insere dados na tabela
INSERT INTO FUNCIONARIOS VALUES  (10, 'John', 'Lennon', 'Compositor', 1234.55);

XML – hibernate.cfg.xml

<!DOCTYPE hibernate-configuration PUBLIC
        "-//Hibernate/Hibernate Configuration DTD 3.0//EN"
        "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>

<session-factory>
<property name="hibernate.connection.driver_class">oracle.jdbc.driver.OracleDriver</property>
<property name="hibernate.connection.url">jdbc:oracle:thin:@localhost:1521:xe</property>
<property name="hibernate.connection.username">user</property>
<property name="hibernate.connection.password">pass</property>
<property name="hibernate.connection.pool_size">10</property>
<property name="show_sql">true</property>
<property name="hibernate.dialect">org.hibernate.dialect.OracleDialect</property>
<property name="hibernate.current_session_context_class">thread</property>

<mapping class="org.desenvolvimento.aberto.Funcionario" />

</session-factory>
</hibernate-configuration>

Java

Servlet – Hello World Hibernate

package org.desenvolvimento.aberto;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import org.hibernate.Session;

public class HelloWorldHibernate extends HttpServlet {

	private static final long serialVersionUID = 1L;

	public HelloWorldHibernate() {
		super();
	}

	protected void doGet(HttpServletRequest request,
			HttpServletResponse response) throws ServletException, IOException {

		// Abre sessão recuperando a conexão
		Session session = HibernateFactory.getSessionFactory().openSession();

		// Inicia transação
		session.beginTransaction();

		// Cria objeto de negocio
		Funcionario funcionario = new Funcionario();

		// Adiciona sessão ao objeto
		funcionario = (Funcionario) session.load(Funcionario.class, 10);

		// Cria conteudo HTML
		response.setContentType("text/html");

		PrintWriter html = response.getWriter();

		// Retorna valores do objeto
		html.println("<html>");
		html.println("<body>");
		html.println("<h1>Desenvolvimento Aberto</h1>");
		html.println("<h2>Maven - Dependências ADD: Hibernate Framework: </h2>");
		html.println(funcionario.getId() + " - ");
		html.println(funcionario.getNome() + " ");
		html.println(funcionario.getSobrenome() + " - ");
		html.println(funcionario.getCargo() + " - ");
		html.println(funcionario.getSalario());
		html.println("</body>");
		html.println("</html>");

		// Encerra sessão
		session.getTransaction().commit();

	}

}

Hibernate – Session Factory

package org.desenvolvimento.aberto;

import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;

public class HibernateFactory {

	// Cria objeto da sessão
	private static final SessionFactory sessionFactory = buildSessionFactory();

	// Constroi sessão
	private static SessionFactory buildSessionFactory() {
		try {
			// buildSessionFactory não será utilizado em versões superiores
			// Veremos outros métodos para criar um Factory
			// Não é necessário incluir o "hibernate.cfg.xml" no configure()
            // Incluímos somente a nível de fácil entendimento da chamada da configuração.
			// Você pode retirar a chamada.
			return new Configuration().configure("hibernate.cfg.xml").buildSessionFactory();
		} catch (Throwable ex) {
			// Em caso de erro
			System.err.println("Initial SessionFactory creation failed." + ex);
			throw new ExceptionInInitializerError(ex);
		}
	}

	// Retorna Factory da sessão
	public static SessionFactory getSessionFactory() {
		return sessionFactory;
	}

	// Encerra Sessão
	public static void shutdown() {
		getSessionFactory().close();
	}

}

Objeto de negocio – Funcionário

package org.desenvolvimento.aberto;

import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.Id;
import javax.persistence.Table;

// Define Entidade e tabela
@Entity
@Table(name = "funcionarios")
public class Funcionario {

	// Define atributos e decoradores Hibernate como ID e colunas
	@Id
	@GeneratedValue
	@Column(name = "ID_FUNCIONARIO")
	private int id;

	@Column(name = "NOME")
	private String nome;

	@Column(name = "SOBRENOME")
	private String sobrenome;

	@Column(name = "CARGO")
	private String Cargo;

	@Column(name = "SALARIO")
	private double salario;

	// Métodos Getter e Setter
	public long getId() {
		return id;
	}

	public void setId(int id) {
		this.id = id;
	}

	public String getNome() {
		return nome;
	}

	public void setNome(String nome) {
		this.nome = nome;
	}

	public String getSobrenome() {
		return sobrenome;
	}

	public void setSobrenome(String sobrenome) {
		this.sobrenome = sobrenome;
	}

	public String getCargo() {
		return Cargo;
	}

	public void setCargo(String cargo) {
		Cargo = cargo;
	}

	public double getSalario() {
		return salario;
	}

	public void setSalario(double salario) {
		this.salario = salario;
	}

}

No ciência da computação, Data Access Object é um padrão para um objeto que fornece uma interface abstrata para algum tipo de banco de dados ou outro mecanismo de persistência e que permite separar regras de negócio das regras de acesso a banco de dados. A vantagem de usar objetos de acesso a dados é a separação simples e rigorosa entre duas partes importantes de uma aplicação que não devem e não podem conhecer quase que nada uma da outra, e que podem evoluir frequentemente e independentemente.

O DAO implementa o mecanismo de acesso necessário para trabalhar com a fonte de dados. A fonte de dados pode ser um armazenamento persistente como um RDBMS, um serviço externo, como uma troca de B2B, um repositório como um banco de dados LDAP, um serviço de negócios acessado via CORBA, Internet Inter-ORB Protocol (IIOP) ou soquetes de baixo nível. O componente de negócio que se baseia no DAO usa a interface mais simples exposta pelo DAO para seus clientes.

ABAP e DAO

O ABAP Objects possui conceitos comuns com o Java e utilizar o DAO Pattern que é um método padrão já consagrado para separar a camada de negocio da camada do banco de dados facilita muito a legibilidade e organização do código ABAP, visto que o SAP R/3 já comtempla uma arquitetura propicia em três camadas e um ambiente estabelecido onde podemos cortar certos caminhos, tornado simples, fácil e até mesmo divertido criar este tipo de programação, pois na pratica você tem uma classe para o objeto de negocio que contem as regras para cada método do objeto e uma classe para o objeto de dados que é responsável por manipular os dados no banco de dados e negocia-lo com o objeto de transferência que fica responsável pela comunicação com a interface de usuário.

O ABAP possui a vantagem de que não precisamos aplicar o Pattern Factory Method ao DAO, pois o Open SQL já nos possibilita uma função semelhante e podemos utiliza-lo em nosso objeto DAO, a vantagem é que outros desenvolvedores que utilizarão seu código já saberão onde está a regra e onde está a funcionalidade de acesso a dados e também possibilita uma sintaxe simples e homogênea na programação da GUI caso seu programa utilize alguma interface com o usuário

DAO - CRUD - ABAP

DAO – CRUD – ABAP

DAO Pattern

O DAO é um padrão flexível e não uma regra ele é utilizado em conjunto com Factory Pattern e Broker Pattern (veja Patterns relacionados no link abaixo) por isto é comum você encontrar algumas variações de sua implementação, o padrão possui quatro especificações para que possa ser utilizado corretamente elas são: DataAccessObject, DataSourceObject, BussinesObject e TransferObject.

  1. DataAccessObjecté o objeto principal desse padrão. O Data Access Object abstrai a implementação fundamental de acesso a dados para o Business Objects para permitir acesso transparente à fonte de dados.
  2. DataSourceObjectrepresenta uma implementação da fonte de dados. Uma fonte de dados pode ser uma base de dados tal como um RDBMS, repositório XML, e assim por diante.
  3. BussinesObject – o objeto de negócios representa o dados do cliente. É o objeto que requer acesso à fonte de dados para obter e armazenar dados.
  4. TransferObjectrepresenta um objeto de transferência usado como um suporte de dados. O Data Access Object pode usar um objeto de transferência para retornar dados para o cliente. O Data Access Object também pode receber os dados do cliente em um objeto de transferência para atualizar os dados na fonte de dados.

DAO Pattern: http://www.oracle.com/technetwork/java/dataaccessobject-138824.html

CRUD – DAO

CRUD acrónimo de Create, Read, Update e Delete, utiliza as quatro operações básicas  para criação, consulta, atualização e exclusão de dados.

Através do padrão DAO vamos utilizar as operações CRUD para manipular dados no banco de dados. O DAO é um Pattern J2EE, mas como ele separa as regras de negocio do acesso a dados também podemos utiliza-lo com qualquer tipo de interface, seja pela linha de comando, uma GUI desktop ou aplicações web.

Criando um programa ABAP

1 – Crie uma tabela transparente chamada ZFUNCIONARIOS utilizando os elementos de dados e as referencias necessárias aos campos CURR do dicionário de dados ABAP:

Tabela transparente - ZFUNCIONARIOS

Tabela transparente – ZFUNCIONARIOS

2 – Crie um menu e um titulo para o Status 100 com as funções necessárias para os eventos dos botões em seu programa e utilize a imagem abaixo para referencia:

Menu Painter

Menu Painter

3 – Crie uma tela de numero 100 no Screen Painter para seu programa com o seguinte layout:

Screen Painter

Screen Painter

 

Exemplo:

Neste exemplo usamos o Pattern DAO para criar operações CRUD utilizando uma interface gráfica. O DAO torna o código ABAP  mais legível pois separa as classes em objetos distintos e proporciona aos desenvolvedores a utilização de uma sintaxe mais homogênea em seus programas.

O exemplo separa o programa principal do objeto de negocio e do objeto de acesso a dados entretanto colocamos as duas classes DAO em um único include, você pode utiliza-las do modo que achar melhor, como por exemplo utilizando-as como classes globais.

ABAP

GUI – ZDAAPP

*&//---------------------------------------------------------------------*
*&// Report  ZDAAPP
*&//
*&//---------------------------------------------------------------------*
*&// Desenvolvimento Aberto
*&// DAO - DAAPP
*&//---------------------------------------------------------------------*

REPORT  ZDAAPP.

*// Chama include
*// ZFUNCIONARIO é a classe de negocio
*//              você pode incluir qualquer regra
*//              para validação em seus métodos.
*//
*// ZFUNCIONARIODAO é a classe de acesso a dados
*//                 utiliza o OPEN SQL como o
*//                 Pattern Factory Method já
*//                 que ele faz um trabalho equivalente

INCLUDE ZFUNCIONARIO.

*// Define objetos e variáveis
DATA : funcionario     TYPE REF TO ZFUNCIONARIO,
       funcionarioDAO  TYPE REF TO ZFUNCIONARIODAO,
       resultado       TYPE ABAP_BOOL,
       TPESQUISAR      TYPE string,
       TID             TYPE string,
       tnome           TYPE string,
       tsobre          TYPE string,
       tcargo          TYPE string,
       tsalario        TYPE string,
       cid             TYPE i,
       csal            TYPE ZSAL.

START-OF-SELECTION.

*// Cria objetos
  CREATE OBJECT FUNCIONARIO.
  CREATE OBJECT FUNCIONARIODAO.

*// Define eventos clique para os botões
  DATA : OK_CODE    LIKE   SY-UCOMM,
         clique_ok  LIKE   sy-ucomm.

*// chama tela numero 100
  CALL SCREEN 100.

*// Modulo PBO
MODULE STATUS_0100 OUTPUT.

*// Define Menu e titulo do programa
  SET PF-STATUS '100'.
  SET TITLEBAR 'ZDAAPPT'.

*// Limpa evento de clique
 clique_ok = ok_code.
 CLEAR ok_code.

*// verifica ação dos botões
  CASE clique_ok.

    WHEN 'FPESQUISAR'.

      "// Trasferencia de objeto
      FUNCIONARIO = FUNCIONARIODAO->BUSCAFUNCIONARIO( TPESQUISAR ).

      "// Recupera valores e alimenta GUI
      tid = FUNCIONARIO->GETID( ).
      tnome = FUNCIONARIO->GETNOME( ).
      tsobre = FUNCIONARIO->GETSOBRENOME( ).
      tcargo = FUNCIONARIO->GETCARGO( ).
      tsalario = FUNCIONARIO->GETSALARIO( ).

    WHEN 'FNOVO'.

      " Limpa GUI
      clear:
      tid,
      tnome,
      tsobre,
      tcargo,
      tsalario.

    WHEN 'FINSERIR'.

      "// Converte valores para o objeto
      cid = tid.
      csal = tsalario.

      "// Adicona valores ao objeto
      FUNCIONARIO->SETID( cid  ).
      FUNCIONARIO->SETNOME( tnome ).
      FUNCIONARIO->SETSOBRENOME( tsobre ).
      FUNCIONARIO->SETCARGO( tcargo ).
      FUNCIONARIO->SETSALARIO( csal ).

      "// Insere dados no banco
      RESULTADO = FUNCIONARIODAO->INSERIRFUNCIONARIO( FUNCIONARIO ).

      "// Verifica resultados
      IF ( RESULTADO EQ ABAP_TRUE ).
        MESSAGE 'Dados inseridos com sucesso' TYPE 'S'.
      ELSE.
        MESSAGE 'Erro ao inserir dados' TYPE 'E'.
      ENDIF.

*// Os evento subsequentes utilizam a mesma sintaxe do evento acima
*// criando um metodo simples e facil para gravar dados
*// uma vez que você tenha qualquer objeto de negocio
*// e um objeto de acesso a dados.

      WHEN 'FALTERAR'.

      cid = tid.
      csal = tsalario.

      FUNCIONARIO->SETID( cid  ).
      FUNCIONARIO->SETNOME( tnome ).
      FUNCIONARIO->SETSOBRENOME( tsobre ).
      FUNCIONARIO->SETCARGO( tcargo ).
      FUNCIONARIO->SETSALARIO( csal ).

      RESULTADO = FUNCIONARIODAO->ALTERARFUNCIONARIO( FUNCIONARIO ).
      IF ( RESULTADO EQ ABAP_TRUE ).
        MESSAGE 'Dados alterados com sucesso' TYPE 'S'.
      ELSE.
        MESSAGE 'Erro ao inserir dados' TYPE 'E'.
      ENDIF.

      WHEN 'FAPAGAR'.

      cid = tid.
      csal = tsalario.

      FUNCIONARIO->SETID( cid  ).
      FUNCIONARIO->SETNOME( tnome ).
      FUNCIONARIO->SETSOBRENOME( tsobre ).
      FUNCIONARIO->SETCARGO( tcargo ).
      FUNCIONARIO->SETSALARIO( csal ).

      RESULTADO = FUNCIONARIODAO->APAGARFUNCIONARIO( FUNCIONARIO ).
      IF ( RESULTADO EQ ABAP_TRUE ).
        MESSAGE 'Dados apagados com sucesso' TYPE 'S'.
      ELSE.
        MESSAGE 'Erro ao inserir dados' TYPE 'E'.
      ENDIF.

    WHEN 'FSAIR'.
      LEAVE PROGRAM.

  ENDCASE.
ENDMODULE.

Include – Objeto negocio e Objeto dados

*&//---------------------------------------------------------------------*
*&// Desenvolvimento Aberto - DAO
*&// Objeto de Negocio
*&// Objeto de Dados
*&//
*&// Include           ZFUNCIONARIO
*&//---------------------------------------------------------------------*

*// Cria classe Funcionário
class ZFUNCIONARIO definition.

  public section.

*// Declara construtor com efeito Overload
    methods CONSTRUCTOR IMPORTING
               id        TYPE i      OPTIONAL
               nome      TYPE string OPTIONAL
               sobrenome TYPE string OPTIONAL
               cargo     TYPE string OPTIONAL
               salario   TYPE ZSAL    OPTIONAL.

*// Declara métodos Getter e Setter
*// Você pode incluir algumas validações
*// E criar eventos com um método de retorno para a GUI

    methods SETID importing  !ID type i .
    methods GETID returning value(RESULTADO) type i .

    methods SETNOME importing  !NOME type STRING .
    methods GETNOME returning value(RESULTADO) type STRING .

    methods SETSOBRENOME importing  !SOBRENOME type STRING .
    methods GETSOBRENOME returning value(RESULTADO) type STRING .

    methods SETCARGO importing  !CARGO type STRING .
    methods GETCARGO returning value(RESULTADO) type STRING .

    methods SETSALARIO importing  !SALARIO type ZSAL.
    methods GETSALARIO returning value(RESULTADO) TYPE ZSAL.

*// Declara atributos privados
  private section.

    data ID        type i.
    data NOME      type STRING .
    data SOBRENOME type STRING .
    data CARGO     type STRING.
    data SALARIO   type ZSAL .

ENDCLASS.

*// Implementação da classe
CLASS ZFUNCIONARIO IMPLEMENTATION.

*//  Construtor

  METHOD CONSTRUCTOR.
    me->ID = ID.
    me->NOME = NOME.
    me->SOBRENOME = SOBRENOME.
    me->CARGO = CARGO.
    me->SALARIO = SALARIO.
  ENDMETHOD.

*//  Metodos Getter e Setter

  METHOD GETID.
    RESULTADO = me->ID.
  ENDMETHOD.

  METHOD SETID.
    me->ID = ID.
  ENDMETHOD.

  METHOD GETNOME.
    RESULTADO = me->NOME.
  ENDMETHOD.

  METHOD SETNOME.
    me->NOME = NOME.
  ENDMETHOD.

  METHOD GETSOBRENOME.
    RESULTADO = me->SOBRENOME.
  ENDMETHOD.

  METHOD SETSOBRENOME.
    me->SOBRENOME = SOBRENOME.
  ENDMETHOD.

  METHOD GETCARGO.
    RESULTADO = me->CARGO.
  ENDMETHOD.

  METHOD SETCARGO.
    me->CARGO = CARGO.
  ENDMETHOD.

  METHOD GETSALARIO.
    RESULTADO = me->SALARIO.
  ENDMETHOD.

  METHOD SETSALARIO.
    me->SALARIO = SALARIO.
  ENDMETHOD.

ENDCLASS.

*&//---------------------------------------------------------------------*
*&// Desenvolvimento Aberto
*&// DAO - ZFUNCIONARIO DAO
*&//---------------------------------------------------------------------*

CLASS ZFUNCIONARIODAO DEFINITION.

*// Metodos DAO

  PUBLIC SECTION.

    METHODS BUSCAFUNCIONARIO IMPORTING ID TYPE STRING
                 RETURNING VALUE(FUNC) TYPE REF TO ZFUNCIONARIO.

    METHODS INSERIRFUNCIONARIO IMPORTING FUNCIONARIO TYPE REF TO ZFUNCIONARIO
                 RETURNING VALUE(RESULTADO) TYPE ABAP_BOOL.

    METHODS ALTERARFUNCIONARIO IMPORTING FUNCIONARIO TYPE REF TO ZFUNCIONARIO
                 RETURNING VALUE(RESULTADO) TYPE ABAP_BOOL.

    METHODS APAGARFUNCIONARIO IMPORTING FUNCIONARIO TYPE REF TO ZFUNCIONARIO
                 RETURNING VALUE(RESULTADO) TYPE ABAP_BOOL.

ENDCLASS.

CLASS ZFUNCIONARIODAO IMPLEMENTATION.

  METHOD BUSCAFUNCIONARIO.

    "// Cria tabela interna
    DATA tab TYPE ZFUNCIONARIOS.

    "// Cria objeto
    DATA FUNCIONARIO TYPE REF TO ZFUNCIONARIO.
    CREATE OBJECT FUNCIONARIO.

    "// Seleciona dados
    SELECT * INTO tab FROM ZFUNCIONARIOS WHERE ID = ID.
    ENDSELECT.

    "// Alimenta objeto
    FUNCIONARIO->SETID( tab-ID ).
    FUNCIONARIO->SETNOME( tab-NOME ).
    FUNCIONARIO->SETSOBRENOME( tab-SOBRENOME ).
    FUNCIONARIO->SETCARGO( tab-CARGO ).
    FUNCIONARIO->SETSALARIO( tab-SALARIO ).

    "// Transfere objeto
    FUNC = FUNCIONARIO.

  ENDMETHOD.

  METHOD INSERIRFUNCIONARIO.

    "// Cria tabela
    DATA tab TYPE ZFUNCIONARIOS.

    "// Recupe dados do objeto e insere na tabela
    tab-ID = FUNCIONARIO->GETID( ).
    tab-NOME = FUNCIONARIO->GETNOME( ).
    tab-SOBRENOME = FUNCIONARIO->GETSOBRENOME( ).
    tab-CARGO = FUNCIONARIO->GETCARGO( ).
    tab-SALARIO = FUNCIONARIO->GETSALARIO( ).

    "// Insere dados na tabela transparente
    INSERT INTO ZFUNCIONARIOS VALUES tab.
    IF SY-SUBRC = 0.
      RESULTADO = ABAP_TRUE.
    ELSE.
      RESULTADO = ABAP_FALSE.
    ENDIF.

  ENDMETHOD.

  METHOD ALTERARFUNCIONARIO.

    "// Cria tabela
    DATA tab TYPE ZFUNCIONARIOS.

    "// Recupe dados do objeto e insere na tabela
    tab-ID = FUNCIONARIO->GETID( ).
    tab-NOME = FUNCIONARIO->GETNOME( ).
    tab-SOBRENOME = FUNCIONARIO->GETSOBRENOME( ).
    tab-CARGO = FUNCIONARIO->GETCARGO( ).
    tab-SALARIO = FUNCIONARIO->GETSALARIO( ).

    "// Altera dados na tabela transparente
    UPDATE ZFUNCIONARIOS
       SET NOME = tab-NOME
           SOBRENOME = tab-SOBRENOME
           CARGO = tab-CARGO
           SALARIO = tab-SALARIO
           WHERE ID = tab-ID.
    IF SY-SUBRC = 0.
      RESULTADO = ABAP_TRUE.
    ELSE.
      RESULTADO = ABAP_FALSE.
    ENDIF.

  ENDMETHOD.

  METHOD APAGARFUNCIONARIO.

    "// Cria tabela
    DATA tab TYPE ZFUNCIONARIOS.

    "// Recupera ID do objeto
    tab-ID = FUNCIONARIO->GETID( ).

    "// Deleta dados da tabela transparente
    DELETE FROM ZFUNCIONARIOS
           WHERE ID = tab-ID.
    IF SY-SUBRC = 0.
      RESULTADO = ABAP_TRUE.
    ELSE.
      RESULTADO = ABAP_FALSE.
    ENDIF.

  ENDMETHOD.

ENDCLASS.

No ciência da computação, Data Access Object é um padrão para um objeto que fornece uma interface abstrata para algum tipo de banco de dados ou outro mecanismo de persistência e que permite separar regras de negócio das regras de acesso a banco de dados. A vantagem de usar objetos de acesso a dados é a separação simples e rigorosa entre duas partes importantes de uma aplicação que não devem e não podem conhecer quase que nada uma da outra, e que podem evoluir frequentemente e independentemente.

O DAO implementa o mecanismo de acesso necessário para trabalhar com a fonte de dados. A fonte de dados pode ser um armazenamento persistente como um RDBMS, um serviço externo, como uma troca de B2B, um repositório como um banco de dados LDAP, um serviço de negócios acessado via CORBA, Internet Inter-ORB Protocol (IIOP) ou soquetes de baixo nível. O componente de negócio que se baseia no DAO usa a interface mais simples exposta pelo DAO para seus clientes.

Microsoft, C++ e DAO

O DAO Pattern J2EE não deve ser confundido com o DAO método de acesso a dados da Microsoft . O DAO (Microsoftfornece um quadro para a utilização de código para criar e manipular bancos de dados através de um conjunto hierárquico de objetos que usam o mecanismo de banco de dados Microsoft Jet para arquivos MDB, ou através de ODBC ou também banco de dados IASM como o antigo DBase, Paradox entre outros. O DAO Microsoft também é suportado em C++ através das classes de fundação da Microsoft (MFC).

Devido algumas similaridades do C++ com o Java é possível utilizar integralmente o DAO Pattern que é um padrão já consagrado por desenvolvedores Java para separar a camada de negocio da camada do banco de dados. O DAO é um célebre Pattern utilizado sozinho ou também em conjunto com outros frameworks, provavelmente alguns desenvolvedores C++ já o utilizaram de algum modo, implicitamente ou explicitamente, mesmo sem o conhecer em detalhes.

C++ - MFC - DAO

C++ – MFC – DAO

DAO Pattern

O DAO é um padrão flexível e não uma regra ele é utilizado em conjunto com Factory Pattern e Broker Pattern (veja Patterns relacionados no link abaixo) por isto é comum você encontrar algumas variações de sua implementação, o padrão possui quatro especificações para que possa ser utilizado corretamente elas são: DataAccessObject, DataSourceObject, BussinesObject e TransferObject.

  1. DataAccessObjecté o objeto principal desse padrão. O Data Access Object abstrai a implementação fundamental de acesso a dados para o Business Objects para permitir acesso transparente à fonte de dados.
  2. DataSourceObjectrepresenta uma implementação da fonte de dados. Uma fonte de dados pode ser uma base de dados tal como um RDBMS, repositório XML, e assim por diante.
  3. BussinesObject – o objeto de negócios representa o dados do cliente. É o objeto que requer acesso à fonte de dados para obter e armazenar dados.
  4. TransferObjectrepresenta um objeto de transferência usado como um suporte de dados. O Data Access Object pode usar um objeto de transferência para retornar dados para o cliente. O Data Access Object também pode receber os dados do cliente em um objeto de transferência para atualizar os dados na fonte de dados.

DAO Pattern: http://www.oracle.com/technetwork/java/dataaccessobject-138824.html

CRUD – DAO

CRUD acrónimo de Create, Read, Update e Delete, utiliza as quatro operações básicas  para criação, consulta, atualização e exclusão de dados.

Através do padrão DAO vamos utilizar as operações CRUD para manipular dados no banco de dados. O DAO é um Pattern J2EE, mas como ele separa as regras de negocio do acesso a dados também podemos utiliza-lo com qualquer tipo de interface, seja pela linha de comando, uma GUI desktop ou aplicações web.

Para usar o DAO você utiliza o Factory Pattern para criar uma abstração para o acesso a dados e uma classe concreta para seu tipo de acesso como por exemplo OracleDAOFactory, DB2DAOFactory e assim por diante. Então você pode criar a interface para seu objeto DAO chamada DAOFuncionario e a partir da interface você pode criar as classes DAO como, DAOFuncionarioOracle, DAOFuncionarioDB2 e utiliza o objeto de transferência para manipular dados.

Neste exemplo não criamos uma classe abstrata utilizando o Pattern Factory Method, cortamos caminho pois utilizamos apenas um objeto DAO para todos os bancos de dados, mas caso deseje criar uma abstração para classes concretas para cada banco de dados siga a especificação oficial do DAO Pattern no link logo acima.

Visual Studio - Design

Visual Studio – Design

Utilize a imagem acima para criar um design parecido.

Exemplo:

Neste exemplo usamos o Pattern DAO para criar operações CRUD utilizando uma interface gráfica, como este exemplo não possuí uma tela de login mude o acesso ao banco e usuário e senha diretamente na classe FuncionarioDAO.

O DAO  pode ser utilizado para varias soluções como no exemplo abaixo para enfatizar sua eficiência utilizamos o DAO em uma interface gráfica escrita com MFC justamente para mostrar a independência do negocio e acesso a dados.

Este é o terceiro método que disponibilizamos para manipular dados através de um banco de dados, para ver este mesmo programa utilizando SQL direto da aplicação clique aqui.

Pare ver este programa usando objetos no banco de dados como Views e Triggers clique aqui ou procure na busca também por Stored Procedures e cursores.

Ainda veremos outros métodos para manipular dados através de frameworks específicos.

SQL

Oracle

-- Cria tabela de funcionarios
create table Funcionarios(
  ID_Funcionario  NUMBER(5),
  Nome            VARCHAR2(30),
  Sobrenome       VARCHAR2(70),
  Cargo           VARCHAR2(30),
  Salario         NUMBER(9,2));

DB2

-- Cria tabela de funcionarios
create table Funcionarios (
    ID_Funcionario  INTEGER,
    Nome            VARCHAR(30),
    Sobrenome       VARCHAR(70),
    Cargo           VARCHAR(30),
    Salario         NUMERIC(9,2));

MSSQL

-- Cria tabela de funcionarios
create table Funcionarios (
   ID_Funcionario  Int,
   Nome            VARCHAR(30),
   Sobrenome       VARCHAR(70),
   Cargo           VARCHAR(30),
   Salario         Decimal(9,2));

C++

Objeto – Negócio

Header

#pragma once

class Funcionario
{

private:
	// Atributos
	long id;
	CString nome;
	CString sobrenome;
	CString cargo;
	double  salario;

public:

	// Construtor
	Funcionario();
	~Funcionario();

	// Construtor Overload
	Funcionario(long id, CString nome, CString sobrenome, CString cargo, double salario);

	// Metodos Getter e Setter
	void setId(long id);
	long getId();

	void setNome(CString nome);
	CString getNome();

	void setSobrenome(CString sobrenome);
	CString getSobrenome();

	void setCargo(CString cargo);
	CString getCargo();

	void setSalario(double salario);
	double getSalario();

};

Cpp

#include "stdafx.h"
#include "Funcionario.h"

// Implementação da classe Funcionarios

Funcionario::Funcionario()
{
}

Funcionario::~Funcionario()
{
}

// Construtor Overload
Funcionario::Funcionario(long id, CString nome, CString sobrenome, CString cargo, double salario)
{
	this->id = id;
	this->nome = nome;
	this->sobrenome = sobrenome;
	this->cargo = cargo;
	this->salario = salario;
}

// Getters e Setters
void Funcionario::setId(long id)
{
	this->id = id;
}

long Funcionario::getId()
{
	return this->id;
}

void Funcionario::setNome(CString nome)
{
	this->nome = nome;
}

CString Funcionario::getNome()
{
	return this->nome;
}

void Funcionario::setSobrenome(CString sobrenome)
{
	this->sobrenome = sobrenome;
}

CString Funcionario::getSobrenome()
{
	return this->sobrenome;
}

void Funcionario::setCargo(CString cargo)
{
	this->cargo = cargo;
}

CString Funcionario::getCargo()
{
	return this->cargo;
}

void Funcionario::setSalario(double salario)
{
	this->salario = salario;
}

double Funcionario::getSalario()
{
	return this->salario;
}

Factory Pattern – DAConexaoFactory

Header

#pragma once

// Inclui classe de banco de dados MFC
#include "afxdb.h"

class DAConexaoFactory
{
private:

	// Define constantes para fonte de dados
	const int ORACLE = 1;
	const int DB2 = 2;
	const int MSSQL = 3;

	// Define dados do usuario
	CString dns, usuario, senha;

	// Define banco de dados

public:

	DAConexaoFactory();
	~DAConexaoFactory();

	CString getConexao(int banco);
};

Cpp

#include "stdafx.h"
#include "DAConexaoFactory.h"

DAConexaoFactory::DAConexaoFactory()
{
}

DAConexaoFactory::~DAConexaoFactory()
{
}

CString DAConexaoFactory::getConexao(int banco)
{

	// Define banco de dados
	if (banco == ORACLE)
	{
		dns = L"OracleXE";
		usuario = L"user";
		senha = L"pass";
	}

	if (banco == DB2)
	{
		dns = L"IBMDB2";
		usuario = L"user";
		senha = L"pass";
	}

	if (banco == MSSQL)
	{
		dns = L"MSSQLSERVER";
		usuario = L"user";
		senha = L"pass";
	}

	// Cria string de conexão ODBC
	CString conexao;

	// Cria string de conexão
	conexao = L"DSN=" + dns + L";UID=" + usuario + L";PWD=" + senha;

	// Abre conexão

	return  conexao;
}

Objeto DAO – FuncionarioDAO

Header

#pragma once

#include "afxdb.h"
#include "IDaoFuncionario.h"

class FuncionarioDAO
{

private:
	// Define objetos
	CDatabase conn;
	CString erro;
	TCHAR menssagem[255];

public:	

	FuncionarioDAO();
	~FuncionarioDAO();

	// Metodos DAO

	Funcionario buscaFuncionario(CString id);

	bool insereFuncionario(Funcionario& funcionario);

	bool alterarFuncionario(Funcionario& funcionario);

	bool deletarFuncionario(Funcionario& funcionario);

	CString getErro();

};

Cpp

#include "stdafx.h"
#include "FuncionarioDAO.h"
#include "DAConexaoFactory.h"

FuncionarioDAO::FuncionarioDAO()
{
	DAConexaoFactory conexao = DAConexaoFactory();
	conn.OpenEx(conexao.getConexao(1), 0);

}

FuncionarioDAO::~FuncionarioDAO()
{
}

Funcionario FuncionarioDAO::buscaFuncionario(CString id)
{
	// Cria objeto de negocio
	Funcionario funcionario = Funcionario();
	CString m_conteudo;

	try
	{
		// Define Set de dados
		CRecordset dados(&conn);

		// Executa SQL
		dados.Open(CRecordset::forwardOnly,
			L"Select * From Funcionarios Where  ID_FUNCIONARIO = " + id);

		// carrega dados no objeto
		dados.GetFieldValue(L"ID_FUNCIONARIO", m_conteudo);
		funcionario.setId(_wtoi(m_conteudo));
		dados.GetFieldValue(L"NOME", m_conteudo);
		funcionario.setNome(m_conteudo);
		dados.GetFieldValue(L"SOBRENOME", m_conteudo);
		funcionario.setSobrenome(m_conteudo);
		dados.GetFieldValue(L"CARGO", m_conteudo);
		funcionario.setCargo(m_conteudo);
		dados.GetFieldValue(L"SALARIO", m_conteudo);
		m_conteudo.Replace(_T(","), _T("."));
		funcionario.setSalario(_wtof(m_conteudo));

		dados.Close();
	}
	catch (CDBException* ex )
	{
		// Define erro
		ex->GetErrorMessage(menssagem, 255);
	    erro += menssagem ;
	}

	// Retorna objeto
	return funcionario;
}

bool FuncionarioDAO::insereFuncionario(Funcionario& funcionario)
{
	// Define variaveis
	CString m_id;
	CString m_salario;

	// Formata valores
	long id = funcionario.getId();
	m_id.Format(_T("%ld"), id);

	double salario = funcionario.getSalario();
    m_salario.Format(_T("%g"), salario);

	// Cria instrução SQL
	CString sql = L"Insert into  Funcionarios  values ( " + m_id + ", " +
		"'" + funcionario.getNome() + "', " +
		"'" + funcionario.getSobrenome() + "', " +
		"'" + funcionario.getCargo() + "', " +
		m_salario + ")";

	try
	{
		// Executa SQL
		conn.ExecuteSQL(sql);
		return true;
	}
	catch (CDBException* ex)
	{
		// Define erro
		ex->GetErrorMessage(menssagem, 255);
		erro += menssagem;
		return false;
	}

}

bool FuncionarioDAO::alterarFuncionario(Funcionario& funcionario)
{
	// Define variaveis
	CString m_id;
	CString m_salario;

	// Define valores
	long id = funcionario.getId();
	m_id.Format(_T("%ld"), id);

	double salario = funcionario.getSalario();
	m_salario.Format(_T("%g"), salario);

	// Cria instrução SQL
	CString sql = L"Update  Funcionarios  set ID_FUNCIONARIO = " + m_id + ", " +
		" NOME= '" + funcionario.getNome() + "', " +
		" SOBRENOME= '" + funcionario.getSobrenome() + "', " +
		" CARGO = '" + funcionario.getCargo() +
		" ', SALARIO = " + 	m_salario +
		" WHERE ID_FUNCIONARIO = " + m_id ;

	try
	{
		// Executa SQL
		conn.ExecuteSQL(sql);
		return true;
	}
	catch (CDBException* ex)
	{
		// Define erro
		ex->GetErrorMessage(menssagem, 255);
		erro += menssagem;
		return false;
	}

}

bool FuncionarioDAO::deletarFuncionario(Funcionario& funcionario)
{
	// Define variaveis
	CString m_id;

	// Define valores
	long id = funcionario.getId();
	m_id.Format(_T("%ld"), id);

	// Cria instrução SQL
	CString sql = L"Delete from  Funcionarios WHERE ID_FUNCIONARIO = " + m_id;

	try
	{
		// Executa SQL
		conn.ExecuteSQL(sql);
		return true;
	}
	catch (CDBException* ex)
	{
		// Define Erro
		ex->GetErrorMessage(menssagem, 255);
		erro += menssagem;
		return false;
	}
}

CString FuncionarioDAO::getErro()
{
	// Retorna Erro
	return erro;
}

GUI – DADaoApp

Header


// CamposcppDlg.h : header file
//

#pragma once

#include "afxwin.h"

// CCamposcppDlg dialog
class CCamposcppDlg : public CDialogEx
{

public:
	CCamposcppDlg(CWnd* pParent = NULL);	// standard constructor

// Dialog Data
	enum { IDD = IDD_CAMPOSCPP_DIALOG };

	protected:
	virtual void DoDataExchange(CDataExchange* pDX);	// DDX/DDV support

// Implementation
protected:
	HICON m_hIcon;

	// Generated message map functions
	virtual BOOL OnInitDialog();
	afx_msg void OnPaint();
	afx_msg HCURSOR OnQueryDragIcon();
	DECLARE_MESSAGE_MAP()

public:

	// Variaveis Edits
	CEdit m_pesquisa;
	CEdit m_codigo;
	CEdit m_pnome;
	CEdit m_snome;
	CEdit m_cargo;
	CEdit m_salario;

	// Variaveis Botões
	CButton m_apagar;
	CButton m_novo;

	// Eventos
	afx_msg void OnShowWindow(BOOL bShow, UINT nStatus);
	afx_msg void OnBnClickedButton1();
	afx_msg void OnBnClickedButton2();
	afx_msg void OnBnClickedButton3();
	afx_msg void OnBnClickedButton4();
	afx_msg void OnBnClickedButton5();

private:

	// Campos
	CString codigo;
	CString pnome;
	CString snome;
	CString cargo;
	CString salario;

};

Cpp


// CamposcppDlg.cpp : implementation file
//

#include "stdafx.h"
#include "afxwin.h"
#include "Camposcpp.h"
#include "CamposcppDlg.h"
#include "afxdialogex.h"
#include "Funcionario.h"
#include "FuncionarioDAO.h"

#ifdef _DEBUG
#define new DEBUG_NEW
#endif

CCamposcppDlg::CCamposcppDlg(CWnd* pParent /*=NULL*/)
	: CDialogEx(CCamposcppDlg::IDD, pParent)
{
	m_hIcon = AfxGetApp()->LoadIcon(IDR_MAINFRAME);
}

void CCamposcppDlg::DoDataExchange(CDataExchange* pDX)
{
	CDialogEx::DoDataExchange(pDX);
	DDX_Control(pDX, IDC_EDIT6, m_pesquisa);
	DDX_Control(pDX, IDC_EDIT1, m_codigo);
	DDX_Control(pDX, IDC_EDIT2, m_pnome);
	DDX_Control(pDX, IDC_EDIT3, m_snome);
	DDX_Control(pDX, IDC_EDIT4, m_cargo);
	DDX_Control(pDX, IDC_EDIT5, m_salario);
	DDX_Control(pDX, IDC_BUTTON5, m_apagar);
	DDX_Control(pDX, IDC_BUTTON2, m_novo);

}

BEGIN_MESSAGE_MAP(CCamposcppDlg, CDialogEx)
	ON_WM_PAINT()
	ON_WM_QUERYDRAGICON()
	ON_BN_CLICKED(IDC_BUTTON1, &CCamposcppDlg::OnBnClickedButton1)
	ON_BN_CLICKED(IDC_BUTTON2, &CCamposcppDlg::OnBnClickedButton2)

ON_WM_SHOWWINDOW()
ON_BN_CLICKED(IDC_BUTTON3, &CCamposcppDlg::OnBnClickedButton3)
ON_BN_CLICKED(IDC_BUTTON4, &CCamposcppDlg::OnBnClickedButton4)
ON_BN_CLICKED(IDC_BUTTON5, &CCamposcppDlg::OnBnClickedButton5)
ON_WM_CTLCOLOR()
END_MESSAGE_MAP()

BOOL CCamposcppDlg::OnInitDialog()
{
	CDialogEx::OnInitDialog();

	SetIcon(m_hIcon, TRUE);
	SetIcon(m_hIcon, FALSE);
	return TRUE;
}

void CCamposcppDlg::OnPaint()
{
	if (IsIconic())
	{
		CPaintDC dc(this); 

		SendMessage(WM_ICONERASEBKGND, reinterpret_cast<WPARAM>(dc.GetSafeHdc()), 0);

		int cxIcon = GetSystemMetrics(SM_CXICON);
		int cyIcon = GetSystemMetrics(SM_CYICON);
		CRect rect;
		GetClientRect(&rect);
		int x = (rect.Width() - cxIcon + 1) / 2;
		int y = (rect.Height() - cyIcon + 1) / 2;

		dc.DrawIcon(x, y, m_hIcon);
	}
	else
	{
		CDialogEx::OnPaint();
	}
}

HCURSOR CCamposcppDlg::OnQueryDragIcon()
{
	return static_cast<HCURSOR>(m_hIcon);
}

// ************************         Desenvolvimento Aberto
// Nosso código começa aqui

void CCamposcppDlg::OnBnClickedButton1()
{
	// Referincia objeto statico
	CWnd * p_rotulo;

	// Associa objeto statico
	p_rotulo = GetDlgItem(IDC_Rotulo);
	p_rotulo->SetWindowTextW(L"DAO - Pattern");

	// Define variaveis
	CString codigo;

	// Cria objetos DAO
	Funcionario funcionario = Funcionario();
	FuncionarioDAO pesquisar = FuncionarioDAO();

	// Cria pesquisa
	m_pesquisa.GetWindowTextW(codigo);

	// Busca objeto
	funcionario = pesquisar.buscaFuncionario(codigo);

	// recupera dados do objeto e transfere para a GUI
	CString m_conteudo;
	long m_id = funcionario.getId();
	m_conteudo.Format(_T("%ld"), m_id);

	m_codigo.SetWindowTextW(m_conteudo);
	m_pnome.SetWindowTextW(funcionario.getNome());
	m_snome.SetWindowTextW(funcionario.getSobrenome());
	m_cargo.SetWindowTextW(funcionario.getCargo());

	double m_sal = funcionario.getSalario();
	m_conteudo.Format(_T("%g"), m_sal);
	m_salario.SetWindowTextW(m_conteudo);
}

void CCamposcppDlg::OnBnClickedButton2()
{
	// Limpa componentes
	m_codigo.SetWindowTextW(NULL);
	m_pnome.SetWindowTextW(NULL);
	m_snome.SetWindowTextW(NULL);
	m_cargo.SetWindowTextW(NULL);
	m_salario.SetWindowTextW(NULL);

	// Define foco
	CEdit* pesquisa;
	pesquisa = (CEdit*)GetDlgItem(IDC_EDIT1);
	GotoDlgCtrl(pesquisa);
}

void CCamposcppDlg::OnShowWindow(BOOL bShow, UINT nStatus)
{
	CDialogEx::OnShowWindow(bShow, nStatus);

	// Define foco inicial
	CEdit* pesquisa;
	pesquisa = (CEdit*)GetDlgItem(IDC_EDIT6);
	GotoDlgCtrl(pesquisa);
}

// Clique do botão inserir
void CCamposcppDlg::OnBnClickedButton3()
{
	// Recupara texto dos componentes
	m_codigo.GetWindowTextW(codigo);
	m_pnome.GetWindowTextW(pnome);
	m_snome.GetWindowTextW(snome);
	m_cargo.GetWindowTextW(cargo);
	m_salario.GetWindowTextW(salario);

	// Troca ponto decimal para o banco de dados
	int i = salario.Replace(L",", L".");

	// Cria objetos DAO
	Funcionario funcionario = Funcionario();
	FuncionarioDAO inserir = FuncionarioDAO();

	// Alimenta dados ao objeto
	funcionario.setId(_wtoi(codigo));
	funcionario.setNome(pnome);
	funcionario.setSobrenome(snome);
	funcionario.setCargo(cargo);
	funcionario.setSalario(_wtof(salario));

	// Verifica resultado
	bool resultado = inserir.insereFuncionario(funcionario);

	if (resultado)
	{
		AfxMessageBox(L"Dados inseridos com sucesso!");
	}
	else
	{
		AfxMessageBox(inserir.getErro());
	}	

}

// botão Updata
void CCamposcppDlg::OnBnClickedButton4()
{
	// Recupara texto dos componentes
	m_codigo.GetWindowTextW(codigo);
	m_pnome.GetWindowTextW(pnome);
	m_snome.GetWindowTextW(snome);
	m_cargo.GetWindowTextW(cargo);
	m_salario.GetWindowTextW(salario);

	// Troca ponto decimal para o banco de dados
	int i = salario.Replace(L",", L".");

	// Cria objetos DAO
	Funcionario funcionario = Funcionario();
	FuncionarioDAO alterar = FuncionarioDAO();

	// Alimenta dados no objeto
	funcionario.setId(_wtoi(codigo));
	funcionario.setNome(pnome);
	funcionario.setSobrenome(snome);
	funcionario.setCargo(cargo);
	funcionario.setSalario(_wtof(salario));

	// Altera objeto
	bool resultado = alterar.alterarFuncionario(funcionario);

	// Verifica resultado
	if (resultado)
	{
		AfxMessageBox(L"Dados alterados com sucesso!");
	}
	else
	{
		AfxMessageBox(alterar.getErro());
	}
}

void CCamposcppDlg::OnBnClickedButton5()
{
	// Recupera dados da GUI
	m_codigo.GetWindowTextW(codigo);
	m_pnome.GetWindowTextW(pnome);
	m_snome.GetWindowTextW(snome);
	m_cargo.GetWindowTextW(cargo);
	m_salario.GetWindowTextW(salario);

	// Troca ponto decimal para o banco de dados
	int i = salario.Replace(L",", L".");

	// Cria objetos DAO
	Funcionario funcionario = Funcionario();
	FuncionarioDAO apagar = FuncionarioDAO();

	// Alimenta dados ao objeto
	funcionario.setId(_wtoi(codigo));
	funcionario.setNome(pnome);
	funcionario.setSobrenome(snome);
	funcionario.setCargo(cargo);
	funcionario.setSalario(_wtof(salario));

	// Apaga objeto
	bool resultado = apagar.deletarFuncionario(funcionario);

	// Verifica resultado
	if (resultado)
	{
		AfxMessageBox(L"Dados apagados com sucesso!");
	}
	else
	{
		AfxMessageBox(apagar.getErro());
	}
}