Spring JDBC - Guia rápido
Ao trabalhar com banco de dados usando JDBC antigo simples, torna-se complicado escrever código desnecessário para lidar com exceções, abrindo e fechando conexões de banco de dados, etc. No entanto, o Spring JDBC Framework cuida de todos os detalhes de baixo nível, começando pela abertura da conexão, preparação e executar a instrução SQL, processar exceções, manipular transações e, finalmente, fechar a conexão.
O que você precisa fazer é apenas definir os parâmetros de conexão e especificar a instrução SQL a ser executada e fazer o trabalho necessário para cada iteração enquanto busca dados do banco de dados.
O Spring JDBC fornece várias abordagens e classes correspondentes diferentes para fazer a interface com o banco de dados. Neste tutorial, usaremos a abordagem clássica e mais popular que faz uso da classe JDBC Template do framework. Esta é a classe de estrutura central que gerencia toda a comunicação do banco de dados e tratamento de exceções.
Classe de modelo JDBC
A classe JDBC Template executa consultas SQL, atualiza instruções e chamadas de procedimento armazenado, realiza iteração em ResultSets e extração de valores de parâmetro retornados. Ele também captura exceções JDBC e as traduz para a hierarquia de exceção genérica e mais informativa definida no pacote org.springframework.dao.
As instâncias da classe JDBC Template são threadsafe, uma vez configuradas. Portanto, você pode configurar uma única instância de um modelo JDBC e, em seguida, injetar com segurança essa referência compartilhada em vários DAOs.
Uma prática comum ao usar a classe JDBC Template é configurar um DataSource em seu arquivo de configuração Spring e, em seguida, injetar em dependência esse bean DataSource compartilhado em suas classes DAO. O modelo JDBC é criado no setter para o DataSource.
Objeto de acesso a dados (DAO)
DAO significa Data Access Objectque é comumente usado para interação com o banco de dados. Os DAOs existem para fornecer um meio de ler e gravar dados no banco de dados e devem expor essa funcionalidade por meio de uma interface pela qual o restante do aplicativo os acessará.
O suporte a Data Access Object (DAO) no Spring torna mais fácil trabalhar com tecnologias de acesso a dados como JDBC, Hibernate, JPA ou JDO de maneira consistente.
Este capítulo o conduz pelo processo de configuração do Spring-AOP em sistemas baseados em Windows e Linux. O Spring AOP pode ser facilmente instalado e integrado ao seu ambiente Java e MAVEN atual, seguindo algumas etapas simples sem quaisquer procedimentos de configuração complexos. A administração do usuário é necessária durante a instalação.
Requisitos de sistema
JDK | Java SE 2 JDK 1.5 ou superior |
Memória | 1 GB de RAM (recomendado) |
Espaço em disco | Sem requisitos mínimos |
Versão do sistema operacional | Windows XP ou superior, Linux |
Vamos agora prosseguir com as etapas para instalar o Spring AOP.
Etapa 1 - Verifique sua instalação Java
Em primeiro lugar, você precisa ter o Java Software Development Kit (SDK) instalado em seu sistema. Para verificar isso, execute qualquer um dos dois comandos a seguir, dependendo da plataforma em que está trabalhando.
Se a instalação do Java foi feita corretamente, ele exibirá a versão atual e as especificações de sua instalação do Java. Um exemplo de saída é fornecido na tabela a seguir.
Plataforma | Comando | Saída de amostra |
---|---|---|
janelas | Abra o console de comando e digite - \>java -version |
Versão Java "1.7.0_60" Java (TM) SE Run Time Environment (build 1.7.0_60-b19) Java Hotspot (TM) Servidor VM de 64 bits (versão 24.60-b09, modo misto) |
Linux | Abra o terminal de comando e digite - $java -version |
versão java "1.7.0_25" Open JDK Runtime Environment (rhel-2.3.10.4.el6_4-x86_64) Abra o servidor VM JDK de 64 bits (compilação 23.7-b01, modo misto) |
Presumimos que os leitores deste tutorial tenham o Java SDK versão 1.7.0_60 instalado no sistema. Caso você não tenha Java SDK, baixe sua versão atual emhttps://www.oracle.com/technetwork/java/javase/downloads/index.html e instalá-lo.
Etapa 2 - Definir seu ambiente Java
Defina a variável de ambiente JAVA_HOME para apontar para o local do diretório base onde o Java está instalado em sua máquina. Por exemplo,
Plataforma | Descrição |
---|---|
janelas | Defina JAVA_HOME como C: \ ProgramFiles \ java \ jdk1.7.0_60 |
Linux | Exportar JAVA_HOME = / usr / local / java-current |
Anexe o caminho completo do local do compilador Java ao caminho do sistema.
Plataforma | Descrição |
---|---|
janelas | Anexe a string "C: \ Arquivos de programas \ Java \ jdk1.7.0_60 \ bin" ao final da variável de sistema PATH. |
Linux | Exportar PATH = $ PATH: $ JAVA_HOME / bin / |
Execute o comando java -version no prompt de comando, conforme explicado acima.
Etapa 3 - Baixe o arquivo Maven
Baixe o Maven 3.3.3 de https://maven.apache.org/download.cgi
SO | Nome do arquivo |
---|---|
janelas | apache-maven-3.3.3-bin.zip |
Linux | apache-maven-3.3.3-bin.tar.gz |
Mac | apache-maven-3.3.3-bin.tar.gz |
Etapa 4 - Extraia o arquivo Maven
Extraia o arquivo para o diretório em que deseja instalar o Maven 3.3.3. O subdiretório apache-maven-3.3.3 será criado a partir do arquivo.
SO | Localização (pode ser diferente com base na sua instalação) |
---|---|
janelas | C: \ Arquivos de programas \ Apache Software Foundation \ apache-maven-3.3.3 |
Linux | / usr / local / apache-maven |
Mac | / usr / local / apache-maven |
Etapa 5 - Definir as variáveis de ambiente Maven
Adicione M2_HOME, M2, MAVEN_OPTS às variáveis de ambiente.
SO | Resultado |
---|---|
janelas | Defina as variáveis de ambiente usando propriedades do sistema. M2_HOME = C: \ Arquivos de programas \ Apache Software Foundation \ apachemaven-3.3.3 M2 =% M2_HOME% \ bin MAVEN_OPTS = -Xms256m -Xmx512m |
Linux | Abra o terminal de comando e defina as variáveis de ambiente. export M2_HOME = /usr/local/apache-maven/apache-maven-3.3.3 exportar M2 = $ M2_HOME / bin export MAVEN_OPTS = -Xms256m -Xmx512m |
Mac | Abra o terminal de comando e defina as variáveis de ambiente. export M2_HOME = /usr/local/apache-maven/apache-maven-3.3.3 exportar M2 = $ M2_HOME / bin export MAVEN_OPTS = -Xms256m -Xmx512m |
Etapa 6 - Adicionar localização do diretório Maven Bin ao caminho do sistema
Agora anexe a variável M2 ao caminho do sistema.
SO | Resultado |
---|---|
janelas | Anexe a string;% M2% ao final da variável do sistema, Caminho. |
Linux | exportar PATH = $ M2: $ PATH |
Mac | exportar PATH = $ M2: $ PATH |
Etapa 7 - Verificar a instalação do Maven
Agora abra o console, execute o seguinte mvn comando.
SO | Tarefa | Comando |
---|---|---|
janelas | Abrir console de comando | c: \> mvn --version |
Linux | Abra o terminal de comando | $ mvn --version |
Mac | Terminal aberto | máquina: <joseph $ mvn --version |
Finalmente, verifique a saída dos comandos acima, que devem ser algo como a seguir -
SO | Resultado |
---|---|
janelas | Apache Maven 3.3.3 (7994120775791599e205a5524ec3e0dfe41d4a06; 2015-04-22T17: 27: 37 + 05: 30) Página inicial do Maven: C: \ Arquivos de programas \ Apache Software Foundation \ apache-maven-3.3.3 Versão Java: 1.7.0_75, fornecedor: Oracle Corporation Página inicial do Java: C: \ Arquivos de programas \ Java \ jdk1.7.0_75 \ jre Localidade padrão: en_US, codificação de plataforma: Cp1252 |
Linux | Apache Maven 3.3.3 (7994120775791599e205a5524ec3e0dfe41d4a06; 2015-04-22T17: 27: 37 + 05: 30) Página inicial do Maven: /usr/local/apache-maven/apache-maven-3.3.3 Versão Java: 1.7.0_75, fornecedor: Oracle Corporation Página inicial do Java: /usr/local/java-current/jdk1.7.0_75/jre |
Mac | Apache Maven 3.3.3 (7994120775791599e205a5524ec3e0dfe41d4a06; 2015-04-22T17: 27: 37 + 05: 30) Página inicial do Maven: /usr/local/apache-maven/apache-maven-3.3.3 Versão Java: 1.7.0_75, fornecedor: Oracle Corporation Página inicial do Java: /Library/Java/Home/jdk1.7.0_75/jre |
Etapa 8 - Configurar IDE Eclipse
Todos os exemplos neste tutorial foram escritos usando Eclipse IDE. Portanto, sugiro que você tenha a versão mais recente do Eclipse instalada em sua máquina.
Para instalar o Eclipse IDE, baixe os binários mais recentes do Eclipse em https://www.eclipse.org/downloads/. Depois de fazer o download da instalação, descompacte a distribuição binária em um local conveniente. Por exemplo, em C: \ eclipse no Windows ou / usr / local / eclipse no Linux / Unix. Finalmente, defina a variável PATH apropriadamente.
O Eclipse pode ser iniciado executando os comandos a seguir na máquina Windows ou você pode simplesmente clicar duas vezes em eclipse.exe.
%C:\eclipse\eclipse.exe
O Eclipse pode ser iniciado executando os seguintes comandos na máquina Unix (Solaris, Linux, etc.).
$/usr/local/eclipse/eclipse
Após uma inicialização bem-sucedida, se tudo estiver bem, ele deve exibir o seguinte resultado.
Depois de concluir esta última etapa, você está pronto para prosseguir para seu primeiro exemplo de JDBC, que verá no próximo capítulo.
Vamos criar uma tabela de banco de dados Student em nosso banco de dados TEST. Presumo que você esteja trabalhando com banco de dados MySQL. Se você trabalhar com qualquer outro banco de dados, poderá alterar suas consultas DDL e SQL de acordo.
CREATE TABLE Student(
ID INT NOT NULL AUTO_INCREMENT,
NAME VARCHAR(20) NOT NULL,
AGE INT NOT NULL,
PRIMARY KEY (ID)
);
Agora precisamos fornecer uma fonte de dados ao modelo JDBC para que ele possa se configurar para obter acesso ao banco de dados. Você pode configurar o DataSource no arquivo XML com um trecho de código mostrado a seguir -
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "admin"/>
</bean>
No próximo capítulo, escreveremos o primeiro aplicativo usando o banco de dados configurado.
Para entender os conceitos relacionados à estrutura Spring JDBC com a classe JDBC Template, vamos escrever um exemplo simples que implementará as operações Insert e Read na seguinte tabela Student.
CREATE TABLE Student(
ID INT NOT NULL AUTO_INCREMENT,
NAME VARCHAR(20) NOT NULL,
AGE INT NOT NULL,
PRIMARY KEY (ID)
);
Vamos continuar a escrever um aplicativo Spring JDBC simples baseado em console, que demonstrará os conceitos JDBC.
Criar Projeto
Vamos abrir o console de comando, vá para o diretório C: \ MVN e execute o seguinte mvn comando.
C:\MVN>mvn archetype:generate -DgroupId = com.tutorialspoint -DartifactId = Student
-DarchetypeArtifactId = maven-archetype-quickstart -DinteractiveMode = false
O Maven iniciará o processamento e criará a estrutura completa do projeto do aplicativo Java.
[INFO] Scanning for projects...
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building Maven Stub Project (No POM) 1
[INFO] ------------------------------------------------------------------------
[INFO]
[INFO] >>> maven-archetype-plugin:2.4:generate (default-cli) > generate-sources
@ standalone-pom >>>
[INFO]
[INFO] <<< maven-archetype-plugin:2.4:generate (default-cli) < generate-sources
@ standalone-pom <<<
[INFO]
[INFO] --- maven-archetype-plugin:2.4:generate (default-cli) @ standalone-pom --
-
[INFO] Generating project in Batch mode
Downloading: https://repo.maven.apache.org/maven2/org/apache/maven/archetypes/ma
ven-archetype-quickstart/1.0/maven-archetype-quickstart-1.0.jar
Downloaded: https://repo.maven.apache.org/maven2/org/apache/maven/archetypes/mav
en-archetype-quickstart/1.0/maven-archetype-quickstart-1.0.jar (5 KB at 1.1 KB/s
ec)
Downloading: https://repo.maven.apache.org/maven2/org/apache/maven/archetypes/ma
ven-archetype-quickstart/1.0/maven-archetype-quickstart-1.0.pom
Downloaded: https://repo.maven.apache.org/maven2/org/apache/maven/archetypes/mav
en-archetype-quickstart/1.0/maven-archetype-quickstart-1.0.pom (703 B at 1.2 KB/
sec)
[INFO] -------------------------------------------------------------------------
---
[INFO] Using following parameters for creating project from Old (1.x) Archetype:
maven-archetype-quickstart:1.0
[INFO] -------------------------------------------------------------------------
---
[INFO] Parameter: groupId, Value: com.tutorialspoint
[INFO] Parameter: packageName, Value: com.tutorialspoint
[INFO] Parameter: package, Value: com.tutorialspoint
[INFO] Parameter: artifactId, Value: Student
[INFO] Parameter: basedir, Value: C:\MVN
[INFO] Parameter: version, Value: 1.0-SNAPSHOT
[INFO] project created from Old (1.x) Archetype in dir: C:\MVN\Student
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 01:17 min
[INFO] Finished at: 2017-02-19T21:11:14+05:30
[INFO] Final Memory: 15M/114M
[INFO] ------------------------------------------------------------------------
Agora vá para o diretório C: / MVN. Você verá um projeto de aplicativo Java criado com o nome student (conforme especificado em artifactId). Atualize o POM.xml para incluir dependências Spring JDBC. Adicione os arquivos Student.java, StudentMapper.java, MainApp.java, StudentDAO.java e StudentJDBCTemplate.java.
POM.xml
<project xmlns = "http://maven.apache.org/POM/4.0.0"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://maven.apache.org/POM/4.0.0
http://maven.apache.org/maven-v4_0_0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.tutorialspoint</groupId>
<artifactId>Student</artifactId>
<packaging>jar</packaging>
<version>1.0-SNAPSHOT</version>
<name>Student</name>
<url>http://maven.apache.org</url>
<dependencies>
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>3.8.1</version>
<scope>test</scope>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>4.1.0.RELEASE</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>4.1.4.RELEASE</version>
</dependency>
</dependencies>
</project>
A seguir está o conteúdo do arquivo de interface do Data Access Object StudentDAO.java.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
public interface StudentDAO {
/**
* This is the method to be used to initialize
* database resources ie. connection.
*/
public void setDataSource(DataSource ds);
/**
* This is the method to be used to create
* a record in the Student table.
*/
public void create(String name, Integer age);
public Student getStudent(Integer id);
/**
* This is the method to be used to list down
* all the records from the Student table.
*/
public List<Student> listStudents();
}
A seguir está o conteúdo do Student.java Arquivo.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
private Integer id;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getId() {
return id;
}
}
A seguir está o conteúdo do StudentMapper.java Arquivo.
package com.tutorialspoint;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class StudentMapper implements RowMapper<Student> {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
return student;
}
}
A seguir está o arquivo de classe de implementação StudentJDBCTemplate.java para a interface DAO definida StudentDAO.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
public class StudentJDBCTemplate implements StudentDAO {
private DataSource dataSource;
private JdbcTemplate jdbcTemplateObject;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
this.jdbcTemplateObject = new JdbcTemplate(dataSource);
}
public void create(String name, Integer age) {
String SQL = "insert into Student (name, age) values (?, ?)";
jdbcTemplateObject.update( SQL, name, age);
System.out.println("Created Record Name = " + name + " Age = " + age);
return;
}
public List<Student> listStudents() {
String SQL = "select * from Student";
List <Student> students = jdbcTemplateObject.query(SQL, new StudentMapper());
return students;
}
}
A seguir está o conteúdo do MainApp.java Arquivo.
package com.tutorialspoint;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
StudentJDBCTemplate studentJDBCTemplate = (StudentJDBCTemplate)
context.getBean("studentJDBCTemplate");
System.out.println("------Records Creation--------" );
studentJDBCTemplate.create("Zara", 11);
studentJDBCTemplate.create("Nuha", 2);
studentJDBCTemplate.create("Ayan", 15);
System.out.println("------Listing Multiple Records--------" );
List<Student> students = studentJDBCTemplate.listStudents();
for (Student record : students) {
System.out.print("ID : " + record.getId() );
System.out.print(", Name : " + record.getName() );
System.out.println(", Age : " + record.getAge());
}
}
}
A seguir está o arquivo de configuração Beans.xml.
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">
<!-- Initialization for data source -->
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "admin"/>
</bean>
<!-- Definition for studentJDBCTemplate bean -->
<bean id = "studentJDBCTemplate"
class = "com.tutorialspoint.StudentJDBCTemplate">
<property name = "dataSource" ref = "dataSource" />
</bean>
</beans>
Assim que terminar de criar os arquivos de configuração de código-fonte e bean, vamos executar o aplicativo. Se tudo estiver bem com seu aplicativo, ele imprimirá a seguinte mensagem.
------Records Creation--------
Created Record Name = Zara Age = 11
Created Record Name = Nuha Age = 2
Created Record Name = Ayan Age = 15
------Listing Multiple Records--------
ID : 1, Name : Zara, Age : 11
ID : 2, Name : Nuha, Age : 2
ID : 3, Name : Ayan, Age : 15
O exemplo a seguir demonstrará como criar uma consulta usando a consulta Insert com a ajuda do Spring JDBC. Vamos inserir alguns registros na Tabela do Aluno.
Sintaxe
String insertQuery = "insert into Student (name, age) values (?, ?)";
jdbcTemplateObject.update( insertQuery, name, age);
Onde,
insertQuery - Insira a consulta com espaços reservados.
jdbcTemplateObject - Objeto StudentJDBCTemplate para inserir o objeto aluno no banco de dados.
Para entender os conceitos mencionados acima relacionados ao Spring JDBC, vamos escrever um exemplo que irá inserir uma consulta. Para escrever nosso exemplo, vamos ter um Eclipse IDE funcionando e usar as seguintes etapas para criar um aplicativo Spring.
Degrau | Descrição |
---|---|
1 | Atualize o projeto Aluno criado no capítuloSpring JDBC - First Application. |
2 | Atualize a configuração do bean e execute o aplicativo conforme explicado abaixo. |
A seguir está o conteúdo do arquivo de interface do Data Access Object StudentDAO.java.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
public interface StudentDAO {
/**
* This is the method to be used to initialize
* database resources ie. connection.
*/
public void setDataSource(DataSource ds);
/**
* This is the method to be used to create
* a record in the Student table.
*/
public void create(String name, Integer age);
/**
* This is the method to be used to list down
* all the records from the Student table.
*/
public List<Student> listStudents();
}
A seguir está o conteúdo do Student.java Arquivo.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
private Integer id;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getId() {
return id;
}
}
A seguir está o conteúdo do StudentMapper.java Arquivo.
package com.tutorialspoint;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class StudentMapper implements RowMapper<Student> {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
return student;
}
}
A seguir está o arquivo de classe de implementação StudentJDBCTemplate.java para a interface DAO definida StudentDAO.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
public class StudentJDBCTemplate implements StudentDAO {
private DataSource dataSource;
private JdbcTemplate jdbcTemplateObject;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
this.jdbcTemplateObject = new JdbcTemplate(dataSource);
}
public void create(String name, Integer age) {
String insertQuery = "insert into Student (name, age) values (?, ?)";
jdbcTemplateObject.update( insertQuery, name, age);
System.out.println("Created Record Name = " + name + " Age = " + age);
return;
}
public List<Student> listStudents() {
String SQL = "select * from Student";
List <Student> students = jdbcTemplateObject.query(SQL, new StudentMapper());
return students;
}
}
A seguir está o conteúdo do MainApp.java Arquivo.
package com.tutorialspoint;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
StudentJDBCTemplate studentJDBCTemplate =
(StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
System.out.println("------Records Creation--------" );
studentJDBCTemplate.create("Zara", 11);
studentJDBCTemplate.create("Nuha", 2);
studentJDBCTemplate.create("Ayan", 15);
System.out.println("------Listing Multiple Records--------" );
List<Student> students = studentJDBCTemplate.listStudents();
for (Student record : students) {
System.out.print("ID : " + record.getId() );
System.out.print(", Name : " + record.getName() );
System.out.println(", Age : " + record.getAge());
}
}
}
A seguir está o arquivo de configuração Beans.xml.
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">
<!-- Initialization for data source -->
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "admin"/>
</bean>
<!-- Definition for studentJDBCTemplate bean -->
<bean id = "studentJDBCTemplate"
class = "com.tutorialspoint.StudentJDBCTemplate">
<property name = "dataSource" ref = "dataSource" />
</bean>
</beans>
Assim que terminar de criar os arquivos de configuração de código-fonte e bean, vamos executar o aplicativo. Se tudo estiver bem com seu aplicativo, ele imprimirá a seguinte mensagem.
------Records Creation--------
Created Record Name = Zara Age = 11
Created Record Name = Nuha Age = 2
Created Record Name = Ayan Age = 15
------Listing Multiple Records--------
ID : 1, Name : Zara, Age : 11
ID : 2, Name : Nuha, Age : 2
ID : 3, Name : Ayan, Age : 15
O exemplo a seguir demonstrará como ler uma consulta usando Spring JDBC. Leremos os registros disponíveis na Tabela do Aluno.
Sintaxe
String selectQuery = "select * from Student";
List <Student> students = jdbcTemplateObject.query(selectQuery, new StudentMapper());
Onde,
selectQuery - Selecione consulta para ler os alunos.
jdbcTemplateObject - Objeto StudentJDBCTemplate para ler o objeto do aluno do banco de dados.
StudentMapper - StudentMapper é um objeto RowMapper para mapear cada registro obtido para o objeto do aluno.
Para entender os conceitos mencionados acima relacionados ao Spring JDBC, vamos escrever um exemplo que selecionará uma consulta. Para escrever nosso exemplo, vamos ter um Eclipse IDE funcionando e usar as seguintes etapas para criar um aplicativo Spring.
Degrau | Descrição |
---|---|
1 | Atualize o projeto que o Aluno criou no capítulo Spring JDBC - Primeiro Aplicativo . |
2 | Atualize a configuração do bean e execute o aplicativo conforme explicado abaixo. |
A seguir está o conteúdo do arquivo de interface do Data Access Object StudentDAO.java.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
public interface StudentDAO {
/**
* This is the method to be used to initialize
* database resources ie. connection.
*/
public void setDataSource(DataSource ds);
/**
* This is the method to be used to list down
* all the records from the Student table.
*/
public List<Student> listStudents();
}
A seguir está o conteúdo do Student.java Arquivo.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
private Integer id;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getId() {
return id;
}
}
A seguir está o conteúdo do StudentMapper.java Arquivo.
package com.tutorialspoint;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class StudentMapper implements RowMapper<Student> {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
return student;
}
}
A seguir está o arquivo de classe de implementação StudentJDBCTemplate.java para a interface DAO definida StudentDAO.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
public class StudentJDBCTemplate implements StudentDAO {
private DataSource dataSource;
private JdbcTemplate jdbcTemplateObject;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
this.jdbcTemplateObject = new JdbcTemplate(dataSource);
}
public List<Student> listStudents() {
String SQL = "select * from Student";
List <Student> students = jdbcTemplateObject.query(SQL, new StudentMapper());
return students;
}
}
A seguir está o conteúdo do MainApp.java Arquivo.
package com.tutorialspoint;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
StudentJDBCTemplate studentJDBCTemplate =
(StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
System.out.println("------Listing Multiple Records--------" );
List<Student> students = studentJDBCTemplate.listStudents();
for (Student record : students) {
System.out.print("ID : " + record.getId() );
System.out.print(", Name : " + record.getName() );
System.out.println(", Age : " + record.getAge());
}
}
}
A seguir está o arquivo de configuração Beans.xml.
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">
<!-- Initialization for data source -->
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "admin"/>
</bean>
<!-- Definition for studentJDBCTemplate bean -->
<bean id="studentJDBCTemplate"
class = "com.tutorialspoint.StudentJDBCTemplate">
<property name = "dataSource" ref = "dataSource" />
</bean>
</beans>
Assim que terminar de criar os arquivos de configuração de código-fonte e bean, vamos executar o aplicativo. Se tudo estiver bem com seu aplicativo, ele imprimirá a seguinte mensagem.
------Listing Multiple Records--------
ID : 1, Name : Zara, Age : 11
ID : 2, Name : Nuha, Age : 2
ID : 3, Name : Ayan, Age : 15
O exemplo a seguir demonstrará como atualizar uma consulta usando Spring JDBC. Atualizaremos os registros disponíveis na Tabela do Aluno.
Sintaxe
String updateQuery = "update Student set age = ? where id = ?";
jdbcTemplateObject.update(updateQuery, age, id);
Onde,
updateQuery - Atualizar consulta para atualizar o aluno com espaços reservados.
jdbcTemplateObject - Objeto StudentJDBCTemplate para atualizar o objeto aluno no banco de dados.
Para entender os conceitos mencionados acima relacionados ao Spring JDBC, vamos escrever um exemplo que atualizará uma consulta. Para escrever nosso exemplo, vamos ter um Eclipse IDE funcionando e usar as seguintes etapas para criar um aplicativo Spring.
Degrau | Descrição |
---|---|
1 | Atualize o projeto que o Aluno criou no capítulo Spring JDBC - Primeiro Aplicativo . |
2 | Atualize a configuração do bean e execute o aplicativo conforme explicado abaixo. |
A seguir está o conteúdo do arquivo de interface do Data Access Object StudentDAO.java.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
public interface StudentDAO {
/**
* This is the method to be used to initialize
* database resources ie. connection.
*/
public void setDataSource(DataSource ds);
/**
* This is the method to be used to update
* a record into the Student table.
*/
public void update(Integer id, Integer age);
/**
* This is the method to be used to list down
* a record from the Student table corresponding
* to a passed student id.
*/
public Student getStudent(Integer id);
}
A seguir está o conteúdo do Student.java Arquivo.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
private Integer id;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getId() {
return id;
}
}
A seguir está o conteúdo do StudentMapper.java Arquivo.
package com.tutorialspoint;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class StudentMapper implements RowMapper<Student> {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
return student;
}
}
A seguir está o arquivo de classe de implementação StudentJDBCTemplate.java para a interface DAO definida StudentDAO.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
public class StudentJDBCTemplate implements StudentDAO {
private DataSource dataSource;
private JdbcTemplate jdbcTemplateObject;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
this.jdbcTemplateObject = new JdbcTemplate(dataSource);
}
public void update(Integer id, Integer age){
String SQL = "update Student set age = ? where id = ?";
jdbcTemplateObject.update(SQL, age, id);
System.out.println("Updated Record with ID = " + id );
return;
}
public Student getStudent(Integer id) {
String SQL = "select * from Student where id = ?";
Student student = jdbcTemplateObject.queryForObject(
SQL, new Object[]{id}, new StudentMapper());
return student;
}
}
A seguir está o conteúdo do MainApp.java Arquivo.
package com.tutorialspoint;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
StudentJDBCTemplate studentJDBCTemplate =
(StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
System.out.println("----Updating Record with ID = 2 -----" );
studentJDBCTemplate.update(2, 20);
System.out.println("----Listing Record with ID = 2 -----" );
Student student = studentJDBCTemplate.getStudent(2);
System.out.print("ID : " + student.getId() );
System.out.print(", Name : " + student.getName() );
System.out.println(", Age : " + student.getAge());
}
}
A seguir está o arquivo de configuração Beans.xml.
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">
<!-- Initialization for data source -->
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "admin"/>
</bean>
<!-- Definition for studentJDBCTemplate bean -->
<bean id = "studentJDBCTemplate"
class = "com.tutorialspoint.StudentJDBCTemplate">
<property name = "dataSource" ref = "dataSource" />
</bean>
</beans>
Assim que terminar de criar os arquivos de configuração de código-fonte e bean, vamos executar o aplicativo. Se tudo estiver bem com seu aplicativo, ele imprimirá a seguinte mensagem.
----Updating Record with ID = 2 -----
Updated Record with ID = 2
----Listing Record with ID = 2 -----
ID : 2, Name : Nuha, Age : 20
O exemplo a seguir demonstrará como excluir uma consulta usando Spring JDBC. Excluiremos um dos registros disponíveis na Tabela do aluno.
Sintaxe
String deleteQuery = "delete from Student where id = ?";
jdbcTemplateObject.update(deleteQuery, id);
Onde,
deleteQuery - Excluir consulta para excluir o aluno com espaços reservados.
jdbcTemplateObject - Objeto StudentJDBCTemplate para excluir o objeto aluno no banco de dados.
Para entender os conceitos mencionados acima relacionados ao Spring JDBC, vamos escrever um exemplo que excluirá uma consulta. Para escrever nosso exemplo, vamos ter um Eclipse IDE funcionando e usar as seguintes etapas para criar um aplicativo Spring.
Degrau | Descrição |
---|---|
1 | Atualize o projeto que o Aluno criou no capítulo Spring JDBC - Primeiro Aplicativo . |
2 | Atualize a configuração do bean e execute o aplicativo conforme explicado abaixo. |
A seguir está o conteúdo do arquivo de interface do Data Access Object StudentDAO.java.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
public interface StudentDAO {
/**
* This is the method to be used to initialize
* database resources ie. connection.
*/
public void setDataSource(DataSource ds);
/**
* This is the method to be used to list down
* all the records from the Student table.
*/
public List<Student> listStudents();
/**
* This is the method to be used to delete
* a record from the Student table corresponding
* to a passed student id.
*/
public void delete(Integer id);
}
A seguir está o conteúdo do Student.java Arquivo.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
private Integer id;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getId() {
return id;
}
}
A seguir está o conteúdo do StudentMapper.java Arquivo.
package com.tutorialspoint;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class StudentMapper implements RowMapper<Student> {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
return student;
}
}
A seguir está o arquivo de classe de implementação StudentJDBCTemplate.java para a interface DAO definida StudentDAO.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
public class StudentJDBCTemplate implements StudentDAO {
private DataSource dataSource;
private JdbcTemplate jdbcTemplateObject;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
this.jdbcTemplateObject = new JdbcTemplate(dataSource);
}
public List<Student> listStudents() {
String SQL = "select * from Student";
List <Student> students = jdbcTemplateObject.query(SQL, new StudentMapper());
return students;
}
public void delete(Integer id){
String SQL = "delete from Student where id = ?";
jdbcTemplateObject.update(SQL, id);
System.out.println("Deleted Record with ID = " + id );
return;
}
}
A seguir está o conteúdo do MainApp.java Arquivo.
package com.tutorialspoint;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
StudentJDBCTemplate studentJDBCTemplate =
(StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
System.out.println("----Delete Record with ID = 2 -----" );
studentJDBCTemplate.delete(2);
System.out.println("------Listing Multiple Records--------" );
List<Student> students = studentJDBCTemplate.listStudents();
for (Student record : students) {
System.out.print("ID : " + record.getId() );
System.out.print(", Name : " + record.getName() );
System.out.println(", Age : " + record.getAge());
}
}
}
A seguir está o arquivo de configuração Beans.xml.
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">
<!-- Initialization for data source -->
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "admin"/>
</bean>
<!-- Definition for studentJDBCTemplate bean -->
<bean id = "studentJDBCTemplate"
class = "com.tutorialspoint.StudentJDBCTemplate">
<property name = "dataSource" ref = "dataSource" />
</bean>
</beans>
Assim que terminar de criar os arquivos de configuração de código-fonte e bean, vamos executar o aplicativo. Se tudo estiver bem com seu aplicativo, ele imprimirá a seguinte mensagem.
----Updating Record with ID = 2 -----
Updated Record with ID = 2
----Listing Record with ID = 2 -----
ID : 2, Name : Nuha, Age : 20
O exemplo a seguir demonstrará como chamar um procedimento armazenado usando Spring JDBC. Leremos um dos registros disponíveis na Tabela do aluno chamando um procedimento armazenado. Vamos passar uma id e receber um registro de estudante.
Sintaxe
SimpleJdbcCall jdbcCall = new SimpleJdbcCall(dataSource).withProcedureName("getRecord");
SqlParameterSource in = new MapSqlParameterSource().addValue("in_id", id);
Map<String, Object> out = jdbcCall.execute(in);
Student student = new Student();
student.setId(id);
student.setName((String) out.get("out_name"));
student.setAge((Integer) out.get("out_age"));
Onde,
jdbcCall - Objeto SimpleJdbcCall para representar um procedimento armazenado.
in - Objeto SqlParameterSource para passar um parâmetro para um procedimento armazenado.
student - Objeto do aluno.
out - Objeto de mapa para representar a saída do resultado da chamada de procedimento armazenado.
o SimpleJdbcCallclasse pode ser usada para chamar um procedimento armazenado com parâmetros IN e OUT. Você pode usar essa abordagem ao trabalhar com qualquer um dos RDBMS, como Apache Derby, DB2, MySQL, Microsoft SQL Server, Oracle e Sybase.
Para entender a abordagem, considere o seguinte procedimento armazenado do MySQL, que pega a ID do aluno e retorna o nome e a idade do aluno correspondente usando os parâmetros OUT. Vamos criar este procedimento armazenado no banco de dados TEST usando o prompt de comando do MySQL -
DELIMITER $$ DROP PROCEDURE IF EXISTS `TEST`.`getRecord` $$
CREATE PROCEDURE `TEST`.`getRecord` (
IN in_id INTEGER,
OUT out_name VARCHAR(20),
OUT out_age INTEGER)
BEGIN
SELECT name, age
INTO out_name, out_age
FROM Student where id = in_id;
END $$
DELIMITER ;
Para entender os conceitos mencionados acima relacionados ao Spring JDBC, vamos escrever um exemplo que chamará um procedimento armazenado. Para escrever nosso exemplo, vamos ter um Eclipse IDE funcionando e usar as seguintes etapas para criar um aplicativo Spring.
Degrau | Descrição |
---|---|
1 | Atualize o projeto que o Aluno criou no capítulo Spring JDBC - Primeiro Aplicativo . |
2 | Atualize a configuração do bean e execute o aplicativo conforme explicado abaixo. |
A seguir está o conteúdo do arquivo de interface do Data Access Object StudentDAO.java.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
public interface StudentDAO {
/**
* This is the method to be used to initialize
* database resources ie. connection.
*/
public void setDataSource(DataSource ds);
/**
* This is the method to be used to list down
* a record from the Student table corresponding
* to a passed student id.
*/
public Student getStudent(Integer id);
}
A seguir está o conteúdo do Student.java Arquivo.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
private Integer id;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getId() {
return id;
}
}
A seguir está o conteúdo do StudentMapper.java Arquivo.
package com.tutorialspoint;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class StudentMapper implements RowMapper<Student> {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
return student;
}
}
A seguir está o arquivo de classe de implementação StudentJDBCTemplate.java para a interface DAO definida StudentDAO.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
import org.springframework.jdbc.core.simple.SimpleJdbcCall;
public class StudentJDBCTemplate implements StudentDAO {
private DataSource dataSource;
private JdbcTemplate jdbcTemplateObject;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
this.jdbcTemplateObject = new JdbcTemplate(dataSource);
}
public Student getStudent(Integer id) {
SimpleJdbcCall jdbcCall = new
SimpleJdbcCall(dataSource).withProcedureName("getRecord");
SqlParameterSource in = new MapSqlParameterSource().addValue("in_id", id);
Map<String, Object> out = jdbcCall.execute(in);
Student student = new Student();
student.setId(id);
student.setName((String) out.get("out_name"));
student.setAge((Integer) out.get("out_age"));
return student;
}
}
O código que você escreve para a execução da chamada envolve a criação de um SqlParameterSource contendo o parâmetro IN. É importante combinar o nome fornecido para o valor de entrada com o nome do parâmetro declarado no procedimento armazenado. O método execute usa os parâmetros IN e retorna um Map contendo quaisquer parâmetros de saída digitados pelo nome conforme especificado no procedimento armazenado.
A seguir está o conteúdo do MainApp.java Arquivo.
package com.tutorialspoint;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
StudentJDBCTemplate studentJDBCTemplate =
(StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
Student student = studentJDBCTemplate.getStudent(1);
System.out.print("ID : " + student.getId() );
System.out.print(", Name : " + student.getName() );
System.out.println(", Age : " + student.getAge());
}
}
A seguir está o arquivo de configuração Beans.xml.
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">
<!-- Initialization for data source -->
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "admin"/>
</bean>
<!-- Definition for studentJDBCTemplate bean -->
<bean id = "studentJDBCTemplate"
class = "com.tutorialspoint.StudentJDBCTemplate">
<property name = "dataSource" ref = "dataSource" />
</bean>
</beans>
Assim que terminar de criar os arquivos de configuração de código-fonte e bean, vamos executar o aplicativo. Se tudo estiver bem com seu aplicativo, ele imprimirá a seguinte mensagem.
ID : 1, Name : Zara, Age : 11
O exemplo a seguir demonstrará como chamar uma função armazenada usando Spring JDBC. Leremos um dos registros disponíveis na Tabela do aluno chamando uma função armazenada. Vamos passar uma id e receber um nome de aluno.
Sintaxe
SimpleJdbcCall jdbcCall = new
SimpleJdbcCall(dataSource).withFunctionName("get_student_name");
SqlParameterSource in = new MapSqlParameterSource().addValue("in_id", id);
String name = jdbcCall.executeFunction(String.class, in);
Student student = new Student();
student.setId(id);
student.setName(name);
Onde,
in - Objeto SqlParameterSource para passar um parâmetro para uma função armazenada.
jdbcCall - Objeto SimpleJdbcCall para representar uma função armazenada.
jdbcTemplateObject - Objeto StudentJDBCTemplate para função armazenada chamada do banco de dados.
student - Objeto do aluno.
o SimpleJdbcCallclasse pode ser usada para chamar uma função armazenada com o parâmetro IN e um valor de retorno. Você pode usar essa abordagem ao trabalhar com qualquer um dos RDBMS, como Apache Derby, DB2, MySQL, Microsoft SQL Server, Oracle e Sybase.
Para entender a abordagem, considere o seguinte procedimento armazenado do MySQL, que pega a ID do aluno e retorna o nome do aluno correspondente. Então, vamos criar esta função armazenada em seu banco de dados TEST usando o prompt de comando do MySQL -
DELIMITER $$
DROP FUNCTION IF EXISTS `TEST`.`get_student_name` $$
CREATE FUNCTION `get_student_name` (in_id INTEGER)
RETURNS varchar(200)
BEGIN
DECLARE out_name VARCHAR(200);
SELECT name
INTO out_name
FROM Student where id = in_id;
RETURN out_name;
DELIMITER ;
Para entender os conceitos mencionados acima relacionados ao Spring JDBC, vamos escrever um exemplo que chamará uma função armazenada. Para escrever nosso exemplo, vamos ter um Eclipse IDE funcionando e usar as seguintes etapas para criar um aplicativo Spring.
Degrau | Descrição |
---|---|
1 | Atualize o projeto que o Aluno criou no capítulo Spring JDBC - Primeiro Aplicativo . |
2 | Atualize a configuração do bean e execute o aplicativo conforme explicado abaixo. |
A seguir está o conteúdo do arquivo de interface do Data Access Object StudentDAO.java.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
public interface StudentDAO {
/**
* This is the method to be used to initialize
* database resources ie. connection.
*/
public void setDataSource(DataSource ds);
/**
* This is the method to be used to list down
* a record from the Student table corresponding
* to a passed student id.
*/
public Student getStudent(Integer id);
}
A seguir está o conteúdo do Student.java Arquivo.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
private Integer id;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getId() {
return id;
}
}
A seguir está o conteúdo do StudentMapper.java Arquivo.
package com.tutorialspoint;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class StudentMapper implements RowMapper<Student> {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
return student;
}
}
A seguir está o arquivo de classe de implementação StudentJDBCTemplate.java para a interface DAO definida StudentDAO.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
import org.springframework.jdbc.core.simple.SimpleJdbcCall;
public class StudentJDBCTemplate implements StudentDAO {
private DataSource dataSource;
private JdbcTemplate jdbcTemplateObject;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
this.jdbcTemplateObject = new JdbcTemplate(dataSource);
}
public Student getStudent(Integer id) {
SimpleJdbcCall jdbcCall = new
SimpleJdbcCall(dataSource).withFunctionName("get_student_name");
SqlParameterSource in = new MapSqlParameterSource().addValue("in_id", id);
String name = jdbcCall.executeFunction(String.class, in);
Student student = new Student();
student.setId(id);
student.setName(name);
return student;
}
}
O código que você escreve para a execução da chamada envolve a criação de um SqlParameterSource contendo o parâmetro IN. É importante combinar o nome fornecido para o valor de entrada com o nome do parâmetro declarado na função armazenada. O método executeFunction usa os parâmetros IN e retorna uma String conforme especificado na função armazenada.
A seguir está o conteúdo do MainApp.java Arquivo
package com.tutorialspoint;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
StudentJDBCTemplate studentJDBCTemplate =
(StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
Student student = studentJDBCTemplate.getStudent(1);
System.out.print("ID : " + student.getId() );
System.out.print(", Name : " + student.getName() );
}
}
A seguir está o arquivo de configuração Beans.xml.
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">
<!-- Initialization for data source -->
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "admin"/>
</bean>
<!-- Definition for studentJDBCTemplate bean -->
<bean id = "studentJDBCTemplate"
class = "com.tutorialspoint.StudentJDBCTemplate">
<property name = "dataSource" ref = "dataSource" />
</bean>
</beans>
Assim que terminar de criar os arquivos de configuração de código-fonte e bean, vamos executar o aplicativo. Se tudo estiver bem com seu aplicativo, ele imprimirá a seguinte mensagem.
ID : 1, Name : Zara
O exemplo a seguir demonstrará como atualizar um BLOB usando uma consulta de atualização com a ajuda do Spring JDBC. Atualizaremos os registros disponíveis na Tabela do Aluno.
Mesa do Aluno
CREATE TABLE Student(
ID INT NOT NULL AUTO_INCREMENT,
NAME VARCHAR(20) NOT NULL,
AGE INT NOT NULL,
IMAGE BLOB,
PRIMARY KEY (ID)
);
Sintaxe
MapSqlParameterSource in = new MapSqlParameterSource();
in.addValue("id", id);
in.addValue("image", new SqlLobValue(new ByteArrayInputStream(imageData),
imageData.length, new DefaultLobHandler()), Types.BLOB);
String SQL = "update Student set image = :image where id = :id";
NamedParameterJdbcTemplate jdbcTemplateObject = new NamedParameterJdbcTemplate(dataSource);
jdbcTemplateObject.update(SQL, in);
Onde,
in - Objeto SqlParameterSource para passar um parâmetro para atualizar uma consulta.
SqlLobValue - Objeto para representar um parâmetro de valor SQL BLOB / CLOB.
jdbcTemplateObject - Objeto NamedParameterJdbcTemplate para atualizar o objeto do aluno no banco de dados.
Para entender os conceitos mencionados acima relacionados ao Spring JDBC, vamos escrever um exemplo que atualizará uma consulta. Para escrever nosso exemplo, vamos ter um Eclipse IDE funcionando e usar as seguintes etapas para criar um aplicativo Spring.
Degrau | Descrição |
---|---|
1 | Atualize o projeto que o Aluno criou no capítulo Spring JDBC - Primeiro Aplicativo . |
2 | Atualize a configuração do bean e execute o aplicativo conforme explicado abaixo. |
A seguir está o conteúdo do arquivo de interface do Data Access Object StudentDAO.java.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
public interface StudentDAO {
/**
* This is the method to be used to initialize
* database resources ie. connection.
*/
public void setDataSource(DataSource ds);
/**
* This is the method to be used to update
* a record into the Student table.
*/
public void updateImage(Integer id, byte[] imageData);
}
A seguir está o conteúdo do Student.java Arquivo.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
private Integer id;
private byte[] image;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getId() {
return id;
}
public byte[] getImage() {
return image;
}
public void setImage(byte[] image) {
this.image = image;
}
}
A seguir está o conteúdo do Student.java Arquivo.
package com.tutorialspoint;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class StudentMapper implements RowMapper<Student> {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
student.setImage(rs.getBytes("image"));
return student;
}
}
A seguir está o arquivo de classe de implementação StudentJDBCTemplate.java para a interface DAO definida StudentDAO.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
import org.springframework.jdbc.core.simple.SimpleJdbcCall;
import org.springframework.jdbc.core.support.SqlLobValue;
import org.springframework.jdbc.support.lob.DefaultLobHandler;
import java.io.ByteArrayInputStream;
import java.sql.Types;
public class StudentJDBCTemplate implements StudentDAO {
private DataSource dataSource;
private JdbcTemplate jdbcTemplateObject;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
}
public void updateImage(Integer id, byte[] imageData) {
MapSqlParameterSource in = new MapSqlParameterSource();
in.addValue("id", id);
in.addValue("image", new SqlLobValue(new ByteArrayInputStream(imageData),
imageData.length, new DefaultLobHandler()), Types.BLOB);
String SQL = "update Student set image = :image where id = :id";
NamedParameterJdbcTemplate jdbcTemplateObject = new
NamedParameterJdbcTemplate(dataSource);
jdbcTemplateObject.update(SQL, in);
System.out.println("Updated Record with ID = " + id );
}
}
A seguir está o conteúdo do MainApp.java Arquivo.
package com.tutorialspoint;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
StudentJDBCTemplate studentJDBCTemplate =
(StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
byte[] imageData = {0,1,0,8,20,40,95};
studentJDBCTemplate.updateImage(1, imageData);
}
}
A seguir está o arquivo de configuração Beans.xml.
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">
<!-- Initialization for data source -->
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "admin"/>
</bean>
<!-- Definition for studentJDBCTemplate bean -->
<bean id = "studentJDBCTemplate"
class = "com.tutorialspoint.StudentJDBCTemplate">
<property name = "dataSource" ref = "dataSource" />
</bean>
</beans>
Assim que terminar de criar os arquivos de configuração de código-fonte e bean, vamos executar o aplicativo. Se tudo estiver bem com seu aplicativo, ele imprimirá a seguinte mensagem.
Updated Record with ID = 1
Você pode verificar o byte [] armazenado consultando o banco de dados.
O exemplo a seguir demonstrará como atualizar um CLOB usando uma consulta de atualização com a ajuda do Spring JDBC. Atualizaremos os registros disponíveis na Tabela do Aluno.
Mesa do Aluno
CREATE TABLE Student(
ID INT NOT NULL AUTO_INCREMENT,
NAME VARCHAR(20) NOT NULL,
AGE INT NOT NULL,
DESCRIPTION LONGTEXT,
PRIMARY KEY (ID)
);
Sintaxe
MapSqlParameterSource in = new MapSqlParameterSource();
in.addValue("id", id);
in.addValue("description", new SqlLobValue(
description, new DefaultLobHandler()), Types.CLOB);
String SQL = "update Student set description = :description where id = :id";
NamedParameterJdbcTemplate jdbcTemplateObject = new NamedParameterJdbcTemplate(dataSource);
jdbcTemplateObject.update(SQL, in);
Onde,
in - Objeto SqlParameterSource para passar um parâmetro para atualizar uma consulta.
SqlLobValue - Objeto para representar um parâmetro de valor SQL BLOB / CLOB.
jdbcTemplateObject - Objeto NamedParameterJdbcTemplate para atualizar o objeto do aluno no banco de dados.
Para entender os conceitos mencionados acima relacionados ao Spring JDBC, vamos escrever um exemplo, que atualizará uma consulta. Para escrever nosso exemplo, vamos ter um Eclipse IDE funcionando e usar as seguintes etapas para criar um aplicativo Spring.
Degrau | Descrição |
---|---|
1 | Atualize o projeto que o Aluno criou no capítulo Spring JDBC - Primeiro Aplicativo . |
2 | Atualize a configuração do bean e execute o aplicativo conforme explicado abaixo. |
A seguir está o conteúdo do arquivo de interface do Data Access Object StudentDAO.java.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
public interface StudentDAO {
/**
* This is the method to be used to initialize
* database resources ie. connection.
*/
public void setDataSource(DataSource ds);
/**
* This is the method to be used to update
* a record into the Student table.
*/
public void updateDescription(Integer id, String description);
}
A seguir está o conteúdo do Student.java Arquivo.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
private Integer id;
private String description;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getId() {
return id;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
}
A seguir está o conteúdo do StudentMapper.java Arquivo.
package com.tutorialspoint;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class StudentMapper implements RowMapper<Student> {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
student.setDescription(rs.getString("description"));
return student;
}
}
A seguir está o arquivo de classe de implementação StudentJDBCTemplate.java para a interface DAO definida StudentDAO.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
import org.springframework.jdbc.core.simple.SimpleJdbcCall;
import org.springframework.jdbc.core.support.SqlLobValue;
import org.springframework.jdbc.support.lob.DefaultLobHandler;
import java.io.ByteArrayInputStream;
import java.sql.Types;
public class StudentJDBCTemplate implements StudentDAO {
private DataSource dataSource;
private JdbcTemplate jdbcTemplateObject;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
}
public void updateDescription(Integer id, String description) {
MapSqlParameterSource in = new MapSqlParameterSource();
in.addValue("id", id);
in.addValue("description", new SqlLobValue(description,
new DefaultLobHandler()), Types.CLOB);
String SQL = "update Student set description = :description where id = :id";
NamedParameterJdbcTemplate jdbcTemplateObject = new
NamedParameterJdbcTemplate(dataSource);
jdbcTemplateObject.update(SQL, in);
System.out.println("Updated Record with ID = " + id );
}
}
A seguir está o conteúdo do MainApp.java Arquivo.
package com.tutorialspoint;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
StudentJDBCTemplate studentJDBCTemplate =
(StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
studentJDBCTemplate.updateDescription(1,
"This can be a very long text upto 4 GB of size.");
}
}
A seguir está o arquivo de configuração Beans.xml.
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">
<!-- Initialization for data source -->
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "admin"/>
</bean>
<!-- Definition for studentJDBCTemplate bean -->
<bean id = "studentJDBCTemplate"
class = "com.tutorialspoint.StudentJDBCTemplate">
<property name = "dataSource" ref = "dataSource" />
</bean>
</beans>
Assim que terminar de criar os arquivos de configuração de código-fonte e bean, vamos executar o aplicativo. Se tudo estiver bem com seu aplicativo, ele imprimirá a seguinte mensagem.
Updated Record with ID = 1
Você pode verificar a descrição armazenada consultando o banco de dados.
O exemplo a seguir demonstrará como fazer uma atualização em lote usando Spring JDBC. Atualizaremos os registros disponíveis na tabela Aluno em uma única operação em lote.
Sintaxe
String SQL = "update Student set age = ? where id = ?";
int[] updateCounts = jdbcTemplateObject.batchUpdate(SQL,
new BatchPreparedStatementSetter() {
public void setValues(PreparedStatement ps, int i) throws SQLException {
ps.setInt(1, students.get(i).getAge());
ps.setInt(2, students.get(i).getId());
}
public int getBatchSize() {
return students.size();
}
});
Onde,
SQL - Atualizar consulta para atualizar a idade do aluno.
jdbcTemplateObject - Objeto StudentJDBCTemplate para atualizar o objeto do aluno no banco de dados.
BatchPreparedStatementSetter- Executor de lote, define valores em PerparedStatement por item identificado por lista de objetos aluno e índice i. getBatchSize () retorna o tamanho do lote.
updateCounts - Matriz int contendo contagem de linha atualizada por consulta de atualização.
Para entender os conceitos mencionados acima relacionados ao Spring JDBC, vamos escrever um exemplo que atualizará uma operação em lote. Para escrever nosso exemplo, vamos ter um Eclipse IDE funcionando e usar as seguintes etapas para criar um aplicativo Spring.
Degrau | Descrição |
---|---|
1 | Atualize o projeto que o Aluno criou no capítulo Spring JDBC - Primeiro Aplicativo . |
2 | Atualize a configuração do bean e execute o aplicativo conforme explicado abaixo. |
A seguir está o conteúdo do arquivo de interface do Data Access Object StudentDAO.java.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
public interface StudentDAO {
/**
* This is the method to be used to initialize
* database resources ie. connection.
*/
public void setDataSource(DataSource ds);
/**
* This is the method to be used to list down
* all the records from the Student table.
*/
public List<Student> listStudents();
public void batchUpdate(final List<Student> students);
}
A seguir está o conteúdo do Student.java Arquivo.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
private Integer id;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getId() {
return id;
}
}
A seguir está o conteúdo do StudentMapper.java Arquivo.
package com.tutorialspoint;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class StudentMapper implements RowMapper<Student> {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
return student;
}
}
A seguir está o arquivo de classe de implementação StudentJDBCTemplate.java para a interface DAO definida StudentDAO.
package com.tutorialspoint;
import java.sql.PreparedStatement;
import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.BatchPreparedStatementSetter;
import java.sql.SQLException;
public class StudentJDBCTemplate implements StudentDAO {
private DataSource dataSource;
private JdbcTemplate jdbcTemplateObject;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
this.jdbcTemplateObject = new JdbcTemplate(dataSource);
}
public List<Student> listStudents() {
String SQL = "select * from Student";
List <Student> students = jdbcTemplateObject.query(SQL,
new StudentMapper());
return students;
}
public void batchUpdate(final List<Student> students){
String SQL = "update Student set age = ? where id = ?";
int[] updateCounts = jdbcTemplateObject.batchUpdate(SQL,
new BatchPreparedStatementSetter() {
public void setValues(PreparedStatement ps, int i) throws SQLException {
ps.setInt(1, students.get(i).getAge());
ps.setInt(2, students.get(i).getId());
}
public int getBatchSize() {
return students.size();
}
});
System.out.println("Records updated!");
}
}
A seguir está o conteúdo do MainApp.java Arquivo.
package com.tutorialspoint;
import java.util.ArrayList;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
StudentJDBCTemplate studentJDBCTemplate =
(StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
List<Student> initialStudents = studentJDBCTemplate.listStudents();
System.out.println("Initial Students");
for(Student student2: initialStudents){
System.out.print("ID : " + student2.getId() );
System.out.println(", Age : " + student2.getAge());
}
Student student = new Student();
student.setId(1);
student.setAge(10);
Student student1 = new Student();
student1.setId(3);
student1.setAge(10);
List<Student> students = new ArrayList<Student>();
students.add(student);
students.add(student1);
studentJDBCTemplate.batchUpdate(students);
List<Student> updatedStudents = studentJDBCTemplate.listStudents();
System.out.println("Updated Students");
for(Student student3: updatedStudents){
System.out.print("ID : " + student3.getId() );
System.out.println(", Age : " + student3.getAge());
}
}
}
A seguir está o arquivo de configuração Beans.xml.
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">
<!-- Initialization for data source -->
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "admin"/>
</bean>
<!-- Definition for studentJDBCTemplate bean -->
<bean id = "studentJDBCTemplate"
class = "com.tutorialspoint.StudentJDBCTemplate">
<property name = "dataSource" ref = "dataSource" />
</bean>
</beans>
Assim que terminar de criar os arquivos de configuração de código-fonte e bean, vamos executar o aplicativo. Se tudo estiver bem com seu aplicativo, ele imprimirá a seguinte mensagem.
Initial Students
ID : 1, Age : 11
ID : 3, Age : 15
Records updated!
Updated Students
ID : 1, Age : 10
ID : 3, Age : 10
O exemplo a seguir demonstrará como fazer uma atualização em lote usando objetos no Spring JDBC. Atualizaremos os registros disponíveis na tabela Aluno em uma única operação em lote.
Sintaxe
String SQL = "update Student set age = :age where id = :id";
SqlParameterSource[] batch = SqlParameterSourceUtils.createBatch(students.toArray());
NamedParameterJdbcTemplate jdbcTemplateObject = new NamedParameterJdbcTemplate(dataSource);
int[] updateCounts = jdbcTemplateObject.batchUpdate(SQL,batch);
System.out.println("records updated!");
Onde,
SQL - Atualizar consulta para atualizar a idade do aluno.
jdbcTemplateObject - Objeto StudentJDBCTemplate para atualizar o objeto do aluno no banco de dados.
batch - Objeto SqlParameterSource para representar um lote de objetos.
updateCounts - Matriz int contendo contagem de linha atualizada por consulta de atualização.
Para entender os conceitos mencionados acima relacionados ao Spring JDBC, vamos escrever um exemplo que atualizará uma operação em lote. Para escrever nosso exemplo, vamos ter um Eclipse IDE funcionando e usar as seguintes etapas para criar um aplicativo Spring.
Degrau | Descrição |
---|---|
1 | Atualize o projeto que o Aluno criou no capítulo Spring JDBC - Primeiro Aplicativo . |
2 | Atualize a configuração do bean e execute o aplicativo conforme explicado abaixo. |
A seguir está o conteúdo do arquivo de interface do Data Access Object StudentDAO.java.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
public interface StudentDAO {
/**
* This is the method to be used to initialize
* database resources ie. connection.
*/
public void setDataSource(DataSource ds);
/**
* This is the method to be used to list down
* all the records from the Student table.
*/
public List<Student> listStudents();
public void batchUpdate(final List<Student> students);
}
A seguir está o conteúdo do Student.java Arquivo.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
private Integer id;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getId() {
return id;
}
}
A seguir está o conteúdo do StudentMapper.java Arquivo.
package com.tutorialspoint;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class StudentMapper implements RowMapper<Student> {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
return student;
}
}
A seguir está o arquivo de classe de implementação StudentJDBCTemplate.java para a interface DAO definida StudentDAO.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
import org.springframework.jdbc.core.namedparam.SqlParameterSourceUtils;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
public class StudentJDBCTemplate implements StudentDAO {
private DataSource dataSource;
private JdbcTemplate jdbcTemplateObject;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
this.jdbcTemplateObject = new JdbcTemplate(dataSource);
}
public List<Student> listStudents() {
String SQL = "select * from Student";
List <Student> students = jdbcTemplateObject.query(SQL, new StudentMapper());
return students;
}
public void batchUpdate(final List<Student> students){
String SQL = "update Student set age = :age where id = :id";
SqlParameterSource[] batch = SqlParameterSourceUtils.createBatch(students.toArray());
NamedParameterJdbcTemplate jdbcTemplateObject = new
NamedParameterJdbcTemplate(dataSource);
int[] updateCounts = jdbcTemplateObject.batchUpdate(SQL,batch);
System.out.println("Records updated!");
}
}
A seguir está o conteúdo do MainApp.java Arquivo.
package com.tutorialspoint;
import java.util.ArrayList;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
StudentJDBCTemplate studentJDBCTemplate =
(StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
List<Student> initialStudents = studentJDBCTemplate.listStudents();
System.out.println("Initial Students");
for(Student student2: initialStudents){
System.out.print("ID : " + student2.getId() );
System.out.println(", Age : " + student2.getAge());
}
Student student = new Student();
student.setId(1);
student.setAge(15);
Student student1 = new Student();
student1.setId(3);
student1.setAge(16);
List<Student> students = new ArrayList<Student>();
students.add(student);
students.add(student1);
studentJDBCTemplate.batchUpdate(students);
List<Student> updatedStudents = studentJDBCTemplate.listStudents();
System.out.println("Updated Students");
for(Student student3: updatedStudents){
System.out.print("ID : " + student3.getId() );
System.out.println(", Age : " + student3.getAge());
}
}
}
A seguir está o arquivo de configuração Beans.xml.
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">
<!-- Initialization for data source -->
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "admin"/>
</bean>
<!-- Definition for studentJDBCTemplate bean -->
<bean id = "studentJDBCTemplate"
class = "com.tutorialspoint.StudentJDBCTemplate">
<property name = "dataSource" ref = "dataSource" />
</bean>
</beans>
Assim que terminar de criar os arquivos de configuração de código-fonte e bean, vamos executar o aplicativo. Se tudo estiver bem com seu aplicativo, ele imprimirá a seguinte mensagem.
Initial Students
ID : 1, Age : 10
ID : 3, Age : 10
Records updated!
Updated Students
ID : 1, Age : 15
ID : 3, Age : 16
O exemplo a seguir demonstrará como fazer várias atualizações em lote em uma única chamada usando Spring JDBC. Atualizaremos os registros disponíveis na tabela do aluno em uma operação de lote múltiplo em que o tamanho do lote é 1.
Sintaxe
String SQL = "update Student set age = ? where id = ?";
int[][] updateCounts = jdbcTemplateObject.batchUpdate(SQL,students,1,
new ParameterizedPreparedStatementSetter<Student>() {
public void setValues(PreparedStatement ps, Student student)
throws SQLException {
ps.setInt(1, student.getAge());
ps.setInt(2, student.getId());
}
});
Onde,
SQL - Atualizar consulta para atualizar a idade do aluno.
jdbcTemplateObject - Objeto StudentJDBCTemplate para atualizar o objeto aluno no banco de dados.
ParameterizedPreparedStatementSetter - Executor em lote, define valores em PerparedStatement por item identificado pela lista de objetos do aluno.
updateCounts - Array Int [] [] contendo contagem de linha atualizada por consulta de atualização por lote.
Para entender os conceitos mencionados acima relacionados ao Spring JDBC, vamos escrever um exemplo que atualizará várias operações em lote. Para escrever nosso exemplo, vamos ter um Eclipse IDE funcionando e usar as seguintes etapas para criar um aplicativo Spring.
Degrau | Descrição |
---|---|
1 | Atualize o projeto que o Aluno criou no capítulo Spring JDBC - Primeiro Aplicativo . |
2 | Atualize a configuração do bean e execute o aplicativo conforme explicado abaixo. |
A seguir está o conteúdo do arquivo de interface do Data Access Object StudentDAO.java.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
public interface StudentDAO {
/**
* This is the method to be used to initialize
* database resources ie. connection.
*/
public void setDataSource(DataSource ds);
/**
* This is the method to be used to list down
* all the records from the Student table.
*/
public List<Student> listStudents();
public void batchUpdate(final List<Student> students);
}
A seguir está o conteúdo do Student.java Arquivo.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
private Integer id;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getId() {
return id;
}
}
A seguir está o conteúdo do StudentMapper.java Arquivo.
package com.tutorialspoint;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class StudentMapper implements RowMapper<Student> {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
return student;
}
}
A seguir está o arquivo de classe de implementação StudentJDBCTemplate.java para a interface DAO definida StudentDAO.
package com.tutorialspoint;
import java.sql.PreparedStatement;
import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.ParameterizedPreparedStatementSetter;
import java.sql.SQLException;
public class StudentJDBCTemplate implements StudentDAO {
private DataSource dataSource;
private JdbcTemplate jdbcTemplateObject;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
this.jdbcTemplateObject = new JdbcTemplate(dataSource);
}
public List<Student> listStudents() {
String SQL = "select * from Student";
List <Student> students = jdbcTemplateObject.query(SQL, new StudentMapper());
return students;
}
public void batchUpdate(final List<Student> students){
String SQL = "update Student set age = ? where id = ?";
int[][] updateCounts = jdbcTemplateObject.batchUpdate(SQL,students,1,
new ParameterizedPreparedStatementSetter<Student>() {
public void setValues(PreparedStatement ps, Student student)
throws SQLException {
ps.setInt(1, student.getAge());
ps.setInt(2, student.getId());
}
});
System.out.println("Records updated!");
}
}
A seguir está o conteúdo do MainApp.java Arquivo.
package com.tutorialspoint;
import java.util.ArrayList;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
StudentJDBCTemplate studentJDBCTemplate =
(StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
List<Student> initialStudents = studentJDBCTemplate.listStudents();
System.out.println("Initial Students");
for(Student student2: initialStudents){
System.out.print("ID : " + student2.getId() );
System.out.println(", Age : " + student2.getAge());
}
Student student = new Student();
student.setId(1);
student.setAge(17);
Student student1 = new Student();
student1.setId(3);
student1.setAge(18);
List<Student> students = new ArrayList<Student>();
students.add(student);
students.add(student1);
studentJDBCTemplate.batchUpdate(students);
List<Student> updatedStudents = studentJDBCTemplate.listStudents();
System.out.println("Updated Students");
for(Student student3: updatedStudents){
System.out.print("ID : " + student3.getId() );
System.out.println(", Age : " + student3.getAge());
}
}
}
A seguir está o arquivo de configuração Beans.xml.
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">
<!-- Initialization for data source -->
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "admin"/>
</bean>
<!-- Definition for studentJDBCTemplate bean -->
<bean id = "studentJDBCTemplate"
class = "com.tutorialspoint.StudentJDBCTemplate">
<property name = "dataSource" ref = "dataSource" />
</bean>
</beans>
Assim que terminar de criar os arquivos de configuração de código-fonte e bean, vamos executar o aplicativo. Se tudo estiver bem com seu aplicativo, ele imprimirá a seguinte mensagem.
Initial Students
ID : 1, Age : 15
ID : 3, Age : 16
records updated!
Updated Students
ID : 1, Age : 17
ID : 3, Age : 18
o org.springframework.jdbc.core.JdbcTemplateclass é a classe central no pacote principal JDBC. Simplifica o uso de JDBC e ajuda a evitar erros comuns. Ele executa o fluxo de trabalho JDBC principal, deixando o código do aplicativo para fornecer SQL e extrair os resultados. Esta classe executa consultas ou atualizações SQL, iniciando a iteração em ResultSets e capturando exceções JDBC e traduzindo-as para a hierarquia de exceção genérica e mais informativa definida noorg.springframework.dao pacote.
Declaração de Classe
A seguir está a declaração para a classe org.springframework.jdbc.core.JdbcTemplate -
public class JdbcTemplate
extends JdbcAccessor
implements JdbcOperations
Uso
Step 1 - Crie um objeto JdbcTemplate usando uma fonte de dados configurada.
Step 2 - Use métodos de objeto JdbcTemplate para fazer operações de banco de dados.
Exemplo
O exemplo a seguir demonstrará como ler uma consulta usando a classe JdbcTemplate. Leremos os registros disponíveis na Tabela do Aluno.
Sintaxe
String selectQuery = "select * from Student";
List <Student> students = jdbcTemplateObject.query(selectQuery, new StudentMapper());
Onde,
selectQuery - Selecione consulta para ler os alunos.
jdbcTemplateObject - Objeto StudentJDBCTemplate para ler o objeto do aluno do banco de dados.
StudentMapper - StudentMapper é um objeto RowMapper para mapear cada registro obtido para o objeto de aluno.
Para entender os conceitos mencionados acima relacionados ao Spring JDBC, vamos escrever um exemplo que selecionará uma consulta. Para escrever nosso exemplo, vamos ter um Eclipse IDE funcionando e usar as seguintes etapas para criar um aplicativo Spring.
Degrau | Descrição |
---|---|
1 | Atualize o projeto que o Aluno criou no capítulo Spring JDBC - Primeiro Aplicativo . |
2 | Atualize a configuração do bean e execute o aplicativo conforme explicado abaixo. |
A seguir está o conteúdo do arquivo de interface do Data Access Object StudentDAO.java.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
public interface StudentDAO {
/**
* This is the method to be used to initialize
* database resources ie. connection.
*/
public void setDataSource(DataSource ds);
/**
* This is the method to be used to list down
* all the records from the Student table.
*/
public List<Student> listStudents();
}
A seguir está o conteúdo do Student.java Arquivo.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
private Integer id;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getId() {
return id;
}
}
A seguir está o conteúdo do StudentMapper.java Arquivo.
package com.tutorialspoint;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class StudentMapper implements RowMapper<Student> {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
return student;
}
}
A seguir está o arquivo de classe de implementação StudentJDBCTemplate.java para a interface DAO definida StudentDAO.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
public class StudentJDBCTemplate implements StudentDAO {
private DataSource dataSource;
private JdbcTemplate jdbcTemplateObject;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
this.jdbcTemplateObject = new JdbcTemplate(dataSource);
}
public List<Student> listStudents() {
String SQL = "select * from Student";
List <Student> students = jdbcTemplateObject.query(SQL, new StudentMapper());
return students;
}
}
A seguir está o conteúdo do MainApp.java Arquivo.
package com.tutorialspoint;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
StudentJDBCTemplate studentJDBCTemplate =
(StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
System.out.println("------Listing Multiple Records--------" );
List<Student> students = studentJDBCTemplate.listStudents();
for (Student record : students) {
System.out.print("ID : " + record.getId() );
System.out.print(", Name : " + record.getName() );
System.out.println(", Age : " + record.getAge());
}
}
}
A seguir está o arquivo de configuração Beans.xml.
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">
<!-- Initialization for data source -->
<bean id="dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "admin"/>
</bean>
<!-- Definition for studentJDBCTemplate bean -->
<bean id="studentJDBCTemplate"
class = "com.tutorialspoint.StudentJDBCTemplate">
<property name = "dataSource" ref = "dataSource" />
</bean>
</beans>
Assim que terminar de criar os arquivos de configuração de código-fonte e bean, vamos executar o aplicativo. Se tudo estiver bem com seu aplicativo, ele imprimirá a seguinte mensagem.
------Listing Multiple Records--------
ID : 1, Name : Zara, Age : 11
ID : 2, Name : Nuha, Age : 2
ID : 3, Name : Ayan, Age : 15
o org.springframework.jdbc.core.PreparedStatementSetterinterface atua como uma interface de retorno de chamada geral usada pela classe JdbcTemplate. Essa interface define valores em um PreparedStatement fornecido pela classe JdbcTemplate, para cada uma das várias atualizações em um lote usando o mesmo SQL.
As implementações são responsáveis por definir todos os parâmetros necessários. SQL com marcadores de posição já terá sido fornecido. É mais fácil usar essa interface do que PreparedStatementCreator. O JdbcTemplate criará o PreparedStatement, com o callback sendo responsável apenas por definir os valores dos parâmetros.
Declaração de Interface
A seguir está a declaração para a interface org.springframework.jdbc.core.PreparedStatementSetter -
public interface PreparedStatementSetter
Uso
Step 1 - Crie um objeto JdbcTemplate usando uma fonte de dados configurada.
Step 2 - Use métodos de objeto JdbcTemplate para fazer operações de banco de dados enquanto passa o objeto PreparedStatementSetter para substituir os marcadores de posição na consulta.
Exemplo
O exemplo a seguir demonstrará como ler uma consulta usando a classe JdbcTemplate e a interface PreparedStatementSetter. Leremos o registro disponível de um aluno na Tabela do Aluno.
Sintaxe
final String SQL = "select * from Student where id = ? ";
List <Student> students = jdbcTemplateObject.query(
SQL, new PreparedStatementSetter() {
public void setValues(PreparedStatement preparedStatement) throws SQLException {
preparedStatement.setInt(1, id);
}
},
new StudentMapper());
Onde,
SQL - Selecione consulta para ler os alunos.
jdbcTemplateObject - Objeto StudentJDBCTemplate para ler o objeto do aluno do banco de dados.
PreparedStatementSetter - Objeto PreparedStatementSetter para definir parâmetros na consulta.
StudentMapper - StudentMapper é um objeto RowMapper para mapear cada registro obtido para o objeto do aluno.
Para entender os conceitos mencionados acima relacionados ao Spring JDBC, vamos escrever um exemplo que selecionará uma consulta. Para escrever nosso exemplo, vamos ter um Eclipse IDE funcionando e usar as seguintes etapas para criar um aplicativo Spring.
Degrau | Descrição |
---|---|
1 | Atualize o projeto que o Aluno criou no capítulo Spring JDBC - Primeiro Aplicativo . |
2 | Atualize a configuração do bean e execute o aplicativo conforme explicado abaixo. |
A seguir está o conteúdo do arquivo de interface do Data Access Object StudentDAO.java.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
public interface StudentDAO {
/**
* This is the method to be used to initialize
* database resources ie. connection.
*/
public void setDataSource(DataSource ds);
/**
* This is the method to be used to list down
* a record from the Student table corresponding
* to a passed student id.
*/
public Student getStudent(Integer id);
}
A seguir está o conteúdo do Student.java Arquivo.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
private Integer id;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getId() {
return id;
}
}
A seguir está o conteúdo do StudentMapper.java Arquivo.
package com.tutorialspoint;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class StudentMapper implements RowMapper<Student> {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
return student;
}
}
A seguir está o arquivo de classe de implementação StudentJDBCTemplate.java para a interface DAO definida StudentDAO.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
public class StudentJDBCTemplate implements StudentDAO {
private DataSource dataSource;
private JdbcTemplate jdbcTemplateObject;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
this.jdbcTemplateObject = new JdbcTemplate(dataSource);
}
public Student getStudent(final Integer id) {
final String SQL = "select * from Student where id = ? ";
List <Student> students = jdbcTemplateObject.query(
SQL, new PreparedStatementSetter() {
public void setValues(PreparedStatement preparedStatement) throws SQLException {
preparedStatement.setInt(1, id);
}
},
new StudentMapper());
return students.get(0);
}
}
A seguir está o conteúdo do MainApp.java Arquivo.
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
StudentJDBCTemplate studentJDBCTemplate =
(StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
Student student = studentJDBCTemplate.getStudent(1);
System.out.print("ID : " + student.getId() );
System.out.println(", Age : " + student.getAge());
}
}
A seguir está o arquivo de configuração Beans.xml.
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">
<!-- Initialization for data source -->
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "admin"/>
</bean>
<!-- Definition for studentJDBCTemplate bean -->
<bean id = "studentJDBCTemplate"
class = "com.tutorialspoint.StudentJDBCTemplate">
<property name = "dataSource" ref = "dataSource" />
</bean>
</beans>
Assim que terminar de criar os arquivos de configuração de código-fonte e bean, vamos executar o aplicativo. Se tudo estiver bem com seu aplicativo, ele imprimirá a seguinte mensagem.
ID : 1, Age : 17
o org.springframework.jdbc.core.ResultSetExtractorinterface é uma interface de retorno de chamada usada pelos métodos de consulta do JdbcTemplate. As implementações dessa interface executam o trabalho real de extração de resultados de um ResultSet, mas não precisa se preocupar com o tratamento de exceções.
SQLExceptions serão capturados e manipulados pelo JdbcTemplate de chamada. Essa interface é usada principalmente na própria estrutura JDBC. Um RowMapper é geralmente uma escolha mais simples para o processamento ResultSet, mapeando um objeto de resultado por linha em vez de um objeto de resultado para todo o ResultSet.
Declaração de Interface
A seguir está a declaração para a interface org.springframework.jdbc.core.ResultSetExtractor -
public interface ResultSetExtractor
Uso
Step 1 - Crie um objeto JdbcTemplate usando uma fonte de dados configurada.
Step 2 - Use métodos de objeto JdbcTemplate para fazer operações de banco de dados enquanto analisa o conjunto de resultados usando ResultSetExtractor.
Exemplo
O exemplo a seguir demonstrará como ler uma consulta usando a classe JdbcTemplate e a interface ResultSetExtractor. Leremos o registro disponível de um aluno na Tabela do Aluno.
Sintaxe
public List<Student> listStudents() {
String SQL = "select * from Student";
List <Student> students = jdbcTemplateObject.query(SQL,
new ResultSetExtractor<List<Student>>(){
public List<Student> extractData(
ResultSet rs) throws SQLException, DataAccessException {
List<Student> list = new ArrayList<Student>();
while(rs.next()){
Student student = new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
student.setDescription(rs.getString("description"));
student.setImage(rs.getBytes("image"));
list.add(student);
}
return list;
}
});
return students;
}
Onde,
SQL - Selecione consulta para ler os alunos.
jdbcTemplateObject - Objeto StudentJDBCTemplate para ler o objeto do aluno do banco de dados.
ResultSetExtractor - Objeto ResultSetExtractor para analisar o objeto do conjunto de resultados.
Para entender os conceitos mencionados acima relacionados ao Spring JDBC, vamos escrever um exemplo que selecionará uma consulta. Para escrever nosso exemplo, vamos ter um Eclipse IDE funcionando e usar as seguintes etapas para criar um aplicativo Spring.
Degrau | Descrição |
---|---|
1 | Atualize o projeto que o Aluno criou no capítulo Spring JDBC - Primeiro Aplicativo . |
2 | Atualize a configuração do bean e execute o aplicativo conforme explicado abaixo. |
A seguir está o conteúdo do arquivo de interface do Data Access Object StudentDAO.java.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
public interface StudentDAO {
/**
* This is the method to be used to initialize
* database resources ie. connection.
*/
public void setDataSource(DataSource ds);
/**
* This is the method to be used to list down
* all the records from the Student table.
*/
public List<Student> listStudents();
}
A seguir está o conteúdo do Student.java Arquivo.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
private Integer id;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getId() {
return id;
}
}
A seguir está o arquivo de classe de implementação StudentJDBCTemplate.java para a interface DAO definida StudentDAO.
package com.tutorialspoint;
import java.util.List;
import java.util.ArrayList;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
public class StudentJDBCTemplate implements StudentDAO {
private DataSource dataSource;
private JdbcTemplate jdbcTemplateObject;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
this.jdbcTemplateObject = new JdbcTemplate(dataSource);
}
public List<Student> listStudents() {
String SQL = "select * from Student";
List <Student> students = jdbcTemplateObject.query(SQL,
new ResultSetExtractor<List<Student>>(){
public List<Student> extractData(
ResultSet rs) throws SQLException, DataAccessException {
List<Student> list = new ArrayList<Student>();
while(rs.next()){
Student student = new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
student.setDescription(rs.getString("description"));
student.setImage(rs.getBytes("image"));
list.add(student);
}
return list;
}
});
return students;
}
}
A seguir está o conteúdo do MainApp.java Arquivo.
package com.tutorialspoint;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context =
new ClassPathXmlApplicationContext("Beans.xml");
StudentJDBCTemplate studentJDBCTemplate =
(StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
List<Student> students = studentJDBCTemplate.listStudents();
for(Student student: students){
System.out.print("ID : " + student.getId() );
System.out.println(", Age : " + student.getAge());
}
}
}
A seguir está o arquivo de configuração Beans.xml.
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">
<!-- Initialization for data source -->
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "admin"/>
</bean>
<!-- Definition for studentJDBCTemplate bean -->
<bean id = "studentJDBCTemplate"
class = "com.tutorialspoint.StudentJDBCTemplate">
<property name = "dataSource" ref = "dataSource" />
</bean>
</beans>
Assim que terminar de criar os arquivos de configuração de código-fonte e bean, vamos executar o aplicativo. Se tudo estiver bem com seu aplicativo, ele imprimirá a seguinte mensagem.
ID : 1, Age : 17
ID : 3, Age : 18
o org.springframework.jdbc.core.RowMapper<T>interface é usada por JdbcTemplate para mapear linhas de um ResultSet por linha. As implementações dessa interface realizam o trabalho real de mapear cada linha para um objeto de resultado. SQLExceptions, se houver, serão capturados e tratados pelo JdbcTemplate de chamada.
Declaração de Interface
A seguir está a declaração para org.springframework.jdbc.core.RowMapper<T> interface -
public interface RowMapper<T>
Uso
Step 1 - Crie um objeto JdbcTemplate usando uma fonte de dados configurada.
Step 2 - Crie um objeto StudentMapper implementando a interface RowMapper.
Step 3 - Use métodos de objeto JdbcTemplate para fazer operações de banco de dados enquanto usa o objeto StudentMapper.
O exemplo a seguir demonstrará como ler uma consulta usando spring jdbc. Mapearemos os registros de leitura da Tabela de Aluno para o objeto Aluno usando o objeto StudentMapper.
Sintaxe
String SQL = "select * from Student";
List <Student> students = jdbcTemplateObject.query(SQL, new StudentMapper());
Onde
SQL - Leia a consulta para ler todos os registros do aluno.
jdbcTemplateObject - Objeto StudentJDBCTemplate para ler registros de alunos do banco de dados.
StudentMapper - Objeto StudentMapper para mapear registros de alunos para objetos de alunos.
Para entender os conceitos mencionados acima relacionados ao Spring JDBC, vamos escrever um exemplo que irá ler uma consulta e mapear o resultado usando o objeto StudentMapper. Para escrever nosso exemplo, vamos ter um Eclipse IDE funcionando e usar as seguintes etapas para criar um aplicativo Spring.
Degrau | Descrição |
---|---|
1 | Atualize o projeto que o Aluno criou no capítulo Spring JDBC - Primeiro Aplicativo . |
2 | Atualize a configuração do bean e execute o aplicativo conforme explicado abaixo. |
A seguir está o conteúdo do arquivo de interface do Data Access Object StudentDao.java.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
public interface StudentDao {
/**
* This is the method to be used to initialize
* database resources ie. connection.
*/
public void setDataSource(DataSource ds);
/**
* This is the method to be used to list down
* all the records from the Student table.
*/
public List<Student> listStudents();
}
A seguir está o conteúdo do Student.java Arquivo.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
private Integer id;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getId() {
return id;
}
}
A seguir está o conteúdo do StudentMapper.java Arquivo.
package com.tutorialspoint;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class StudentMapper implements RowMapper<Student> {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
return student;
}
}
A seguir está o arquivo de classe de implementação StudentJDBCTemplate.java para a interface DAO definida StudentDAO.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
public class StudentJDBCTemplate implements StudentDao {
private DataSource dataSource;
private JdbcTemplate jdbcTemplateObject;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
this.jdbcTemplateObject = new JdbcTemplate(dataSource);
}
public List<Student> listStudents() {
String SQL = "select * from Student";
List <Student> students = jdbcTemplateObject.query(SQL, new StudentMapper());
return students;
}
}
A seguir está o conteúdo do MainApp.java Arquivo
package com.tutorialspoint;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
StudentJDBCTemplate studentJDBCTemplate =
(StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
System.out.println("------Listing Multiple Records--------" );
List<Student> students = studentJDBCTemplate.listStudents();
for (Student record : students) {
System.out.print("ID : " + record.getId() );
System.out.print(", Name : " + record.getName() );
System.out.println(", Age : " + record.getAge());
}
}
}
A seguir está o arquivo de configuração Beans.xml.
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">
<!-- Initialization for data source -->
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "admin"/>
</bean>
<!-- Definition for studentJDBCTemplate bean -->
<bean id = "studentJDBCTemplate"
class = "com.tutorialspoint.StudentJDBCTemplate">
<property name = "dataSource" ref = "dataSource" />
</bean>
</beans>
Assim que terminar de criar os arquivos de configuração de código-fonte e bean, vamos executar o aplicativo. Se tudo estiver bem com seu aplicativo, ele imprimirá a seguinte mensagem.
------Listing Multiple Records--------
ID : 1, Name : Zara, Age : 17
ID : 3, Name : Ayan, Age : 18
o org.springframework.jdbc.core.NamedParameterJdbcTemplateclass é uma classe de modelo com um conjunto básico de operações JDBC, permitindo o uso de parâmetros nomeados em vez do tradicional '?' marcadores de posição. Esta classe delega para um JdbcTemplate encapsulado uma vez que a substituição dos parâmetros nomeados para o estilo JDBC '?' placeholders é feito em tempo de execução. Também permite expandir uma lista de valores para o número apropriado de marcadores de posição.
Declaração de Interface
A seguir está a declaração para org.springframework.jdbc.core.NamedParameterJdbcTemplate classe -
public class NamedParameterJdbcTemplate
extends Object
implements NamedParameterJdbcOperations
Sintaxe
MapSqlParameterSource in = new MapSqlParameterSource();
in.addValue("id", id);
in.addValue("description", new SqlLobValue(description, new DefaultLobHandler()), Types.CLOB);
String SQL = "update Student set description = :description where id = :id";
NamedParameterJdbcTemplate jdbcTemplateObject = new NamedParameterJdbcTemplate(dataSource);
jdbcTemplateObject.update(SQL, in);
Onde,
in - Objeto SqlParameterSource para passar um parâmetro para atualizar uma consulta.
SqlLobValue - Objeto para representar um parâmetro de valor SQL BLOB / CLOB.
jdbcTemplateObject - Objeto NamedParameterJdbcTemplate para atualizar o objeto do aluno no banco de dados.
Para entender os conceitos mencionados acima relacionados ao Spring JDBC, vamos escrever um exemplo que atualizará uma consulta. Para escrever nosso exemplo, vamos ter um Eclipse IDE funcionando e usar as seguintes etapas para criar um aplicativo Spring.
Degrau | Descrição |
---|---|
1 | Atualize o projeto que o Aluno criou no capítulo Spring JDBC - Primeiro Aplicativo . |
2 | Atualize a configuração do bean e execute o aplicativo conforme explicado abaixo. |
A seguir está o conteúdo do arquivo de interface do Data Access Object StudentDAO.java.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
public interface StudentDAO {
/**
* This is the method to be used to initialize
* database resources ie. connection.
*/
public void setDataSource(DataSource ds);
/**
* This is the method to be used to update
* a record into the Student table.
*/
public void updateDescription(Integer id, String description);
}
A seguir está o conteúdo do Student.java Arquivo.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
private Integer id;
private String description;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getId() {
return id;
}
public String getDescription() {
return description;
}
public void setDescription(String description) {
this.description = description;
}
}
A seguir está o conteúdo do StudentMapper.java Arquivo.
package com.tutorialspoint;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class StudentMapper implements RowMapper<Student> {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
student.setDescription(rs.getString("description"));
return student;
}
}
A seguir está o arquivo de classe de implementação StudentJDBCTemplate.java para a interface DAO definida StudentDAO.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
import org.springframework.jdbc.core.namedparam.NamedParameterJdbcTemplate;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
import org.springframework.jdbc.core.simple.SimpleJdbcCall;
import org.springframework.jdbc.core.support.SqlLobValue;
import org.springframework.jdbc.support.lob.DefaultLobHandler;
import java.io.ByteArrayInputStream;
import java.sql.Types;
public class StudentJDBCTemplate implements StudentDAO {
private DataSource dataSource;
private JdbcTemplate jdbcTemplateObject;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
}
public void updateDescription(Integer id, String description) {
MapSqlParameterSource in = new MapSqlParameterSource();
in.addValue("id", id);
in.addValue("description", new SqlLobValue(
description, new DefaultLobHandler()), Types.CLOB);
String SQL = "update Student set description = :description where id = :id";
NamedParameterJdbcTemplate jdbcTemplateObject =
new NamedParameterJdbcTemplate(dataSource);
jdbcTemplateObject.update(SQL, in);
System.out.println("Updated Record with ID = " + id );
}
}
A seguir está o conteúdo do MainApp.java Arquivo.
package com.tutorialspoint;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
StudentJDBCTemplate studentJDBCTemplate =
(StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
studentJDBCTemplate.updateDescription(1,
"This can be a very long text upto 4 GB of size.");
}
}
A seguir está o arquivo de configuração Beans.xml.
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">
<!-- Initialization for data source -->
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "admin"/>
</bean>
<!-- Definition for studentJDBCTemplate bean -->
<bean id = "studentJDBCTemplate"
class = "com.tutorialspoint.StudentJDBCTemplate">
<property name = "dataSource" ref = "dataSource" />
</bean>
</beans>
Assim que terminar de criar os arquivos de configuração de código-fonte e bean, vamos executar o aplicativo. Se tudo estiver bem com seu aplicativo, ele imprimirá a seguinte mensagem.
Updated Record with ID = 1
Você pode verificar a descrição armazenada consultando o banco de dados.
o org.springframework.jdbc.core.SimpleJdbcInsertclasse é um objeto reutilizável multithread que fornece recursos de inserção fácil para uma tabela. Ele fornece processamento de metadados para simplificar o código necessário para construir uma instrução de inserção básica. A inserção real está sendo tratada usando JdbcTemplate do Spring
Declaração de Classe
A seguir está a declaração para org.springframework.jdbc.core.SimpleJdbcInsert classe -
public class SimpleJdbcInsert
extends AbstractJdbcInsert
implements SimpleJdbcInsertOperations
O exemplo a seguir demonstrará como inserir uma consulta usando Spring JDBC. Vamos inserir um registro na Tabela do Aluno usando o objeto SimpleJdbcInsert.
Sintaxe
jdbcInsert = new SimpleJdbcInsert(dataSource).withTableName("Student");
Map<String,Object> parameters = new HashMap<String,Object>();
parameters.put("name", name);
parameters.put("age", age);
jdbcInsert.execute(parameters);
Onde,
jdbcInsert - Objeto SimpleJdbcInsert para inserir registro na tabela do aluno.
jdbcTemplateObject - Objeto StudentJDBCTemplate para ler o objeto do aluno no banco de dados.
Para entender os conceitos mencionados acima relacionados ao Spring JDBC, vamos escrever um exemplo que irá inserir uma consulta. Para escrever nosso exemplo, vamos ter um Eclipse IDE funcionando e usar as seguintes etapas para criar um aplicativo Spring.
Degrau | Descrição |
---|---|
1 | Atualize o projeto que o Aluno criou no capítulo Spring JDBC - Primeiro Aplicativo . |
2 | Atualize a configuração do bean e execute o aplicativo conforme explicado abaixo. |
A seguir está o conteúdo do arquivo de interface do Data Access Object StudentDAO.java.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
public interface StudentDAO {
/**
* This is the method to be used to initialize
* database resources ie. connection.
*/
public void setDataSource(DataSource ds);
/**
* This is the method to be used to create
* a record in the Student table.
*/
public void create(String name, Integer age);
/**
* This is the method to be used to list down
* all the records from the Student table.
*/
public List<Student> listStudents();
}
A seguir está o conteúdo do Student.java Arquivo.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
private Integer id;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getId() {
return id;
}
}
A seguir está o conteúdo do StudentMapper.java Arquivo.
package com.tutorialspoint;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class StudentMapper implements RowMapper<Student> {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
return student;
}
}
A seguir está o arquivo de classe de implementação StudentJDBCTemplate.java para a interface DAO definida StudentDAO.
package com.tutorialspoint;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.simple.SimpleJdbcInsert;
public class StudentJDBCTemplate implements StudentDao {
private DataSource dataSource;
private JdbcTemplate jdbcTemplateObject;
SimpleJdbcInsert jdbcInsert;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
this.jdbcTemplateObject = new JdbcTemplate(dataSource);
this.jdbcInsert = new SimpleJdbcInsert(dataSource).withTableName("Student");
}
public void create(String name, Integer age) {
Map<String,Object> parameters = new HashMap<String,Object>();
parameters.put("name", name);
parameters.put("age", age);
jdbcInsert.execute(parameters);
System.out.println("Created Record Name = " + name + " Age = " + age);
return;
}
public List<Student> listStudents() {
String SQL = "select * from Student";
List <Student> students = jdbcTemplateObject.query(SQL, new StudentMapper());
return students;
}
}
A seguir está o conteúdo do MainApp.java Arquivo.
package com.tutorialspoint;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
StudentJDBCTemplate studentJDBCTemplate =
(StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
System.out.println("------Records Creation--------" );
studentJDBCTemplate.create("Nuha", 2);
System.out.println("------Listing Multiple Records--------" );
List<Student> students = studentJDBCTemplate.listStudents();
for (Student record : students) {
System.out.print("ID : " + record.getId() );
System.out.print(", Name : " + record.getName() );
System.out.println(", Age : " + record.getAge());
}
}
}
A seguir está o arquivo de configuração Beans.xml.
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">
<!-- Initialization for data source -->
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "admin"/>
</bean>
<!-- Definition for studentJDBCTemplate bean -->
<bean id = "studentJDBCTemplate"
class = "com.tutorialspoint.StudentJDBCTemplate">
<property name = "dataSource" ref = "dataSource" />
</bean>
</beans>
Assim que terminar de criar os arquivos de configuração de código-fonte e bean, vamos executar o aplicativo. Se tudo estiver bem com seu aplicativo, ele imprimirá a seguinte mensagem.
------Records Creation--------
Created Record Name = Nuha Age = 12
------Listing Multiple Records--------
ID : 1, Name : Zara, Age : 17
ID : 3, Name : Ayan, Age : 18
ID : 4, Name : Nuha, Age : 12
o org.springframework.jdbc.core.SimpleJdbcCallclasse é um objeto reutilizável multithread que representa uma chamada para um procedimento armazenado ou uma função armazenada. Ele fornece processamento de metadados para simplificar o código necessário para acessar procedimentos / funções armazenados básicos.
Tudo o que você precisa fornecer é o nome do procedimento / função e um mapa contendo os parâmetros ao executar a chamada. Os nomes dos parâmetros fornecidos serão combinados com os parâmetros de entrada e saída declarados quando o procedimento armazenado foi criado.
Declaração de Classe
A seguir está a declaração para org.springframework.jdbc.core.SimpleJdbcCall classe -
public class SimpleJdbcCall
extends AbstractJdbcCall
implements SimpleJdbcCallOperations
O exemplo a seguir demonstrará como chamar um procedimento armazenado usando Spring SimpleJdbcCall. Leremos um dos registros disponíveis na Tabela do aluno chamando um procedimento armazenado. Vamos passar uma id e receber um registro de estudante.
Sintaxe
SimpleJdbcCall jdbcCall = new SimpleJdbcCall(dataSource).withProcedureName("getRecord");
SqlParameterSource in = new MapSqlParameterSource().addValue("in_id", id);
Map<String, Object> out = jdbcCall.execute(in);
Student student = new Student();
student.setId(id);
student.setName((String) out.get("out_name"));
student.setAge((Integer) out.get("out_age"));
Onde,
jdbcCall - Objeto SimpleJdbcCall para representar um procedimento armazenado.
in - Objeto SqlParameterSource para passar um parâmetro para um procedimento armazenado.
student - Objeto do aluno.
out - Objeto de mapa para representar a saída do resultado da chamada de procedimento armazenado.
Para entender os conceitos mencionados acima relacionados ao Spring JDBC, vamos escrever um exemplo que chamará um procedimento armazenado. Para escrever nosso exemplo, vamos ter um Eclipse IDE funcionando e usar as seguintes etapas para criar um aplicativo Spring.
Degrau | Descrição |
---|---|
1 | Atualize o projeto que o Aluno criou no capítulo Spring JDBC - Primeiro Aplicativo . |
2 | Atualize a configuração do bean e execute o aplicativo conforme explicado abaixo. |
A seguir está o conteúdo do arquivo de interface do Data Access Object StudentDAO.java.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
public interface StudentDAO {
/**
* This is the method to be used to initialize
* database resources ie. connection.
*/
public void setDataSource(DataSource ds);
/**
* This is the method to be used to list down
* a record from the Student table corresponding
* to a passed student id.
*/
public Student getStudent(Integer id);
}
A seguir está o conteúdo do Student.java Arquivo.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
private Integer id;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getId() {
return id;
}
}
A seguir está o conteúdo do StudentMapper.java Arquivo.
package com.tutorialspoint;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class StudentMapper implements RowMapper<Student> {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
return student;
}
}
A seguir está o arquivo de classe de implementação StudentJDBCTemplate.java para a interface DAO definida StudentDAO.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
import org.springframework.jdbc.core.simple.SimpleJdbcCall;
public class StudentJDBCTemplate implements StudentDAO {
private DataSource dataSource;
private JdbcTemplate jdbcTemplateObject;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
this.jdbcTemplateObject = new JdbcTemplate(dataSource);
}
public Student getStudent(Integer id) {
SimpleJdbcCall jdbcCall = new
SimpleJdbcCall(dataSource).withProcedureName("getRecord");
SqlParameterSource in = new MapSqlParameterSource().addValue("in_id", id);
Map<String, Object> out = jdbcCall.execute(in);
Student student = new Student();
student.setId(id);
student.setName((String) out.get("out_name"));
student.setAge((Integer) out.get("out_age"));
return student;
}
}
O código que você escreve para a execução da chamada envolve a criação de um SqlParameterSource contendo o parâmetro IN. É importante combinar o nome fornecido para o valor de entrada com o nome do parâmetro declarado no procedimento armazenado. O método execute usa os parâmetros IN e retorna um Map contendo quaisquer parâmetros de saída digitados pelo nome conforme especificado no procedimento armazenado.
A seguir está o conteúdo do MainApp.java Arquivo.
package com.tutorialspoint;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
StudentJDBCTemplate studentJDBCTemplate =
(StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
Student student = studentJDBCTemplate.getStudent(1);
System.out.print("ID : " + student.getId() );
System.out.print(", Name : " + student.getName() );
System.out.println(", Age : " + student.getAge());
}
}
A seguir está o arquivo de configuração Beans.xml.
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">
<!-- Initialization for data source -->
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "admin"/>
</bean>
<!-- Definition for studentJDBCTemplate bean -->
<bean id = "studentJDBCTemplate"
class = "com.tutorialspoint.StudentJDBCTemplate">
<property name = "dataSource" ref = "dataSource" />
</bean>
</beans>
Assim que terminar de criar os arquivos de configuração de código-fonte e bean, vamos executar o aplicativo. Se tudo estiver bem com seu aplicativo, ele imprimirá a seguinte mensagem.
ID : 1, Name : Zara, Age : 11
o org.springframework.jdbc.object.SqlQuery A classe fornece um objeto de operação reutilizável que representa uma consulta SQL.
Declaração de Classe
A seguir está a declaração para org.springframework.jdbc.object.SqlQuery classe -
public abstract class SqlQuery<T>
extends SqlOperation
Uso
Step 1 - Crie um objeto JdbcTemplate usando uma fonte de dados configurada.
Step 2 - Crie um objeto StudentMapper implementando a interface RowMapper.
Step 3 - Use métodos de objeto JdbcTemplate para fazer operações de banco de dados enquanto usa o objeto SqlQuery.
O exemplo a seguir demonstrará como ler uma consulta usando o objeto SqlQuery. Mapearemos os registros de leitura da Tabela de Aluno para o objeto Aluno usando o objeto StudentMapper.
Sintaxe
String sql = "select * from Student";
SqlQuery<Student> sqlQuery = new SqlQuery<Student>() {
@Override
protected RowMapper<Student> newRowMapper(Object[] parameters,
Map<?, ?> context) {
return new StudentMapper();
}
};
sqlQuery.setDataSource(dataSource);
sqlQuery.setSql(sql);
List <Student> students = sqlQuery.execute();
Onde,
SQL - Leia a consulta para ler todos os registros do aluno.
jdbcTemplateObject - Objeto StudentJDBCTemplate para ler registros de alunos do banco de dados.
StudentMapper - Objeto StudentMapper para mapear os registros do aluno para objetos do aluno.
SqlQuery - Objeto SqlQuery para consultar registros de alunos e mapeá-los para objetos de alunos.
Para entender os conceitos mencionados acima relacionados ao Spring JDBC, vamos escrever um exemplo que irá ler uma consulta e mapear o resultado usando o objeto StudentMapper. Para escrever nosso exemplo, vamos ter um Eclipse IDE funcionando e usar as seguintes etapas para criar um aplicativo Spring.
Degrau | Descrição |
---|---|
1 | Atualize o projeto que o Aluno criou no capítulo Spring JDBC - Primeiro Aplicativo . |
2 | Atualize a configuração do bean e execute o aplicativo conforme explicado abaixo. |
A seguir está o conteúdo do arquivo de interface do Data Access Object StudentDao.java.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
public interface StudentDao {
/**
* This is the method to be used to initialize
* database resources ie. connection.
*/
public void setDataSource(DataSource ds);
/**
* This is the method to be used to list down
* all the records from the Student table.
*/
public List<Student> listStudents();
}
A seguir está o conteúdo do Student.java Arquivo.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
private Integer id;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getId() {
return id;
}
}
A seguir está o conteúdo do StudentMapper.java Arquivo.
package com.tutorialspoint;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class StudentMapper implements RowMapper<Student> {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
return student;
}
}
A seguir está o arquivo de classe de implementação StudentJDBCTemplate.java para a interface DAO definida StudentDAO.
package com.tutorialspoint;
import java.util.List;
import java.util.Map;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.RowMapper;
import org.springframework.jdbc.object.SqlQuery;
public class StudentJDBCTemplate implements StudentDao {
private DataSource dataSource;
private JdbcTemplate jdbcTemplateObject;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
this.jdbcTemplateObject = new JdbcTemplate(dataSource);
}
public List<Student> listStudents() {
String sql = "select * from Student";
SqlQuery<Student> sqlQuery = new SqlQuery<Student>() {
@Override
protected RowMapper<Student> newRowMapper(Object[] parameters, Map<?, ?> context){
return new StudentMapper();
}
};
sqlQuery.setDataSource(dataSource);
sqlQuery.setSql(sql);
List <Student> students = sqlQuery.execute();
return students;
}
}
A seguir está o conteúdo do MainApp.java Arquivo.
package com.tutorialspoint;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
StudentJDBCTemplate studentJDBCTemplate =
(StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
System.out.println("------Listing Multiple Records--------" );
List<Student> students = studentJDBCTemplate.listStudents();
for (Student record : students) {
System.out.print("ID : " + record.getId() );
System.out.print(", Name : " + record.getName() );
System.out.println(", Age : " + record.getAge());
}
}
}
A seguir está o arquivo de configuração Beans.xml.
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">
<!-- Initialization for data source -->
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "admin"/>
</bean>
<!-- Definition for studentJDBCTemplate bean -->
<bean id = "studentJDBCTemplate"
class = "com.tutorialspoint.StudentJDBCTemplate">
<property name = "dataSource" ref = "dataSource" />
</bean>
</beans>
Assim que terminar de criar os arquivos de configuração de código-fonte e bean, vamos executar o aplicativo. Se tudo estiver bem com seu aplicativo, ele imprimirá a seguinte mensagem.
------Listing Multiple Records--------
ID : 1, Name : Zara, Age : 17
ID : 3, Name : Ayan, Age : 18
ID : 4, Name : Nuha, Age : 12
o org.springframework.jdbc.object.SqlUpdate classe fornece objeto de operação reutilizável que representa uma atualização de SQL.
Declaração de Classe
A seguir está a declaração para org.springframework.jdbc.object.SqlUpdate classe -
public abstract class SqlUpdate<T>
extends SqlOperation
Uso
Step 1 - Crie um objeto JdbcTemplate usando uma fonte de dados configurada.
Step 2 - Crie um objeto StudentMapper implementando a interface RowMapper.
Step 3 - Use métodos de objeto JdbcTemplate para realizar operações de banco de dados enquanto usa o objeto SqlUpdate.
O exemplo a seguir demonstrará como atualizar uma consulta usando o objeto SqlUpdate. Mapearemos os registros de atualização da Tabela de Aluno para o objeto Aluno usando o objeto StudentMapper.
Sintaxe
String SQL = "update Student set age = ? where id = ?";
SqlUpdate sqlUpdate = new SqlUpdate(dataSource,SQL);
sqlUpdate.declareParameter(new SqlParameter("age", Types.INTEGER));
sqlUpdate.declareParameter(new SqlParameter("id", Types.INTEGER));
sqlUpdate.compile();
sqlUpdate.update(age.intValue(),id.intValue());
Onde,
SQL - Atualizar consulta para atualizar os registros do aluno.
jdbcTemplateObject - Objeto StudentJDBCTemplate para ler os registros do aluno do banco de dados.
StudentMapper - Objeto StudentMapper para mapear registros de alunos para objetos de alunos.
sqlUpdate - Objeto SqlUpdate para atualizar os registros do aluno.
Para entender os conceitos mencionados acima relacionados ao Spring JDBC, vamos escrever um exemplo que irá ler uma consulta e mapear o resultado usando o objeto StudentMapper. Para escrever nosso exemplo, vamos ter um Eclipse IDE funcionando e usar as seguintes etapas para criar um aplicativo Spring.
Degrau | Descrição |
---|---|
1 | Atualize o projeto que o Aluno criou no capítulo Spring JDBC - Primeiro Aplicativo . |
2 | Atualize a configuração do bean e execute o aplicativo conforme explicado abaixo. |
A seguir está o conteúdo do arquivo de interface do Data Access Object StudentDao.java.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
public interface StudentDao {
/**
* This is the method to be used to initialize
* database resources ie. connection.
*/
public void setDataSource(DataSource ds);
/**
* This is the method to be used to update
* a record into the Student table.
*/
public void update(Integer id, Integer age);
/**
* This is the method to be used to list down
* a record from the Student table corresponding
* to a passed student id.
*/
public Student getStudent(Integer id);
}
A seguir está o conteúdo do Student.java Arquivo.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
private Integer id;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getId() {
return id;
}
}
A seguir está o conteúdo do StudentMapper.java Arquivo.
package com.tutorialspoint;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class StudentMapper implements RowMapper<Student> {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
return student;
}
}
A seguir está o arquivo de classe de implementação StudentJDBCTemplate.java para a interface DAO definida StudentDAO.
package com.tutorialspoint;
import java.sql.Types;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.SqlParameter;
import org.springframework.jdbc.object.SqlUpdate;
public class StudentJDBCTemplate implements StudentDao {
private DataSource dataSource;
private JdbcTemplate jdbcTemplateObject;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
this.jdbcTemplateObject = new JdbcTemplate(dataSource);
}
public void update(Integer id, Integer age){
String SQL = "update Student set age = ? where id = ?";
SqlUpdate sqlUpdate = new SqlUpdate(dataSource,SQL);
sqlUpdate.declareParameter(new SqlParameter("age", Types.INTEGER));
sqlUpdate.declareParameter(new SqlParameter("id", Types.INTEGER));
sqlUpdate.compile();
sqlUpdate.update(age.intValue(),id.intValue());
System.out.println("Updated Record with ID = " + id );
return;
}
public Student getStudent(Integer id) {
String SQL = "select * from Student where id = ?";
Student student = jdbcTemplateObject.queryForObject(
SQL, new Object[]{id}, new StudentMapper());
return student;
}
}
A seguir está o conteúdo do MainApp.java Arquivo.
package com.tutorialspoint;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
StudentJDBCTemplate studentJDBCTemplate =
(StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
System.out.println("----Updating Record with ID = 1 -----" );
studentJDBCTemplate.update(1, 10);
System.out.println("----Listing Record with ID = 1 -----" );
Student student = studentJDBCTemplate.getStudent(1);
System.out.print("ID : " + student.getId() );
System.out.print(", Name : " + student.getName() );
System.out.println(", Age : " + student.getAge());
}
}
A seguir está o arquivo de configuração Beans.xml.
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">
<!-- Initialization for data source -->
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "admin"/>
</bean>
<!-- Definition for studentJDBCTemplate bean -->
<bean id = "studentJDBCTemplate"
class = "com.tutorialspoint.StudentJDBCTemplate">
<property name = "dataSource" ref = "dataSource" />
</bean>
</beans>
Assim que terminar de criar os arquivos de configuração de código-fonte e bean, vamos executar o aplicativo. Se tudo estiver bem com seu aplicativo, ele imprimirá a seguinte mensagem.
----Updating Record with ID = 1 -----
Updated Record with ID = 1
----Listing Record with ID = 1 -----
ID : 1, Name : Zara, Age : 10
o org.springframework.jdbc.core.StoredProcedureclass é a superclasse para abstrações de objetos de procedimentos armazenados RDBMS. Esta classe é abstrata e pretende-se que as subclasses forneçam um método tipado para invocação que delega ao método execute (java.lang.Object ...) fornecido. A propriedade SQL herdada é o nome do procedimento armazenado no RDBMS.
Declaração de Classe
A seguir está a declaração para org.springframework.jdbc.core.StoredProcedure classe -
public abstract class StoredProcedure
extends SqlCall
O exemplo a seguir demonstrará como chamar um procedimento armazenado usando Spring StoredProcedure. Leremos um dos registros disponíveis na Tabela do aluno chamando um procedimento armazenado. Vamos passar uma id e receber um registro de estudante.
Sintaxe
class StudentProcedure extends StoredProcedure{
public StudentProcedure(DataSource dataSource, String procedureName){
super(dataSource,procedureName);
declareParameter(new SqlParameter("in_id", Types.INTEGER));
declareParameter(new SqlOutParameter("out_name", Types.VARCHAR));
declareParameter(new SqlOutParameter("out_age", Types.INTEGER));
compile();
}
public Student execute(Integer id){
Map<String, Object> out = super.execute(id);
Student student = new Student();
student.setId(id);
student.setName((String) out.get("out_name"));
student.setAge((Integer) out.get("out_age"));
return student;
}
}
Onde,
StoredProcedure - Objeto StoredProcedure para representar um procedimento armazenado.
StudentProcedure - O objeto StudentProcedure estende StoredProcedure para declarar a entrada, a variável de saída e o resultado do mapa para o objeto Student.
student - Objeto do aluno.
Para entender os conceitos mencionados acima relacionados ao Spring JDBC, vamos escrever um exemplo que chamará um procedimento armazenado. Para escrever nosso exemplo, vamos ter um Eclipse IDE funcionando e usar as seguintes etapas para criar um aplicativo Spring.
Degrau | Descrição |
---|---|
1 | Atualize o projeto que o Aluno criou no capítulo Spring JDBC - Primeiro Aplicativo . |
2 | Atualize a configuração do bean e execute o aplicativo conforme explicado abaixo. |
A seguir está o conteúdo do arquivo de interface do Data Access Object StudentDAO.java.
package com.tutorialspoint;
import java.util.List;
import javax.sql.DataSource;
public interface StudentDAO {
/**
* This is the method to be used to initialize
* database resources ie. connection.
*/
public void setDataSource(DataSource ds);
/**
* This is the method to be used to list down
* a record from the Student table corresponding
* to a passed student id.
*/
public Student getStudent(Integer id);
}
A seguir está o conteúdo do Student.java Arquivo.
package com.tutorialspoint;
public class Student {
private Integer age;
private String name;
private Integer id;
public void setAge(Integer age) {
this.age = age;
}
public Integer getAge() {
return age;
}
public void setName(String name) {
this.name = name;
}
public String getName() {
return name;
}
public void setId(Integer id) {
this.id = id;
}
public Integer getId() {
return id;
}
}
A seguir está o conteúdo do StudentMapper.java Arquivo.
package com.tutorialspoint;
import java.sql.ResultSet;
import java.sql.SQLException;
import org.springframework.jdbc.core.RowMapper;
public class StudentMapper implements RowMapper<Student> {
public Student mapRow(ResultSet rs, int rowNum) throws SQLException {
Student student = new Student();
student.setId(rs.getInt("id"));
student.setName(rs.getString("name"));
student.setAge(rs.getInt("age"));
return student;
}
}
A seguir está o arquivo de classe de implementação StudentJDBCTemplate.java para a interface DAO definida StudentDAO.
package com.tutorialspoint;
import java.sql.Types;
import java.util.List;
import java.util.Map;
import javax.sql.DataSource;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.SqlOutParameter;
import org.springframework.jdbc.core.SqlParameter;
import org.springframework.jdbc.core.namedparam.MapSqlParameterSource;
import org.springframework.jdbc.core.namedparam.SqlParameterSource;
import org.springframework.jdbc.object.StoredProcedure;
public class StudentJDBCTemplate implements StudentDao {
private DataSource dataSource;
private JdbcTemplate jdbcTemplateObject;
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
this.jdbcTemplateObject = new JdbcTemplate(dataSource);
}
public Student getStudent(Integer id) {
StudentProcedure studentProcedure = new StudentProcedure(dataSource, "getRecord");
return studentProcedure.execute(id);
}
}
class StudentProcedure extends StoredProcedure{
public StudentProcedure(DataSource dataSource, String procedureName) {
super(dataSource,procedureName);
declareParameter(new SqlParameter("in_id", Types.INTEGER));
declareParameter(new SqlOutParameter("out_name", Types.VARCHAR));
declareParameter(new SqlOutParameter("out_age", Types.INTEGER));
compile();
}
public Student execute(Integer id){
Map<String, Object> out = super.execute(id);
Student student = new Student();
student.setId(id);
student.setName((String) out.get("out_name"));
student.setAge((Integer) out.get("out_age"));
return student;
}
}
O código que você escreve para a execução da chamada envolve a criação de um SqlParameterSource contendo o parâmetro IN. É importante combinar o nome fornecido para o valor de entrada com o nome do parâmetro declarado no procedimento armazenado. O método execute usa os parâmetros IN e retorna um Map contendo quaisquer parâmetros de saída digitados pelo nome conforme especificado no procedimento armazenado.
A seguir está o conteúdo do MainApp.java Arquivo.
package com.tutorialspoint;
import java.util.List;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import com.tutorialspoint.StudentJDBCTemplate;
public class MainApp {
public static void main(String[] args) {
ApplicationContext context = new ClassPathXmlApplicationContext("Beans.xml");
StudentJDBCTemplate studentJDBCTemplate =
(StudentJDBCTemplate)context.getBean("studentJDBCTemplate");
Student student = studentJDBCTemplate.getStudent(1);
System.out.print("ID : " + student.getId() );
System.out.print(", Name : " + student.getName() );
System.out.println(", Age : " + student.getAge());
}
}
A seguir está o arquivo de configuração Beans.xml.
<?xml version = "1.0" encoding = "UTF-8"?>
<beans xmlns = "http://www.springframework.org/schema/beans"
xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation = "http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.0.xsd ">
<!-- Initialization for data source -->
<bean id = "dataSource"
class = "org.springframework.jdbc.datasource.DriverManagerDataSource">
<property name = "driverClassName" value = "com.mysql.jdbc.Driver"/>
<property name = "url" value = "jdbc:mysql://localhost:3306/TEST"/>
<property name = "username" value = "root"/>
<property name = "password" value = "admin"/>
</bean>
<!-- Definition for studentJDBCTemplate bean -->
<bean id = "studentJDBCTemplate"
class = "com.tutorialspoint.StudentJDBCTemplate">
<property name = "dataSource" ref = "dataSource" />
</bean>
</beans>
Assim que terminar de criar os arquivos de configuração de código-fonte e bean, vamos executar o aplicativo. Se tudo estiver bem com seu aplicativo, ele imprimirá a seguinte mensagem.
ID : 1, Name : Zara, Age : 10