标签：10 update book jdbcTemplate sql Spring5 public batchArgs jdbctemplate

1、JDBCTemplate(概念和相关准备工作)

1、什么是jdbctemplate

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

 

2、准备工作

 （1）引入相关jar包（依赖）

　　mysql-connector-java-jar

　　spring-jdbc-jar　　Spring对jdbc做封装

　　spring-tx-jar　　Spring针对事务的相关依赖

　　spring-orm.jar　　使用Spring整合其他框架，如mybaits等数据库需要引入的依赖

 

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

　　配置文件 jdbc.properties 如下：

prop.driverClass=com.mysql.cj.jdbc.Driver
prop.url=jdbc:mysql://localhost:3306/test
prop.userName=root
prop.password=124869
#在属性名当前最好加prop用于区分不会冲突

　　在spring配置文件中的配置如下：

    <!--引入外部属性文件-->
    <context:property-placeholder location="classpath:jdbc.properties"/>
    <!--配置数据库连接池-->
    <!-- DruidDataSource dataSource = new DruidDataSource(); -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource">
        <!-- dataSource.setDriverClassName("com.mysql.jdbc.Driver");
            set方法注入
        -->
        <!-- 获取properties文件内容，根据key获取，使用spring表达式获取 -->
        <property name="driverClassName" value="${prop.driverClass}"></property>
        <property name="url" value="${prop.url}"></property>
        <property name="username" value="${prop.userName}"></property>
        <property name="password" value="${prop.password}"></property>
    </bean>

（3）配置JdbcTemplate对象，并注入DataSource

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

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

　　在配置文件中，开启组件扫描

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

　　在Service中

@Service
public class BookService {

    //注入Dao
    @Autowired
    private BookDao bookDao;
}

　　在Dao中

@Autowired
public class BookDaoImpl implements BookDao{

    //注入jdbcTemplate
    @Autowired
    private JdbcTemplate jdbcTemplate;
}

 

2、使用jdbcTemplate操作数据库

（1）jdbcTemplate对数据库的添加操作

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

public class Book {
    private int bookId;
    private String bookName;
    private String author;

下面还有get、set方法

2、编写service和dao

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

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

update(String sql,Object... args)

两个参数：

　　第一个参数：sql语句

　　第二个参数：可变参数，设置sql语句的占位符的值

 BookService 如下：

@Service
public class BookService {

    //注入Dao
    @Autowired
    private BookDao bookDao;

    //添加方法
    public void addBook(Book book){
        bookDao.add(book);
    }
}

BookDao修改操作 如下：

@Repository
public class BookDaoImpl implements BookDao{

    //注入jdbcTemplate
    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Override
    public void add(Book book) {
        String sql = "insert into t_book values(?,?,?)";
        Object[] args={ book.getBookId(), book.getBookName(), book.getAuthor()};
        //调用jdbcTemplate.update(sql,args)方法
        int update = jdbcTemplate.update(sql,args);
        System.out.println(update);
    }
}

测试类

    @Test
    public void testAdd(){
        ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");
        BookService service = context.getBean("bookService", BookService.class);
        Book book = new Book();
        book.setBookId(1);
        book.setBookName("活着");
        book.setAuthor("余华");

        service.addBook(book);
    }

 

（2）jdbcTemplate对数据库的修改和删除操作

在BookDao中添加修改和删除功能（步骤与添加基本一致）

    //修改的方法
    @Override
    public void updateBook(Book book) {
        String sql = "update t_book set book_name=?,author=? where book_id=?";
        Object[] args={  book.getBookName(), book.getAuthor(),book.getBookId()};
        int update = jdbcTemplate.update(sql, args);
        System.out.println(update);
    }

    //删除的方法
    @Override
    public void deleteBook(int id) {
        String sql = "delete from t_book where book_id=?";
        int update = jdbcTemplate.update(sql, id);
        System.out.println(update);
    }

在BookService中调用BookDao的修改和删除方法

    //修改的方法
    public  void updateBook(Book book){
        bookDao.updateBook(book);
    }
    //删除的方法
    public void deleteBook(int id){
        bookDao.deleteBook(id);
    }

增删改三个操作基本步骤是一样的，只是sql语句不一样。

 

（3）jdbcTemplate对数据库的查询操作（查询返回某个值）

　　1、如：查询表中有多少条记录，返回的是某个值

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

　　　　使用 jdbcTemplate 中的 queryForObject(String sql,Class<T> requiredType) 方法

　　　　两个参数：一个是sql语句，一个是返回类型的class

service中的查询方法如下：

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

dao中的查询方法如下：

