`JDBCTemplate`基本查询详解

昱晟168

已于 2022-05-15 21:33:23 修改

阅读量6k

点赞数 4

分类专栏： Spring家庭文章标签： java spring 开发语言

于 2022-05-15 21:31:55 首次发布

本文链接：https://blog.csdn.net/weixin_47267628/article/details/124774151

版权

Spring家庭专栏收录该内容

29 篇文章 0 订阅

订阅专栏

文章目录

`JDBCTemplate`
4.查询用户信息【重点】
5.批量处理【重点】

`JDBCTemplate`

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

`1.JDBCTeamplate`使用步骤：

1.引入相关的jar包
druid mysql-connector srping-jdbc sprint-tx spring-orm

2.创建数据库连接池properties文件

jdbc.driver=com.mysql.jdbc.Driver
jdbc.url=jdbc:mysql://localhost:3306/mybatis
jdbc.username=root
jdbc.password=root

3.在Spring配置文件引入properties文件和配置数据库连接池，并注入数据源
注意引入proerties需要命名context命名空间

<!--引入jdbc文件-->
    <context:property-placeholder location="jdbc.properties"/>
    <!--配置druid数据源-->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource" destroy-method="close">
        <property name="driverClassName" value="${jdbc.driver}"/>
        <property name="url"  value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

4.配置JdbcTeamplate对象，注入DataSource对象

<!--配置JdbcTemplate-->
    <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
        <!--注入数据源dataSource-->
        <property name="dataSource" ref="dataSource"/>
    </bean>

5.在Dao层的实现类中使用注解的方式注入JdbcTeamplate对象

public interface UserDao {}

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

6.在Service层注入UserDao对象，调用UserDao对象

@Service
public class UserService {
    // 注入UserDao对象
    @Autowired
    private UserDao userDao;
}

7.JavaBean类，并且提供setter和getter方法

package com.haikang.spring5.jdbc.pojo;

/**
 * @Author 海康
 * @Version 1.0
 */
public class User {
    private Integer id;
    private String userName;
    private String password;
    private Integer age;
    private String sex;
    private String email;

	提供：
        无参构造器 和 有参构造器
        setter方法和getter方法
        toString方法
}

2.添加用户信息

添加，修改，删除都是使用这个方法

public int update(String sql, @Nullable Object... args) throws DataAccessException {}

方法中参数：
第一个参数：sql语句
第二个参数：可变参数，设置sql语句值

1.Dao层

public interface UserDao {
    void addUser(User user);
    // 添加一个员工
}


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


    @Override
    public void addUser(User user) {
        // 第一步：定义Sql语句
        String sql = "insert into t_user(username,password,age,sex,email) values(?,?,?,?,?)";
        int update = jdbcTemplate.update(sql, user.getUsername(), user.getPassword(),
                user.getAge(), user.getSex(), user.getEmail());
        System.out.println(update);
    }
}

2.Service层

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

    public void addUser(User user){
        userDao.addUser(user);
    }
}

Test类

@Test
    public void test(){
       ApplicationContext context = new
               ClassPathXmlApplicationContext("bean.xml");
        UserService userService = context.getBean("userService", UserService.class);
        userService.addUser(new User(null,"瑞丽","123",21,"男","123@qq.com"));
    }

3.修改和删除用户信息

修改是根据用户的ID修改，删除同时也是根据用户ID删除
1.Dao层

    // 删除员工信息
    int deleteUser(Integer id);

    // 修改员工信息
    int updateUser(User user);

 @Override
    public int updateUser(User user) {
        // 定义Sql语句
        String sql = "update t_user set username=?,password=?,age=?,sex=?,email=? where id=?";
        int update = jdbcTemplate.update(sql, user.getUsername(), user.getPassword(), user.getAge(), user.getSex(),
                user.getEmail(), user.getId());
        return update;
    }

    @Override
    public int deleteUser(Integer id) {
        // 定义Sql语句
        String sql = "delete from t_user where id=?";
        int update = jdbcTemplate.update(sql, id);
        return update;
    }

2.Service层

    // 修改用户信息
    public int updateUser(User user){
        int i = userDao.updateUser(user);
        return i;
    }
    // 删除用户信息

    public int deleteUser(Integer id){
      return userDao.deleteUser(id);
    }

3.test类

   @Test
    public void testUpdate(){
        ApplicationContext context = new
                ClassPathXmlApplicationContext("bean.xml");
        UserService userService = context.getBean("userService", UserService.class);
        userService.updateUser(new User(19,"瑞丽","AAupdate123",21,"男","123@qq.com"));
    }

    @Test
    public void testDelete() {
        ApplicationContext context = new
                ClassPathXmlApplicationContext("bean.xml");
        UserService userService = context.getBean("userService", UserService.class);
        System.out.println(userService.deleteUser(19));;
    }

