Spring JDBC - Classe StoredProcedure
Il org.springframework.jdbc.core.StoredProcedureclass è la superclasse per le astrazioni degli oggetti delle procedure memorizzate RDBMS. Questa classe è astratta ed è inteso che le sottoclassi forniranno un metodo tipizzato per l'invocazione che delega al metodo execute (java.lang.Object ...) fornito. La proprietà SQL ereditata è il nome della procedura memorizzata nell'RDBMS.
Dichiarazione di classe
Di seguito è riportata la dichiarazione per org.springframework.jdbc.core.StoredProcedure classe -
public abstract class StoredProcedure
extends SqlCallL'esempio seguente mostrerà come chiamare una stored procedure utilizzando Spring StoredProcedure. Leggeremo uno dei record disponibili in Student Table chiamando una stored procedure. Passeremo un documento d'identità e riceveremo un record dello studente.
Sintassi
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;
}
}Dove,
StoredProcedure - Oggetto StoredProcedure per rappresentare una stored procedure.
StudentProcedure - L'oggetto StudentProcedure estende StoredProcedure per dichiarare l'input, la variabile di output e associare il risultato all'oggetto Student.
student - Oggetto studente.
Per comprendere i concetti sopra menzionati relativi a Spring JDBC, scriviamo un esempio che chiamerà una procedura memorizzata. Per scrivere il nostro esempio, disponiamo di un IDE Eclipse funzionante e utilizziamo i seguenti passaggi per creare un'applicazione Spring.
| Passo | Descrizione |
|---|---|
| 1 | Aggiorna il progetto Studente creato nel capitolo Spring JDBC - Prima applicazione . |
| 2 | Aggiorna la configurazione del bean ed esegui l'applicazione come spiegato di seguito. |
Di seguito è riportato il contenuto del file di interfaccia dell'oggetto di accesso ai dati 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);
}Di seguito è riportato il contenuto del file Student.java file.
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;
}
}Di seguito è riportato il contenuto del file StudentMapper.java file.
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;
}
}Di seguito è riportato il file della classe di implementazione StudentJDBCTemplate.java per l'interfaccia DAO definita 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;
}
}Il codice che scrivi per l'esecuzione della chiamata implica la creazione di un SqlParameterSource contenente il parametro IN. È importante far corrispondere il nome fornito per il valore di input con quello del nome del parametro dichiarato nella stored procedure. Il metodo execute accetta i parametri IN e restituisce una mappa contenente tutti i parametri out codificati dal nome come specificato nella procedura memorizzata.
Di seguito è riportato il contenuto del file MainApp.java file.
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());
}
}Di seguito è riportato il file di configurazione 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>Una volta terminata la creazione dei file di configurazione dei bean e dei sorgenti, eseguiamo l'applicazione. Se tutto va bene con la tua applicazione, verrà stampato il seguente messaggio.
ID : 1, Name : Zara, Age : 10