Spring JDBC - Aufrufen einer gespeicherten Funktion

Das folgende Beispiel zeigt, wie eine gespeicherte Funktion mit Spring JDBC aufgerufen wird. Wir werden einen der verfügbaren Datensätze in der Schülertabelle lesen, indem wir eine gespeicherte Funktion aufrufen. Wir geben einen Ausweis ab und erhalten einen Schülernamen.

Syntax

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

Wo,

in - SqlParameterSource-Objekt zum Übergeben eines Parameters an eine gespeicherte Funktion.
jdbcCall - SimpleJdbcCall-Objekt zur Darstellung einer gespeicherten Funktion.
jdbcTemplateObject - StudentJDBCTemplate-Objekt für die aufgerufene gespeicherte Funktion aus der Datenbank.
student - Schülerobjekt.

Das SimpleJdbcCallKlasse kann verwendet werden, um eine gespeicherte Funktion mit dem Parameter IN und einem Rückgabewert aufzurufen. Sie können diesen Ansatz verwenden, wenn Sie mit einem der RDBMS wie Apache Derby, DB2, MySQL, Microsoft SQL Server, Oracle und Sybase arbeiten.

Um den Ansatz zu verstehen, betrachten Sie die folgende gespeicherte MySQL-Prozedur, die die Schüler-ID verwendet und den Namen des entsprechenden Schülers zurückgibt. Lassen Sie uns diese gespeicherte Funktion in Ihrer TEST-Datenbank mithilfe der MySQL-Eingabeaufforderung erstellen.

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 ;

Um die oben genannten Konzepte in Bezug auf Spring JDBC zu verstehen, schreiben wir ein Beispiel, das eine gespeicherte Funktion 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).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;      
   }
}

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 Funktion deklarierten Parameternamen abzugleichen. Die executeFunction-Methode verwendet die IN-Parameter und gibt einen String zurück, wie in der gespeicherten Funktion angegeben.

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

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