Spring中数据库编程

最新推荐文章于 2023-04-11 11:12:39 发布

每一刻都是崭新的71

最新推荐文章于 2023-04-11 11:12:39 发布

阅读量550

点赞数

分类专栏：新手求指教求一起探讨文章标签： Java Spring 数据库 JdbcTemplate

本文链接：https://blog.csdn.net/qq_43298772/article/details/99690267

版权

新手求指教同时被 2 个专栏收录

90 篇文章 2 订阅

订阅专栏

求一起探讨

79 篇文章 0 订阅

订阅专栏

在之前讲解了Spring中的两大重要元素：IOC和AOP，接下来我们需要讲解一下Spring中的数据库编程

Spring中数据库编程

传统的JDBC代码即使执行一条简单的SQL语句也并不简单，首先要打开数据库连接执行SQL语句，然后组装结果，最后关闭数据库资源，但是太多的try、catch、finally语句造成了代码泛滥

在Spring出现后，为了解决这些问题，Spring提供了自己的方案，那就是JdbcTemplate模板，Spring JDBC是Spring 所提供的持久层技术，它的主要目的是降低JDBC API的使用暗度，以一种更直接、更简洁的方式使用JDBC API。Spring中的JDBC模块负责数据库资源管理，可以省去连接和关闭数据库的代码

Spring中的`JdbcTemplate`类

Spring框架在数据库开发中的应用主要使用的是JdbcTemplate类，该类作为Spring JDBC的核心类，提供了对所有数据库操作功能的支持。该类是在原始JDBC的基础上，构建了一个抽象层，提供多种使用JDBC的模板和驱动模块，为Spring的应用操作关系数据库提供了更大的便利

JdbcTemplate类的继承关系也很简单，它继承了抽象类JdbcAccessor，同时实现了接口JdbcOperations

在抽象类JdbcAccessor设计中，为它的子类提供了一些访问数据库时的公共属性：

DataSource：其主要功能是获取数据库连接，具体实现时还可以引入对数据库连接的缓冲池和分布式事务的支持，他可以作为访问数据库资源的标准接口
SQLExceptionTranslator：通过必要的设置或者获取SQLExceptionTranslator中的方法，可以使JdbcTemplate类在需要处理SQLException时，委托SQLExceptionTranslator的实现类来完成相关的转译工作

在JdbcOperations接口中，定义了通过Jdbc操作数据库的基本操作方法，而JdbcTemplate类提供了这些接口方法的实现

Spring JDBC的配置

我们新建一个普通Maven项目

在编写程序前我们最先进行的肯定是在pom.xml文件中导入相关的依赖

    <!--junit包单元测试-->
    <dependency>
        <groupId>junit</groupId>
        <artifactId>junit</artifactId>
        <version>4.11</version>
        <scope>test</scope>
    </dependency>

    <!-- Spring MVC 及 Spring系列包 -->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-webmvc</artifactId>
        <version>4.3.24.RELEASE</version>
    </dependency>

   <!--spring-jdbc-->
   <dependency>
      <groupId>org.springframework</groupId>
      <artifactId>spring-jdbc</artifactId>
      <version>4.3.24.RELEASE</version>
    </dependency>

    <!--数据库驱动包-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>5.1.47</version>
    </dependency>

我们需要导入数据库驱动和Spring JDBC的包

和之前一样，先在java目录下创建com目录，在com目录下创建westos目录，在westos目录下创建我们需要的包。

在resources目录下创建applicationContext.xml文件，在该文件中进行相关的配置

applicationContext.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
        https://www.springframework.org/schema/beans/spring-beans.xsd">
   
</beans>

