Spring JDBC 【转】

已于 2022-08-05 11:08:52 修改
阅读量489 收藏 1
点赞数 1
分类专栏： Java Web 文章标签： SpringJDBC 事务管理 DAO模式 JdbcTemplate PlatformTransactionManager
于 2022-07-20 16:13:34 首次发布
原文链接：https://www.liaoxuefeng.com/wiki/1252599548343744/1282383699509281
版权

以下内容转载和参考自 使用JDBC - 廖雪峰的官方网站

1、Spring JDBC

  Spring中包含支持JDBC的数据访问模块，其提供了简化的JDBC操作，不必手动释放资源，通过使用JdbcTemplate。如下所示，我们通过IoC创建并管理一个DataSource实例（DataSource使用HikariCP），一个JdbcTemplate实例，，然后就可以通过JdbcTemplate来执行SQL操作： 

@Configuration
@ComponentScan
@PropertySource("jdbc.properties") //读取数据库配置文件jdbc.properties
public class AppConfig {

    @Value("${jdbc.url}") //获取配置文件中jdbc.url属性值到jdbcUrl
    String jdbcUrl;

    @Value("${jdbc.username}") //获取配置文件中jdbc.username属性值到jdbcUsername
    String jdbcUsername;

    @Value("${jdbc.password}") //获取配置文件中jdbc.password属性值到jdbcPassword
    String jdbcPassword;

    @Bean //提供给IoC创建DataSource对象的方法
    DataSource createDataSource() {
        HikariConfig config = new HikariConfig();
        config.setJdbcUrl(jdbcUrl);
        config.setUsername(jdbcUsername);
        config.setPassword(jdbcPassword);
        config.addDataSourceProperty("autoCommit", "true");
        config.addDataSourceProperty("connectionTimeout", "5");
        config.addDataSourceProperty("idleTimeout", "60");
        return new HikariDataSource(config);
    }

    @Bean //提供给IoC创建JdbcTemplate对象的方法
    JdbcTemplate createJdbcTemplate(@Autowired DataSource dataSource) {
        return new JdbcTemplate(dataSource);
    }
}

  配置文件jdbc.properties：

# 数据库文件名为testdb:
jdbc.url=jdbc:hsqldb:file:testdb

# Hsqldb默认的用户名是sa，口令是空字符串:
jdbc.username=sa
jdbc.password=

   因为我们要使用@PostConstruct注解，以及使用的JDBC连接池是HikariCP，所以除了Spring和JDBC依赖外，还需要Annotation和HikariCP相关依赖。另外我们需要添加使用的MySQL或者Oracle等数据库的驱动依赖，我们这里使用的是HSQLDB这个数据库：

<dependencies>

    <!--Spring Context-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-context</artifactId>
        <version>5.2.0.RELEASE</version>
    </dependency>

	<!--Spring JDBC-->
    <dependency>
        <groupId>org.springframework</groupId>
        <artifactId>spring-jdbc</artifactId>
        <version>5.2.0.RELEASE</version>
    </dependency>

	<!--@PostConstruct注解-->
    <dependency>
        <groupId>javax.annotation</groupId>
        <artifactId>javax.annotation-api</artifactId>
        <version>1.3.2</version>
    </dependency>

	<!--JDBC连接池-->
    <dependency>
        <groupId>com.zaxxer</groupId>
        <artifactId>HikariCP</artifactId>
        <version>3.4.2</version>
    </dependency>

	<!--JDBC驱动-->
	<dependency>
        <groupId>org.hsqldb</groupId>
        <artifactId>hsqldb</artifactId>
        <version>2.5.0</version>
    </dependency>

</dependencies>

    在需要访问数据库的类中，注入JdbcTemplate，然后可以通过JdbcTemplate的queryForObject()来执行SQL查询、update()来执行插入、更新和删除操作：

@Component
public class DatabaseOper {
    @Autowired
    JdbcTemplate jdbcTemplate;

    @PostConstruct
    public void init() {
        //创建数据库表
        //int	update(String sql) 返回值为生效的行数
        jdbcTemplate.update("CREATE TABLE IF NOT EXISTS users (" //
                + "id BIGINT IDENTITY NOT NULL PRIMARY KEY, " //
                + "email VARCHAR(100) NOT NULL, " //
                + "password VARCHAR(100) NOT NULL, " //
                + "name VARCHAR(100) NOT NULL, " //
                + "UNIQUE (email))");
    }

