PHP - MYSQL mysql acesso ao banco.

PHP está em constante evolução e prova disso são as novidades que vamos comentar neste artigo. Se trata das novas funções de acesso a bases de dados MySQL que estão disponíveis a partir de PHP 5, com nomes diferentes das funções disponíveis no passado e que também têm algumas mudanças no modo de trabalhar. As novas funções foram criadas para dar resposta a diversas melhorias que o sistema gestor de bases de dados MySQL incorporou recentemente.

Este é um assunto fundamental, sobretudo para as pessoas que conhecem PHP há tempo, que como eu, estávamos acostumados a usar um jogo de funções que atualmente se encontra obsoleto e que não se recomenda utilizar. Realmente, no momento de escrever este artigo as funções de MySQL antigas ainda, se podem usar, mas a previsão é que sejam eliminadas em PHP 5.5, razão pela qual é imprescindível atualizar nossos conhecimentos.

Felizmente, é bastante simples o passo para as novas funções de MySQL, uma vez que o esquema de funcionamento é praticamente o mesmo, assim como os novos nomes de funções, que têm muito poucas variações. Portanto, se você leu o Manual de PHP de CriarWeb.com e aprendeu conosco a trabalhar com as bases de dados, não terá realmente muitos problemas em aprender as novidades que passo a relatar a continuação.

Dois tipos de funções para acesso às bases de dados MySQL

Uma das novidades que PHP nos oferece nas recentes funções de PHP é a incorporação de dois tipos de aproximações ao trabalho com MySQL, que agora pode ser feita por procedimentos (funções normais de sempre) e por objetos.

Nota: Antes só podíamos acessar MySQL por funções comuns, Mas agora também podemos acessar por meio de classes e objetos de programação orientada a objetos (POO). A incorporação no API de métodos baseados em POO torna patente que PHP está tendo muito presente este paradigma de desenvolvimento dentro de seu núcleo e que a tendencia nas nuevas versões de PHP será a de potencializá-lo ainda mais.

Funções baseadas em procedimentos: Como vimos fazendo desde sempre com PHP.

Funções normais e correntes, que recebem parâmetros e que retornam valores.

Funções baseadas em POO: Realmente são construtores para obter objetos e métodos aos que podemos acessar dentro desses objetos para realizar as operações com a base de dados.

Há que esclarecer que ambas aproximações são perfeitamente válidas e que não mudam as coisas que podem ser feitas de uma ou outra. Portanto, elogiar um ou outro modo não implicará em nenhuma vantagem em funcionalidade, nem sequer de rendimento. Na verdade, ambos modos de trabalho são o"mesmo cachorro com diferente coleira". Portanto, é tão válida uma escolha quanto a outra e nossa preferência será mais por gosto ou costume à hora de desenvolver.

Nota: O que não se recomenda em um mesmo projeto é mudar de um outro estilo de acesso à base de dados MySQL de maneira arbitrária. Devemos ter em conta que realmente essa recomendação não se deve a que seu programa não vai funcionar, ou que você possa ter algum problema determinado, mas que é uma questão de estilo e clareza à hora de manter o código de seu proyeto.

Acesso a MySQL com funções por procedimentos

No mencionado Manual de PHP vimos oferecendo exemplos para acesso à base de dados com funções desde sempre. Por isso, neste artigo vamos mostrar as diferenças que existem relacionadas às funções antigas, usando também código por procedimentos. Contudo, como você verá a seguir, as funções são praticamente as mesmas às que se acrescentou um "i". Por exemplo, mysql_connect() passa a ser mysqli_connect(). Os parâmetros são os mesmos em muitos casos, ou muito parecidos.

Nota: este artigo não é um tutorial de acesso a bases de dados com PHP, para isso já dispomos do manual de PHP em CriarWeb.com. Realmente se trata de uma serie de guias para poder reciclar nossos conhecimentos com o PHP de versões anteriores.

Conexão com a base de dados: mysqli_connect()

Agora indicamos também a base de dados à que nos queremos conectar. E atenção, porque o que nos retorna a função não é um link ou identificador da conexão com a base de dados, mas um objeto. Porém, mesmo que você não saiba POO, não se preocupe com este detalhe, pois pouco importa aos desenvolvedores, dado que vamos usar esse objeto como se fosse simplesmente o identificador da conexão, ou seja, vamos usá-lo como fazíamos anteriormente em PHP.

$conexao = mysqli_connect("localhost", "usuario", "chave", "meu_bbdd");

Fechar a conexão: mysqli_close()

Temos que passar como parâmetro sempre o objeto que obtivemos ao iniciar a conexão.

mysqli_close($conexao);

Executar uma consulta: mysqli_query()

Esta função é exatamente igual, embora neste caso recebe obrigatoriamente como primeiro parâmetro o objeto de conexão à base de dados que recebemos ao nos conectarmos. O segundo parâmetro é a sentença SQL que se deseja executar em MySQL.

$resultado = mysqli_query($conexao, "select * from cliente");

