Instalando e configurando o PostgreSQL

Instalando e configurando o PostgreSQL

Isaac
25-10-2010
Neste tutorial ensinarei como instalar e configurar de maneira simples o PostgreSQL. A instalação será feita a partir do código-fonte, sem levar em conta o pacote que pode ser distribuído pelo repositório de seu Linux.
Por: Isaac

Lembrando que se trata de uma configuração básica, porém funcional.

Antes da mais nada precisamos baixar o postgresql-8.1.9, podemos encontrá-lo em:
http://www.postgresql.org/ftp/source/v8.1.9/

Escolha o postgresql-8.1.9.tar.bz2. Em seguida selecione o "mirror" de onde você quer baixar. Se o mirror escolhido não funcionar, selecione outro.
Caso tenha baixado na área de trabalho e não sabe como chegar até lá, digite:
# cd /home/usuário/Desktop/
Troque a palavra "usuário" pelo nome de seu usuário.
Agora precisamos descompactá-lo:
Para descompactar digite no diretório onde você o baixou:
# tar -jxvf postgresql-8.1.9.tar.bz2
Entre na pasta do PostgreSQL.
Para entrar digite:
# cd postgresql-8.1.9
Agora vamos compilar e instalar o PostgreSQL.
Digite:
# ./configure --prefix=/usr/local/pgsql
Depois digite:
# make
E por último digite:
# make install
Pronto, o PostgreSQL está instalado, vamos agora para a parte de configuração, que é um pouco mais chata. =)
Precisamos criar um usuário para o PostgreSQL, digite:
# useradd postgres
Agora precisamos criar uma senha para este usuário, digite:
# passwd postgres
Digite uma senha e pressione "Enter", depois repita a senha.
Se você digitou a senha corretamente aparecerá um frase parecida com essa:
passwd: all authentication tokens updated successfully.
Agora vamos criar o diretório onde ficará os bancos de dados criados, digite:
# mkdir /usr/local/pgsql/data
Precisamos agora alterar o "dono" da pasta "data", digite:
# chown postgres /usr/local/pgsql/data
Pronto!
Agora vamos entrar com o usuário "postgres" que criamos para o PostgreSQL, digite:
# su - postgres
E depois digite a senha que você criou para este usuário.
Agora vamos inicializar o PostgreSQL, digite:
$ /usr/local/pgsql/bin/initdb -D /usr/local/pgsql/data
Se tudo ocorrer bem, o PostgreSQL vai mostrar na tela dois comandos para iniciar o "postmaster", não inicie ainda, vou explicar mais ou menos a diferença entre os dois comandos:

O comando "/usr/local/pgsql/bin/postmaster -D /usr/local/pgsql/data" faz com que o postmaster seja iniciado, mas esta janela vai ficar emitindo os logs do PostgreSQL, ou seja, as seguintes linhas irão aparecer na tela:

LOG: database system was shut down at 2007-08-10 10:16:21 BRT
LOG: checkpoint record is at 0/8C5104[/td][/tr][/table]
LOG: redo record is at 0/8C5104; undo record is at 0/0; shutdown TRUE
LOG: next transaction ID: 22896; next OID: 27828
LOG: next MultiXactId: 1; next MultiXactOffset: 0
LOG: database system is ready
LOG: transaction ID wrap limit is 2147484146, limited by database "postgres"

E esta janela ficará em uso mostrando os logs.

E o outro comando faz com que o postmaster se inicie, mas esta janela não fica em uso e os logs são armazenados em um arquivo.

A primeira opção é boa para você ficar monitorando os logs em tempo real.

Agora precisamos adicionar algumas linhas no arquivo "profile", que fica no diretório /etc e para isso precisamos das permissões de "root" novamente.

Para virar root digite:

$ su -

Depois digite a sua senha e pressione "Enter".

Agora para editar o arquivo /etc/profile digite:

# vim /etc/profile

E insira as seguintes linhas no conteúdo do arquivo sem alterar as demais:
PATH=$PATH:/usr/local/pgsql/bin
MANPATH=$MANPATH:/usr/local/pgsql/man
export PATH MANPATH
Agora entre novamente no diretório do PostgreSQL, digite:
# cd /home/usuario/Desktop/postgresql-8.1.9
Troque "usuário" pelo nome do seu usuário.
Agora precisamos entrar no diretório contrib/start-scripts/.
Digite:
# cd contrib/start-scripts/
Agora digite:
# cp linux /usr/local/pgsql/rc.postgresql
Depois digite:
# chmod a+x /usr/local/pgsql/rc.postgresql
Pronto!
Para criar outro banco de dados caso você queira digite:
# /usr/local/pgsql/bin/createdb "nome do banco de dados"
Troque o "nome do banco de dados" pelo nome do banco de dados que você deseja criar, sem as aspas. Mas lembre-se que somente com o usuário postgres você pode criar um novo banco de dados.
Para iniciar o PostgreSQL digite:
# /usr/local/pgsql/bin/postmaster -D /usr/local/pgsql/data
LEMBRE-SE que o PostgreSQL somente pode ser iniciado pelo usuário "postgres" que criamos, ou seja, para iniciá-lo você deve primeiro entrar no usuário postgres.
Para entrar no usuário postgres digite:
# su - postgres
Digite a senha do usuário postgres que você criou.
E para iniciar o PostgreSQL digite:
$ /usr/local/pgsql/bin/postmaster -D /usr/local/pgsql/data
Pronto. O PostgreSQL está funcionando!
Chegamos ao fim do artigo, qualquer dúvida, erro, sugestão e elogios comentem. =D

