从源码到实战之Spring中的JdbcTemplate及策略模式自定义JdbcTemplate实现

最新推荐文章于 2024-05-06 16:50:11 发布
最新推荐文章于 2024-05-06 16:50:11 发布
阅读量1k 收藏 1
点赞数 1
分类专栏： 数据库 文章标签： java mysql spring 数据库 mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/swzhang_01/article/details/109269160
版权

目  录：

    1. JdbcTemplate 简单概述

        1.1 源码解析

         1.2 相关方法说明

         1.3 实战演练入门

                1.3.1 基本类型测试

                1.3.2 大文本对象测试

    2. NamedParameterJdbcTemplate 简单概述

        2.1 源码分析

        2.2 实战演练入门

    3. JdbcTemplate 的实现原理解密

        3.1 自定义实现 JdbcTemplate

        3.2 MyResultSetHandler 接口及实现（策略模式）

        3.3 测试MyJdbcTemplate

  1. JdbcTemplate 简单概述

Spring 对数据库的操作在 JDBC 上面做了基本的封装，让开发者在操作数据库时只需关注SQL语句和查询结果处理器，即可完成对数据库表相应的 CURD 功能（当然，只使用 JdbcTemplate，还不能摆脱持久层 DAO 实现类的编写）。

在配合 Spring 的 IoC 功能，可以把 DataSource 注册到 JdbcTemplate 之中。同时利用 Spring 基于 AOP 的事务即可完成简单的数据库 CRUD 操作。存在多数据源时，可以将不同的 DataSource 注册到 各自的 JdbcTemplate 中，Spring 实现不同对 JdbcTemplate 的 Bean 进行管理，从而实现多数据源操作数据库。

1.1 JdbcTemplate 的全限定名为 org.springframework.jdbc.core.JdbcTemplate。对于 SpringBoot 项目要使用 JDBC 模板，只需引入 spring-boot-starter-jdbc 坐标，然后通过 @Autowired 注解完成自动注入 JdbcTemplate。其源码分析如下：

/**
 * JdbcTemplate实现了JdbcOperations接口，操作方法都定义在此接口中
 */
public class JdbcTemplate extends JdbcAccessor implements JdbcOperations {
    /**
     * 使用默认构造函数构建JdbcTemplate
     */
    public JdbcTemplate() {
    }


    /**
     * 通过数据源构建JdbcTemplate
     * @param dataSource
     */
    public JdbcTemplate(DataSource dataSource) {
        setDataSource(dataSource);
        afterPropertiesSet();
    }


    /**
     * 当使用默认构造函数构建时，提供了设置数据源的方法
     * @param dataSource
     */
    public void setDataSource(@Nullable DataSource dataSource) {
        this.dataSource = dataSource;
    }
}

1.2 JdbcTemplate 相关方法的说明如下：

execute 方法：
    可以用于执行任何 SQL 语句，一般用于执行 DDL 语句；
update 方法及batchUpdate方法：
    update 方法用于执行新增、修改、删除等语句；batchUpdate 方法用于执行批处理相关语句；
query 方法及 queryForXXX 方法：
    用于执行查询相关语句；
call 方法：
    用于执行存储过程、函数相关语句。

1.3 实战演练入门（分两部分）

以 SpringBoot 应用为例，参考《Spring Boot 快速入门系列（III）—— 数据操作篇之 JdbcTemplate》进行测试：

比如存在一个用户实体如下：

public class User implements Serializable {
    // 主键
    private String id;
    // 姓名
    private String name;
    // 年龄
    private String age;
    // 性别
    private String sex;
    // 头像
    private byte[] image; 
     // 个人简介
    private String description;


    /** 省略getter/setter */
}

1.3.1 （基本类型）测试类代码编写如下：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfiguration.class)
public class SpringJdbcTemplateTest {
    @Autowired
    private JdbcTemplate jdbcTemplate;


    @Test
    public void testInsert() {
        jdbcTemplate.update("insert into user(name, age, sex) values (?,?,?)", "giserway", 18, "1");
    }


    @Test
    public void testUpdate() {
        jdbcTemplate.update("update user set name = ?, age = ? where id = ?", "tom", 20, 1);
    }