Outro aspecto interessante é que nos retorna um valor que pode ser, ou um booleano para saber se a consulta foi executada com sucesso, como no caso de um "insert" ou "delete", ou então um objeto resultado com um conjunto de registros no caso de um "select".

Extrair um registro do conjunto de resultados: 

mysqli_fetch_array()

Esta função é exatamente igual, recebe o conjunto de resultados do que queremos extrairr um registro. Retorna neste caso um "array", mas está igualmente mysqli_fetch_object() que retornaría um objeto.

$fila = mysqli_fetch_array($resultado);

Contar o número de filas de um resultado: 

mysqli_num_rows()

Também é exatamente igual, simplesmente lhe passamos o objeto conjunto de registros do que queremos saber o número de filas ou registros que contém.

$fila = mysqli_num_rows($resultado) 

Conclusão

Em geral, como você está podendo comprovar, o sistema não varia muito em relação ao que você já conhecia. Mudam nomes de funções minimamente e algum parâmetro solto aqui e ali.

Creio que o passo para usar as novas funções MySQL é tão rápido que não tem sentido continuar usando as funções antigas e, ademais, em breve a mudança será obrigatória porque os acessos antigos que fazíamos a MySQL deixaram de funcionar.

JAVA Um sistema de logim com senha embutida no código. Com JOPtionPane.

Um sistema de logim com senha embutida no código. 

 Com JOPtionPane. Primeiro a Class de Login aqui e a Logus.java. 

Ela a senha digitada como parâmetro, através da string nome, faz o teste de correspondência e retorna um boleano.

 import javax.swing.JOptionPane; 

/** * @author Edson Pessotti */ 

public class Logus { 

 private String nome;

 private int resul; 

 private int loginus(String nome) {

 return getResul(); } 

 // @return the resul 

 public int getResul() { return resul; }

 /** * @param resul the resul to set */

 public void setResul(int resul) {

 if (nome == null || nome.equals("") || !nome.equals("A sua senha Aqui")) {

 setResul(1) 

;} 

 else{ setResul(0)

;} 

 this.resul = resul; } 

 /** * @return the nome */ 

 public String getNome() { return nome; }

 /** * @param nome the nome to set */

 public void setNome(String nome) {

 this.nome = nome; loginus(this.nome); } } 