BY Isaac Amorim

Isaac_Amorim - NETBEANS

>CHAMANDO UMA CLASSE (cadastro de produto)

|||||||||||CODIGO... USO NETBEANS 5.0||||||||||||||


/*
* Cadastro_de_Produtos.java
*
* Created on 19 de Outubro de 2010 as 22:13
/

package examples;

/**
*
* @author User
*/
public class Cadastro_de_Produtos extends javax.swing.JFrame {

/** Creates new form Cadastro_de_Produtos */
public Cadastro_de_Produtos() {
initComponents();
}

/** This method is called from within the constructor to
* initialize the form.
* WARNING: Do NOT modify this code. The content of this method is
* always regenerated by the Form Editor.
*/
//
private void initComponents() {
jTabbedPane1 = new javax.swing.JTabbedPane();
jPanel1 = new javax.swing.JPanel();
jPanel2 = new javax.swing.JPanel();
jLabel1 = new javax.swing.JLabel();
jTextField1 = new javax.swing.JTextField();

setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
jPanel1.setBackground(new java.awt.Color(255, 255, 255));
jPanel2.setBackground(new java.awt.Color(245, 243, 239));
jPanel2.setBorder(javax.swing.BorderFactory.createTitledBorder("Descri\u00e7oes e Medidas"));
jLabel1.setText("Produto");

org.jdesktop.layout.GroupLayout jPanel2Layout = new org.jdesktop.layout.GroupLayout(jPanel2);
jPanel2.setLayout(jPanel2Layout);
jPanel2Layout.setHorizontalGroup(
jPanel2Layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING)
.add(jPanel2Layout.createSequentialGroup()
.add(jLabel1)
.addPreferredGap(org.jdesktop.layout.LayoutStyle.RELATED)
.add(jTextField1, org.jdesktop.layout.GroupLayout.PREFERRED_SIZE, 76, org.jdesktop.layout.GroupLayout.PREFERRED_SIZE)
.addContainerGap(326, Short.MAX_VALUE))
);
jPanel2Layout.setVerticalGroup(
jPanel2Layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING)
.add(jPanel2Layout.createSequentialGroup()
.addContainerGap()
.add(jPanel2Layout.createParallelGroup(org.jdesktop.layout.GroupLayout.BASELINE)
.add(jLabel1)
.add(jTextField1, org.jdesktop.layout.GroupLayout.PREFERRED_SIZE, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, org.jdesktop.layout.GroupLayout.PREFERRED_SIZE))
.addContainerGap(233, Short.MAX_VALUE))
);

org.jdesktop.layout.GroupLayout jPanel1Layout = new org.jdesktop.layout.GroupLayout(jPanel1);
jPanel1.setLayout(jPanel1Layout);
jPanel1Layout.setHorizontalGroup(
jPanel1Layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING)
.add(org.jdesktop.layout.GroupLayout.TRAILING, jPanel1Layout.createSequentialGroup()
.addContainerGap()
.add(jPanel2, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
.addContainerGap())
);
jPanel1Layout.setVerticalGroup(
jPanel1Layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING)
.add(jPanel1Layout.createSequentialGroup()
.addContainerGap()
.add(jPanel2, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, Short.MAX_VALUE)
.addContainerGap())
);
jTabbedPane1.addTab("tab1", jPanel1);

org.jdesktop.layout.GroupLayout layout = new org.jdesktop.layout.GroupLayout(getContentPane());
getContentPane().setLayout(layout);
layout.setHorizontalGroup(
layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING)
.add(jTabbedPane1, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, 485, Short.MAX_VALUE)
);
layout.setVerticalGroup(
layout.createParallelGroup(org.jdesktop.layout.GroupLayout.LEADING)
.add(jTabbedPane1, org.jdesktop.layout.GroupLayout.DEFAULT_SIZE, 343, Short.MAX_VALUE)
);
pack();
}//

/**
* @param args the command line arguments
*/
public static void main(String args[]) {
java.awt.EventQueue.invokeLater(new Runnable() {
public void run() {
new Cadastro_de_Produtos().setVisible(true);
Cadastro_de_Produtos.setDefaultLookAndFeelDecorated(true);
}
});
}