4.查询用户信息【重点】

4.1查询一行一列数据，例如查询ID为1的邮箱信息

使用的方法API

@Nullable
public <T> T queryForObject(String sql, Class<T> requiredType) throws {}
 
public <T> T queryForObject(String sql, Class<T> requiredType, @Nullable Object... args){}


`Class<T>`表示返回类型的`Calss`，如返回int类型，则传入`Integer.class`，返回String，则传入`String.class`

Dao层

    // 根据Id查询邮箱信息
    String getEmailById(Integer id);
    // 根据Id查询用户邮箱
    @Override
    public String getEmailById(Integer id) {
        // 定义String语句
        String sql = "select email from t_user where id=?";
        String email = jdbcTemplate.queryForObject(sql, String.class, id);
        return email;
    }

Service层

    // 根据Id查询邮箱
    public String getEmailById(Integer id){
      return   userDao.getEmailById(id);
    }

test类

    // 根据ID查询员工邮箱
    @Test
    public void testGetEmailById(){
        ApplicationContext context = new
                ClassPathXmlApplicationContext("bean.xml");
        UserService userService = context.getBean("userService", UserService.class);
        System.out.println(userService.getEmailById(1));
    }

4.2查询一个用户信息

使用API方法是
JdbcTemplage中queryForObject(String sql,RowMapper<T> rowMapper,Object...args)方法

`JdbcTemplage`中`queryForObject(String sql,RowMapper<T> rowMapper,Object...args)`

第一个参数是：sql
第二个参数是：RowMapper是接口，针对返回不同类型数据，使用这个接口里面实现类完成数据封装
第三个参数是；sql占位符参数值


RowMapper<T> rowMapper是传入Spring实现类
new BeanPropertyRowMapper<T>(Class<T> mappedClass)
传入需要封装数据的`JavaBeab`对象

根据Id查询一个用户信息

Dao层

    // 根据Id查询指定用户信息
    User getUserById(Integer id);

    // 根据Id查询指定用户信息
    @Override
    public User getUserById(Integer id) {
        // 定义Sql语句
        String sql = "select * from t_user where id=?";
        User user = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<>(User.class), id);
        return user;
    }

Service层

	// 根据ID查询一个用户
    public User getUserById(Integer id){
       User user = userDao.getUserById(id);
       return user;
    }

test类

    // 根据用户Id查询信息
    @Test
    public void testGetUserById(){
        ApplicationContext context = new
                ClassPathXmlApplicationContext("bean.xml");
        UserService userService = context.getBean("userService", UserService.class);
        System.out.println(userService.getUserById(1));
        // 返回值：User{id=1, username='明天 ', password='123', age=21, sex='女', email='123qq.com'}
    }

4.3查询用户信息返回一个List集合

查询返回一个List集合方法AIP

JdbcTemplate中方法

`JdbcTemplage`中`queryForObject(String sql,RowMapper<T> rowMapper)`// 用于查询所有记录

`JdbcTemplage`中`queryForObject(String sql,RowMapper<T> rowMapper,Object...args)`// 根据条件查询记录


第一个参数是：sql
第二个参数是：RowMapper是接口，针对返回不同类型数据，使用这个接口里面实现类完成数据封装
第三个参数是；sql占位符参数值


RowMapper<T> rowMapper是传入Spring实现类
new BeanPropertyRowMapper<T>(Class<T> mappedClass)
传入需要封装数据的`JavaBeab`对象

情况一：查询所有员工信息
情况二：根据条件查询员工信息

dao层

    // 查询所有员工的信息
    List<User> getAllUser();

    // 查询员工年龄为21的员工信息
    List<User> getUserByAge(Integer age);

    // 查询所有员工信息
    @Override
    public List<User> getAllUser() {
        // 定义Sql语句
        String sql = "select * from t_user";
        List<User> query = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(User.class));
        return query;
    }

    @Override
    public List<User> getUserByAge(Integer age) {
        // 定义Sql语句
        String sql = "select * from t_user where age=?";
        List<User> query = jdbcTemplate.query(sql, new BeanPropertyRowMapper<>(User.class), age);
        return query;
    }

service层

    // 查询所有员工信息
    public List<User> getAllUser(){
        return userDao.getAllUser();
    }

    // 根据年龄查询员工信息
    public List<User> getUserByAge(Integer age){
        return userDao.getUserByAge(age);
    }

