O objetivo deste tutorial é usar uma camada separada gravada em Java para acessar tabelas em um banco de dados. Esta camada é geralmente chamada de camada de acesso a dados (dal)
O maior benefício do uso do DAL é que ele simplifica a operação de acesso do banco de dados usando diretamente alguns métodos como inserção () e find (), em vez de sempre fazer links primeiro e depois executar algumas consultas.
Essa camada lida com todas as chamadas e consultas relacionadas ao banco de dados dentro dela.
Crie um banco de dados
Queremos criar uma tabela simples para o usuário, podemos usar esses campos para criar
id int
Nome Varchar (200)
Senha Varchar (200)
idade int
Objeto de transferência de dados
Essa camada deve conter uma classe simples chamada Objeto de Transferência de Dados (DTO). Esta classe é apenas um mapa simples correspondente à tabela no banco de dados e cada coluna na tabela corresponde a uma variável de membro da classe.
Nosso objetivo é usar objetos Java simples, em vez de processar instruções SQL e outros comandos relacionados ao banco de dados para adicionar, excluir, modificar e verificar o banco de dados.
Se queremos mapear a tabela no código Java, precisamos apenas criar uma classe (Bean) contendo os mesmos campos.
Para melhor encapsular, além dos construtores, devemos declarar todas as variáveis de campo como privadas, criar acessadores (getters e setters), um dos quais é o construtor padrão.
Public class Usuário {ID inteiro privado; nome de string privado; Passo de string privado; idade inteira privada;}Para mapear os campos corretamente, devemos considerar o valor nulo no banco de dados. Para os valores padrão originais do Java, como o Type Int, seu valor padrão é 0, portanto, devemos fornecer um novo tipo de dados que possa acomodar valores nulos. Podemos substituir o INT usando uma classe de encapsulamento de tipo especial, como o número inteiro.
Finalmente nossa classe deve ficar assim:
Public class Usuário {ID inteiro privado; nome de string privado; Passo de string privado; idade inteira privada; public user () {} public user (nome da string, string passa, idade inteira) {this.name = name; this.pass = pass; this.age = idade; } usuário público (ID inteiro, nome da string, passagem de string, idade inteira) {this.id = id; this.name = nome; this.pass = pass; this.age = idade; } public integer getage () {retorna idade; } public void setage (idade inteira) {this.age = Age; } public integer getId () {return id; } public void SetId (ID inteiro) {this.id = id; } public string getName () {return name; } public void setName (nome da string) {this.name = name; } public string getPass () {return passa; } public void setPass (string pass) {this.pass = pass; }}Uma boa prática é fornecer o construtor vazio padrão, um construtor completo e um construtor completo sem parâmetros de identificação.
Conecte -se ao banco de dados
Podemos usar uma classe intermediária para facilitar a conexão com o banco de dados. Nesta classe, forneceremos os parâmetros de conexão do banco de dados, como JDBC, URL, nome de usuário e senha e definir essas variáveis como final (será melhor obter esses dados de propriedades ou arquivos de configuração XML)
Fornece um método para retornar um objeto de conexão ou retornar um nulo quando a conexão falha ou lançar uma exceção de tempo de execução.
public static final string url = "jdbc: mysql: // localhost: 3306/testdb"; public static final string user = "testUser"; public static final string pass = "testpassp";/*** obtenha objeto de conexão* @return conexão*/public static conexão getConnection () {try {driver.Manager.Restriver (driver. retornar driverManager.getConnection (URL, usuário, passe); } catch (sqLexception ex) {lança nova RunTimeException ("Erro conectando -se ao banco de dados", ex); }}Também podemos incluir um método principal na classe para testar a conexão. A classe completa se parece com isto:
importação com.mysql.jdbc.driver; importar java.sql.connection; importar java.sql.drivermanager; importar java.sql.sqLexception;/** * conectar -se ao banco de dados * @author hany.sad */public ConnectionFactory {public estática final string url "JDBC: MySQL: // localhost: 3306/testdb"; public static final string user = "testUser"; public static final string pass = "testpass"; / ** * Obtenha uma conexão com o banco de dados * @return conexão objeto */ public static conexão getConnection () {try {driverManager.registerDriver (new Driver ()); retornar driverManager.getConnection (URL, usuário, passe); } catch (sqLexception ex) {lança nova RunTimeException ("Erro conectando -se ao banco de dados", ex); }} / ** * Conexão de teste * / public static void main (string [] args) {conexão conexão = conexãoFactory.getConnection (); }}Objeto de acesso a dados
A camada DAO pode executar operações CRUD. Pode adicionar, excluir, modificar e verificar nossas tabelas.
Nossa interface da camada DAO deve ficar assim:
interface pública userdao {user getUser (); Set <suser> getAllUsers (); Usuário getUserByUsernameAndPassword (); insertUser booleano (); boolean updateUser (); Boolean DeleteUser ();}Encontre usuários
Os usuários podem consultar quaisquer campos exclusivos como ID, nome ou e -mail. Neste exemplo, usamos o ID para encontrar o usuário. A primeira etapa é criar uma conexão através da classe Connector e, em seguida, executar a instrução SELECT para levar o usuário a seu ID 7. Podemos usar essa instrução para consultar o usuário:
Selecione * do usuário onde id = 7
É aqui que fazemos uma declaração dinâmica para obter o ID dos parâmetros.
Ao executar esta consulta, é obtido um conjunto de resultados, onde o usuário ou nulo é salvo. Podemos usar o método Next () do ResultSet para detectar se existe um valor. Se o TRUE for retornado, continuaremos usando o Data Getters para obter dados do usuário do ResultSet. Quando encapsulamos todos os dados no usuário, retornamos. Se um usuário com esse ID não existir ou ocorrer qualquer outra exceção (como uma instrução SQL inválida), esse método retornará nulo.
Usuário público getUser (int id) {Connection Connection = ConnectionFactory.getConnection (); tente {declaração stmt = conexão.createstatement (); ResultSet rs = stmt.executeQuery ("Selecione * do usuário onde id =" + id); if (rs.Next ()) {usuário do usuário = new User (); user.setId (rs.getInt ("id")); user.setName (rs.getString ("nome")); user.setPass (rs.getString ("pass")); user.setage (rs.getInt ("idade")); devolver usuário; }} catch (sqLexception ex) {ex.printStackTrace (); } retornar nulo;}Será mais conveniente usar um método separado para extrair dados do conjunto de resultados, porque em muitos métodos chamaremos.
Este novo método lançará uma SqLexception e, por uma questão de limitações, deve ser privado:
ExtractUser de usuário privado de setão (ResultSet RS) lança SQLEXCECCIONE {Usuário do usuário = new User (); user.setId (rs.getInt ("id")); user.setName (rs.getString ("nome")); user.setPass (rs.getString ("pass")); user.setage (rs.getInt ("idade")); Retornar usuário;}Nosso método acima deve ser modificado em um novo método:
Usuário público getUser (int id) {Connection Connection = ConnectionFactory.getConnection (); tente {declaração stmt = conexão.createstatement (); ResultSet rs = stmt.executeQuery ("Selecione * do usuário onde id =" + id); if (rs.Next ()) {return extractUserFromResultSet (rs); }} catch (sqLexception ex) {ex.printStackTrace (); } retornar nulo;}Método de login
A operação de login é semelhante. Queremos fornecer IDs alternativas de usuário e senha, que não afetarão a lista de parâmetros e as instruções de consulta. Se o nome de usuário e a senha estiverem corretos, esse método retornará um usuário válido, caso contrário, NULL. Como existem muitos parâmetros, o uso do preparado será mais útil.
Usuário público getUserByUserNameAndPassword (Usuário da String, String Pass) {Connector Connector = new Connector (); Conexão de conexão = Connector.getConnection (); tente {preparadostatement ps = conexão.Preparestatement ("Selecione * do usuário onde o usuário =? e passa =?"); ps.SetString (1, usuário); ps.SetString (2, passe); ResultSet rs = ps.executeQuery (); if (rs.Next ()) {return extractUserFromResultSet (rs); }} catch (sqLexception ex) {ex.printStackTrace (); } retornar nulo;}Como consultar todos os usuários
Esse método retornará todos os usuários, para que devamos devolvê-los em um contêiner semelhante a uma matriz. Mas porque não sabemos quantos registros existem. Seria melhor usar uma coleção como set ou list:
public Set getAllUsers () {Connector Connector = new Connector (); Conexão de conexão = Connector.getConnection (); tente {declaração stmt = conexão.createstatement (); ResultSet rs = stmt.executeQuery ("selecione * do usuário"); Set usuários = new hashset (); while (rs.Next ()) {usuário do usuário = ExtractUserFromResultSet (rs); usuários.add (usuário); } retornar usuários; } catch (sqlexception ex) {ex.printStackTrace (); } retornar nulo;}Inserir método
O método Insert tomará o usuário como um parâmetro e usará o objeto preparado para executar a instrução SQL Atualize. O método executeUpdate retorna o número de linhas afetadas. Se adicionarmos uma única linha, significa que o método deve retornar 1, se for o caso, retornamos verdadeiro, caso contrário, retornamos falsos
public boolean InsertUser (usuário do usuário) {Connector Connector = new Connector (); Conexão de conexão = Connector.getConnection (); tente {preparadostatement ps = Connection.Preparestatement ("Insira nos valores do usuário (null ,?,?)"); ps.SetString (1, user.getName ()); ps.SetString (2, user.getpass ()); ps.SetInt (3, user.getage ()); int i = ps.executeUpdate (); if (i == 1) {return true; }} catch (sqLexception ex) {ex.printStackTrace (); } retornar false;}Método de atualização
O método de atualização é semelhante ao método de inserção. A única mudança é a declaração SQL
public boolean updateUser (usuário do usuário) {Connector Connector = new Connector (); Conexão de conexão = Connector.getConnection (); tente {preparadostatement ps = conexão.Preparestatement ("Atualizar nome do conjunto de usuários =?, passa =?, idade =? Onde id =?"); ps.SetString (1, user.getName ()); ps.SetString (2, user.getpass ()); ps.SetInt (3, user.getage ()); ps.SetInt (4, user.getId ()); int i = ps.executeUpdate (); if (i == 1) {return true; }} catch (sqLexception ex) {ex.printStackTrace (); } retornar false;}Método de exclusão
O método a ser excluído é usar uma consulta simples como
Exclua do usuário onde id = 7
Enviar a consulta com o parâmetro ID excluirá este registro. Se excluído com sucesso, eu será devolvido
public boolean DeleteUser (int id) {Connector Connector = new Connector (); Conexão de conexão = Connector.getConnection (); tente {declaração stmt = conexão.createstatement (); int i = stmt.executeUpdate ("Exclua do usuário onde id =" + id); if (i == 1) {return true; }} catch (sqLexception ex) {ex.printStackTrace (); } retornar false;}Obrigado pela leitura, espero que isso possa ajudá -lo. Obrigado pelo seu apoio a este site!