// Variables declaration - do not modify
private javax.swing.JLabel jLabel1;
private javax.swing.JPanel jPanel1;
private javax.swing.JPanel jPanel2;
private javax.swing.JTabbedPane jTabbedPane1;
private javax.swing.JTextField jTextField1;
// End of variables declaration

}

Isaac_Amorim - DAO

DAO: o intermediário entre os mundos

XMLs, a grosso modo, são um conjunto de tags dispostas de modo hierárquico, contendo informações estruturadas. Arquivos texto são um conjunto de caracteres. Bancos de dados relacionais são um conjunto de tabelas, colunas, e linhas. Aplicações Java são um conjunto de objetos.

O DAO deve funcionar como um tradutor dos mundos. Suponha um banco relacional. O DAO deve saber buscar os dados do banco e converter em objetos para ser usado pela aplicação. Semelhantemente, deve saber como pegar os objetos, converter em instruções SQL e mandar para o banco de dados. É assim que um DAO trabalha.

Abstração

Devido à sua qualidade de tradutor, o DAO abstrai a origem e o modo de obtenção / gravação dos dados, de modo que o restante do sistema manipula os dados de forma transparente, sem se preocupar com o que acontece por trás dos panos. Isso ajuda muito em processos de migrações de fonte de dados e testes unitários.

Unificação do acesso a dados

É muito comum em códigos de programadores iniciantes vermos a base de dados sendo acessada em diversos pontos da aplicação, de maneira extremamente explícita e repetitiva. Isso é um crime contra um bom design OO. Além de não abstrair a fonte dos dados, transforma o código em um espaguete difícil de manter. O DAO também nos ajuda a resolver este problema, provendo pontos unificados de acesso a dados. Desse modo, a? lógica? de interação com a base de dados ficam em lugares específicos e especializados nisso, além de eliminar códigos redundantes, facilitando a manutenção e futuras migrações.

DAO na prática

Geralmente, temos um DAO para cada objeto do domínio do sistema (Produto, Cliente, Compra, etc.), ou então para cada módulo, ou conjunto de entidades fortemente relacionadas.

Cada DAO deve possuir uma interface, que especifica os métodos de manipulação de dados. Nossos códigos trabalharão apenas com as interfaces dos DAOs, desconhecendo a implementação utilizada. Isso é uma boa prática, não somente em termos de persistência, mas em vários outros pontos de uma aplicação.

Para exemplificar, vamos tratar dos usuários do nosso sistema. O primeiro passo é definir uma classe User.



public class User {
private String name, password;
// Construtores e sets / gets omitidos
}
public class User {
private String name, password;
// Construtores e sets / gets omitidos
}



Agora, especificaremos a interface UserDao:



public interface UserDao {
public void save (User user);
public void delete (User user);
public List list ();
public User find (String name);
}


public interface UserDao {
public void save (User user);
public void delete (User user);
public List list ();
public User find (String name);
}




Observe que UserDao não contem nenhuma informação específica da origem dos dados. Agora, podemos codificar os nosso Daos, implementando esta interface.

class JDBCUserDao implements UserDao {...}

class HibernateUserDao implements UserDao {...}



class TextFileUserDao implements UserDao {...}
class JDBCUserDao implements UserDao {...}

class HibernateUserDao implements UserDao {...}



class TextFileUserDao implements UserDao {...}



Aqui exemplificamos três implementações possíveis. Uma, usando ? JDBC puro ?; a segunda, usando o framework Hibernate e a última persistindo em arquivo texto.


DAO + Factory ou DI (Dependency Injection)

Apesar de termos a interface UserDao, não há nenhum proveito em criarmos nossos DAOs desta maneira:



UserDao dao = new HibernateUserDao();


UserDao dao = new HibernateUserDao();



Se fizermos de tal modo, de nada nos aproveitará, em termos de abstração, usarmos uma interface para o DAO. O ideal é que usemos o pattern Factory ou DI (Injeção de Dependências) para máxima transparência. Nesse artigo, usaremos o Factory.

O pattern Factory implementa uma fábrica de objetos, abstraindo e isolando o modo de criação dos objetos. Veja um exemplo simples:



public class Factory {
public static UserDao createUserDao () {
return new HibernateUserDao ();
}
}
public class Factory {
public static UserDao createUserDao () {
return new HibernateUserDao ();
}
}



Assim, o único lugar em toda a aplicação que conhece a implementação de DAO usada é aqui. Quando precisarmos do UserDao, ao invés de instanciar com um new, chamaremos a fábrica:

UserDao userDao = Factory.createUserDao ();



//... use a abuse do userDao
UserDao userDao = Factory.createUserDao ();



//... use a abuse do userDao



Não entraremos em detalhes sobre a implementação destes patterns, visto que poderão ser alvos de estudo em próximos artigos.

Patterns relacionados

Há outros patterns relacionados à persistência, como o ActiveRecord e o Repository.