    @Test
    public void testDelete() {
        jdbcTemplate.update("delete from user where id = ?", 1);
    }


    @Test
    public void testFindOne(){
        User user = null;
        try {
            user = jdbcTemplate.queryForObject("select name, age, sex from user where id = ?", new BeanPropertyRowMapper<>(User.class),1);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    @Test
    public void testFindAll() {
        List<User> users = jdbcTemplate.query("select id,name,age,sex from user", new BeanPropertyRowMapper<>(User.class));
    }


    @Test
    public void testFindCount() {
        Long count = jdbcTemplate.queryForObject("select count(*) from user where age > ?", Long.class, 18);
    }


    @Test
    public void testQueryForList() {
        List<Map<String, Object>> list = jdbcTemplate.queryForList("select id,name,age,sex from user where age > ?", 18);
        for (Map<String, Object> map : list) {
            for (Map.Entry<String, Object> me : map.entrySet()) {
                System.out.println(me.getKey() + "," + me.getValue());
            }
        }
    }


    @Test
    public void testQueryForList2() {
        List<String> list = jdbcTemplate.queryForList("select name from user where age > ?", String.class, 18);
        for (String name : list) {
            System.out.println(name);
        }
    }


    @Test
    public void testQueryForMap() {
        Map<String, Object> map = jdbcTemplate.queryForMap("select id,name,age,sex from user where id = ?", 1);
        for (Map.Entry me : map.entrySet()) {
            System.out.println(me.getKey() + "," + me.getValue());
        }
    }
}

1.3.2 大文本对象测试类代码编写如下：

  • 在数据库中，CLOB 和 BLOB 都是大字段类型。

  • CLOB 是可以直接存储文字的，而 BLOB 是按二进制来存储的。

  • 其实这两个字段类型是可以互换的的，或者可以直接用 LOB 字段代替这两个。

  • 对于 ORACLE 数据库，通常像图片、文件、音乐等信息就用 BLOB 字段来存储，先将文件转为二进制再存储进去。而像文章或者是较长的文字，就用 CLOB 存储，这样对以后的查询更新存储等操作都提供很大的方便。

下面是通过 JdbcTemplate 实现大字段类型的存储，编码测试示例如下：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfiguration.class)
public class SpringJdbcTemplateCLOBAndBLOBTest {
    @Autowired
    private JdbcTemplate jdbcTemplate;


    @Autowired
    private LobHandler lobHandler;


    @Test
    public void testClobBlobWrite() {
        try {
            FileSystemResource res = new FileSystemResource("D:\\test\\1.jpg");
            byte[] personImg = FileCopyUtils.copyToByteArray(res.getFile());
            User user = new User();
            user.setId(1);
            user.setImage(personImg);
            user.setDescription("本人性格热情开朗，待人友好，为人诚实谦虚。工作勤奋，认真负责，能吃苦耐劳，尽职尽责，有耐心。具有亲和力，平易近人，善于与人沟通，也许这天的我没什么值得推荐的荣誉，但是我有一颗简单的心，做好了应对困难的准备，期望您的机会和慧眼，相信我下次在做自我介绍时，会给您一个惊喜。");
            jdbcTemplate.execute("update user set image = ?, description =? where id = ?", new AbstractLobCreatingPreparedStatementCallback(lobHandler) {
                @Override
                protected void setValues(PreparedStatement ps, LobCreator lobCreator) throws SQLException, DataAccessException {
                    lobCreator.setBlobAsBytes(ps, 1, user.getImage());
                    lobCreator.setClobAsString(ps, 2, user.getDescription());
                    ps.setInt(3, user.getId());
                }
            });
        } catch (Exception e) {
            e.printStackTrace();
        }
    }


    @Test
    public void testClobBlobRead() {
        User user = jdbcTemplate.query("select id, name, image, description from user where id = ?", new ResultSetExtractor<User>() {
            @Override
            public User extractData(ResultSet rs) throws SQLException, DataAccessException {
                User user = null;
                if (rs.next()) {
                    user = new User();
                    user.setId(rs.getInt(1));
                    user.setName(rs.getString(2));
                    user.setImage(lobHandler.getBlobAsBytes(rs, 3));
                    user.setDescription(lobHandler.getClobAsString(rs, 4));
                }
                return user;
            }
        }, 3);
        System.out.println(user);
    }
}

