当前位置:   article > 正文

学习SpringAOP之如何用jdbcTemplate操作数据库_java 使用aop对数据库操作

java 使用aop对数据库操作

首先进行xml文件的配置,包括开启组件扫描,配置数据库连接池和创建jdbcTemplate对象;

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3. xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4. xmlns:context="http://www.springframework.org/schema/context"
  5. xmlns:aop="http://www.springframework.org/schema/aop"
  6. xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd
  7. http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context.xsd
  8. http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop.xsd">
  9. <!--组件扫描-->
  10. <context:component-scan base-package="com.atguigu"></context:component-scan>
  11. <!-- 数据库连接池 -->
  12. <bean id="dataSource" class="com.alibaba.druid.pool.DruidDataSource"
  13. destroy-method="close">
  14. <property name="url" value="jdbc:mysql:///user_db" />
  15. <property name="username" value="root" />
  16. <property name="password" value="root" />
  17. <property name="driverClassName" value="com.mysql.jdbc.Driver" />
  18. </bean>
  19. <!-- 创建JdbcTemplate对象 -->
  20. <bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
  21. <!--注入dataSource-->
  22. <property name="dataSource" ref="dataSource"></property>
  23. </bean>
  24. </beans>

        其中@Autowired属于Spring内置的注解,默认的注入方式为byType(根据类型进行匹配),也就是说会优先根据接口类型去匹配并注入Bean(接口的实现类);但是,当一个接口存在多个类的话,byType这种方式就无法正常注入对象了,因为这个时候Spring会同时找到满足条件的选择,默认情况下它不知道自己选择哪一个。这种情况下,注入方式就会变为byName(根据名称进行匹配),这个名称通常就是类名(首字母小写)。

接下来是类BookService、接口BookDao和实现类BookDaoImpl:

BookService:

  1. package com.atguigu.service;
  2. import com.atguigu.dao.BookDao;
  3. import com.atguigu.entity.Book;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.stereotype.Service;
  6. import java.util.List;
  7. @Service
  8. public class BookService {
  9. //注入dao
  10. @Autowired
  11. private BookDao bookDao;
  12. //添加的方法
  13. public void addBook(Book book){
  14. bookDao.add(book);
  15. }
  16. //修改的方法
  17. public void updateBook(Book book){
  18. bookDao.updateBook(book);
  19. }
  20. //删除方法
  21. public void delete(Book book){
  22. bookDao.delete(book);
  23. }
  24. //查询表的记录数
  25. public int findCount(){
  26. return bookDao.selectCount();
  27. }
  28. //查询返回对象
  29. public Book fondOne(String id){
  30. return bookDao.findBookInfo(id);
  31. }
  32. //查询返回集合
  33. public List<Book> findAll(){
  34. return bookDao.findAllBook();
  35. }
  36. //批量添加
  37. public void batchAdd(List<Object[]> batchArgs){
  38. bookDao.batchAddBook(batchArgs);
  39. }
  40. //批量修改
  41. public void batchUpdateBook(List<Object[]> batchArgs){
  42. bookDao.batchUpdateBook(batchArgs);
  43. }
  44. //批量删除
  45. public void batchDelete(List<Object[]> batchArgs){
  46. bookDao.batchDelete(batchArgs);
  47. }
  48. }

BookDao:

  1. package com.atguigu.dao;
  2. import com.atguigu.entity.Book;
  3. import java.util.List;
  4. public interface BookDao {
  5. //添加方法
  6. void add(Book book);
  7. //修改方法
  8. void updateBook(Book book);
  9. //删除方法
  10. void delete(Book book);
  11. //查询表的记录数
  12. int selectCount();
  13. //查询返回对象
  14. Book findBookInfo(String id);
  15. //查询返回集合
  16. List<Book> findAllBook();
  17. //批量添加
  18. void batchAddBook(List<Object[]> batchArgs);
  19. //批量修改
  20. void batchUpdateBook(List<Object[]> batchArgs);
  21. //批量删除
  22. void batchDelete(List<Object[]> batchArgs);
  23. }