    public void updateUser(User user) {
    //int	update(String sql, Object... args/*SQL语句参数*/) 返回值为更新的行数 
    if (1 != jdbcTemplate.update("UPDATE users SET name = ? WHERE id=?", user.getName(), user.getId())) {
        throw new RuntimeException("User not found by id");
    }
}

    public User getUserByEmail(String email) {
        User user = null;
        //T queryForObject(String sql /*SQL语句*/, Object[] args/*SQL语句的参数，不需要可以为null*/, RowMapper<T> rowMapper/*包含结果的Lambda表达式*/)
        user = jdbcTemplate.queryForObject("SELECT * FROM users WHERE email = ?", new Object[] { email },
                (ResultSet rs/*结果集*/, int rowNum/*行号？行数？*/) -> {
                    //Lambda表达式可以返回一个对象
                    return new User(
                            rs.getLong("id"), // id
                            rs.getString("email"), // email
                            rs.getString("password"), // password
                            rs.getString("name")); // name
                });

        return user;
    }
}

  如果SQL查询结果的结构恰好和JavaBean的属性名称一致，那么使用BeanPropertyRowMapper就可以直接把一行记录按列名转换为JavaBean。如果数据库表中列名与JavaBean不一致的话，也可以在查询的时候指定列的别名与JavaBean中一致，如"SELECT id, email, office_address AS workAddress, name FROM users WHERE email = ?"。

    public User getUserByEmail(String email) {
        User user = null;
        user = jdbcTemplate.queryForObject("SELECT * FROM users WHERE email = ?", new Object[] { email },
                new BeanPropertyRowMapper<>(User.class));
        return user;
    }

  如果SQL查询返回的是多行记录，可以使用query()方法：

    public List<User> getUsers(int pageIndex) {
        int limit = 100;
        int offset = limit * (pageIndex - 1);
        //<T> List<T>	query(String sql, Object[] args, RowMapper<T> rowMapper)
        return jdbcTemplate.query("SELECT * FROM users LIMIT ? OFFSET ?", new Object[] { limit, offset },
                new BeanPropertyRowMapper<>(User.class));
    }

  可以看到，使用Spring JDBC可以直接使用JdbcTemplate来进行SQL操作，不用再使用Connection、Statement / PreparedStatementJdbcTemplate对象，如果我们需要自己手动操作Jdbc的Connection或PreparedStatement来执行SQL语句的话，可以使用jdbcTemplate的execute()方法：

    public User getUserById(long id) {
        //<T> T	execute(ConnectionCallback<T> action)
        return jdbcTemplate.execute((Connection conn) -> {
            //回调结束后Connection自动释放，在回调中自己创建的PreparedStatement、ResultSet必须用try(...)手动释放
            try (var ps = conn.prepareStatement("SELECT * FROM users WHERE id = ?")) {
                ps.setObject(1, id);
                try (var rs = ps.executeQuery()) {
                    if (rs.next()) {
                        return new User(
                                rs.getLong("id"),
                                rs.getString("email"),
                                rs.getString("password"),
                                rs.getString("name"));
                    }

                    throw new RuntimeException("user not found by id.");
                }
            }
        });
    }

    public User getUserByName(String name) {
        //<T> T	execute(String sql, PreparedStatementCallback<T> action)
        return jdbcTemplate.execute("SELECT * FROM users WHERE name = ?", (PreparedStatement ps) -> {
            // PreparedStatement会在回调后自动释放，在回调中自己创建的ResultSet必须用try(...)手动释放
            ps.setObject(1, name);
            try (var rs = ps.executeQuery()) {
                if (rs.next()) {
                    return new User(
                            rs.getLong("id"),
                            rs.getString("email"),
                            rs.getString("password"),
                            rs.getString("name"));
                }
                throw new RuntimeException("user not found by id.");
            }
        });
    }

    如果某一列是自增列（例如自增主键），我们需要获取其插入后的自增值的话，那么JdbcTemplate提供了一个KeyHolder来进行这一操作：

    public User register(String email, String password, String name) {
        KeyHolder holder = new GeneratedKeyHolder(); // 创建一个KeyHolder
        //int	update(PreparedStatementCreator psc, KeyHolder generatedKeyHolder)
        int iRet = jdbcTemplate.update((conn) -> {
                    var ps = conn.prepareStatement("INSERT INTO users(email,password,name) VALUES(?,?,?)",
                            Statement.RETURN_GENERATED_KEYS); // 创建PreparedStatement时，必须指定RETURN_GENERATED_KEYS
                    ps.setObject(1, email);
                    ps.setObject(2, password);
                    ps.setObject(3, name);
                    return ps;
                }, holder);

        if(iRet != 1){
            throw new RuntimeException("Insert failed.");
        }

        // 从KeyHolder中获取返回的自增值
        return new User(holder.getKey().longValue(), email, password, name);
    }