  1. NamedParameterJdbcTemplate 简单概述

  • 在 JDBC 标准用法中, SQL 参数是用占位符 ? 替换

表示，参数绑定受到位置的限制。定位参数的问题在于，一旦参数的顺序发生变化，就必须改变参数绑定。在 Spring JDBC 框架中，绑定 SQL 参数的另一种选择是使用具名参数（named parameter）。

  • 那么什么是具名参数？

具名参数：SQL 按名称（以冒号开头）而不是按位置进行指定。具名参数更易于维护，也提升了可读性。具名参数由框架类在运行时用占位符取代，具名参数只在 NamedParameterJdbcTemplate 中得到支持。NamedParameterJdbcTemplate 可以使用全部 jdbcTemplate 对象方法。

2.1 源码分析如下：

/**
 * 通过观察源码我们发现，NamedParameterJdbcTemplate 里面封装了一个JdbcTemplate对象
 * 只不过把它看成了接口类型JdbcOperations。
 */
public class NamedParameterJdbcTemplate implements NamedParameterJdbcOperations {
    /**
     * The JdbcTemplate we are wrapping.
     */
    private final JdbcOperations classicJdbcTemplate;


    /**
     * 通过数据源构建 JdbcOperations
     * @param dataSource
     */
    public NamedParameterJdbcTemplate(DataSource dataSource) {
        Assert.notNull(dataSource, "DataSource must not be null");
        this.classicJdbcTemplate = new JdbcTemplate(dataSource);
    }


    /**
     * 使用JdbcOperations 构建一个NamedParameterJdbcTemplate
     * @param classicJdbcTemplate
     */
    public NamedParameterJdbcTemplate(JdbcOperations classicJdbcTemplate) {
        Assert.notNull(classicJdbcTemplate, "JdbcTemplate must not be null");
        this.classicJdbcTemplate = classicJdbcTemplate;
    }


    //...
}

2.2 实战演练入门

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfiguration.class)
public class SpringJdbcTemplateUseTest {
    @Autowired
    private NamedParameterJdbcTemplate namedParameterJdbcTemplate;


    @Autowired
    private JdbcTemplate jdbcTemplate;


    @Test
    public void testFindMore() {
        // 不知道有多少个id需要查询时，使用占位符?极其不方便
        // List<User> users = jdbcTemplate.query("select name, age, sex from user where id in (?,?)",new Object[]{1,2},new BeanPropertyRowMapper<> (User.class));
        Map<String, List<Integer>> map = new HashMap<>();
        List<Integer> list = new ArrayList<>();
        list.add(1);
        list.add(2);
        map.put("ids", list);
        List<User> users = namedParameterJdbcTemplate.query("select name, age, sex from user where id in(:ids)", map, new BeanPropertyRowMapper<>(User.class));
        System.out.println(users);
    }


    @Test
    public void testNamedParameter() {
        User user = new User();
        user.setName("jack");
        user.setAge(18);
        user.setSex("1");
        BeanMap beanMap = BeanMap.create(user);
        namedParameterJdbcTemplate.update("insert into user(name, age, sex) values (:name, :age, :sex)", beanMap);
    }
}

  1. JdbcTemplate 的实现原理解密

3.1 自定义实现 MyJdbcTemplate

3.1.1 首先导入 pom 文件相关依赖

坐标如下：

<dependencies>
    <dependency>
        <groupId>com.alibaba</groupId>
        <artifactId>druid</artifactId>
        <version>1.1.9</version>
    </dependency>
    <dependency>
        <groupId>mysql</groupId>
        <artifactId>mysql-connector-java</artifactId>
        <version>5.1.45</version>
    </dependency>
</dependencies>

3.1.2 自定义 MyJdbcTemplate 

代码实现编码如下：

public class MyJdbcTemplate {
    // 定义数据源
    private DataSource dataSource;


    // 通过构造函数给数据源赋值
    public MyJdbcTemplate(DataSource dataSource) {
        this.dataSource = dataSource;
    }


    //通过set方法给数据源赋值
    public void setDataSource(DataSource dataSource) {
        this.dataSource = dataSource;
    }