// Agora o Metodo que vai capturar a senha. Neste metodo capturamos a senha e passamos para a //class Logus que testa e retorna um boleano, que de retorno e testado neste metodo, caso correto o //processamento continua, senão fica “no cosa do exemplo amarrado ao um loop “ até acetar 

 public void run() { String nome="";  // string que receberá a senha 

 Logus login = new Logus(); // instância da classe Logus. //

 while (nome == null || nome.equals("")) {

 JPasswordField password = new JPasswordField(10); 

 password.setEchoChar('*'); // Cria um rótulo para o campo JLabel

 rotulo = new JLabel("Entre com a senha:");  // Coloca o rótulo e a caixa de entrada numa JPanel:

 JPanel entUsuario = new JPanel(); 

 entUsuario.add(rotulo); 

 entUsuario.add(password); // Mostra o rótulo e a caixa de entrada de password para o usuario fornecer a senha:  //as letras digitas são substituidas por '*'.

JOptionPane.showMessageDialog(null, entUsuario, "Acesso restrito", JOptionPane.PLAIN_MESSAGE); 

 // O programa só prossegue quando o usuário clicar o botao de OK do showMessageDialog. 

 // Aí, é só pegar a senha: // 

Captura a senha: 

 nome = password.getText();

 login.setNome(nome); 

// Aqui a senha e passada como parametro 

 if (login.getResul()!=0) { } 

else { nome = "sai"; }}

Java manipulando dados de um Jtable

                  Java com JTable

A Classe JTable é a classe responsável por representar um grid no swing, ao meu ver é umas das classes de GUI mais difícil de se trabalhar pela sua flexibilidade. Esta é uma classe que usa o padrão MVC(Model , View e Controller):

Model: é a classe responsável por representar os dados da tabela, sempre que iremos modificar os dados de uma JTable deve ser feito através do objeto model que é implementado pela interface TableModel ( AbstractTableModel e DefaultTableModel).

View: É a apresentação da célula na JTable é implementado pela interface CellRenderer, que através de seus métodos define como seram apresentados os valores.

Controller: é a parte que controla os dados e a apresentação, ele é representado pela própria JTable.

Vejamos agora como criar a mais simples das JTable:

1 2 3 4 5 6 7 8 9 10 11

String[] colunas = new String[]{"Nome","Idade","Sexo"};   String[][] dados = new String[][]{     {"Rodrigo","28","Masculino"},     {"Maria","30","Feminino"} };   JTable tabela = new JTable(dados,colunas); JScrollPane scroll = new JScrollPane(); scroll.setViewportView(tabela); this.add(scroll);

Na lina 1 criamos uma array de strings que serão os nomes das colunas e os usaremos para construir nossa JTable, na linha 3 criamos uma matriz que será utilizada como dados da tabela, sendo o primeiro índice as linhas e o segundo as colunas sendo assim nossa tabela de exemplo tem 2 linha e 3 colunas. No exemplo utilizamos uma matriz de String, mas poderia ser uma matriz de Object ou objeto do tipo Vector

Na linha 8 criamos o objeto JTable passando como argumento para o construtor dos dados e os nomes das colunas, com este construtor ele cria internamente um objeto DefaultTableModel para armazenar os dados que posteriormente podemos pegar utilizando o método tabela.getModel().

Na linha 9 criamos um JScrollPane para colocar a tabela dentro através do seu método setViewportView(JTable), ele serve para a tabela possuir uma barra de rolagem e mostrar os nomes das colunas.

Na linha 11 adicionamos o JScrollPane na janela.

Também poderiamos ter criado a mesma tabela através do seguinte código:

1 2 3 4 5 6 7 8 9 10 11 12

String[] colunas = new String[]{"Nome","Idade","Sexo"}; String[][] dados = new String[][]{     {"Rodrigo","28","Masculino"},     {"Maria","30","Feminino"} };   JTable tabela = new JTable(); DefaultTableModel model = new DefaultTableModel(dados , colunas ); tabela.setModel(model); JScrollPane scroll = new JScrollPane(); scroll.setViewportView(tabela); this.add(scroll);

Como podemos ver criamos um objeto DefaultTableModel(linha 8), com os dados da tabela e os nomes das colunas em vez de passar para para o construtor de JTable, e depois adicionamos o model criado através do método setModel, devemos fazer assim quando quisermos criar nossos próprios models.

Adicionando uma linha:

1 2 3 4

DefaultTableModel model =  (DefaultTableModel) tabela.getModel();   String[] linha = new String[]{"João", "15" , "Masculino"}; model.addRow(linha);

Como vimos, para manipular os dados de um JTable devemos utilizar o objeto model que ela possui, então primeiro devemos pegar o model através do método getModel(), após isto basta criar um array de Strings com os valores correspondentes a cada coluna e adiciona-lo através do método addRow(), do objeto model

Removendo uma linha da tabela

1 2 3

DefaultTableModel model =  (DefaultTableModel) tabela.getModel();   model.removeRow(0);

Para remover uma linha devemos primeiro pegar o model do JTable como antes e depois chamar o método removeRow() que recebe como parâmetro um inteiro que será o número da linha que ele deve excluir, lembrando que as linha são contadas iniciando em 0.

Na maior parte dos caso queremos remover um linha do JTable que esta selecionada, para isso devemos pegar o número desta linha.

1 2 3 4 5

int linha = tabela.getSelectedRow();   if( linha != -1){     model.removeRow( linha ); }

Como vemos na linha 1, para descobrir qual linha está selecionada utilizamos o método getSelectedRow() da JTable, que retorna o numero da linha selecionada ou -1 se não tiver nenhuma linha selecionada.

Bom não adianta nada ter uma tabela se não podemos manipular os valores dela, veremos abaixo como pegar um valor de uma célula do JTable

1 2 3 4

int linha = tabela.getSelectedRow();//pegando linha selecionada String nome = tabela.getValueAt(linha , 0) ); String idade = tabela.getValueAt(linha , 1) ); String sexo = tabela.getValueAt(linha , 2) );

O modo mais fácil de pegar um valor de uma célula de uma JTable é através do método getValueAt(int , int), que recebe como primeiro parâmetros o número da linha e como segundo o número da coluna, lembrando que como as linhas a numeração das colunas começa em 0.

Para colocar um valor especifico em uma célula podemos utilizar o método setValueAt(Object, int, int):

1 2 3 4

int linha = tabela.getSelectedRow();//pegando linha selecionada tabela.setValueAt("Nome alterado" , linha , 0); tabela.setValueAt("0" , linha , 1); tabela.setValueAt("indefinido" , linha , 2);

Ao utilizar getValueAt(int , int) e setValueAt(Objec , int , int ) você pode querer percorrer todas as linhas ou colunas da JTable e para isso os métodos getRowCount() e getColumnCount() que retornam respectivamente o número de linhas e colunas.

Também podemos pegar todos os dados da tabela pegando o objeto Vector que representa os dados da tabela através do método getDataVector()

1 2 3 4 5 6 7

Iterator iterator = model.getDataVector().iterator(); while ( iterator.hasNext() ) {     Vector row = (Vector) iterator.next();     System.out.println(row.get(0));     System.out.println(row.get(1));     System.out.println(row.get(2)); }

Como vimos na linha 1 pegamos o Vector do model e utilizamos um iterator para percorrer as linhas, sendo que cada linha também é armazenada como um Vector, sendo cada um dos objetos armazenados nele o valor de uma célula. Só lembrando, se você modificar o Vector retornado pelo método getDateVector() os dados visualizados na JTable serão modificados.

Esta é a maneira mais simples de trabalhar com JTable, para customizarmos mais ela teremos criar o nosso próprio TableModel e CellRenderer que veremos em próximos posts, eu espero.

Referências

http://docs.oracle.com/javase/6/docs/api/javax/swing/JTable.html
http://docs.oracle.com/javase/6/docs/api/javax/swing/table/DefaultTableModel.html