在applicationContext.xml中我们必须先要配置数据源，这样才能获取数据库的链接，有多种数据源的实现，我们这里使用Spring自带的数据源

   <!--配置数据源-->
   <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
      <!--数据库驱动名称、不同类型的数据库名称(如果数据库类型不同，修改value中的值即可)-->
      <property name="driverClassName" value="com.mysql.jdbc.Driver"/>
      <!--选择数据库的数据源所在的url地址,（如果不是本机的数据库，则需要将地址中的localhost替换成相应的主机的IP地址，还要注意端口号）-->
      <property name="url" value="jdbc:mysql://localhost:3306/eshop"/>
      <!--连接数据库的用户名-->
      <property name="username" value="root"/>
      <!--选择数据库的密码，用户在配置数据库时密码设置的是多少就填多少-->
      <property name="password" value="itcast"/>
   </bean>

在配置完成数据源后，我们就可以连接上数据源，但是还需要配置JDBC模板

定义JDBC模板时，需要将dataSource（也就我们上面实例化的bean）注入到JDBC模板中，而其他使用JDBC模板的Bean需要将JDBC模板注入到该Bean中，通常注入到数据访问层Dao类中，在Dao层中进行相关数据库的操作

   <!--配置JDBC模板-->
   <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
      <!--默认必须使用数据源-->
      <property name="dataSource" ref="dataSource"></property>
   </bean>
   
   <!--默认注入的实体类-->
   <bean id="xxx" class="xxx">
      <property name="jdbcTemplate" ref="jdbcTemplate"></property>
   </bean>

至此配置完成

`JdbcTemplate`的常用方法

1.execute(String sql)

execute(String sql)方法能够完成执行SQL语句的功能，下面以创建和删除数据库表的SQL语句为例，讲解此方法的使用

1.启动前端工具SQLyog
在这里插入图片描述在箭头所指处点击鼠标右键，选择创建数据库
之后再IDE中进项数据库的连接，连接的步骤在我的《ssm整合案例MyBatis（1）》博客中有讲解，读者可以自行查阅

在完成上面所有的配置后，我们可以使用execute(String sql)方法在数据库eshop中创建表

在test包中进行测试类的编写
在这里插入图片描述
在Test中进行测试，测试代码如下

package com.westos;

import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.jdbc.core.JdbcTemplate;

public class Test {
    @org.junit.Test
    public void test01(){
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        JdbcTemplate jdbcTemplate = (JdbcTemplate) ctx.getBean("jdbcTemplate");
        String sql = "create table user(id int primary key auto_increment, userName varchar(20), password varchar(32))";
        jdbcTemplate.execute(sql);
        System.out.println("表创建成功");
    }

}

我们将定义好的SQL语句交给JdbcTemplate类的实例jdbcTemplate的execute方法进行执行，就可以在我们之前创建好的eshop数据库中床架一个叫user的表，我们可以在SQLyog中查看我们创建的表
在这里插入图片描述表创建成功

这里一定要注意：在测试类中，有行代码

 ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");

作用是初始化Spring容器并加载applicationContext.xml配置文件，在写这行代码时一定要加.xml后缀，不然就会报错

2.update()

update()方法可以完成插入、更新和删除操作，在JdbcTemplate类中，update方法中存在多个重载的方法，常用方法讲解如下

int update(String sql):该方法时最简单的update方法重载形式，可以直接传入SQL语句，并返回受影响的行数
int update(PreparedStatementCreator psc):该方法执行从PreparedStatementCreator 返回的语句，然后返回收影响的行数
int update(String sql, PreparedStatementSetter pss):该方法通过PreparedStatementSetter设置SQL语句中的参数，并返回受影响的行数
int update(String sql, Object...args):该方法使用Object…args设置SQL语句中的参数，要求参数不能为空，并返回受影响的行数

接下来我们通过一个用户账户管理的实例来实现对用户信息的插入、修改和删除的操作

在westos包下创建pojo包，在pojo包下创建User类

package com.westos.pojo;

public class User {

    private int id;
    private  String userName;
    private  String password;

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public String toString() {
        return "User{" +
                "id=" + id +
                ", userName='" + userName + '\'' +
                ", password='" + password + '\'' +
                '}';
    }


}

创建好User类，在westos包下新建dao包，在dao包下创建UserDao接口，并在接口中定义添加，修改和删除的方法

package com.westos.dao;

