0
点赞
收藏
分享

微信扫一扫

四、JdbcTemplate

进击的铁雾 2022-09-02 阅读 54
spring数据库javaxmlsql虚拟化云计算


四、JdbcTemplate

  • ​​四、JdbcTemplate​​
  • ​​JdbcTemplate（概念和准备）​​
  • ​​1、什么是JdbcTemplate​​
  • ​​2、准备工作​​
  • ​​（1）引入相关jar包​​
  • ​​（2）在spring配置文件配置数据库连接池​​
  • ​​src/bean1/xml​​
  • ​​（3）配置JdbcTemplate对象,注入DataSource​​
  • ​​bean.xml​​
  • ​​（4）创建service类，创建dao类，在dao注入JdbcTemplate对象​​
  • ​​bean1.xml​​
  • ​​spring5/新建service包/新建BookService类​​
  • ​​spring5/新建dao包/新建BookDao接口​​
  • ​​dao包/新建BookDaoImpl类​​
  • ​​JdbcTemplate 操作数据库（添加）​​
  • ​​1、对应数据库创建实体类​​
  • ​​spring5/新建entity包/新建User类​​
  • ​​2、编写service和dao​​
  • ​​（1）在dao进行数据库添加的操作​​
  • ​​dao/新建UserDao​​
  • ​​dao/新建UserDaoImpl​​
  • ​​service/新建UserService​​
  • ​​（2）调用JdbcTemplate对象里面的update方法实现添加操作​​
  • ​​spring5/新建test包/新建TestUser类​​
  • ​​JdbcTemplate 操作数据库（修改和删除）​​
  • ​​UserService​​
  • ​​UserDaoImpl​​
  • ​​TestUser​​
  • ​​JdbcTemplate 操作数据库（查询返回某个值）​​
  • ​​1、查询表里面有多少条记录，返回就是某个值​​
  • ​​2、使用JdbcTemplate实现查询返回某个值代码​​
  • ​​UserService​​
  • ​​UserDaoImpl​​
  • ​​TestUser​​
  • ​​JdbcTemplate 操作数据库（查询返回对象）​​
  • ​​1、场景：查询图书详情页面​​
  • ​​2、JdbcTemplate实现查询返回对象​​
  • ​​UserService​​
  • ​​UserDaoImpl​​
  • ​​TestUser​​
  • ​​JdbcTemplate 操作数据库（查询返回集合）​​
  • ​​1、场景：查询图书列表分页...​​
  • ​​2、调用JdbcTemplate实现查询返回集合​​
  • ​​UserService​​
  • ​​UserDaoImpl​​
  • ​​TestUser​​
  • ​​JdbcTemplate 操作数据库（批量操作）​​
  • ​​1、批量操作：操作表里面的多条记录​​
  • ​​2、JdbcTemplate 实现批量添加操作​​
  • ​​UserService​​
  • ​​UserDaoImpl​​
  • ​​TestUser​​
  • ​​3、JdbcTemplate 实现批量修改操作​​
  • ​​UserService​​
  • ​​UserDaoImpl​​
  • ​​TestUser​​
  • ​​4、JdbcTemplate 实现批量删除操作​​
  • ​​UserService​​
  • ​​UserDaoImpl​​
  • ​​TestUser​​
  • ​​完整代码​​
  • ​​User​​
  • ​​UserDao​​
  • ​​UserDapImpl​​
  • ​​UserService​​
  • ​​TestUser​​

说明

四、JdbcTemplate

JdbcTemplate（概念和准备）

1、什么是JdbcTemplate

（1）Spring框架对JDBC进行封装，使用JdbcTemplate方便实现对数据库操作

2、准备工作

四、JdbcTemplate_数据库

（1）引入相关jar包

druid.jar

mysql驱动.jar

spring-jdbc-5.3.10.jar

spring-tx-5.3.10.jar

spring-orm-5.3.10.jar

四、JdbcTemplate_数据库_02

（2）在spring配置文件配置数据库连接池

src/bean1/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"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xmlns:tx="http://www.springframework.org/schema/tx"
       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
                        http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd
                        http://www.springframework.org/schema/tx http://www.springframework.org/schema/tx/spring-tx.xsd">

    <!-- 组件扫描 -->
    <context:component-scan base-package="com.atguigu"></context:component-scan>

    <!-- 数据库连接池 -->
    <!-- 配置连接池 -->
    <!-- DruidDataSource dataSource = new DruidDataSource(); -->

    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
          destroy-method="close"     >
        <property name="url" value="jdbc:mysql://localhost:3306/user_db?serverTimezone=UTC"/>
        <property name="username" value="root"/>
        <property name="password" value="root"/>
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver"/>
    </bean>

    <!-- JdbcTemplate对象 -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!--注入dataSource-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>

