`

（转）见证spring jdbc

Springjdbc 
阅读更多

一直对Spring都处于一个略懂的阶段，最近在公司看到一个框架，是用spring搞的，写得蛮强大的！其中增删改主要用namedParameterJdbcTemplate 和BeanPropertySqlParameterSource两个类！

 

Java代码 复制代码 收藏代码
  1. 见证Spring Jdbc的强大  
  2. Spring 不仅仅是一个IoC container。  
  3.   
  4. 其提供的Spring Jdbc提供了一层对jdbc很薄的封装，功能却是异常强大。  
  5.   
  6.    
  7.   
  8. 不说多了，直接贴代码  
  9.   
  10.    
  11.   
  12. 1、Template模式的使用，使我们只关心，sql, 输入参数，输出映射。  
  13.   
  14. 2、new BeanPropertySqlParameterSource(t) 直接把bean转成输入参数。  
  15.   
  16. 3、ParameterizedBeanPropertyRowMapper.newInstance(UserInfo.class)直接将bean转成输出映射。  
  17.   
  18. 4、一个dao根据输入参数不同，动态生成多条sql语句。很有一点ibatis的味道。  
  19.   
  20. 5、学习曲线低，会sql和jdbc的可以直接写。适合“你请到了只会写jsp和sql的极品，又想让他明天开始干活..... ”  
  21.   
  22. @Component  
  23. public class UserInfoDaoJdbcImpl extends SimpleJdbcDaoSupport implements UserInfoDao {  
  24.     public int deleteEntity(UserInfo t) throws DataAccessException {  
  25.         if (null != t.getId()) {  
  26.             return super.getSimpleJdbcTemplate().update("delete from user_info where id=:id", t.getId());  
  27.         } else if (null != t.getMap().get("ids")) {  
  28.             return super.getSimpleJdbcTemplate().update(  
  29.                     "delete from user_info where id in (" + t.getMap().get("ids") + ")", t.getId());  
  30.         } else {  
  31.             return -1;  
  32.         }  
  33.     }  
  34.     public Integer insertEntity(UserInfo t) throws DataAccessException {  
  35.         String sql = "insert into user_info (user_name, password, birthday, age) values (:user_name, :password, :birthday, :age)";  
  36.         return super.getSimpleJdbcTemplate().update(sql, new BeanPropertySqlParameterSource(t));  
  37.     }  
  38.     public UserInfo selectEntity(UserInfo t) throws DataAccessException {  
  39.         List<String> sqls = new ArrayList<String>();  
  40.         sqls.add("select * from user_info where 1=1");  
  41.         if (null != t.getId()) {  
  42.             sqls.add("and id=:id");  
  43.         }  
  44.         if (null != t.getUser_name()) {  
  45.             sqls.add("and login_name=:login_name");  
  46.         }  
  47.         if (null != t.getPassword()) {  
  48.             sqls.add("and password=:password");  
  49.         }  
  50.         String sql = StringUtils.join(sqls, " ");  
  51.         List<UserInfo> userInfoList = super.getSimpleJdbcTemplate().query(sql,  
  52.                 ParameterizedBeanPropertyRowMapper.newInstance(UserInfo.class), new BeanPropertySqlParameterSource(t));  
  53.         int listSize = userInfoList.size();  
  54.         if (1 == listSize) {  
  55.             return userInfoList.get(0);  
  56.         } else {  
  57.             return null;  
  58.         }  
  59.     }  
  60.     public Long selectEntityCount(UserInfo t) throws DataAccessException {  
  61.         List<String> sqls = new ArrayList<String>();  
  62.         sqls.add("select count(*) from user_info where 1=1");  
  63.         if (null != t.getId()) {  
  64.             sqls.add("and id=:id");  
  65.         }  
  66.         if (null != t.getUser_name()) {  
  67.             sqls.add("and login_name=:login_name");  
  68.         }  
  69.         if (null != t.getPassword()) {  
  70.             sqls.add("and password=:password");  
  71.         }  
  72.         String sql = StringUtils.join(sqls, " ");  
  73.         return super.getSimpleJdbcTemplate().queryForLong(sql, new BeanPropertySqlParameterSource(t));  
  74.     }  
  75.     public List<UserInfo> selectEntityList(UserInfo t) throws DataAccessException {  
  76.         List<String> sqls = new ArrayList<String>();  
  77.         sqls.add("select * from user_info where 1=1");  
  78.         if (null != t.getId()) {  
  79.             sqls.add("and id=:id");  
  80.         }  
  81.         if (null != t.getUser_name()) {  
  82.             sqls.add("and login_name=:login_name");  
  83.         }  
  84.         if (null != t.getPassword()) {  
  85.             sqls.add("and password=:password");  
  86.         }  
  87.         String sql = StringUtils.join(sqls, " ");  
  88.         return super.getSimpleJdbcTemplate().query(sql, ParameterizedBeanPropertyRowMapper.newInstance(UserInfo.class),  
  89.                 new BeanPropertySqlParameterSource(t));  
  90.     }  
  91.     public List<UserInfo> selectEntityPaginatedList(UserInfo t) throws DataAccessException {  
  92.         // TODO Auto-generated method stub  
  93.         return null;  
  94.     }  
  95.     public int updateEntity(UserInfo t) throws DataAccessException {  
  96.         List<String> sqls = new ArrayList<String>();  
  97.         if (null != t.getAge()) {  
  98.             sqls.add(" age=:age");  
  99.         }  
  100.         if (null != t.getBirthday()) {  
  101.             sqls.add(" birthday=:birthday");  
  102.         }  
  103.         String sql = StringUtils.join(new String[] { "update user_info set ", StringUtils.join(sqls.toArray(), ","),  
  104.                 " where id=:id" });  
  105.         return super.getSimpleJdbcTemplate().update(sql, new BeanPropertySqlParameterSource(t));  
  106.     }  
  107. }  
见证Spring Jdbc的强大
Spring 不仅仅是一个IoC container。

其提供的Spring Jdbc提供了一层对jdbc很薄的封装，功能却是异常强大。

 

不说多了，直接贴代码

 

1、Template模式的使用，使我们只关心，sql, 输入参数，输出映射。

2、new BeanPropertySqlParameterSource(t) 直接把bean转成输入参数。

3、ParameterizedBeanPropertyRowMapper.newInstance(UserInfo.class)直接将bean转成输出映射。

4、一个dao根据输入参数不同，动态生成多条sql语句。很有一点ibatis的味道。

5、学习曲线低，会sql和jdbc的可以直接写。适合“你请到了只会写jsp和sql的极品，又想让他明天开始干活..... ”

@Component
public class UserInfoDaoJdbcImpl extends SimpleJdbcDaoSupport implements UserInfoDao {
    public int deleteEntity(UserInfo t) throws DataAccessException {
        if (null != t.getId()) {
            return super.getSimpleJdbcTemplate().update("delete from user_info where id=:id", t.getId());
        } else if (null != t.getMap().get("ids")) {
            return super.getSimpleJdbcTemplate().update(
                    "delete from user_info where id in (" + t.getMap().get("ids") + ")", t.getId());
        } else {
            return -1;
        }
    }
    public Integer insertEntity(UserInfo t) throws DataAccessException {
        String sql = "insert into user_info (user_name, password, birthday, age) values (:user_name, :password, :birthday, :age)";
        return super.getSimpleJdbcTemplate().update(sql, new BeanPropertySqlParameterSource(t));
    }
    public UserInfo selectEntity(UserInfo t) throws DataAccessException {
        List<String> sqls = new ArrayList<String>();
        sqls.add("select * from user_info where 1=1");
        if (null != t.getId()) {
            sqls.add("and id=:id");
        }
        if (null != t.getUser_name()) {
            sqls.add("and login_name=:login_name");
        }
        if (null != t.getPassword()) {
            sqls.add("and password=:password");
        }
        String sql = StringUtils.join(sqls, " ");
        List<UserInfo> userInfoList = super.getSimpleJdbcTemplate().query(sql,
                ParameterizedBeanPropertyRowMapper.newInstance(UserInfo.class), new BeanPropertySqlParameterSource(t));
        int listSize = userInfoList.size();
        if (1 == listSize) {
            return userInfoList.get(0);
        } else {
            return null;
        }
    }
    public Long selectEntityCount(UserInfo t) throws DataAccessException {
        List<String> sqls = new ArrayList<String>();
        sqls.add("select count(*) from user_info where 1=1");
        if (null != t.getId()) {
            sqls.add("and id=:id");
        }
        if (null != t.getUser_name()) {
            sqls.add("and login_name=:login_name");
        }
        if (null != t.getPassword()) {
            sqls.add("and password=:password");
        }
        String sql = StringUtils.join(sqls, " ");
        return super.getSimpleJdbcTemplate().queryForLong(sql, new BeanPropertySqlParameterSource(t));
    }
    public List<UserInfo> selectEntityList(UserInfo t) throws DataAccessException {
        List<String> sqls = new ArrayList<String>();
        sqls.add("select * from user_info where 1=1");
        if (null != t.getId()) {
            sqls.add("and id=:id");
        }
        if (null != t.getUser_name()) {
            sqls.add("and login_name=:login_name");
        }
        if (null != t.getPassword()) {
            sqls.add("and password=:password");
        }
        String sql = StringUtils.join(sqls, " ");
        return super.getSimpleJdbcTemplate().query(sql, ParameterizedBeanPropertyRowMapper.newInstance(UserInfo.class),
                new BeanPropertySqlParameterSource(t));
    }
    public List<UserInfo> selectEntityPaginatedList(UserInfo t) throws DataAccessException {
        // TODO Auto-generated method stub
        return null;
    }
    public int updateEntity(UserInfo t) throws DataAccessException {
        List<String> sqls = new ArrayList<String>();
        if (null != t.getAge()) {
            sqls.add(" age=:age");
        }
        if (null != t.getBirthday()) {
            sqls.add(" birthday=:birthday");
        }
        String sql = StringUtils.join(new String[] { "update user_info set ", StringUtils.join(sqls.toArray(), ","),
                " where id=:id" });
        return super.getSimpleJdbcTemplate().update(sql, new BeanPropertySqlParameterSource(t));
    }
}
Java代码 复制代码 收藏代码
  1.   






Java代码 复制代码 收藏代码





    

  1. <pre class="java" name="code">使用Spring的NamedParameterJdbcTemplate完成DAO操作    
    2. 

  2.   
    3. 

  3. 2009-06-30 12:42:24|  分类： 技术点滴 |字号 订阅  
    4. 

  4. NamedParameterJdbcTemplate内部包含了一个JdbcTemplate，所以JdbcTemplate能做的事情NamedParameterJdbcTemplate都能干，NamedParameterJdbcTemplate相对于JdbcTemplate主要增加了参数可以命名的功能。  
    5. 

  5. public Object queryForObject(String sql, Map paramMap, RowMapper rowMapper)  
    6. 

  6. public Object queryForObject(String sql, SqlParameterSource paramSource, RowMapper rowMapper)  
    7. 

  7.        SqlParameterSource的两个主要实现MapSqlParameterSource  
    8. 

  8.        和BeanPropertySqlParameterSource  
    9. 

  9. public int update(String sql, SqlParameterSource paramSource, KeyHolder generatedKeyHolder)保存数据获得主键。   
    10. 

  10. 实例说明：  
    11. 

  11. /** 
    12. 

  12.  * 一、NamedParameterJdbcTemplate提供了命名参数，用:x代替了? 
    13. 

  13.  * NamedParameterJdbcTemplate传参数可以用map或者SqlParameterSource 
    14. 

  14.  * 用map的好处是:x,x的值可以自由取，但是所有参数的值都必须要放到map中去，其中的key为:后面的名称，value是你传的值 
    15. 

  15.  * 用SqlParameterSource的好处是不用一个个的赋值,但是:x中的x的值必须和对象的属性名称一样 
    16. 

  16.   
    17. 

  17.  * 二、使用KeyHolder keyholder=new GeneratedKeyHolder(); 
    18. 

  18.    namedjdbctemp.update(sql, ps,keyholder);这个参数可以获得主键生成值 
    19. 

  19.  */  
    20. 

  20. public class StuDaoImple implements StuDaointer{   
    21. 

  21.     private NamedParameterJdbcTemplate namedjdbctemp;  
    22. 

  22.    
    23. 

  23.     public StuDaoImple(){  
    24. 

  24.        namedjdbctemp=new NamedParameterJdbcTemplate(SQLConnUtil.getDataSource());  
    25. 

  25.     }// SQLConnUtil为JDBC工具类，提供了得到数据源的静态方法  
    26. 

  26.     /* 
    27. 

  27.      * 这里会用到NamedParameterJdbcTemplate两个好处： 
    28. 

  28.      * 1，不用一个个的为参数赋值。 
    29. 

  29.      * 2，可以轻易的得到主键自动增长值 
    30. 

  30.      */  
    31. 

  31.     public void addStu(Stu stu) {  
    32. 

  32.        String sql="insert into stu values(:sname,:ssex,:sbrith)";  
    33. 

  33.        //:后面的名称必须和stu属性名称一样  
    34. 

  34.        SqlParameterSource ps=new BeanPropertySqlParameterSource(stu);  
    35. 

  35.        KeyHolder keyholder=new GeneratedKeyHolder();  
    36. 

  36.        namedjdbctemp.update(sql, ps,keyholder);  
    37. 

  37.        //加上KeyHolder这个参数可以得到添加后主键的值  
    38. 

  38.        int m=keyholder.getKey().intValue();  
    39. 

  39.        System.out.println(m);  
    40. 

  40.        //Map map=keyholder.getKeys();//这样可以得到联合主键的值  
    41. 

  41.        //keyholder.getKeyList();//这样可以得到一些主主键值，若一次添加好几条记录  
    42. 

  42.     }  
    43. 

  43.     public int count() {  
    44. 

  44.        String sql="select count(*) from stu";  
    45. 

  45.        //可以通过NamedParameterJdbcTemplate得到JdbcTemplate  
    46. 

  46.        int m=namedjdbctemp.getJdbcOperations().queryForInt(sql);  
    47. 

  47.        return m;  
    48. 

  48.     }  
    49. 

  49.    
    50. 

  50.     /* 
    51. 

  51.      * 这里会用到NamedParameterJdbcTemplate另一个好处： 
    52. 

  52.      * 位置参数 
    53. 

  53.      */  
    54. 

  54.     public void delStu(int sid) {  
    55. 

  55.        String sql="delete stu where s_id=:id";  
    56. 

  56.        Map map=new HashMap();  
    57. 

  57.        map.put("id", sid);  
    58. 

  58.        namedjdbctemp.update(sql, map);  
    59. 

  59.     }  
    60. 

  60.     public List getAllStu() {  
    61. 

  61.        String sql="select s_id as sid,s_name as sname,s_sex as ssex,s_brith as sbrith from stu";  
    62. 

  62.        List list=namedjdbctemp.getJdbcOperations().query(sql,new BeanPropertyRowMapper(Stu.class));  
    63. 

  63.        return list;  
    64. 

  64.     }  
    65. 

  65.     public List getAllStu(Stu stu) {  
    66. 

  66.        String sql="select s_id as sid,s_name as sname,s_sex as ssex,s_brith as sbrith from stu where s_id=:sid";  
    67. 

  67.        SqlParameterSource ps=new BeanPropertySqlParameterSource(stu);  
    68. 

  68.        return namedjdbctemp.query(sql, ps, new BeanPropertyRowMapper(Stu.class));  
    69. 

  69.     }  
    70. 

  70.     public Stu getOneStu(Stu stu) {  
    71. 

  71.        String sql="select s_id as sid,s_name as sname,s_sex as ssex,s_brith as sbrith from stu where s_id=:sid";  
    72. 

  72.        SqlParameterSource ps=new BeanPropertySqlParameterSource(stu);  
    73. 

  73.        return (Stu)namedjdbctemp.queryForObject(sql, ps, new BeanPropertyRowMapper(Stu.class));  
    74. 

  74.     }  
    75. 

  75.     public String getStuName(Stu stu) {  
    76. 

  76.        String sql="select s_name as sname from stu where s_name=:sname";  
    77. 

  77.        SqlParameterSource ps=new BeanPropertySqlParameterSource(stu);  
    78. 

  78.        return (String)namedjdbctemp.queryForObject(sql, ps, String.class);  
    79. 

  79.     }  
    80. 

  80.     public void updStu(Stu stu) {  
    81. 

  81.        String sql="update stu set s_name=:sname,s_sex=:ssex,s_brith=:sbrith where s_id=:sid";  
    82. 

  82.        SqlParameterSource ps=new BeanPropertySqlParameterSource(stu);  
    83. 

  83.        namedjdbctemp.update(sql, ps);  
    84. 

  84.     }  
    85. 

  85. }</pre>  
    86. 







  


  

    
    
分享到：
      
      
    

  


  

    

      
      |
      JVM性能调优监控工具jps、jstack、jmap、 ...
    

  

  

        
  

    
  

    
评论

    
    
    
    
  


  

    
发表评论

            
   您还没有登录,请您登录后再发表评论 

      

  

  





  

    
相关推荐

    
    
    
        
        
    
          
    
            
            
    
              
                
                
                
    
                  
    
                    
                      spring_JDBC整合包
                    
                  
    
                  
    Spring JDBC是Spring框架的一个重要模块，它简化了Java数据库连接（JDBC）的使用，提供了更高级别的抽象，使得数据库操作更加简洁、易管理和模块化。这个"spring_JDBC整合包"显然包含了进行Spring JDBC开发所需的...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      SpringJDBC.rar_SpringJDBC_spring jdbc
                    
                  
    
                  
    通过这个SpringJDBC.rar的案例，初学者可以学习到如何配置DataSource，如何创建JdbcTemplate实例，以及如何编写和执行SQL语句。同时，实践中还可以了解到如何将Spring JDBC整合到Spring Boot项目中，以及如何处理...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      Spring JDBC与事务管理
                    
                  
    
                  
    javaEE 实验三 Spring JDBC与事务管理， 一、实验目的 1、掌握Spring JDBC的配置； 2、掌握JdbcTemplae类中增删改查方法的使用； 3、了解Spring事务管理的3个核心接口； 4、了解Spring事务管理的两种方式； 5、掌握...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      Spring JDBC常用Jar包
                    
                  
    
                  
    Spring JDBC是Spring框架的一部分，主要用于简化Java数据库连接操作。它提供了一个抽象层，使得开发者能够以统一的方式处理各种数据库，而无需直接与JDBC API打交道，从而降低了代码的复杂性和错误率。在"Spring ...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      spring jdbc.zip
                    
                  
    
                  
    《Spring JDBC：Spring框架对JDBC的封装与实践》  Spring框架是Java开发中的一个核心组件，它极大地简化了企业级应用的开发工作。在Spring框架中，Spring JDBC（Java Database Connectivity）模块扮演着重要的角色，...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      springjdbc.zip_SpringJDBC_spring jdbc_spring 增删改查_springjdbc xml
                    
                  
    
                  
    这个`springjdbc.zip`压缩包很可能包含了示例代码和配置文件，用于演示如何使用Spring JDBC来执行基本的数据库操作，如增、删、改、查。  1. **Spring JDBC模块**：Spring JDBC模块主要由`org.springframework.jdbc`...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      spring jdbc示例代码
                    
                  
    
                  
    Spring JDBC是Spring框架的一部分，它提供了一种更高级的方式来处理传统的Java JDBC（Java Database Connectivity），以简化数据库操作。本示例代码将展示如何在Spring环境中使用JDBC进行数据的增删改查操作，并对比...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      spring对jdbc的支持jar包
                    
                  
    
                  
    本文将深入探讨Spring对JDBC（Java Database Connectivity）的支持，以及如何在实际项目中使用这些功能。  首先，Spring JDBC的核心是`org.springframework.jdbc`包，它提供了一套高级抽象，用于简化数据库操作。在...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      Spring JDBC应用实例讲解
                    
                  
    
                  
    Spring JDBC是Spring框架中的一个核心模块，主要用于简化Java数据库编程。在本文中，我们将深入探讨Spring JDBC的应用实例，了解如何利用它来实现高效且灵活的数据访问。首先，我们需要理解Spring JDBC是如何通过...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      spring-jdbc jar包.rar
                    
                  
    
                  
    《Spring JDBC：构建高效数据访问层》  Spring JDBC是Spring框架的一个重要组成部分，它提供了一种简化传统JDBC编程的抽象层，使得开发者能够更轻松、更安全地处理数据库交互。"spring-jdbc jar包"包含了Spring框架...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      spring jdbc相关包版本5.1.3
                    
                  
    
                  
    Spring JDBC模块是Spring框架的一部分，它提供了对JDBC（Java Database Connectivity）的高级抽象，简化了数据库操作。在这个场景中，我们关注的是Spring JDBC的5.1.3版本。  **Spring JDBC 5.1.3 版本详解**  ...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      spring JDbc
                    
                  
    
                  
    Spring JDBC是Spring框架的一个核心模块，它为Java数据库连接（JDBC）提供了一个高级抽象层，简化了数据库操作。在本实例中，我们将深入探讨Spring JDBC的使用，并以`SpringJdbcTemplate`为例来阐述其主要功能和优势...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      SpringMVC+SpringJDBC
                    
                  
    
                  
    SpringMVC和SpringJDBC是Java开发中两个重要的框架，它们分别是Spring框架在Web层和数据访问层的应用。本文将详细介绍这两个组件的核心概念、工作原理以及如何整合使用，旨在帮助开发者更好地理解和应用。  **...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      spring4 、 springmvc4.2、springjdbc
                    
                  
    
                  
    Spring框架是Java开发中广泛应用的一个开源框架，它主要由Spring Core、Spring MVC和Spring JDBC等模块组成。在本文中，我们将深入探讨这三个核心模块以及它们的功能和整合方式。  首先，Spring Core是整个Spring...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      SpringJDBC.rar_jdbc spring_spring jd_spring jdbc_spring使用JDBC进行数
                    
                  
    
                  
    这个“SpringJDBC.rar”压缩包文件可能包含了关于如何在Spring框架中集成和使用JDBC的相关示例和教程。下面将详细解释Spring JDBC的核心概念、功能以及使用方法。  首先，Spring JDBC的核心目标是简化传统的JDBC编程...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      spring JDBC所需jar包
                    
                  
    
                  
    在Java开发中，Spring框架是不可或缺的一部分，尤其在处理数据访问层时，Spring JDBC提供了一种强大而灵活的方式来管理数据库连接。Spring JDBC模块是Spring框架的一部分，它简化了JDBC的使用，使得开发者可以更加...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      Spring JDBC相关jar包：spring_jdbc_4.0.0.zip
                    
                  
    
                  
    Spring JDBC是Spring框架的一个核心模块，它为Java数据库连接（JDBC）提供了一种抽象层，使得开发者可以更轻松地处理数据库操作。Spring JDBC模块的主要目标是减少对JDBC API的直接依赖，通过提供一种更加高级、易于...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      最简单的用户登录与注册系统 spring mvc spring jdbc
                    
                  
    
                  
    Spring MVC是Spring框架的一个模块，主要用于构建Web应用程序，而Spring JDBC则是Spring提供的用于简化数据库操作的工具。  【描述】"用spring4.0.5版本开发的，spring mvc，spring jdbc，最简单的用户登录，注册和...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      Spring事务管理和SpringJDBC思维导图
                    
                  
    
                  
    本话题主要关注Spring的两个重要模块：事务管理和Spring JDBC。这些知识点对于任何使用Spring进行后端开发的程序员来说都是至关重要的。  首先，我们来深入理解Spring事务管理。事务是数据库操作的基本单元，它确保...
    
                
    
                
              
                
                
                
    
                  
    
                    
                      SpringJDBC训练素材.zip
                    
                  
    
                  
    Spring JDBC是Spring框架的一部分，它提供了一种抽象层，使得开发者可以更方便地使用Java数据库连接（JDBC）进行数据库操作。Spring JDBC的核心是JdbcTemplate类，它简化了执行SQL语句的过程，减少了代码量，并提高...
    
                
    
                
              
            
    
          
    
        
    
    

  





  
    Magicbox
  













      

            
    

    
    
  

  



   Global site tag (gtag.js) - Google Analytics