Spring Jdbc模板插入、更新和删除示例

谁借莪１个温暖的怀抱￠ 2023-09-26 10:11 2阅读 0赞

在[Spring框架中数据访问][Spring]的文章中，我们已经看到了Spring如何为各种持久性方法提供**模板**，以及模板如何将数据访问代码划分为**固定部分**和**可变部分**。Spring框架管理固定部分的地方，用户提供的自定义代码通过**回调进行**处理。在这篇文章中，我们将看到如何使用**Spring Jdbc模板从数据库中插入，更新和删除数据**。

*  请参阅 [Spring Jdbc模板选择查询示例][Spring Jdbc]，了解如何使用选择查询从数据库读取数据。

请注意，**JdbcTemplate** 需要一个数据源来执行其对固定部分的管理，例如获取数据库连接、清理资源。  
在这篇文章中**，APACHE DBCP**用于提供池数据源，**MYSQL**用作后端。

#### **使用的技术** ####

*  弹簧 5.0.4
 *  阿帕奇数据库方案 2
 *  我的学习能力 5.1.39
 *  爪哇 8
 *  阿帕奇大师 3.3.3

**目录**

1.  [执行依赖关系][Link 1]
2.  [数据库表][Link 2]
3.  [设置数据源依赖项][Link 3]
4.  [弹簧 Jdbc模板配置][Jdbc]
5.  [爪哇类][Link 4]
6.  [使用带有@Repository注释的自动配置][Repository]

#### **执行依赖关系** ####

如果您使用的是 maven，则可以在 pom.xml 中提供依赖项。

*  请参阅[在 Eclipse 中创建一个 Maven 项目][Eclipse _ Maven]，了解如何设置 Maven 项目。

对于你的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/xsd/maven-4.0.0.xsd">
      <modelVersion>4.0.0</modelVersion>
    
      <groupId>org.netjs.prog</groupId>
      <artifactId>maven-spring</artifactId>
      <version>0.0.1-SNAPSHOT</version>
      <packaging>jar</packaging>
    
      <name>maven-spring</name>
      <url>http://maven.apache.org</url>
    
      <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <spring.version>5.0.4.RELEASE</spring.version>
      </properties>
    
      <dependencies>
        <dependency>
          <groupId>junit</groupId>
          <artifactId>junit</artifactId>
          <version>4.11</version>
          <scope>test</scope>
        </dependency>
        
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-core</artifactId>
          <version>${spring.version}</version>
        </dependency>
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-context</artifactId>
          <version>${spring.version}</version>
        </dependency>
        
        <dependency>
          <groupId>javax.inject</groupId>
          <artifactId>javax.inject</artifactId>
          <version>1</version>
        </dependency>
    
        
        <dependency>
          <groupId>org.springframework</groupId>
          <artifactId>spring-jdbc</artifactId>
          <version>${spring.version}</version>
        </dependency>
        
        
        <dependency>
          <groupId>mysql</groupId>
          <artifactId>mysql-connector-java</artifactId>
          <version>5.1.39</version>
        </dependency>
        
        
        <dependency>
          <groupId>org.apache.commons</groupId>
          <artifactId>commons-dbcp2</artifactId>
          <version>2.1</version>
        </dependency>
      </dependencies>
    </project>

或者，您可以下载 jar 并将其添加到类路径中。

####  ####

数据库表

对于此示例，我在MYSQL数据库中创建了一个名为 **employee** 的表，其中包含列 **ID**、**名称**和**年龄**。列 **ID** 配置为自动递增检查，因此无需从查询中传递 id，因为 DB 将为其提供值。