2、使用事务

  Spring提供了一个PlatformTransactionManager来表示事务管理器，而事务由TransactionStatus表示，Spring除了提供标准JDBC事务外，还支持分布式事务JTA（Java Transaction API），如果仅使用JDBC事务的话，事务管理器的实际类型是DataSourceTransactionManager：

@Configuration
@ComponentScan
@PropertySource("jdbc.properties")
public class AppConfig {
    ......
    @Bean
    PlatformTransactionManager createTxManager(@Autowired DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }
}


@Component
public class Test {
    @Autowired
    private PlatformTransactionManager txManager;
    @Autowired
    JdbcTemplate jdbcTemplate;

    public void func(){
        TransactionStatus tx = null;
        try {
            tx = txManager.getTransaction(new DefaultTransactionDefinition()); // 开启事务

            jdbcTemplate.update("...");
            jdbcTemplate.update("...");

            txManager.commit(tx); // 提交事务
        } catch (RuntimeException e) {
            txManager.rollback(tx); // 回滚事务
            throw e;
        }
    }
}

    也可以使用声明式事务来简化事务代码，对需要成为事务的方法或者所有public方法都需要成为事务方法的类，使用@EnableTransactionManagement和@Transactional注解即可。

@Configuration
@ComponentScan
@EnableTransactionManagement // 启用声明式事务
@PropertySource("jdbc.properties")
public class AppConfig {
    ......
    @Bean
    PlatformTransactionManager createTxManager(@Autowired DataSource dataSource) {
        return new DataSourceTransactionManager(dataSource);
    }
}

Component
public class UserService {
    @Transactional // 此public方法自动具有事务支持
    public User register(String email, String password, String name) {
       ...
    }
}

@Component
@Transactional // 此类的所有public方法自动具有事务支持
public class UserService {
    ...
}

    声明式事务的原理仍然是AOP代理，即通过自动创建Bean的Proxy实现：

public class UserService$$EnhancerBySpringCGLIB extends UserService {
    UserService target;
    PlatformTransactionManager txManager;
    ......
    public User register(String email, String password, String name) {
        TransactionStatus tx = null;
        try {
            tx = txManager.getTransaction(new DefaultTransactionDefinition());
            target.register(email, password, name);
            txManager.commit(tx);
        } catch (RuntimeException e) {
            txManager.rollback(tx);
            throw e;
        }
    }
    ......
}

    在事务方法中如果想要手动回滚事务的话，抛出RuntimeException或其子类对象即可，如果要针对Checked Exception回滚事务，需要在@Transactional注解中指定：

    @Transactional(rollbackFor = {RuntimeException.class, IOException.class}) //在抛出RuntimeException或IOException时，事务将回滚
    public buyProducts(long productId, int num) {
    ...
        if (store < num) {
            // 库存不够，购买失败，回滚事务：
            throw new IllegalArgumentException("No enough products");
        }
    ...
    }

    如果一个方法A是事务方法，在A中又调用了一个事务方法B，那么默认情况下B事务方法会融合到A事务方法中，即相当于B方法中没有了事务。我们也可以改变事务的传播模型，通过@Transactional注解，默认的事务传播级别是REQUIRED，还有一些其他的传播级别：

      REQUIRED：如果当前没有事务，就创建一个新事务，如果当前有事务，就加入到当前事务中执行。

  SUPPORTS：表示如果有事务，就加入到当前事务，如果没有，那也不开启事务执行。这种传播级别可用于查询方法，因为SELECT语句既可以在事务内执行，也可以不需要事务；

  MANDATORY：表示必须要存在当前事务并加入执行，否则将抛出异常。这种传播级别可用于核心更新逻辑，比如用户余额变更，它总是被其他事务方法调用，不能直接由非事务方法调用；

  REQUIRES_NEW：表示不管当前有没有事务，都必须开启一个新的事务执行。如果当前已经有事务，那么当前事务会挂起，等新事务完成后，再恢复执行；

  NOT_SUPPORTED：表示不支持事务，如果当前有事务，那么当前事务会挂起，等这个方法执行完成后，再恢复执行；

  NEVER：和NOT_SUPPORTED相比，它不但不支持事务，而且在监测到当前有事务时，会抛出异常拒绝执行；

  NESTED：表示如果当前有事务，则开启一个嵌套级别事务，如果当前没有事务，则开启一个新事务。

    @Transactional(propagation = Propagation.REQUIRES_NEW)
    public Product A() {
        ...
        B()
        ...
    }

   如果在A事务方法中使用另一个线程来执行B方法，那么将分别开启A和B两个完全独立的事务，即事务的默认传播模型或者我们设置的传播模型会失效。因此，事务能正确传播的前提是，方法调用是在一个线程内才行，换句话说，事务只能在当前线程传播，无法跨线程传播：

    @Transactional
    public void A() {
        ...
        new Thread(() -> {
            B();
        }).start();
        ...
    }

