博客

`JDBCTemplate`基本查询详解

  • Post author:
  • Post category:其他


文章目录




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


版权声明：本文为weixin_47267628原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。