CREATE TABLE `employee` (
      `id` int(11) NOT NULL AUTO_INCREMENT,
      `name` varchar(35) DEFAULT NULL,
      `age` int(11) DEFAULT NULL,
      PRIMARY KEY (`id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=8 DEFAULT CHARSET=utf8;

#### **设置数据源依赖项** ####

第一件事是将数据源设置为 Bean。我使用**属性文件**来配置数据源，其中所有属性都在**db.properties**文件中。

其中，作为 db.properties 文件位于配置文件夹下，具有所有属性。

**数据库属性**

db.driverClassName=com.mysql.jdbc.Driver
    db.url=jdbc:mysql://localhost:3306/netjs
    db.username=
    db.password=
    pool.initialSize=5

此处使用的属性的说明-

**驱动程序类**名是所用数据库的 JDBC 驱动程序。由于此处使用了 MYSQL，因此提供了相同的 jdbc 驱动程序（驱动程序）。

**URL** – 您需要提供 URL 才能访问数据库服务器。我已经创建了一个名为netjs的模式，并且数据库在同一系统上运行，因此网址是**jdbc：mysql：//本地主机：3306 / netjs**。

**数据库**的**用户名和密码**。

**“初始大小”**是连接池的初始大小。它被指定为 5，因此最初将创建 5 个连接并将其存储在池中。

要使用属性文件，您需要在 XML 中放置以下配置。

<context:property-placeholder location="classpath:config/db.properties" />

*  请参阅[如何在Spring框架中读取属性文件][Spring 1]，以了解在Spring框架中读取属性文件的各种方法。

####  ####

弹簧 Jdbc模板配置

数据源 Bean 必须作为 **Jdbc 模板**中的引用提供。

#### **爪哇类** ####

由于Spring总是促进使用[接口][Link 5]，并且还有一种名为**DAO**的数据库层的JEE设计模式，它也说了同样的事情 - *将低级数据访问代码与业务层分开*。

因此，我们有一个**带有**插入，更新和删除方法及其实现类**的员工DAO的**接口。还有一个模型类**员工**与所有获得者/二传手。

**员工.java类**

public class Employee {
     private int empId;
     private String empName;
     private int age;
     
     public int getEmpId() {
      return empId;
     }
     public void setEmpId(int empId) {
      this.empId = empId;
     }
     public String getEmpName() {
      return empName;
     }
     public void setEmpName(String empName) {
      this.empName = empName;
     }
     public int getAge() {
      return age;
     }
     public void setAge(int age) {
      this.age = age;
     }
    }

**EmployeeDAO接口**

import org.netjs.model.Employee;
    
    public interface EmployeeDAO {
     public int save(Employee employee);
     
     public void update(Employee employee);
     
     public void deleteEmpById(int empId);
    }

**EmployeeDAOImpl类**

import org.netjs.dao.EmployeeDAO;
    import org.netjs.model.Employee;
    import org.springframework.jdbc.core.JdbcTemplate;
    
    public class EmployeeDAOImpl implements EmployeeDAO {
      private JdbcTemplate jdbcTemplate;  
      final String INSERT_QUERY = "insert into employee (name, age) values (?, ?)";
      final String UPDATE_QUERY = "update employee set age = ? where id = ?";
      final String DELETE_QUERY = "delete from employee where id = ?";
    
      public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {  
        this.jdbcTemplate = jdbcTemplate;  
      }
    
      public int save(Employee employee) {
        return jdbcTemplate.update(INSERT_QUERY, employee.getEmpName(), employee.getAge());   
      }
    
      public void update(Employee employee) {
        int status = jdbcTemplate.update(UPDATE_QUERY, employee.getAge(), 
          employee.getEmpId()); 
        if(status != 0){
          System.out.println("Employee data updated for ID " + employee.getEmpId());
        }else{
          System.out.println("No Employee found with ID " + employee.getEmpId());
        }       
      }
    
      public void deleteEmpById(int empId) {
        int status = jdbcTemplate.update(DELETE_QUERY, empId);
        if(status != 0){
          System.out.println("Employee data deleted for ID " + empId);
        }else{
          System.out.println("No Employee found with ID " + empId);
        }
      }
    }

此类包含 **jdbc模板**属性，该属性将由 Spring 框架注入。在 **save** 方法中，将执行插入查询并向其提供参数。请注意，这些是索引参数。

*  请参阅[春季命名参数Jdbc模板插入、更新和删除示例][Jdbc 1]，了解如何使用命名参数使用命名参数Jdbc模板。

另请注意，您没有编写任何用于获取或关闭连接的代码，异常处理。所有这些固定部分都由 **Jdbc 模板**类管理。它是 Jdbc 模板，它使用提供给它的数据源获取连接，创建和执行语句并关闭连接。

如果抛出的任何 **SQLException** 也被 **Jdbc 模板**捕获并转换为其中一个**数据访问例外**并重新抛出。

**配置**

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:aop="http://www.springframework.org/schema/aop"
        xmlns:context="http://www.springframework.org/schema/context"
        xsi:schemaLocation="http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
        
      <context:property-placeholder location="classpath:config/db.properties" />
      <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">  
        <property name="dataSource" ref="dataSource"></property>  
      </bean>  
      <bean id="employeeDAO" class="org.netjs.daoimpl.EmployeeDAOImpl">
        <property name="jdbcTemplate" ref="jdbcTemplate"></property>  
      </bean>
        
      <bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource">
        <property name="driverClassName" value = "com.mysql.jdbc.Driver" />
        <property name="url" value = "jdbc:mysql://localhost:3306/netjs" />
        <property name="username" value = "root" />
        <property name="password" value = "admin" />
        <property name="initialSize" value = "5" />
      </bean>
    </beans>

**测试类**

您可以使用以下代码来测试插入和更新

import org.netjs.dao.EmployeeDAO;
    import org.netjs.model.Employee;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    
    public class App {
      public static void main(String[] args) {
        ClassPathXmlApplicationContext context = new ClassPathXmlApplicationContext
        ("appcontext.xml");
    
        EmployeeDAO dao=(EmployeeDAO)context.getBean("employeeDAO");  
        Employee emp = new Employee();
        emp.setEmpName("John");
        emp.setAge(25);
        int status = dao.save(emp);  
        System.out.println(status);  
                
        // For update
        emp.setEmpId(12);
        emp.setAge(35);
    
        dao.update(emp);
    
        // For delete
        dao.deleteEmpById(10);
      }
    }

#### **使用带有@Repository注释的自动配置** ####

您还可以使用组件扫描来自动扫描和连接类。为此，您可以将@Repository注释与 DAO 实现类结合使用，@Autowired注释来自动连接依赖项。

*  请参阅[使用自动配置的 Spring 示例程序][Spring 2]，以了解有关自动配置的更多信息。

在这种情况下，您的**员工DAO将**如下所示 -

@Repository
    public class EmployeeDAOImpl implements EmployeeDAO {
      @Autowired
      private JdbcTemplate jdbcTemplate; 
    
      final String INSERT_QUERY = "insert into employee (name, age) values (?, ?)";
      final String UPDATE_QUERY = "update employee set age = ? where id = ?";
      final String DELETE_QUERY = "delete from employee where id = ?";
    
      public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {  
        this.jdbcTemplate = jdbcTemplate;  
      }
    
      public int save(Employee employee) {
        return jdbcTemplate.update(INSERT_QUERY, employee.getEmpName(), 
            employee.getAge());   
      }
    
      public void update(Employee employee) {
        int status = jdbcTemplate.update(UPDATE_QUERY, employee.getAge(), 
          employee.getEmpId()); 
        if(status != 0){
          System.out.println("Employee data updated for ID " + employee.getEmpId());
        }else{
          System.out.println("No Employee found with ID " + employee.getEmpId());
        }
      }
    
      public void deleteEmpById(int empId) {
        int status = jdbcTemplate.update(DELETE_QUERY, empId);
        if(status != 0){
          System.out.println("Employee data deleted for ID " + empId);
        }else{
          System.out.println("No Employee found with ID " + empId);
        }
      }
    }

**XML Configuration**

XML 配置也会更改，因为您必须提供要扫描**的基本包**，并且您还可以为 EmployeeDAO 注释 Bean 定义，因为它将自动完成。

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:aop="http://www.springframework.org/schema/aop"
        xmlns:context="http://www.springframework.org/schema/context"
        xsi:schemaLocation="http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd">
      
      <context:component-scan base-package="org.netjs.daoimpl" />
      
      <context:property-placeholder location="classpath:config/db.properties" />
      
      <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">  
        <property name="dataSource" ref="dataSource"></property>  
      </bean>  
      
        
      <bean id="dataSource" class="org.apache.commons.dbcp2.BasicDataSource">
        <property name="driverClassName" value = "${db.driverClassName}" />
        <property name="url" value = "${db.url}" />
        <property name="username" value = "${db.username}" />
        <property name="password" value = "${db.password}" />
        <property name="initialSize" value = "${pool.initialSize}" />
      </bean>
    </beans>

现在，在运行程序时，您可以像这样获得员工DAO的豆子 -

EmployeeDAO dao=(EmployeeDAO)context.getBean("employeeDAOImpl");

这就是本主题**的全部内容 春季 Jdbc模板插入、更新和删除示例**。如果您有任何疑问或建议，请发表评论。谢谢！

[Spring]: https://www.netjstech.com/2016/11/data-access-in-spring-framework.html
[Spring Jdbc]: https://www.netjstech.com/2016/11/select-query-using-jdbctemplate-in-spring-framework.html
[Link 1]: https://www.netjstech.com/2016/11/insert-update-using-jdbctemplate-in-spring-framework.html#Mavendependencies
[Link 2]: https://www.netjstech.com/2016/11/insert-update-using-jdbctemplate-in-spring-framework.html#DBtable
[Link 3]: https://www.netjstech.com/2016/11/insert-update-using-jdbctemplate-in-spring-framework.html#DataSourcedependency
[Jdbc]: https://www.netjstech.com/2016/11/insert-update-using-jdbctemplate-in-spring-framework.html#JdbcTemplateConfig
[Link 4]: https://www.netjstech.com/2016/11/insert-update-using-jdbctemplate-in-spring-framework.html#JavaClasses
[Repository]: https://www.netjstech.com/2016/11/insert-update-using-jdbctemplate-in-spring-framework.html#Repositoryannotation
[Eclipse _ Maven]: https://www.netjstech.com/2015/10/creating-maven-project-in-eclipse.html
[Spring 1]: https://www.netjstech.com/2016/11/how-to-read-properties-file-in-spring-framework.html
[Link 5]: https://www.netjstech.com/2015/05/interface-in-java.html
[Jdbc 1]: https://www.netjstech.com/2016/11/insert-update-using-namedparameterjdbctemplate-spring.html
[Spring 2]: https://www.netjstech.com/2015/10/spring-example-program-using-automatic-configuration-annotation.html