Spring JDBC - SimpleJdbcInsert-Klasse

Das org.springframework.jdbc.core.SimpleJdbcInsertclass ist ein wiederverwendbares Multithread-Objekt, das einfache Einfügefunktionen für eine Tabelle bietet. Es bietet eine Metadatenverarbeitung, um den Code zu vereinfachen, der zum Erstellen einer grundlegenden Einfügeanweisung erforderlich ist. Die eigentliche Einfügung wird mit Spring's JdbcTemplate behandelt

Klassenerklärung

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

public class SimpleJdbcInsert
   extends AbstractJdbcInsert
      implements SimpleJdbcInsertOperations

Das folgende Beispiel zeigt, wie Sie eine Abfrage mit Spring JDBC einfügen. Wir werden einen Datensatz mit dem SimpleJdbcInsert-Objekt in die Schülertabelle einfügen.

Syntax

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

Wo,

jdbcInsert - SimpleJdbcInsert-Objekt zum Einfügen eines Datensatzes in die Schülertabelle.
jdbcTemplateObject - StudentJDBCTemplate-Objekt zum Lesen des Student-Objekts in der Datenbank.

Um die oben genannten Konzepte im Zusammenhang mit Spring JDBC zu verstehen, schreiben wir ein Beispiel, in das eine Abfrage eingefügt wird. 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 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();   
}

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

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

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.

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