    /**
     * 查询方法
     * @param sql    sql语句
     * @param rsh    结果集处理器
     * @param params sql语句的参数
     * @return
     */
    public Object query(String sql, MyResultSetHandler rsh, Object... params) {
        //1.判断是否有数据源，没有数据源就直接抛异常
        if (dataSource == null) {
            throw new NullPointerException("DataSource can not empty!");
        }
        //2.定义连接和处理对象
        Connection connection = null;
        PreparedStatement pstm = null;
        ResultSet rs = null;
        try {
            //2.获取连接
            connection = dataSource.getConnection();
            //3.获取预处理对象
            pstm = connection.prepareStatement(sql);
            //4.获取参数元信息
            ParameterMetaData pmd = pstm.getParameterMetaData();
            //5.获取参数个数
            int parameterCount = pmd.getParameterCount();
            //6.验证参数
            if (parameterCount > 0) {
                if (params == null) {
                    throw new NullPointerException("Parameter can not be null !");
                }
                if (parameterCount != params.length) {
                    throw new IllegalArgumentException("Incorrect parameter count: expected " + String.valueOf(parameterCount) + ", actual " + String.valueOf(params.length));
                }
                //7.给参数赋值
                for (int i = 0; i < parameterCount; i++) {
                    pstm.setObject((i + 1), params[i]);
                }
            }
            //8.验证通过，执行SQL语句
            s = pstm.executeQuery();
            //9.处理结果集：策略模式
            return rsh.handle(rs);
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            release(connection, pstm, rs);
        }
    }


    /**
     * 增删改操作
     * @param sql
     * @param params
     * @return
     */
    public int update(String sql, Object... params) {
        //1.判断是否有数据源，没有数据源就直接抛异常
        if (dataSource == null) {
            throw new NullPointerException("DataSource can not empty!");
        }
        //2.定义连接和处理对象
        Connection connection = null;
        PreparedStatement pstm = null;
        try {
            //2.获取连接
            connection = dataSource.getConnection();
            //3.获取预处理对象
            pstm = connection.prepareStatement(sql);
            //4.获取参数元信息
            ParameterMetaData pmd = pstm.getParameterMetaData();
            //5.获取参数个数
            int parameterCount = pmd.getParameterCount();
            //6.验证参数
            if (parameterCount > 0) {
                if (params == null) {
                    throw new NullPointerException("Parameter can not be null !");
                }
                if (parameterCount != params.length) {
                    throw new IllegalArgumentException("Incorrect parameter count: expected " + String.valueOf(parameterCount) + ", actual " + String.valueOf(params.length));
                }
                //7.给参数赋值
                for (int i = 0; i < parameterCount; i++) {
                    pstm.setObject((i + 1), params[i]);
                }
            }
            //8.验证通过，执行SQL语句
            return pstm.executeUpdate();
        } catch (Exception e) {
            throw new RuntimeException(e);
        } finally {
            release(connection, pstm, null);
        }
    }