3、DAO

  编写数据访问层的时候，可以使用DAO模式，DAO即Data Access Object的缩写，如下针对数据库中的用户表Users编写了一个DAO模式的类：

public class User{ //对应Users表中一条记录
    public int id;
    public string name;
    public int age;
    ...
}

public class UserDao { //Users表操作类

    @Autowired
    JdbcTemplate jdbcTemplate;

    User getUserById(long id) {
        ...
    }

    List<User> getUsers(int page) {
        ...
    }

    User createUser(User user) {
        ...
    }

    User updateUser(User user) {
        ...
    }

    void deleteUser(User user) {
        ...
    }
}

  Spring提供了一个JdbcDaoSupport类，用于简化DAO的实现：

ublic abstract class JdbcDaoSupport extends DaoSupport {

    private JdbcTemplate jdbcTemplate;

    public final void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
        initTemplateConfig();
    }

    public final JdbcTemplate getJdbcTemplate() {
        return this.jdbcTemplate;
    }

    ...
}
public class UserDao extends JdbcDaoSupport {
    @Autowired
    private JdbcTemplate jdbcTemplate;

    @PostConstruct
    public UserDao() {
        super.setJdbcTemplate(jdbcTemplate);
    }

    public User getUserById(long id) {
        return getJdbcTemplate().queryForObject(
                "SELECT * FROM users WHERE id = ?",
                new BeanPropertyRowMapper<>(User.class),
                id);
    }
    
    ......
}

    我们可以编写一个样板类，有需要的类从这个样板类继承即拥有了样板类中的SQL操作方法：

public abstract class AbstractDao<T> extends JdbcDaoSupport { //泛型T应该传入记录类的类型
    private String table; //表名
    private RowMapper<T> rowMapper; //保存查询结果

    public AbstractDao() {
        Class<T> entityClass = getParameterizedType(); // 获取当前泛型T的类型
        this.table = entityClass.getSimpleName().toLowerCase() + "s"; //数据库中的表名是"记录类名称 + s"
        this.rowMapper = new BeanPropertyRowMapper<>(entityClass);
    }

    public T getById(long id) {
        return getJdbcTemplate().queryForObject("SELECT * FROM " + table + " WHERE id = ?", this.rowMapper, id);
    }

    public void deleteById(long id) {
        getJdbcTemplate().update("DELETE FROM " + table + " WHERE id = ?", id);
    }

    ...

    private Class getParameterizedType(){
        Type type = getClass().getGenericSuperclass();
        Type[] types = ((ParameterizedType)type).getActualTypeArguments();
        Class<T> clazz = (Class<T>) types[0];
        return clazz;
    }
}


public class User{
    public int id;
    public string name;
    public int age;
    ...
}

@Component
@Transactional
public class UserDao extends AbstractDao<User> {
    // 自动有了下列方法:
    // User getById(long)
    // void deleteById(long)
    //...
}


 public class Book{
    public int id;
    public string name;
    public int pageNum;
    ...
}

@Component
@Transactional
public class BookDao extends AbstractDao<Book> {
    // 自动有了下列方法:
    // Book getById(long)
    // void deleteById(long)
    //...
}

4、总结

   通过Spring JDBC，只需要创建一个JdbcTemplate就可以通过它来执行SQL操作。

   使用Spring JDBC进行SQL查询的话，可以将用来保存查询结果的JavaBean中的属性名（成员名）设置成与数据库表中列名一致，这样可以直接将查询结果保存到JavaBean对象中。

   Spring JDBC支持事务操作。

   DAO模式即根据一定规则编写访问数据库表的类。

