JdbcTemplate

知识点1：准备

导入相关jar包；

解释：

1.第一个框是mysql连接池和连接

2.第二个框是spring里的jar引入

• orm是其他框架，spring结合用
• tx是处理事务的

xml配置

    <!-- 数据库连接池 -->
    <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
          destroy-method="close">
        <property name="url" value="jdbc:mysql:///user_db" />//user_db是你自己的数据库名
        <property name="username" value="root" />
        <property name="password" value="root" />
        <property name="driverClassName" value="com.mysql.cj.jdbc.Driver" />
    </bean>

配置JdbcTemplate对象，注入DataSource

创建service类，dao类，在dao注入jdbcTemplate对象

1. 开启扫描

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

2. service类

@Service
public class BookService {

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

3. dao类

@Repository
public interface BookDao {

}

@Repository
public class BookDaoImpl implements BookDao{

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

知识点2：添加

知识点3：修改

知识点4：查询

知识点5：批量添加

完整代码

server层

@Service
public class BookService {

    //注入dao
    @Autowired
    private BookDao bookDao;

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

    //修改的方法
    public void updateBook(Book book){
        bookDao.updateBook(book);
    }
    //删除的方法
    public void deleteBook(String id){
        bookDao.delete(id);
    }
    //4. 查询返回某个值的方法:表记录数
    public int selectCount(){
       return bookDao.selectCount();
    }
    //5. 查询返回对象
    public Book findOne(String id){
        return bookDao.findBookInfo(id);
    }
    //6. 查询返回集合
    public List<Book> findAllBook(){
        return bookDao.findAllBook();
    }
    //7. 批量操作添加
    public  void batchAdd(List<Object[]> batchArgs){
         bookDao.batchAddBook(batchArgs);
    }
}

Dao层

public interface BookDao {
    //添加的方法
    void add(Book book);

    void updateBook(Book book);

    void delete(String id);

    int selectCount();

    Book findBookInfo(String id);

    List<Book> findAllBook();

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

@Repository
public class BookDaoImpl implements BookDao{

    //注入JdbcTemplate
    @Autowired
    private JdbcTemplate jdbcTemplate;

    //1. 添加的方法
    @Override
    public void add(Book book) {

        String sql = "insert into t_book values(?,?,?)";
        Object[] args = {book.getUserId(), book.getUserName(), book.getUserStatus()};

        int update = jdbcTemplate.update(sql, args);
        System.out.println("添加成功,添加了"+update+"行");
    }
    //2. 修改的方法
    @Override
    public void updateBook(Book book) {

        String sql = "update t_book set name=?,status=? where id=?";
        Object[] args = {book.getUserName(),book.getUserStatus(),book.getUserId()};
        int update = jdbcTemplate.update(sql, args);
        System.out.println("修改成功,修改了"+update+"行");

    }
    //3. 删除的方法
    @Override
    public void delete(String id) {
        String sql ="delete from t_book where id=?";
        jdbcTemplate.update(sql,id);
    }
    //4. 查询返回某个值的方法
    @Override
    public int selectCount() {
        String sql ="select count(*) from t_book";
        Integer count = jdbcTemplate.queryForObject(sql, Integer.class);
        return count;
    }
    //5. 查询返回对象
    @Override
    public Book findBookInfo(String id) {
        String sql = "select id as userId,name as userName,status as userStatus from t_book where id=?";
        //第二参数：RowMapper接口，针对返回不同数据类型数据，用于数据封装，即封装sql语句。
        Book book = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<Book>(Book.class), id);
        return book;
    }
    //6. 查询返回集合
    @Override
    public List<Book> findAllBook() {
        String sql ="select id as userId,name as userName,status as userStatus from t_book";
        List<Book> bookList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Book>(Book.class));

        return bookList;
    }
    //7. 批量操作
    @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));
    }
}

测试

public class testJdbcDemo {

    @Test
    public void testJdbc(){
        ApplicationContext context =
                new ClassPathXmlApplicationContext("bean.xml");
        BookService bookService = context.getBean("bookService", BookService.class);
//        //添加
//        Book book = new Book();
//        book.setUserId("2");
//        book.setUserName("Spring6");
//        book.setUserStatus("a");
//        bookService.addBook(book);

//        //修改:根据id修改
//        Book book2 = new Book();
//        book2.setUserId("1");
//        book2.setUserName("JavaWeb");
//        book2.setUserStatus("a");
//        bookService.updateBook(book2);

//        //删除
//        bookService.deleteBook("2");
//          //查询返回某个值
//        int i = bookService.selectCount();
//        System.out.println("返回查询数量："+i);
//        //查询返回对象
//        Book one = bookService.findOne("1");
//        System.out.println(one);
//        //查询返回集合
//        List<Book> allBook = bookService.findAllBook();
//        System.out.println(allBook);

        //批量添加
        ArrayList<Object[]> batchArgs = new ArrayList<>();
        Object[] o1 = {"2","Java","a"};
        Object[] o2 = {"3","C++","a"};
        Object[] o3 = {"4","Mysql","a"};
        batchArgs.add(o1);
        batchArgs.add(o2);
        batchArgs.add(o3);

        bookService.batchAdd(batchArgs);
    }
}

总结:

1. 使用JdbcTemplate准备工作：

• jar包，德鲁伊连接池，xml的jdbcTemplate的dataSource注入

2. crud环节：

• 添加：使用setX方法添加；
• 修改：根据id修改；
• 删除：根据id删除；
• 查询：查询某个值；查询获取某个对象；查询获取多个对象；
• 批量增加：batchUpdate（sql，batchArgs）：batchArgs为Object类型的集合；

3. 在server层编写方法，对外部暴露调用；在server层的方法实际调用的是：dao层接口的实现类的方法，具体的业务逻辑在实现类中具体编写。

debug

准备环节

bug1：

问题：使用注解autowired 注入jdbctemplate ， 代码爆红，无法注入的解决。

解决思路：可能是xml配置文件的注入dataSource出错，在<property name="dataSource" ref="dataSource"></property>上的光标XML tag has empty body,说明这里出错。

解决：改为<property name="dataSource" ref="dataSource" />

总结：idea太过智能便捷，导致导入标签错误。这里应该使用单标签，进行获取jdbctemplate 对象。