Spring JDBC - SimpleJdbcCall-Klasse

Das org.springframework.jdbc.core.SimpleJdbcCallKlasse ist ein wiederverwendbares Multithread-Objekt, das einen Aufruf einer gespeicherten Prozedur oder einer gespeicherten Funktion darstellt. Es bietet eine Metadatenverarbeitung, um den Code zu vereinfachen, der für den Zugriff auf grundlegende gespeicherte Prozeduren / Funktionen erforderlich ist.

Sie müssen lediglich den Namen der Prozedur / Funktion und eine Zuordnung mit den Parametern angeben, wenn Sie den Aufruf ausführen. Die Namen der angegebenen Parameter werden mit den In- und Out-Parametern abgeglichen, die beim Erstellen der gespeicherten Prozedur deklariert wurden.

Klassenerklärung

Es folgt die Erklärung für org.springframework.jdbc.core.SimpleJdbcCall Klasse -

public class SimpleJdbcCall
   extends AbstractJdbcCall
      implements SimpleJdbcCallOperations

Das folgende Beispiel zeigt, wie eine gespeicherte Prozedur mit Spring SimpleJdbcCall aufgerufen wird. Wir werden einen der verfügbaren Datensätze in der Schülertabelle lesen, indem wir eine gespeicherte Prozedur aufrufen. Wir werden einen Ausweis übergeben und eine Studentenakte erhalten.

Syntax

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"));

Wo,

jdbcCall - SimpleJdbcCall-Objekt zur Darstellung einer gespeicherten Prozedur.
in - SqlParameterSource-Objekt zum Übergeben eines Parameters an eine gespeicherte Prozedur.
student - Schülerobjekt.
out - Zuordnungsobjekt zur Darstellung der Ausgabe des Aufrufergebnisses für gespeicherte Prozeduren.

Um die oben genannten Konzepte in Bezug auf Spring JDBC zu verstehen, schreiben wir ein Beispiel, das eine gespeicherte Prozedur aufruft. Um unser Beispiel zu schreiben, lassen Sie uns eine funktionierende Eclipse-IDE einrichten und führen Sie die folgenden Schritte aus, um eine Spring-Anwendung zu erstellen.

Schritt	Beschreibung
1	Aktualisieren Sie das unter Student Spring JDBC - First Application erstellte Projekt Student .
2	Aktualisieren Sie die Bean-Konfiguration und führen Sie die Anwendung wie unten erläutert aus.

Im Folgenden finden Sie den Inhalt der Data Access Object-Schnittstellendatei 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);  
}

Es folgt der Inhalt der Student.java Datei.

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;
   }
}

Es folgt der Inhalt der StudentMapper.java Datei.

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;
   }
}

Es folgt die Implementierungsklassendatei StudentJDBCTemplate.java für die definierte DAO-Schnittstelle 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;      
   }
}

Der Code, den Sie für die Ausführung des Aufrufs schreiben, umfasst das Erstellen einer SqlParameterSource, die den Parameter IN enthält. Es ist wichtig, den für den Eingabewert angegebenen Namen mit dem in der gespeicherten Prozedur deklarierten Parameternamen abzugleichen. Die Methode execute verwendet die IN-Parameter und gibt eine Map zurück, die alle out-Parameter enthält, die durch den in der gespeicherten Prozedur angegebenen Namen gekennzeichnet sind.

Es folgt der Inhalt der MainApp.java Datei.

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()); 
   }
}

Es folgt die Konfigurationsdatei 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>

Nachdem Sie die Quell- und Bean-Konfigurationsdateien erstellt haben, lassen Sie uns die Anwendung ausführen. Wenn mit Ihrer Anwendung alles in Ordnung ist, wird die folgende Meldung gedruckt.

ID : 1, Name : Zara, Age : 11