BookDaoImpl:

  1. package com.atguigu.dao;
  2. import com.atguigu.entity.Book;
  3. import org.springframework.beans.factory.annotation.Autowired;
  4. import org.springframework.jdbc.core.BeanPropertyRowMapper;
  5. import org.springframework.jdbc.core.JdbcTemplate;
  6. import org.springframework.stereotype.Repository;
  7. import java.util.Arrays;
  8. import java.util.List;
  9. @Repository
  10. public class BookDaoImpl implements BookDao{
  11. //注入JdbcTemplate
  12. @Autowired
  13. private JdbcTemplate jdbcTemplate;
  14. @Override
  15. public void add(Book book) {
  16. //1.创建sql语句
  17. String sql = "insert into t_book values(?,?,?)";
  18. //2.调用方法实现
  19. Object[] args = {book.getUserId(), book.getUsername(), book.getUstatus()};
  20. int update = jdbcTemplate.update(sql, args);
  21. System.out.println(update);
  22. }
  23. @Override
  24. public void updateBook(Book book) {
  25. String sql = "update t_book set username=?,ustatus=? where user_id=?";
  26. Object[] args = {book.getUsername(),book.getUstatus(),book.getUserId()};
  27. int update = jdbcTemplate.update(sql, args);
  28. System.out.println(update);
  29. }
  30. @Override
  31. public void delete(Book book) {
  32. String sql = "delete from t_book where user_id=?";
  33. int update = jdbcTemplate.update(sql, book.getUserId());
  34. System.out.println(update);
  35. }
  36. @Override
  37. public int selectCount() {
  38. String sql = "select COUNT(*) FROM t_book";
  39. return jdbcTemplate.queryForObject(sql,Integer.class);
  40. }
  41. @Override
  42. public Book findBookInfo(String id) {
  43. String sql = "select * from t_book where user_id=?";
  44. Book book = jdbcTemplate.queryForObject(sql, new BeanPropertyRowMapper<Book>(Book.class), id);
  45. return book;
  46. }
  47. @Override
  48. public List<Book> findAllBook() {
  49. String sql = "select * from t_book";
  50. List<Book> bookList = jdbcTemplate.query(sql, new BeanPropertyRowMapper<Book>(Book.class));
  51. return bookList;
  52. }
  53. @Override
  54. public void batchAddBook(List<Object[]> batchArgs) {
  55. String sql = "insert into t_book values(?,?,?)";
  56. int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
  57. System.out.println(Arrays.toString(ints));
  58. }
  59. @Override
  60. public void batchUpdateBook(List<Object[]> batchArgs) {
  61. String sql = "update t_book set username=?,ustatus=? where user_id=?";
  62. int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
  63. System.out.println(Arrays.toString(ints));
  64. }
  65. @Override
  66. public void batchDelete(List<Object[]> batchArgs) {
  67. String sql = "delete from t_book where user_id = ?";
  68. int[] ints = jdbcTemplate.batchUpdate(sql, batchArgs);
  69. System.out.println(Arrays.toString(ints));
  70. }
  71. }

最后进行测试:

  1. package com.atguigu.test;
  2. import com.atguigu.entity.Book;
  3. import com.atguigu.service.BookService;
  4. import org.junit.Test;
  5. import org.springframework.context.ApplicationContext;
  6. import org.springframework.context.support.ClassPathXmlApplicationContext;
  7. import java.util.ArrayList;
  8. import java.util.List;
  9. public class TestBook {
  10. @Test
  11. public void testJdbcTemplate(){
  12. ApplicationContext context = new ClassPathXmlApplicationContext("bean1.xml");
  13. BookService bookService = context.getBean("bookService", BookService.class);
  14. //添加
  15. // Book book = new Book();
  16. // book.setUserId("1");
  17. // book.setUsername("java");
  18. // book.setUstatus("a");
  19. // bookService.addBook(book);
  20. //
  21. // Book book2 = new Book();
  22. // book2.setUserId("2");
  23. // book2.setUsername("pathon");
  24. // book2.setUstatus("b");
  25. // bookService.addBook(book2);
  26. //修改
  27. // Book book = new Book();
  28. // book.setUserId("1");
  29. // book.setUsername("javaupup");
  30. // book.setUstatus("atguigu");
  31. // bookService.updateBook(book);
  32. //删除
  33. // Book book = new Book();
  34. // book.setUserId("1");
  35. // bookService.delete(book);
  36. // System.out.println(bookService.findCount());
  37. //查询返回对象
  38. // Book book = bookService.fondOne("1");
  39. // System.out.println(book.toString());
  40. //查询返回集合
  41. List<Book> bookList = bookService.findAll();
  42. for (Book item : bookList){
  43. System.out.println(item);
  44. }
  45. //批量添加
  46. // List<Object[]> batchArgs = new ArrayList<>();
  47. // Object[] o1 = {"3","spring","study"};
  48. // Object[] o2 = {"4","springMVC","willStudy"};
  49. // Object[] o3 = {"5","myBatis","willStudy"};
  50. // batchArgs.add(o1);
  51. // batchArgs.add(o2);
  52. // batchArgs.add(o3);
  53. // bookService.batchAdd(batchArgs);
  54. //批量修改
  55. // List<Object[]> batchArgs = new ArrayList<>();
  56. // Object[] o1 = {"spring++","study++","3"};
  57. // Object[] o2 = {"springMVC++","willStudy","4"};
  58. // Object[] o3 = {"myBatis++","willStudy++","5"};
  59. // batchArgs.add(o1);
  60. // batchArgs.add(o2);
  61. // batchArgs.add(o3);
  62. // bookService.batchUpdateBook(batchArgs);
  63. //批量删除
  64. // List<Object[]> batchArgs = new ArrayList<>();
  65. // Object[] o1 = {"1"};
  66. // Object[] o2 = {"3"};
  67. // Object[] o3 = {"5"};
  68. // batchArgs.add(o1);
  69. // batchArgs.add(o2);
  70. // batchArgs.add(o3);
  71. // bookService.batchDelete(batchArgs);
  72. }
  73. }

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/2023面试高手/article/detail/706336
推荐阅读
相关标签