    //查询返回某个值
    @Override
    public int selectCount() {
        String sql="select count(*) from t_book";
        Integer count = jdbcTemplate.queryForObject(sql, Integer.class);//Integer.class是返回什么类型的值就传入什么类型
        return count;
    }

（4）jdbcTemplate对数据库的查询操作（查询返回对象）

 　　1、如：查询图书的详情页面，返回的是一个对象

　　2、使用 JdbcTemplate 实现查询返回对象

　　　　使用 

 

　　　　有三个参数：

　　　　　　第一个参数是sql语句，

　　　　　　第二个参数是RowMapper，是接口，返回不同类型数据，使用这个接口里面的实现类完成数据的封装

　　　　　　第三个参数是传递sql语句的占位符的值

 dao中的方法如下：

    //查询返回对象
    @Override
    public Book FindBookInfo(int id) {
        String sql = "select * from t_book where book_id=?";
        Book book = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<Book>(Book.class), id);
        //new BeanPropertyRowMapper<Book>(Book.class)是rowMapper的一个实现类，完成数据的封装
        return book;
    }

（5）jdbcTemplate对数据库的查询操作（查询返回集合）

　　1、如：查询图书列表（多条数据）

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

　　　　使用

　　　　　有三个参数：

　　　　　　第一个参数是sql语句，

　　　　　　第二个参数是RowMapper，是接口，返回不同类型数据，使用这个接口里面的实现类完成数据的封装

　　　　　　第三个参数是传递sql语句的占位符的值

 dao中的代码如下：

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

（6）JdbcTemplate 对数据库的批量添加功能

1、批量操作：指的是操作表中的多条记录

2、JdbcTemplate实现批量添加操作

　　使用的是

 

 　　　　有两个参数：

　　　　　　第一个参数：sql语句

　　　　　　第二个参数：list集合，添加多条记录数据

dao中的代码如下：

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

测试如下：

    @Test
    public void testBatchAdd(){
        ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");
        BookService service = context.getBean("bookService", BookService.class);
        List<Object[]> batchArgs = new ArrayList<>();
        Object[] o1 = {4,"java","a"};
        Object[] o2 = {5,"c++","b"};
        Object[] o3 = {6,"python","c"};
        batchArgs.add(o1);
        batchArgs.add(o2);
        batchArgs.add(o3);
        //调用批量添加方法
        service.batchAdd(batchArgs);
    }

 

（7）JdbcTemplate 对数据库的批量修改删除功能

1、批量修改

dao中的代码实现如下：

    //批量添加
    @Override
    public void batchUpdateBook(List<Object[]> batchArgs) {
        String sql = "update t_book set book_name=?,author=? where book_id=?";
        int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
        System.out.println(Arrays.toString(ints));
    }

 

测试如下：

    @Test
    public void testBatchUpdate(){
        ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");
        BookService service = context.getBean("bookService", BookService.class);
        List<Object[]> batchArgs = new ArrayList<>();
        Object[] o1 = {"java_update","a",3};
        Object[] o2 = {"c++_update","b",4};
        Object[] o3 = {"python_update","c",5};
        batchArgs.add(o1);
        batchArgs.add(o2);
        batchArgs.add(o3);
        //调用批量修改
        service.batchUpdate(batchArgs);
    }

2、批量删除

dao实现如下：

    //批量删除方法
    @Override
    public void batchDelete(List<Object[]> batchArgs) {
        String sql = "delete from t_book where book_id=?";
        jdbcTemplate.batchUpdate(sql,batchArgs);
    }

 

测试如下：

    @Test
    public void testBatchDlete(){
        ApplicationContext context=new ClassPathXmlApplicationContext("bean1.xml");
        BookService service = context.getBean("bookService", BookService.class);
        List<Object[]> batchArgs = new ArrayList<>();
        Object[] o1 = {3};
        Object[] o2 = {4};
        batchArgs.add(o1);
        batchArgs.add(o2);
        //调用批量修改
        service.batchDelete(batchArgs);
    }

 

 

可见批量操作的sql语句和单独操作的sql语句是一样的，只不过对循环部分进行了封装。

 

标签：10,update,book,jdbcTemplate,sql,Spring5,public,batchArgs,jdbctemplate
来源： https://www.cnblogs.com/zhuowen/p/16341478.html

本站声明： 1. iCode9 技术分享网（下文简称本站）提供的所有内容，仅供技术学习、探讨和分享；
2. 关于本站的所有留言、评论、转载及引用，纯属内容发起人的个人观点，与本站观点和立场无关；
3. 关于本站的所有言论和文字，纯属内容发起人的个人观点，与本站观点和立场无关；
4. 本站文章均是网友提供，不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属；如您发现该文章侵犯了您的权益，可联系我们第一时间进行删除；
5. 本站为非盈利性的个人网站，所有内容不会用来进行牟利，也不会利用任何形式的广告来间接获益，纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。