import com.westos.pojo.User;

public interface UserDao {
    //添加用户
    public int addUser(User user);
    //修改用户
    public int updateUser(User user);
    //删除用户
    public int deleteUser(int id);
    
}

紧接着在dao包下创建impl包，在impl包下创建UserDao接口的实现类UserDaoImpl，实现接口中的方法

package com.westos.dao.impl;

import com.westos.dao.UserDao;
import com.westos.pojo.User;
import org.springframework.jdbc.core.JdbcTemplate;

public class UserDaoImpl implements UserDao {

    //因为我们要通过这个类来对数据库中的数据进行基本的增删改查，所以我们需要在这个类添加一个JdbcTemplate类的实例
    private JdbcTemplate jdbcTemplate;

    //1.为了实现依赖注入，需要set方法。2.默认无参构造，不需要再添加
    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    @Override
    public int addUser(User user) {
        String sql = "insert into user(userName,password) value(?,?)";
        //使用数组来存储SQL语句中的参数
        Object[] objects = new Object[]{user.getUserName(), user.getPassword()};
        //执行添加操作，返回的是受SQL语句影响的行数
        int result = jdbcTemplate.update(sql, objects);
        return  result;
    }

    @Override
    public int updateUser(User user) {
        String sql = "update user set userName=?,password=? where id=?";
        //使用数组来存储SQL语句中的参数
        Object[] objects = new Object[]{user.getUserName(), user.getPassword(), user.getId()};
        int result = jdbcTemplate.update(sql,objects);
        return result;
    }

    @Override
    public int deleteUser(int id) {
        String sql = "delete from user where id=?";
        //执行删除操作，返回的是受SQL影响的行数
        int result = jdbcTemplate.update(sql,id);
        return result;
    }
}

可以看出添加、删除和修改的操作类似，只是定义的SQL语句不同。在上述类中使用到了JdbcTemplate类的实例，我们需要在applicationContext.xml文件中进行依赖的注入

   <!--配置一个id为userdao的Bean-->
   <bean id="userdao" class="com.westos.dao.impl.UserDaoImpl">
      <!--进行实例的注入-->
      <property name="jdbcTemplate" ref="jdbcTemplate"></property>
   </bean>

在之前的Test测试类中继续进行测试

添加用户

    @org.junit.Test
    public void addUserTest(){
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userdao = (UserDao)ctx.getBean("userdao");

        //创建要添加的对象
        User user = new User();
        user.setUserName("qiangjingzhou");
        user.setPassword("123456");
        //执行添加方法
        int result = userdao.addUser(user);
        if (result>0){
            System.out.println("成功往表中插入了" + result + "条数据");
        }else {
            System.out.println("插入失败");
        }
    }

编写完测试类后运行，可以看到控制台输出
在这里插入图片描述我们在SQLyog中查看user表
数据添加成功

修改用户

    @org.junit.Test
    public void updateUserTest(){
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userdao = (UserDao)ctx.getBean("userdao");

        //创建要修改的对象
        User user = new User();
        user.setId(1);
        user.setUserName("huluwa");
        user.setPassword("123456");
        //执行修改方法
        int result = userdao.updateUser(user);
        if (result>0){
            System.out.println("成功修改了" + result + "条数据");
        }else {
            System.out.println("修改失败");
        }
    }

编写完成后运行，可以看到控制台输出
在这里插入图片描述我们在SQLyog中查看表中修改后的内容
修改用户完成

删除用户

    @org.junit.Test
    public void deleteUserTest(){
        ApplicationContext ctx = new ClassPathXmlApplicationContext("applicationContext.xml");
        UserDao userdao = (UserDao)ctx.getBean("userdao");


        //执行删除方法
        int result = userdao.deleteUser(1);
        if (result>0){
            System.out.println("成功删除了" + result + "条数据");
        }else {
            System.out.println("删除失败");
        }
    }

编写完成后运行，可以看到控制台的输出
在这里插入图片描述在SQLyog中查看我们删除后的结果
记录已经被删除，删除完成