</beans>

（3）配置JdbcTemplate对象,注入DataSource

bean.xml

<!--  JdbcTemplate对象  -->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
<!--        注入DataSource-->
        <property name="dataSource" ref="dataSource"></property>
    </bean>

（4）创建service类，创建dao类，在dao注入JdbcTemplate对象

bean1.xml

<!--    开启组件扫描-->
    <context:component-scan base-package="com.atguigu"></context:component-scan>

spring5/新建service包/新建BookService类

package com.atguigu.spring5.service;

import com.atguigu.spring5.dao.BookDao;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class BookService {
    //注入dao
    @Autowired
    private BookDao bookDao;
}

spring5/新建dao包/新建BookDao接口

package com.atguigu.spring5.dao;



public interface BookDao{

}

dao包/新建BookDaoImpl类

package com.atguigu.spring5.dao;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

@Repository
public class BookDapImpl implements BookDao{
   //注入JdbcTemplate
    @Autowired
    private JdbcTemplate jdbcTemplate;

}

JdbcTemplate 操作数据库（添加）

四、JdbcTemplate_sql_03

四、JdbcTemplate_xml_04


四、JdbcTemplate_spring_05

1、对应数据库创建实体类

spring5/新建entity包/新建User类

package com.atguigu.spring5.entity;

public class User {
    private String userId;
    private String username;
    private String ustatus;

    public String getUserId() {
        return userId;
    }

    public void setUserId(String userId) {
        this.userId = userId;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getUstatus() {
        return ustatus;
    }

    public void setUstatus(String ustatus) {
        this.ustatus = ustatus;
    }
}

2、编写service和dao

（1）在dao进行数据库添加的操作

dao/新建UserDao

package com.atguigu.spring5.dao;


import com.atguigu.spring5.entity.User;

public interface UserDao {
    //添加的方法
    public void add(User user);
}

dao/新建UserDaoImpl

package com.atguigu.spring5.dao;

import com.atguigu.spring5.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

@Repository
public class UserDapImpl implements UserDao{
   //注入JdbcTemplate
    @Autowired
    private JdbcTemplate jdbcTemplate;

    //添加的方法
    @Override
    public void add(User user) {
        //1.创建sql语句
        String sql="insert into t_user values (?,?,?)";
        //2.调用方法实现
        Object[] args={user.getUserId(), user.getUsername(), user.getUstatus()};
        int update = jdbcTemplate.update(sql,args);
        System.out.println(update);
    }
}

service/新建UserService

package com.atguigu.spring5.service;


import com.atguigu.spring5.dao.UserDao;
import com.atguigu.spring5.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class UserService {
    //注入dao
    @Autowired
    private UserDao userDao;

    //添加的方法
    public void addUser(User user){
        userDao.add(user);
    }
}

（2）调用JdbcTemplate对象里面的update方法实现添加操作

.update(String sql，Object... args);

  • 有两个参数
  • 第一个参数：sql语句
  • 第二个参数：可变参数，设置sql语句值
spring5/新建test包/新建TestUser类

package com.atguigu.spring5.test;

import com.atguigu.spring5.entity.User;
import com.atguigu.spring5.service.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class TestUser {
    @Test
    public void testJdbcTemplate(){
        ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");
        UserService userService = context.getBean("userService", UserService.class);

        User user=new User();
        user.setUserId("1");
        user.setUsername("java");
        user.setUstatus("a");

        userService.addUser(user);

    }
}

JdbcTemplate 操作数据库（修改和删除）

UserService

//修改的方法
    public void updateUser(User user){
        userDao.update(user);
    }

    //删除的方法
    public void deleteUser(String id){
        userDao.delete(id);
    }

UserDaoImpl

//修改
    @Override
    public void update(User user) {
        String sql ="update t_user set username=?,ustatus=?where user_id=?";
        Object[] args={user.getUsername(), user.getUstatus(),user.getUserId() };
        int update = jdbcTemplate.update(sql, args);
        System.out.println(update);
    }