    /**
     * 释放数据库连接
     * @param conn
     * @param pstm
     * @param rs
     */
    private void release(Connection conn, PreparedStatement pstm, ResultSet rs) {
        if (rs != null) {
            try {
                rs.close();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        if (pstm != null) {
            try {
                pstm.close();
            } catch (Exception e) {
            }
            if (conn != null) {
                try {
                    conn.close();
                } catch (Exception e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

3.1.3 定义结果集处理接口 MyResultSetHandler

public interface MyResultSetHandler<T> {
    /**
     * 处理结果集
     * @param rs
     * @return
     * @throws Exception
     */
    Object handle(ResultSet rs) throws Exception;
}

接口两种实现方式如下（使用策略模式）：

  • 获取 JavaBean 对象

    实现代码如下：

public class BeanHandler<T> implements ResultSetHandler {


    private Class<T> requiredType;


    private BeanListHandler<T> beanListHandler;


    /**
     * 覆盖默认无参构造
     * @param requriedType
     */
    public BeanHandler(Class requriedType) {
        this.requiredType = requriedType;
    }


    public BeanHandler(BeanListHandler beanListHandler) {
        this.beanListHandler = beanListHandler;
    }


    @Override
    public T handle(ResultSet rs) throws Exception {
        if (beanListHandler != null) {
            return beanListHandler.handle(rs).get(0);
        }
        //1.定义返回值
        T bean = null;
        //2.由于是查询一个，所以只需判断rs能往下走，不用while循环即可
        if (rs.next()) {
            //3.实例化bean对象
            bean = requiredType.newInstance();
            // 4.获取参数元信息
            ResultSetMetaData rsmd = rs.getMetaData();
            //5.取出参数个数
            int columnCount = rsmd.getColumnCount();
            //6.遍历参数个数
            for (int i = 0; i < columnCount; i++) {
                //7.取出列名称
                String columnLabel = rsmd.getColumnLabel(i + 1);
                //8.取出列的值
                Object value = rs.getObject(columnLabel);
                //9.创建实体类的属性描述器，使用内省填充对象数据
                PropertyDescriptor pd = new PropertyDescriptor(columnLabel, requiredType);
                // 10. 获取属性的写方法
                Method method = pd.getWriteMethod();
                //11.填充数据
                method.invoke(bean, value);
            }
        }
        //返回
        return bean;
    }
}

  • 获取 JavaBean 对象集合

    实现代码如下：

public class BeanListHandler<T> implements ResultSetHandler {
    private Class<T> requiredType;


    /**
     * 覆盖默认无参构造
     * @param requriedType
     */
    public BeanListHandler(Class requriedType) {
        this.requiredType = requriedType;
    }


    @Override
    public List<T> handle(ResultSet rs) throws Exception {
        //1.定义返回值
        List<T> list = new ArrayList();
        T bean = null;
        //2.由于是查询一个，所以只需判断rs能往下走，不用while循环即可 
        if (rs.next()) {
            //3.实例化bean对象
            bean = requiredType.newInstance();
            //4.获取参数元信息
            ResultSetMetaData rsmd = rs.getMetaData();
            //5.取出参数个数
            int columnCount = rsmd.getColumnCount();
            //6.遍历参数个数
            for (int i = 0; i < columnCount; i++) {
                //7.取出列名称
                String columnLabel = rsmd.getColumnLabel(i + 1);
                //8.取出列的值
                Object value = rs.getObject(columnLabel);
                //9.创建实体类的属性描述器，使用内省填充对象数据
                PropertyDescriptor pd = new PropertyDescriptor(columnLabel, requiredType);
                //10.获取属性的写方法
                Method method = pd.getWriteMethod();
                //11.填充数据
                method.invoke(bean, value);
            }
            //12.给list填充数据
            list.add(bean);
        }
        //返回
        return list;
    }
}

3.2 测试自定义的 MyJdbcTemplate

3.2.1 新建配置类及自定义 Bean 对象的注入

/**
 * 配置类
 */
@Configuration
@Import(JdbcConfig.class)
@PropertySource("classpath:jdbc.properties")
public class SpringConfiguration {


}

public class JdbcConfig {
    @Value("${jdbc.driver}")
    private String driver;


    @Value("${jdbc.url}")
    private String url;


    @Value("${jdbc.username}")
    private String username;


    @Value("${jdbc.password}")
    private String password;


    @Bean
    public MyJdbcTemplate createJdbcTemplate(DataSource dataSource) {
        return new MyJdbcTemplate(dataSource);
    }


    @Bean
    public DataSource createDataSource() {
        DruidDataSource dataSource = new DruidDataSource();
        dataSource.setDriverClassName(driver);
        dataSource.setUrl(url);
        dataSource.setUsername(username);
        dataSource.setPassword(password);
        return dataSource;
    }
}

3.2.2 在 resources/ 下新建配置文件 

jdbc.properties，内容如下：

jdbc.driver=com.mysql.jdbc.Driver 
jdbc.url=jdbc:mysql://localhost:3306/db_test
jdbc.username=root 
jdbc.password=123456

3.2.3 新建测试类

测试代码如下：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(classes = SpringConfiguration.class)
public class SpringJdbcTemplateUseTest {
    @Autowired
    private MyJdbcTemplate jdbcTemplate;


    @Test
    public void testInsert() {
        jdbcTemplate.update("insert into user(name, age, sex) values (?,?,?)", "giserway", 18, "1");
    }


    @Test
    public void testUpdate() {
        jdbcTemplate.update("update user set name = ?, age = ? where id = ?", "tom", 20, 1);
    }


    @Test
    public void testDelete() {
        jdbcTemplate.update("delete from user where id = ?", 1);
    }


    @Test
    public void testFindOne() {
        User user = (User) jdbcTemplate.query("select name, age, sex from user where id = ?", new BeanHandler<>(User.class), 1);
        System.out.println(user);
    }


    @Test
    public void testFindList() {
        List<User> users = (List<User>) jdbcTemplate.query("select name, age, sex from user where age > 18", new BeanListHandler<>(User.class));
        for (User user : users) {
            System.out.println(user);
        }
    }
}

4. 小结

本文从 JdbcTemplate 实现持久层入门到自定义实现，了解并掌握 JdbcTemplate 的基本使用及其实现原理；从自定义 JdbcTemplate 实现中，可以了解到策略模式的用法，策略模式是面向接口编程思想的具体体现，通常情况下，作为设计者会暴露出来一个接口，同时可以提供一些接口实现，也可以不提供，而让使用者根据具体情况去编写具体实现代码。以达到灵活的扩展目的。

加油

# 精彩推荐 #

 分布式系统「全链路日志追踪」实战之 RestTemplate & Feign

 分布式任务调度框架 Elastic-Job 之动态任务发布实现详解

  小白都能看得懂的服务调用链路追踪设计与实现

   事务看完这篇你只能算入门

   微服务架构中你必须了解的 CAP 原理

  趣谈微服务之点-线-面关系

  [三步法] 可视化分析定位线上 JVM 问题

  从 Java 代码如何运行聊到 JVM 和对象的创建-分配-定位-布局-垃圾回收

   记一次生产频繁出现 Full GC 的 GC日志图文详解

 "在看"吗，赶快分享和收藏吧

行走的GISer
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
利用spring的jdbcTemplate处理blob、clob
08-03
spring 中对大数据的处理，包括clob，blob的数据。比之jdbc下简便很多。
Spring 学习 JdbcTemplate，模板模式，回调
03-13
在Spring JdbcTemplate中，回调机制体现在RowCallbackHandler和ResultSetExtractor接口上。开发者可以实现这些接口，定义回调函数来处理每个查询结果行或者整个结果集。这样，JdbcTemplate在执行SQL查询后，会调用...
jdbcTemplate读取BLOB大字段
change的博客
04-03 4223
在开发中遇到读取BLOB大字段问题，在这里总结下。 BLOB全称为二进制大型对象（Binary Large Object)。它用于存储数据库中的大型二进制对象。可存储的最大大小为4G字节。 CLOB全称为字符大型对象（Character Large Object)。它与LONG数据类型类似，只不过CLOB用于存储数据库中的大型单字节字符数据块，不支持宽度不等的字符集。可存储的...
Spring JdbcTemplate实现自定义动态sql拼接功能
最新发布
thinkers
05-06 530
sql 需要能满足支持动态拼接，包含 查询字段、查询表、关联表、查询条件、关联表的查询条件、排序、分组、去重等。11，核心类之 BasicConditionQueryCriteria（入参）7，核心类之 PredicateCondition。8，核心类之 PropertyCondition。10，核心类之 ExecutionSql。9，核心类之 SqlBuilder。6，核心类之 Condition。2，创建项目并引入 pom依赖。4，核心类之 Column。5，核心类之 Table。
自定义一个JdbcTemplate(增删改数据库中表记录)
weixin_30649859的博客
06-16 211
需求: 自定义一个JdbcTemplate模板,实现增删改数据库中表记录的功能 1 package demo03; 2 3 import utils.JDBC_DBCP_Utils; 4 5 import javax.sql.DataSource; 6 import java.sql.Connection; 7 import java.sql.Parame...
自定义MyJdbcTemplate
weixin_44469445的博客
05-05 488
一.JavaBean类 public class User { private Integer id; private String username; private String password; private String nickname; @Override public String toString() { return “User{” + “id=” + id + “, use...
jdbc 读取mysql blob_jdbcTemplate获取mysql的blob
weixin_39761558的博客
01-19 237
java使用jdbcTemplate操作mysql数据库，遇到blob字段，正常读取出来是blob的地址，而不是blob的内容。下面采用2中方式读取blob的内容：1、以二进制数组形式读取blob，适用于文本数据public void testJdbc(){ApplicationContext ctx = new ClassPathXmlApplicationContext("restlet-se...
spring jdbcTemplate 源码
10-05
Spring JDBCTemplate是Spring框架中的一个核心组件，它提供了一种简化数据库操作的抽象层，使得开发者可以更加方便、高效地处理数据库事务。本篇将深入探讨Spring JDBCTemplate的使用及其源码解析，帮助你理解其背后...
Spring-JdbcTemplate
03-18
`Spring-JdbcTemplate` 是 Spring 框架中的一个核心模块，主要用于简化数据库操作，提供了强大的数据访问功能。它通过模板方法设计模式封装了 SQL 的执行，使得开发者无需直接与 JDBC API 打交道，从而降低了数据库...
spring jdbcTemplate 注入到servlet
05-27
在Java Web开发中，Spring框架提供了丰富的工具来简化数据库操作，其中之一就是`Spring JdbcTemplate`。`JdbcTemplate`是Spring对JDBC（Java Database Connectivity）的一层轻量级封装，它使得开发者能够更加方便地...
Spring JdbcTemplate例子
04-10
这通常通过Spring的IoC容器（依赖注入）完成，将DataSource配置到JdbcTemplate中。例如： ```java @Autowired private DataSource dataSource; @Bean public JdbcTemplate jdbcTemplate() { return new ...
JDBC框架(JDBCTemplate)
qq_56101688的博客
05-03 872
/6.6列名其实就是对象中成员变量的名称。于是就可以使用列名得到对象中属性的描述器(get和set方法)//6.6列名其实就是对象中成员变量的名称。于是就可以使用列名得到对象中属性的描述器(get和set方法)java.sql.ParameterMetaData：封装的是预编译执行者对象中每个参数的类型和属性。这个对象可以通过预编译执行者对象中的getParameterMetaData()方法来获取。java.sql.ResultSetMetaData：封装的是结果集对象中列的类型和属性。
JDBC_22.8.2
cicadaaas的博客
08-02 853
JDBC
JDBC典型用法、执行SQL语句方式
weixin_45823991的博客
03-22 2724
JDBC典型用法 API： DriverManager:用于管理JDBC驱动的服务类。程序中使用该类的主要功能是获取Connection对象 Connection: 代表数据库连接对象，每个Connection代表一个物理连接会话。要想访问数据库,必须先获得数据库连接 Statement:用于执行SQL语句的工具接口。该对象既可用于执行DDL、DCL语句，也可用于执行DML语句，还可用于执行SQL...
使用SpringJdbcTemplate进行批量的更新/新增（高效率）
热门推荐
小码哥222的博客
12-03 1万+
refer：几种批量删除分析比较：https://blog.csdn.net/fbysss/article/details/4152703?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-4.control&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-4.
JDBC--查询操作
qq_48508643的博客
11-29 205
JDBC--查询
Spring Boot数据持久化之JdbcTemplate
江南一点雨的专栏
03-16 2290
在Java领域，数据持久化有几个常见的方案，有Spring自带的JdbcTemplate、有MyBatis，还有JPA，在这些方案中，最简单的就是Spring自带的JdbcTemplate了，这个东西虽然没有MyBatis那么方便，但是比起最开始的Jdbc已经强了很多了，它没有MyBatis功能那么强大，当然也意味着它的使用比较简单，事实上，JdbcTemplate算是最简单的数据持久化方案了，本...
自定义JdbcTemplet,自定义JDBC框架,实现基本功能.包括连接池
佐月儿
11-04 205
本文运用到的技术和思想有:反射, 动态代理, 策略模式等 package com.zuoyueer.util; import java.io.InputStream; import java.sql.*; import java.util.List; import java.util.Properties; /** * @author Zuoyueer * Date: 2019/11/4...
Spring源码学习-JdbcTemplate batchUpdate批量操作
05-31
好的，关于Spring源码中的JdbcTemplate batchUpdate批量操作，可以简单地介绍一下其实现原理。 JdbcTemplate是Spring框架中用于简化JDBC操作的模板类，其中的batchUpdate方法可以用于批量执行SQL语句。batchUpdate...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值