test类

    // 查询所有员工
    @Test
    public void testAllUser(){
        ApplicationContext context = new
                ClassPathXmlApplicationContext("bean.xml");
        UserService userService = context.getBean("userService", UserService.class);
        System.out.println(userService.getAllUser());
        /**
         * 返回值：
         * [User{id=1, username='明天 ', password='123', age=21, sex='女', email='123qq.com'},
         * User{id=2, username='南宁', password='123', age=23, sex='男', email='123qq.com'},
         * User{id=3, username='湛江', password='123', age=23, sex='女', email='123qq.com'},
         * User{id=6, username='海康', password='123', age=23, sex='男', email='123qq.com'},
         * User{id=7, username='大同', password='123', age=23, sex='男', email='123qq.com'},
         * User{id=18, username='苏州', password='123', age=21, sex='女', email='123qq.com'}]
         */
    }

    // 查询所有员工
    @Test
    public void testUserByAge(){
        ApplicationContext context = new
                ClassPathXmlApplicationContext("bean.xml");
        UserService userService = context.getBean("userService", UserService.class);
        System.out.println(userService.getUserByAge(21));
        /**
         * 返回值：
         * [User{id=1, username='明天 ', password='123', age=21, sex='女', email='123qq.com'}, 
         * User{id=18, username='苏州', password='123', age=21, sex='女', email='123qq.com'}]
         */
    }

5.批量处理【重点】

情况一：批量添加
情况二：批量修改
情况三：批量删除

JdbcTemplate实现批量添加操作方法，不管是批量添加，批量修改，批量删除都是使用这个方法

方法：
`batchUpdate(String sql,List<Object[]> batchArgs)`方法

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

Dao层

    int[] batchAdd(List<Object[]> batchArgs);

    int[] batchUpdate(List<Object[]> batchArgs);

    int[] batchDelete(List<Object[]> batchArgs);

    @Override
    public int[] batchAdd(List<Object[]> batchArgs) {
        // 定义sql
        String sql = "insert into t_user(id,username,password,age,sex,email) values(?,?,?,?,?,?)";
        int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
        System.out.println(Arrays.toString(ints));
        return ints;
    }

    @Override
    public int[] batchUpdate(List<Object[]> batchArgs) {
        // 定义Sql语句
        String sql = "update t_user set username=?,password=?,age=?,sex=?,email=? where id=?";
        int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
        System.out.println(Arrays.toString(ints));
        return ints;
    }

    @Override
    public int[] batchDelete(List<Object[]> batchArgs) {
        // 定义Sql语句
        String sql = "delete from t_user where id=?";
        int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
        System.out.println(Arrays.toString(ints));
        return ints;
    }

Service层

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

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

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

test类

    // 批量添加
    @Test
    public void testBatchAdd(){
        ApplicationContext context = new
                ClassPathXmlApplicationContext("bean.xml");
        UserService userService = context.getBean("userService", UserService.class);
        Object[] obj1 = {null,"新疆","123",21,"男","123@qq.com"};
        Object[] obj2 = {null,"内蒙","123",21,"女","123@qq.com"};
        Object[] obj3 = {null,"宁波","123",21,"女","123@qq.com"};
        List<Object[]> list = new ArrayList<>();
        list.add(obj1);
        list.add(obj2);
        list.add(obj3);
        userService.batchAdd(list);
    }

    // 批量修改
    @Test
    public void testBatchUpdate(){
        ApplicationContext context = new
                ClassPathXmlApplicationContext("bean.xml");
        UserService userService = context.getBean("userService", UserService.class);
        Object[] obj1 = {"新疆","123",21,"男","1dfd23@dfsfqq.com",20};
        Object[] obj2 = {"内蒙","123",21,"女","123@qsdfsdq.com",21};
        Object[] obj3 = {"宁波","123",21,"女","12dfdsasf3@qq.com",22};
        List<Object[]> list = new ArrayList<>();
        list.add(obj1);
        list.add(obj2);
        list.add(obj3);
        userService.batchUpdate(list);
    }

    // 批量修改
    @Test
    public void testBatchDelete(){
        ApplicationContext context = new
                ClassPathXmlApplicationContext("bean.xml");
        UserService userService = context.getBean("userService", UserService.class);
        Object[] obj1 = {20};
        Object[] obj2 = {21};
        Object[] obj3 = {22};
        List<Object[]> list = new ArrayList<>();
        list.add(obj1);
        list.add(obj2);
        list.add(obj3);
        userService.batchDelete(list);
    }

昱晟168

关注

4
点赞
踩
17

收藏

觉得还不错? 一键收藏
0
评论
`JDBCTemplate`基本查询详解

JDBCTemplateSpring框架对JDBC进行封装，使用JDBCTemplate方便实现对数据库操作JDBCTeamplate使用步骤：1.引入相关的jar包druid mysql-connector srping-jdbc sprint-tx spring-orm2.创建数据库连接池properties文件jdbc.driver=com.mysql.jdbc.Driverjdbc.url=jdbc:mysql://localhost:3306/mybatisjdbc.user
复制链接

扫一扫