    //删除
    @Override
    public void delete(String id) {
        String sql ="delete from t_user where user_id=?";
        int update = jdbcTemplate.update(sql, id);
        System.out.println(update);
    }

TestUser

//修改
//        User user=new User();
//        user.setUserId("1");
//        user.setUsername("javaupup");
//        user.setUstatus("atguigu");
//
//        userService.updateUser(user);

        //删除
//        userService.deleteUser("1");

JdbcTemplate 操作数据库（查询返回某个值）

1、查询表里面有多少条记录，返回就是某个值

2、使用JdbcTemplate实现查询返回某个值代码

queryForObject(String sql, Class<T> requiredType);

  • 有两个参数
  • 第一个参数：sql语句
  • 第二个参数：返回类型Class
UserService

//查询表中的记录数
    public int findCount(){
        return userDao.selectCount();
    }

UserDaoImpl

//查询表记录数
    @Override
    public int selectCount() {
        String sql="select count(*) from t_user";
        Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
        return count;
    }

TestUser

//查询返回某个值
        int count = userService.findCount();
        System.out.println(count);

JdbcTemplate 操作数据库（查询返回对象）

1、场景：查询图书详情页面

2、JdbcTemplate实现查询返回对象

queryForObject(String sql, RowMapper<T> rowMapper, @Nullable Object... args)

  • 有三个参数
  • 第一个参数：sql语句
  • 第二个参数：RowMapper，是接口，返回不同类型的数据，使用这个接口里面实现类完成数据封装
  • 第三个参数：sql语句值

queryForObject(String sql, Class<T> requiredType);

  • 有两个参数
  • 第一个参数：sql语句
  • 第二个参数：返回类型Class

User增加toString方法

UserService

//查询表中的记录数
    public User findOne(String id){
        return userDao.findUserInfo(id);
    }

UserDaoImpl

//查询返回对象
    @Override
    public User findUserInfo(String id) {
        String sql ="select * from t_user where user_id=?";
        User user = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<User>(User.class), id);
        return user;
    }

TestUser

//查询返回对象
        User user = userService.findOne("1");
        System.out.println(user);

JdbcTemplate 操作数据库（查询返回集合）

1、场景：查询图书列表分页…

2、调用JdbcTemplate实现查询返回集合

query(String sql, RowMapper<T> rowMapper, Object... args)

  • 有三个参数
  • 第一个参数：sql语句
  • 第二个参数：RowMapper，是接口，返回不同类型的数据，使用这个接口里面实现类完成数据封装
  • 第三个参数：sql语句值

queryForObject(String sql, Class<T> requiredType);

  • 有两个参数
  • 第一个参数：sql语句
  • 第二个参数：返回类型Class
UserService

//查询返回集合
    public List<User> findAll(){
        return userDao.findAllUser();
    }

UserDaoImpl

//查询返回集合
    @Override
    public List<User> findAllUser() {
        String sql ="select * from t_user";
        List<User> userList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<User>(User.class));
        return userList;
    }

TestUser

//查询返回集合
        List<User> all = userService.findAll();
        System.out.println(all);

JdbcTemplate 操作数据库（批量操作）

1、批量操作：操作表里面的多条记录

2、JdbcTemplate 实现批量添加操作

batchUpdate(String sql,List<Object[]> batchArgs)

  • 有两个参数
  • 第一个参数：sql语句
  • 第二个参数：List集合，添加多条记录数据
UserService

//批量添加
    public void batchAdd(List<Object[]> batchArgs){
        userDao.batchAddUser(batchArgs);
    }

UserDaoImpl

//批量添加
    @Override
    public void batchAddUser(List<Object[]> batchArgs) {
        String sql="insert into t_user values (?,?,?)";
        int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
        System.out.println(Arrays.toString(ints));
    }

TestUser

//批量添加
        List<Object[]> batchArgs=new ArrayList<>();
        Object[] o1={"3","java","a"};
        Object[] o2={"4","C++","b"};
        Object[] o3={"5","MySQL","c"};
        batchArgs.add(o1);
        batchArgs.add(o2);
        batchArgs.add(o3);
        //调用批量添加方法
        userService.batchAdd(batchArgs);

3、JdbcTemplate 实现批量修改操作

UserService

//批量修改
    public void batchUpdate(List<Object[]> batchArgs){
        userDao.batchUpdateUser(batchArgs);
    }

UserDaoImpl

