java jdbc transaction management with example
Este tutorial explica os tipos de transações JDBC, tipos de dados, métodos de gerenciamento de transações e como usá-los no programa Java:
No JDBC ResultSet tutorial do Série de tutoriais JDBC , aprendemos a usar JDBC ResultSet para recuperar dados.
Neste tutorial, discutiremos os tipos de transação em JDBC. Vimos uma breve introdução aos tipos de transação em nossos tutoriais anteriores. Aqui veremos de forma detalhada. Também cobriremos quais são os tipos de dados em JDBC e como usá-los no programa Java.
O banco de dados terá diferentes tipos de dados e o Java terá diferentes tipos de dados. O JDBC administrará essa diferenciação. Vamos nos preparar para conhecer o tópico importante em JDBC.
O que você aprenderá:
Gerenciamento de transações JDBC
A sequência de ações (instruções SQL) é tratada como uma unidade única, conhecida como transação. O gerenciamento de transações é importante para aplicativos orientados a RDBMS para manter a integridade e consistência dos dados.
Ao realizar a transação, usaremos os métodos getXXX e setXXX para recuperar e definir os dados no objeto ResultSet. XXX representa os tipos de dados das colunas. Discutiremos a transação e os tipos de dados do JDBC neste tutorial.
Tipos de transação
Em JDBC, toda consulta SQL será considerada uma transação. Quando criamos uma conexão de banco de dados em JDBC, ela será executada no modo de confirmação automática (o valor da confirmação automática é TRUE). Após a execução da instrução SQL, ela será confirmada automaticamente.
Às vezes, podemos querer confirmar a transação após a execução de mais algumas instruções SQL. Nesse momento, precisamos definir o valor de auto-commit para False. Para que os dados não sejam confirmados antes de executar todas as consultas. Se obtivermos uma exceção na transação, podemos rollback () alterações e fazer como antes. O gerenciamento de transações pode ser bem explicado - usando propriedades ACID.
ACID significa
- A – Atomicidade -> Se todas as consultas forem executadas com sucesso, os dados serão confirmados, caso contrário, não.
- C - Consistência -> O banco de dados deve estar em um estado consistente após qualquer transação.
- I– Isolamento -> A transação é isolada de outras transações.
- D – Durabilidade -> Se a transação for confirmada uma vez, ela permanecerá sempre confirmada.
Existem três funções mais importantes no gerenciamento de transações. Eles são:
estrutura de dados de pilha c ++
- Comprometer-se: Após a execução das instruções SQL, queremos tornar as alterações permanentes no Banco de Dados. Devemos chamar o método commit (). Normalmente, o que é commit significa que fará as alterações permanentemente no Banco de Dados. Não podemos desfazer / revogar as alterações. Mas podemos alterar os dados no banco de dados.
- Rollback: Rollback desfaz as mudanças até o último commit ou ponto de salvamento mencionado. Às vezes, podemos querer desfazer as alterações. Por exemplo, temos uma consulta aninhada, uma parte foi executada com sucesso e a outra gerou alguma exceção. Nesse momento, queremos desfazer as alterações feitas pela primeira parte, devemos chamar o método Rollback () para fazer isso se ocorrer uma exceção.
- Salvar ponto: Savepoint ajuda a criar checkpoint em uma transação e permite realizar um rollback para aquele savepoint particular. Qualquer ponto de salvamento que tenha sido criado para uma transação será destruído automaticamente e se tornará inválido assim que a transação for confirmada ou revertida.
Até agora nós vimos o que é commit, rollback e savepoint e suas operações. Abaixo, veremos os métodos dele e como usá-lo no programa.
Métodos de gerenciamento de transações
A interface de conexão fornece 5 métodos para gerenciamento de transações. Eles são os seguintes:
# 1) Método setAutoCommit ()
Por padrão, o valor de AutoCommit é TRUE. Após a execução da instrução SQL, ela será confirmada automaticamente. Usando o método setAutoCommit (), podemos definir o valor como AutoCommit.
# 2) Método Commit ()
O método commit é usado para confirmar os dados. Após a execução da instrução SQL, podemos chamar o commit (). Ele irá confirmar as alterações feitas pela instrução SQL.
Sintaxe: conn.commit ();
# 3) Método Rollback ()
O método rollback é usado para desfazer as mudanças até que o último commit aconteça. Se enfrentarmos qualquer problema ou exceção no fluxo de execução das instruções SQL, podemos reverter a transação.
Sintaxe: conn.rollback ();
# 4) Método setSavepoint ()
Savepoint oferece controle adicional sobre a transação. Ao definir um ponto de salvamento na transação (um grupo de instruções SQL), você pode usar o método rollback () para desfazer todas as alterações até o ponto de salvamento ou após o ponto de salvamento (). O método setSavepoint () é usado para criar um novo ponto de salvamento.
# 5) Método releaseSavepoint ()
É usado para deletar o ponto de salvamento criado.
No programa abaixo, você saberá mais sobre esses métodos e também aprenderá a usá-los no programa Java.
Neste tutorial, todos os programas são escritos em Java. Usamos a versão Java 8 e Oracle DB.
>> Clique aqui para baixar o software Oracle.
>> Clique aqui para baixar o Java versão 8.
Possui o processo de instalação do Java passo a passo.
Programa de exemplo de transação
package com.STH.JDBC; import java.sql.Connection; import java.sql.DriverManager; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Savepoint; import java.sql.Statement; public class Transaction_Management { public static void main(String[] args) throws ClassNotFoundException { // TODO Auto-generated method stub //Select Query to get the Data from employee_details table String QUERY = 'select * from employee_details where empNum = 2001'; String QUERY1 = 'select * from employee_details where empNum = 2002'; Boolean autoCommit; String update_query = 'update employee_details set salary = 41000 where empNum = 2001'; String update_query1 = 'update employee_details set salary = 42000 where empNum = 2002'; //Update query to set the email id for the employee whose empNUM is 1001 Class.forName('oracle.jdbc.driver.OracleDriver'); try(Connection conn = DriverManager.getConnection('jdbc:oracle:thin:system/pass123@localhost:1521:XE')) { Statement statemnt1 = conn.createStatement(); ResultSet rs1 =null; //Checking whether the SELECT query is executed successfully or not rs1 = statemnt1.executeQuery(QUERY); //Executed the SELECT Query System.out.println('Getting the data from employee_details table'); displayData(rs1); //Set the autoCommit value of the connection to FALSE System.out.println('Setting the AutoCommit value as FALSE'); conn.setAutoCommit(false); autoCommit = conn.getAutoCommit(); System.out.println('AutoCommit value of the Connection = '+ autoCommit); //Creating Statement to execute the update query statemnt1 = conn.createStatement(); System.out.println('Executing Update query to update salary of EMPNUM = 2001'); System.out.println('Update Query is ' + update_query); int return_rows = statemnt1.executeUpdate(update_query); System.out.println('Updated the data but didn't commit'); //Getting data after Updation Connection conn1 = DriverManager.getConnection('jdbc:oracle:thin:system/pass123@localhost:1521:XE'); System.out.println('Opening new connection'); System.out.println('EMPNUM = 2001 data'); Statement statement2 = conn1.createStatement(); ResultSet rs; rs = statement2.executeQuery(QUERY); displayData(rs); System.out.println('Commit has been done'); conn.commit(); Savepoint s1 = conn.setSavepoint(); System.out.println('SavePoint has been created'); System.out.println('Displaying data of EMPNUM = 2001'); System.out.println('Using The Second Connection'); rs = statement2.executeQuery(QUERY); displayData(rs); rs = statemnt1.executeQuery(QUERY); //Rollback the transaction System.out.println('Data of EMPNUM = 2002'); rs1 = statemnt1.executeQuery(QUERY1); displayData(rs1); System.out.println('Updating the salary of EMPNUM = 2002'); System.out.println('Update Query is ' + update_query1); statemnt1.executeUpdate(update_query1); System.out.println('Data of EMPNUM = 2002 but didn't commit'); rs1 = statemnt1.executeQuery(QUERY1); displayData(rs1); System.out.println('Rollback is done... so updated data won't be reflected'); conn.rollback(s1); System.out.println('Data of EMPNUM = 2002 after Rollback till the last savepoint'); rs1 = statemnt1.executeQuery(QUERY1); displayData(rs1); } catch (SQLException e) { e.printStackTrace(); } } public static void displayData(ResultSet rs1) throws SQLException { while(rs1.next()) { int empNum = rs1.getInt('empNum'); String lastName = rs1.getString('lastName'); String firstName = rs1.getString('firstName'); String email = rs1.getString('email'); String deptNum = rs1.getString('deptNum'); String salary = rs1.getString('salary'); System.out.println(empNum + ',' +lastName+ ',' +firstName+ ',' +email +','+deptNum +',' +salary); } } }
Resultado:
Explicação:
O que fizemos no programa de gerenciamento de transações acima é atualizar os valores de um determinado funcionário na tabela EMPLOYEE_DETAILS e confirmar os dados. Se qualquer erro ou exceção ocorreu, então fizemos a operação rollback (). Agora vamos ver a explicação completa do programa.
# 1) Criado 2 Selecione a consulta para 2 funcionários com base em seu EMPID
Abaixo estão as 2 consultas selecionadas.
String QUERY = 'select * from employee_details where empNum = 2001'; String QUERY1 = 'select * from employee_details where empNum = 2002';
#dois) Criou duas consultas de atualização para 2 funcionários com base em seu EMPID
Duas consultas atualizadas:
String update_query = 'update employee_details set salary = 41000 where empNum = 2001'; String update_query1 = 'update employee_details set salary = 42000 where empNum = 2002';
# 3) Abra a Conexão, execute a consulta selecionada e exiba os dados de EMPNUM = 2001.
# 4) Usando o método setAutoCommit (), defina o valor de autoCommit como false.
# 5) Executada a consulta de atualização de EMPNUM = 2001 e criada outra conexão para o mesmo Banco de Dados e selecionado o valor de EMPNUM = 2001.
# 6) Os dados resultantes do Employee cujo EMPNUM = 2001 não são os dados atualizados. Porque não realizamos a operação commit (). Se você usou a mesma conexão onde a usou para atualizar, ela teria mostrado a você os Dados atualizados. Agora cometeu os dados. Os dados foram refletidos na tabela.
# 7) Criado um ponto de salvamento após a operação de confirmação.
# 8) Usando a consulta de seleção para exibir dados de EMPNUM = 2002. Alterado o salário desse funcionário usando uma consulta de atualização. Depois disso, foram exibidos os dados do EMPNUM = 2002, usando a mesma conexão. Deve mostrar os dados atualizados.
# 9) Realizado o rollback até o último savepoint usando o método rollback. Agora, quando exibimos os dados daquele funcionário usando a mesma conexão, ele possui os dados antigos porque o rollback desfaz as alterações até o último ponto de salvamento se mencionarmos o ponto de salvamento else no último commit.
# 10) Criamos um método que exibirá os dados porque estamos exibindo dados muitas vezes aqui.
Tipos de dados JDBC
Os bancos de dados têm tipos de dados SQL e Java tem tipos de dados Java. Deve haver um mecanismo para ler e gravar dados entre um aplicativo Java e um banco de dados. Bancos de dados diferentes suportam tipos SQL, mas com algumas variações no nome.
Por exemplo, a maioria dos bancos de dados suporta grandes valores binários, o Oracle o chama de LONG RAW, o Sybase o chama de IMAGEM, o Informix o chama de BYTE e o DB2 o chama de LONG VARCHAR FOR BIT DATA.
Ao escrever o programa JDBC, não precisamos nos preocupar com os tipos de dados SQL usados pelo banco de dados de destino. O JDBC possui um conjunto de identificadores de tipo SQL genérico na classe java.sql.Types. Esses tipos são projetados para oferecer suporte à maioria dos tipos de dados SQL genéricos. Ao escrever um programa JDBC, usaremos apenas tipos de dados JDBC.
O driver JDBC converterá os tipos de dados Java em tipos de dados de banco de dados para frente e para trás. Você pode usar o método java.sql.DatabaseMetaData.getTypeInfo para verificar quais tipos de SQL são realmente suportados por um determinado banco de dados e, em seguida, escrever um programa. JDBC usa um mapeamento padrão para a maioria dos tipos de dados.
Por exemplo, a string Java será convertida em um tipo SQL VARCHAR.
Veremos como o mapeamento é feito nos métodos setXXX, getXXX e updateXXX das interfaces preparadas, CallableStatement ou ResultSet na seguinte tabela:
SQL TYPE | TIPO JAVA / JDBC | setXXX | getXXX | updateXXX |
---|---|---|---|---|
INTEIRO | int | setInt | matizado | updateInt |
CARACTERES | java.lang.String | setString | getString | updateString |
VARCHAR | java.lang.String | setString | getString | updateString |
LONGVARCHAR | java.lang.String | setString | getString | updateString |
MORDEU | boleano | setBoolean | getBoolean | updateBoolean |
NUMÉRICO | java.math.BigDecimal | setBigDecimal | getBigDecimal | UpdateBigDecimal |
SMALLINT | baixo | setShort | getShort | updateShort |
BIGINT | longo | setLong | getLong | updateLong |
REAL | flutuador | setFloat | getFloat | updateFloat |
FLUTUADOR | flutuador | setFloat | getFloat | updateFloat |
EM DOBRO | em dobro | setDouble | getDouble | updateDouble |
BINÁRIO | byte[] | setBytes | getBytes | updateBytes |
ENCONTRO | java.sql.Date | setDate | getDate | data de atualização |
TEMPO | java.sql.Time | definir tempo | consiga tempo | tempo de atualização |
TIMESTAMP | java.sql.Timestamp | setTimestamp | getTimestamp | updateTimeStamp |
CLOB | java.sql.Clob | setClob | getClob | updateClob |
BLOB | java.sql.Blob | setBlob | getBlob | updateBlob |
VARIEDADE | Variedade | setArray | getArray | updateArray |
XML | Xml | setSQLXML | getSQLXML | updateSQLXML |
Tipo estruturado | Objeto | setObject | getObject | updateObject |
Temos os métodos setXXX, getXXX e updateXXX para tipos de dados básicos em nossos tutoriais anteriores. Você pode se referir a isso.
Aqui, explicamos os tipos de clob e blob no exemplo a seguir.
Programa de exemplo BLOB
package com.STH.JDBC; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.sql.Blob; import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; public class Blob_Example { @SuppressWarnings('resource') public static void main(String[] args) throws ClassNotFoundException, IOException { // TODO Auto-generated method stub String QUERY = 'Create table Blob_Sample_Example ( PicName varchar2(30), picture BLOB)'; //Select Query to get the Data from employee_details table //Update query to set the email id for the employee whose empNUM is 1001 Class.forName('oracle.jdbc.driver.OracleDriver'); System.out.println('Establishing Connection'); try(Connection conn = DriverManager.getConnection('jdbc:oracle:thin:system/pass123@localhost:1521:XE')) { Statement statemnt1 = conn.createStatement(); //Executing the Create Query statemnt1.execute(QUERY); System.out.println('Table has been created for BLOB type'); System.out.println('Inserting data into Blob_Sample_Example table'); String insert_query = ' insert into Blob_Sample_Example values(?,?)'; //Passing the values for preparedStatement PreparedStatement pstmnt = conn.prepareStatement(insert_query); pstmnt.setString(1, 'Sotware Testing Help'); //Mention Image path to store the image in DB FileInputStream inputStream = new FileInputStream('D:\Bhakiya\Bhakiya\JDBC\Software Testing Pic.png'); pstmnt.setBlob(2, inputStream); //Executing the preparedStatement to insert the data pstmnt.execute(); System.out.println('Retrieving data'); ResultSet rs = statemnt1.executeQuery('select * from Blob_Sample_Example'); while(rs.next()) { //Getting Picture Name System.out.println('Picture Name:' + rs.getString(1)); Blob blob1 = rs.getBlob(2); //using blob retrieving the Image byte byteArray[] = blob1.getBytes(1,(int)blob1.length()); FileOutputStream outPutStream = new FileOutputStream('D:\Bhakiya\Bhakiya\JDBC\Software Testing Pic output.png'); outPutStream.write(byteArray); System.out.println(' Go to the following path: D:\Bhakiya\Bhakiya\JDBC\Software Testing Pic output.png'); } } catch (SQLException e) { e.printStackTrace(); } } }
Resultado:
O arquivo foi salvo com sucesso no caminho fornecido.
Explicação:
No programa acima o que fizemos foi Primeiro criamos / salvamos uma imagem na pasta 'D: \ Bhakiya \ Bhakiya \ JDBC' . Este local é apenas um exemplo. Você pode criar seu próprio caminho de arquivo em seu sistema. O nome do arquivo é uma imagem de teste de software. Em seguida, criamos um programa Java para armazenar essa imagem na tabela DB e recuperar a imagem da tabela e armazená-la no sistema local.
Até agora, discutimos a visão geral da tarefa. Agora veremos como o conseguimos no programa.
# 1) Crie uma tabela no banco de dados para armazenar a imagem.
Sintaxe:
String QUERY = 'Create table Blob_Sample_Example ( PicName varchar2(30), picture BLOB)';
Na consulta acima, temos 2 colunas.
- PicName - varchar2 -> É usado para armazenar o nome da imagem
- picture - BLOB -> É utilizado para armazenar a Figura na Tabela.
O tipo de dados BLOB é usado para armazenar a figura / imagem na tabela do banco de dados.
#dois) A conexão e a instrução foram criadas e chamadas de método execute para executar a consulta CREATE.
statemnt1.execute(QUERY);
# 3) A seguir, criamos a consulta de inserção e a executamos usando PreparedStatement.
Sintaxe PreparedStatement:
PreparedStatement pstmnt = conn.prepareStatement(insert_query);
# 4) Usando setString () - defina o nome da imagem.
# 5) Para definir a imagem, use a classe FileInputStream para passar a localização da imagem.
Sintaxe:
FileInputStream inputStream = new FileInputStream('Picture Full Path');
Então, usando o método setBlob (), podemos definir a imagem no objeto PreparedStatement. Depois disso, chamei o método execute de PreparedStatement. Isso irá inserir os dados fornecidos na Tabela.
Após executar a consulta de inserção, usando o objeto ResultSet estamos recuperando os dados da Tabela (usando a Consulta Select).
# 6) Usando o método getString, podemos obter o valor da coluna PicName.
# 7) Para obter a imagem, siga as etapas abaixo:
- Crie o objeto Blob e atribua os valores de retorno do método getBlob do objeto ResultSet.
- A sintaxe para isso é: Blob blob1 = rs.getBlob ();
- Crie um objeto de matriz de bytes e obtenha o valor do objeto Blob como bytes.
- Crie o objeto FileOutputStream e passe o caminho completo para armazenar a imagem nesse caminho. Chame o método write () do objeto FileOutputStream - que armazenará a imagem.
- Depois disso, o programa foi executado com sucesso.
# 8) Vá para o local da imagem de saída e verifique se a entrada e a saída são iguais.
Programa de exemplo CLOB
package com.STH.JDBC; import java.io.FileInputStream; import java.io.FileOutputStream; import java.io.FileReader; import java.io.FileWriter; import java.io.IOException; import java.io.Reader; import java.sql.Blob; import java.sql.Clob; import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; import java.sql.Statement; public class Clob_Example { public static void main(String[] args) throws ClassNotFoundException, IOException { // TODO Auto-generated method stub String QUERY = 'Create table Clob_Sample_Example ( FileName varchar2(30), StoreFile CLOB)'; //Create Query to create new table for CLOB example Class.forName('oracle.jdbc.driver.OracleDriver'); //Creating Connection System.out.println('Establishing Connection'); try(Connection conn = DriverManager.getConnection('jdbc:oracle:thin:system/pass123@localhost:1521:XE')) { Statement statemnt1 = conn.createStatement(); //Executing create query statemnt1.execute(QUERY); System.out.println('Table has been created for CLOB type'); System.out.println('Inserting data into Clob_Sample_Example table'); //Insert Query String insert_query = ' insert into Clob_Sample_Example values(?,?)'; //Passing Parameters for PreparedStatement PreparedStatement pstmnt = conn.prepareStatement(insert_query); pstmnt.setString(1, 'File1'); FileReader fileRead = new FileReader('D:\Bhakiya\Bhakiya\JDBC\file1.txt'); pstmnt.setClob(2, fileRead); //Executing the PreparedStatement pstmnt.execute(); System.out.println('Retrieving data'); ResultSet rs = statemnt1.executeQuery('select * from Clob_Sample_Example'); while(rs.next()) { System.out.println('File Name:' + rs.getString(1)); //Getting file data Clob clob1 = rs.getClob(2); Reader r = clob1.getCharacterStream(); //Using Reader - read the data and Writer - Write the data in file in the given location FileWriter fileWrite = new FileWriter('D:\Bhakiya\Bhakiya\JDBC\file1 output.txt'); int i; while((i=r.read())!=-1) fileWrite.write(i); fileWrite.close(); System.out.println(' Go to the following path: D:\Bhakiya\Bhakiya\JDBC\file1 output.txt'); } } catch (SQLException e) { e.printStackTrace(); } } }
Resultado:
Arquivo de entrada:
O arquivo foi salvo com sucesso no caminho fornecido.
Arquivo de saída:
Explicação:
No programa acima, o que fizemos foi primeiro criar / salvar um arquivo de texto “file1.txt” na pasta “D: \ Bhakiya \ Bhakiya \ JDBC”. Este local é apenas um exemplo. Você pode criar seu próprio caminho de arquivo em seu sistema. Em seguida, criamos um programa Java para armazenar esse arquivo na tabela de banco de dados e recuperar esse arquivo da tabela e armazená-lo no sistema local.
Até agora, discutimos a visão geral da tarefa. Agora veremos como o conseguimos no programa.
# 1) Crie uma tabela no banco de dados para armazenar a imagem.
Abaixo está a sintaxe da consulta CREATE TABLE:
String QUERY = 'Create table Clob_Sample_Example ( FileName varchar2(30), StoreFile CLOB)';
Na consulta acima, temos 2 colunas.
- FileName - varchar2 -> É usado para armazenar o nome da imagem.
- StoreFile - CLOB -> É usado para armazenar o arquivo na tabela.
O tipo de dados CLOB é usado para armazenar o tipo de caractere de dados binários na tabela de banco de dados
#dois) A conexão e a instrução foram criadas e chamadas de método execute para executar a consulta CREATE.
statemnt1.execute(QUERY);
# 3) A seguir, criamos a consulta de inserção e a executamos usando PreparedStatement.
Sintaxe PreparedStatement:
PreparedStatement pstmnt = conn.prepareStatement(insert_query);
# 4) Usando setString () - defina o nome do FileName.
# 5) Para definir / armazenar o arquivo, use a classe FileReader para passar o arquivo com o local de preenchimento.
Sintaxe:
FileReader fileRead = new FileReader('D:\Bhakiya\Bhakiya\JDBC\file1.txt');
Então, usando o método setClob (), podemos definir o arquivo no objeto PreparedStatement. Depois disso, chamei o método execute de PreparedStatement. Isso irá inserir os dados fornecidos na Tabela.
Após executar a consulta de inserção, utilizando o objeto ResultSet estamos recuperando os dados da Tabela (Utilizando Consulta Select).
Selecione Consulta:
'select * from Clob_Sample_Example'
# 6) Usando o método getString, podemos obter o valor da coluna FileName.
# 7) Para obter o arquivo, nós seguimos as etapas abaixo:
- Crie o objeto Clob e atribua os valores de retorno do método getClob do objeto ResultSet.
- A sintaxe para isso é: Clob clob1 = rs.getClob ();
- Crie o objeto Reader e obtenha o valor do objeto Clob como Character.
- Crie o objeto FileWriter e passe o caminho completo para armazenar o arquivo nesse caminho. Chame o método write () do objeto FileWrite - que gravará os dados no arquivo no local.
- Depois disso, o programa foi executado com sucesso.
# 8) Vá para a localização do arquivo de Saída e verifique se os arquivos de entrada e saída são os mesmos.
Pontos para lembrar:
- Propriedades ACID explica gerenciamento de transações em banco de dados.
- Commit (), rollback () e ponto de salvamento são as operações mais importantes no Gerenciamento de transações.
- O commit fará as alterações permanentemente no banco de dados, o rollback desfará as alterações até o último commit ou o ponto de salvamento mencionado e o ponto de salvamento ajuda a criar um ponto de verificação.
- O banco de dados mantém os tipos de dados SQL e Java mantém os tipos de dados Java. O driver JDBC é usado para lidar com essa conversão.
- O próprio driver JDBC tem algum tipo de identificadores SQL, então o programador não precisa se preocupar com os tipos de dados.
perguntas frequentes
P # 1) Qual é o tipo de dados JDBC?
Responda: Java tem seus tipos de dados e o banco de dados tem seus tipos de dados. O driver JDBC converte o tipo de dados Java no tipo de dados SQL apropriado que será aceito pelo banco de dados. Os objetos ResultSet também fornecem métodos setXXX () e métodos getXXX () disponíveis para os tipos de dados apropriados.
Q # 2) Qual é o tipo de dados para a data em Java?
Responda: A data em Java não é apenas um tipo de dados, mas uma classe. Uma data em Java contém a data, a hora, o ano, o nome do dia, o dia da semana e o fuso horário. A classe Date tem os métodos apropriados para recuperar os dados relevantes.
P # 3) Qual é a diferença entre java.util.Date e java.sql.Date?
Responda: A principal diferença é java.util.Date também contém informações sobre data e hora. Mas java.sql.Date tem as informações apenas sobre a data. Esta é a principal diferença, não podemos mapear java.util.Date diretamente com java.sql.Date.
P # 4) Temos uma classe em Java para representar o tipo TIME e TIMESTAMP para SQL?
Responda: Sim, temos uma classe para TIME e tipo TIMESTAMP para SQL. A classe java.sql.Time representa informações relacionadas ao TIME. A classe java.sql.timestamp representa informações relacionadas a TIMESTAMP.
P # 5) Como iniciar uma transação em JDBC?
Responda: A conexão JDBC começa com o modo de confirmação automática habilitado, onde cada instrução SQL é considerada como uma transação. Não existe um processo específico para iniciar uma transação em JDBC. Quando você cria uma conexão e começa a executar a instrução SQL, é aí que a transação foi iniciada.
P # 6) Qual é o método commit () em Java?
Responda: O método Commit () em Java é usado para salvar as alterações feitas desde o último commit (). O método Commit () está disponível na interface de conexão. Usando um objeto de conexão, podemos chamar o commit ().
P # 7) Qual é o método de reversão em Java?
Responda: Após o último commit (), se ocorrer algum problema, podemos chamar o método rollback () para reverter todas as alterações feitas até que o último método commit.rollback () esteja disponível na interface de conexão. Usando um objeto de conexão, podemos chamar o método rollback ().
Conclusão
Aqui, cobrimos os tipos de dados em Java e DB e como o driver JDBC os manipula. Discutimos as propriedades do ACID. Isso é muito importante para o setor bancário. Será muito útil para sua carreira. Na seção Gerenciamento de transações, discutimos os métodos de confirmação e reversão, como commit (), rollback (), setAutoCommit (), setSavepoint () e releaseSavepoint ().
Leitura recomendada
- Tutorial Java JDBC: O que é JDBC (Java Database Connectivity)
- Tutorial de conexão Java JDBC com exemplo de programação
- JDBC DriverManager, JDBC PreparedStatement And Statement
- ResultSet JDBC: como usar o ResultSet Java para recuperar dados
- DataTypes Java, Loops, Arrays, Switch e Assertions
- Método Java String length () com exemplos
- Como usar o método toString Java?
- Teste de banco de dados Selenium (usando WebDriver e API JDBC)