milanleon
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Spring JDBC
apmvn的博客
11-10 447
Spring JDBC 四、JdbcTemplate数据查询方法 方法 说明 queryForObject() 查询单条数据 query() 查询复合数据 queryForList() 查询结果转换为List 五、JdbcTemplate实现增删改查 update() 删除、修改、新增 六、Spring 事务管理 1.什么是事务 事务是以一种可靠的、一致的方式，访问和操作数据库的程序单元 说
Spring JDBC常用Jar包
11-20
Spring JDBC是Spring框架的一部分，主要用于简化Java数据库连接操作。它提供了一个抽象层，使得开发者能够以统一的方式处理各种数据库，而无需直接与JDBC API打交道，从而降低了代码的复杂性和错误率。在"Spring ...
Spring-jdbc
m0_53233285的博客
02-20 751
Spring-jdbc Spring的JDBC模块负责数据库资源管理和错误处理，大大简化了开发人员对数据库的操作，使得开发人员可以从繁琐的数据库操作收纳柜解脱出来，从而将更多的精力投入到编写业务逻辑当中。 1.jdbcTemple介绍 可以说，jdbcTemple类是Spring-JDBC的核心类，它提供了大量的更新和查询数据库的方法，我们就是使用这一些方法来操作数据库的。 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kOUQtBDc-1645286527525)(
Spring的数据库编程学习笔记
最新发布
小吴
08-06 994
JDBCTemplate作用针对数据库操作，Spring框架提供了JdbcTemplate类，JdbcTemplate是一个模板类，Spring JDBC中的更高层次的抽象类均在JdbcTemplate模板类的基础上创建。JdbcTemplate类提供了操作数据库的基本方法，包括添加、删除、查询和更新。在操作数据库时，JdbcTemplate类简化了传统JDBC中的复杂步骤，这可以让开发人员将更多精力投入到业务逻辑中。抽象类JdbcAccessor的属性。
Spring之JDBC
m0_58024723的博客
07-16 1365
Spring JDBC是Spring所提供的持久层技术，负责数据库资源和错误处理，降低JDBC API的使用难度，以一种更简洁，更直接的方式使用JDBC API，大大简化了开发人员对数据库的操作。
13_6_Spring JDBCTemplate
qq_37696899的博客
11-13 133
## Spring JDBC * Spring框架对JDBC的简单封装。提供了一个JDBCTemplate对象简化JDBC的开发 * 步骤： 1. 导入jar包 2. 创建JdbcTemplate对象。依赖于数据源DataSource * JdbcTemplate template = new JdbcTemplate(ds); 3. 调用JdbcTemplate的方法来...
SpringJDBC.rar_SpringJDBC_spring jdbc
09-24
通过这个SpringJDBC.rar的案例，初学者可以学习到如何配置DataSource，如何创建JdbcTemplate实例，以及如何编写和执行SQL语句。同时，实践中还可以了解到如何将Spring JDBC整合到Spring Boot项目中，以及如何处理...
springjdbc.zip_SpringJDBC_spring jdbc_spring 增删改查_springjdbc xml
09-20
这个`springjdbc.zip`压缩包很可能包含了示例代码和配置文件，用于演示如何使用Spring JDBC来执行基本的数据库操作，如增、删、改、查。 1. **Spring JDBC模块**：Spring JDBC模块主要由`org.springframework.jdbc`...
springjdbc.rar_SpringJDBC_spring jdbc
09-20
Spring JDBC是Spring框架的一个核心模块，它为Java开发者提供了与数据库交互的能力，简化了传统的JDBC操作。在Spring框架中，Spring JDBC通过提供一个抽象层，使得开发者可以更方便地执行SQL查询，处理结果集，以及...
SpringJDBC.rar_jdbc spring_spring jd_spring jdbc_spring使用JDBC进行数
09-21
这个“SpringJDBC.rar”压缩包文件可能包含了关于如何在Spring框架中集成和使用JDBC的相关示例和教程。下面将详细解释Spring JDBC的核心概念、功能以及使用方法。 首先，Spring JDBC的核心目标是简化传统的JDBC编程...
SpringJDBC
06-01
里面包含对Spring的jDBC的使用方法，包括注解类型及xml类型，包含齐全，包含详细的注释说明，简单易懂
spring JDBC
11-19
springjdbc 详细步骤 教你配置
Spring -- JDBC
Stay Focus
12-05 832
Spring连接数据库的三种方式 1.通过DriverManagerDataSource获取连接对象   这个东西来历可以说一下，JDK中有个接口： 看简介可以得知这是个获取专门生产Connection对象的工厂类，基本上所有框架用来创建数据库连接都会实现这个接口，Spring的jdbc包就实现了这个接口，实现类就是DriverManagerDataSource，在它之前
SpringMVC+Spring+SpringJDBC整合教程
"本文将介绍如何使用Spring MVC、Spring和Spring JDBC进行项目整合，搭建一个基于这三个组件的基础框架。我们将探讨各个组件的作用以及在整合过程中需要注意的配置细节。" Spring MVC是Spring框架的一个模块，专注...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值