//批量修改
   @Override
    public void batchUpdateUser(List<Object[]> batchArgs) {
        String sql ="update t_user set username=?,ustatus=?where user_id=?";
        int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
        System.out.println(Arrays.toString(ints));
    }

TestUser

//批量修改
        List<Object[]> batchArgs=new ArrayList<>();
        Object[] o1={"java0909","a3","3"};
        Object[] o2={"C++1010","b4","4",};
        Object[] o3={"MySQL1111","c5","5"};
        batchArgs.add(o1);
        batchArgs.add(o2);
        batchArgs.add(o3);
        //调用批量修改方法
        userService.batchUpdate(batchArgs);

4、JdbcTemplate 实现批量删除操作

UserService

//批量删除
    public void batchDelete(List<Object[]> batchArgs){
        userDao.batchDeleteUser(batchArgs);
    }

UserDaoImpl

//批量删除
    @Override
    public void batchDeleteUser(List<Object[]> batchArgs) {
        String sql ="delete from t_user where user_id=?";
        int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
        System.out.println(Arrays.toString(ints));
    }

TestUser

//批量删除
        List<Object[]> batchArgs=new ArrayList<>();
        Object[] o1={"3"};
        Object[] o2={"4"};
        batchArgs.add(o1);
        batchArgs.add(o2);

        //调用批量修改方法
        userService.batchDelete(batchArgs);

完整代码

User

package com.atguigu.spring5.entity;

public class User {
    private String userId;
    private String username;
    private String ustatus;

    public String getUserId() {
        return userId;
    }



    public void setUserId(String userId) {
        this.userId = userId;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getUstatus() {
        return ustatus;
    }

    public void setUstatus(String ustatus) {
        this.ustatus = ustatus;
    }
    @Override
    public String toString() {
        return "User{" +
                "userId='" + userId + '\'' +
                ", username='" + username + '\'' +
                ", ustatus='" + ustatus + '\'' +
                '}';
    }
}

UserDao

package com.atguigu.spring5.dao;


import com.atguigu.spring5.entity.User;

import java.util.List;

public interface UserDao {
    //添加的方法
    public void add(User user);

    //修改的方法
    void update(User user);

    //删除的方法
    void delete(String id);

    //查询表中的记录数
    int selectCount();

    User findUserInfo(String id);

    List<User> findAllUser();

    void batchAddUser(List<Object[]> batchArgs);

    void batchUpdateUser(List<Object[]> batchArgs);

    void batchDeleteUser(List<Object[]> batchArgs);
}

UserDapImpl

package com.atguigu.spring5.dao;

import com.atguigu.spring5.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.BeanPropertyRowMapper;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Repository;

import java.util.Arrays;
import java.util.List;

@Repository
public class UserDapImpl implements UserDao{
   //注入JdbcTemplate
    @Autowired
    private JdbcTemplate jdbcTemplate;

    //添加的方法
    @Override
    public void add(User user) {
        //1.创建sql语句
        String sql="insert into t_user values (?,?,?)";
        //2.调用方法实现
//        Object[] args={user.getUserId(), user.getUsername(), user.getUstatus()};
        int update = jdbcTemplate.update(sql,user.getUserId(), user.getUsername(), user.getUstatus());
        System.out.println(update);
    }

    //修改
    @Override
    public void update(User user) {
        String sql ="update t_user set username=?,ustatus=?where user_id=?";
        Object[] args={user.getUsername(), user.getUstatus(),user.getUserId() };
        int update = jdbcTemplate.update(sql, args);
        System.out.println(update);
    }

    //删除
    @Override
    public void delete(String id) {
        String sql ="delete from t_user where user_id=?";
        int update = jdbcTemplate.update(sql, id);
        System.out.println(update);
    }

    //查询表记录数
    @Override
    public int selectCount() {
        String sql="select count(*) from t_user";
        Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
        return count;
    }

    //查询返回对象
    @Override
    public User findUserInfo(String id) {
        String sql ="select * from t_user where user_id=?";
        User user = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<User>(User.class), id);
        return user;
    }

    //查询返回集合
    @Override
    public List<User> findAllUser() {
        String sql ="select * from t_user";
        List<User> userList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<User>(User.class));
        return userList;

    }

    //批量添加
    @Override
    public void batchAddUser(List<Object[]> batchArgs) {
        String sql="insert into t_user values (?,?,?)";
        int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
        System.out.println(Arrays.toString(ints));
    }

    //批量修改
    @Override
    public void batchUpdateUser(List<Object[]> batchArgs) {
        String sql ="update t_user set username=?,ustatus=?where user_id=?";
        int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
        System.out.println(Arrays.toString(ints));
    }

    //批量删除
    @Override
    public void batchDeleteUser(List<Object[]> batchArgs) {
        String sql ="delete from t_user where user_id=?";
        int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
        System.out.println(Arrays.toString(ints));
    }
}

UserService

package com.atguigu.spring5.service;


import com.atguigu.spring5.dao.UserDao;
import com.atguigu.spring5.entity.User;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UserService {
    //注入dao
    @Autowired
    private UserDao userDao;

    //添加的方法
    public void addUser(User user){
        userDao.add(user);
    }

    //修改的方法
    public void updateUser(User user){
        userDao.update(user);
    }

    //删除的方法
    public void deleteUser(String id){
        userDao.delete(id);
    }

    //查询表中的记录数
    public int findCount(){
        return userDao.selectCount();
    }

    //查询表中的记录数
    public User findOne(String id){
        return userDao.findUserInfo(id);
    }

    //查询返回集合
    public List<User> findAll(){
        return userDao.findAllUser();
    }

    //批量添加
    public void batchAdd(List<Object[]> batchArgs){
        userDao.batchAddUser(batchArgs);
    }

    //批量修改
    public void batchUpdate(List<Object[]> batchArgs){
        userDao.batchUpdateUser(batchArgs);
    }

    //批量删除
    public void batchDelete(List<Object[]> batchArgs){
        userDao.batchDeleteUser(batchArgs);
    }
}

TestUser

package com.atguigu.spring5.test;

import com.atguigu.spring5.entity.User;
import com.atguigu.spring5.service.UserService;
import org.junit.Test;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

import java.util.ArrayList;
import java.util.List;
import java.util.Objects;

public class TestUser {
    @Test
    public void testJdbcTemplate(){
        ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");
        UserService userService = context.getBean("userService", UserService.class);

//        User user=new User();
//        user.setUserId("1");
//        user.setUsername("java");
//        user.setUstatus("a");
//
//        userService.addUser(user);


        //修改
//        User user=new User();
//        user.setUserId("1");
//        user.setUsername("javaupup");
//        user.setUstatus("atguigu");
//
//        userService.updateUser(user);

        //删除
//        userService.deleteUser("1");

        //查询返回某个值
//        int count = userService.findCount();
//        System.out.println(count);

        //查询返回对象
//        User user = userService.findOne("1");
//        System.out.println(user);

        //查询返回集合
//        List<User> all = userService.findAll();
//        System.out.println(all);

//        //批量添加
//        List<Object[]> batchArgs=new ArrayList<>();
//        Object[] o1={"3","java","a"};
//        Object[] o2={"4","C++","b"};
//        Object[] o3={"5","MySQL","c"};
//        batchArgs.add(o1);
//        batchArgs.add(o2);
//        batchArgs.add(o3);
//        //调用批量添加方法
//        userService.batchAdd(batchArgs);

//        //批量修改
//        List<Object[]> batchArgs=new ArrayList<>();
//        Object[] o1={"java0909","a3","3"};
//        Object[] o2={"C++1010","b4","4"};
//        Object[] o3={"MySQL1111","c5","5"};
//        batchArgs.add(o1);
//        batchArgs.add(o2);
//        batchArgs.add(o3);
//        //调用批量修改方法
//        userService.batchUpdate(batchArgs);

        //批量删除
        List<Object[]> batchArgs=new ArrayList<>();
        Object[] o1={"3"};
        Object[] o2={"4"};
        batchArgs.add(o1);
        batchArgs.add(o2);

        //调用批量修改方法
        userService.batchDelete(batchArgs);
    }
}


举报

相关推荐

jdbctemplate

bcspringxmlMySQL数据库

Spring JdbcTemplate

spring

【Spring Boot】JdbcTemplate数据连接模板 — JdbcTemplate入门

opencv目标检测

五、JdbcTemplate

JdbcTemplatessmjavaspringsql编程语言

整合JdbcTemplate

java

JdbcTemplate的用法

sqlmysqlunixJava编程语言

26.JdbcTemplate

vue.jspdf前端

JDBCTemplate常用API

sql数据库java

Springboot整合JDBCTemplate

springsql连接池虚拟化云计算

JDBCTemplate操作

spring类方法事务管理Hadoop大数据
0 条评论