Spring Boot 和 JDBCTemplate简介: JDBC Template

Posted 2021-09-14 Java攻城师

与任何编程语言一样，Java有多种工具可以轻松地在语言和数据库之间进行集成。有几种工具，例如Hibernate，Eclipse Link，JPA规范等等。但是，ORM带来了几个问题，有时使用它，然后再将其用于Java Communication层或JDBC并不有意义。本教程将介绍一种使用Spring JDBC模板简化JDBC代码的方法。

诸如ORM之类的映射框架减少了很多样板，减少了重复的代码，避免了错误，并且没有重新发明轮子。但是，当RDBMS由以面向对象的编程语言编写的应用程序提供服务时，经常会遇到对象关系阻抗不匹配的问题，这会带来一系列概念上和技术上的困难。

一个解决方案可能使用JDBC，但是它增加了处理数据和Java的复杂性。应用程序如何减少JDBC的冗长性？Spring JDBCTemplate是一种强大的机制，可以连接到数据库并执行SQL查询。它在内部使用JDBC API，但消除了JDBC API的许多问题。

从Spring Initializr开始

此示例应用程序将结合使用JDBCTemplate和Spring来使用两个数据库：PostgreSQL用于运行该应用程序和H2在测试范围内。对于所有Spring应用程序，您应该从Spring Initializr开始。Initializr提供了一种快速的方法来提取应用程序所需的所有依赖项，并为您完成了许多设置。此示例需要JDBC API，Spring MVC，PostgreSQL驱动程序和H2数据库依赖项。

<dependency> 
    <groupId>org.springframework.boot</groupId> 
    <artifactId>spring-boot-starter-web</artifactId> 
</dependency> 
<dependency> 
    <groupId>org.springframework.boot</groupId> 
    <artifactId>spring-boot-starter-jdbc</artifactId> 
</dependency> 
<dependency> 
    <groupId>org.postgresql</groupId> 
    <artifactId>postgresql</artifactId> 
    <scope>runtime</scope> 
</dependency> 
<dependency> 
    <groupId>com.h2database</groupId> 
    <artifactId>h2</artifactId> 
    <scope>test</scope> 
</dependency> 
<dependency> 
    <groupId>org.springframework.boot</groupId> 
    <artifactId>spring-boot-starter-test</artifactId> 
   <scope>test</scope> 
</dependency> 

下一步是Car实体，其中包含五个字段：id，名称，城市，型号和颜色。在这个项目中，作为贫血模型的POJO足以应付它。丰富的模型可以保证对象的规则并避免任何封装问题，因此，它是防弹API。但是，它仅适用于复杂的项目。突出显示：当我们谈论软件体系结构时，“取决于”始终是一个很好的答案。

public class Car {
    private Long id;
    private String name;
    private String city;
    private String model;
    private String color;
    //...
    public static CarBuilder builder() {
        return new CarBuilder();
    }
}

为了在Java和JDBC的ResultSet之间实现紧密集成，Spring JDBC具有RowMapper接口。开发人员可以创建一个自定义类，也可以使用BeanPropertyRowMapper，从而减少了样板。但是，该实体应具有公共获取者和设置者；除了提供便利而不是高性能之外，它可能还会遇到封装问题。为了获得最佳性能，请考虑使用自定义RowMapper实现。

public class CarRowMapper implements RowMapper<Car> {
    @Override
    public Car mapRow(ResultSet resultSet, int rowNum) throws SQLException {
        Long id = resultSet.getLong("ID");
        String name = resultSet.getString("name");
        String city = resultSet.getString("city");
        String model = resultSet.getString("model");
        String color = resultSet.getString("color");
        return Car.builder().id(id).name(name)
                .city(city)
                .model(model)
                .color(color).build();
    }
}

实体已准备就绪；让我们谈谈数据访问对象DAO；每次要处理庞大或复杂的查询时，都会讨论SQL查询的去向。简而言之，当脚本经过硬编码后，脚本的工作就变得更清楚了，但是当命令量很大时，阅读和理解就变得很有挑战性。因此，我们可以移动它以从属性中读取它。

car.query.find.by.id=SELECT * FROM CAR WHERE ID = :id
car.query.delete.by.id=DELETE FROM CAR WHERE ID =:id
car.query.update=update CAR set name = :name, city = :city, model= :model, color =:color  where id = :id
car.query.find.all=select * from CAR ORDER BY id LIMIT :limit OFFSET :offset

一旦读者熟悉了代码中的查询，我们将在属性文件中探索查询选项。我们将有一个班级来承担这项职责，并且它将与Spring Configuration紧密集成。

@Component
public class CarQueries {
    @Value("${car.query.find.by.id}")
    private String findById;
    @Value("${car.query.delete.by.id}")
    private String deleteById;
    @Value("${car.query.update}")
    private String update;
    @Value("${car.query.find.all}")
    private String findAll;
    //...
}

一旦findAll具有分页支持，则CarDAO将执行CRUD操作。它使用NamedParameterJdbcTemplate对一组基本的JDBC操作进行分类，从而允许使用命名参数而不是传统的“？” 占位符。为了避免连接泄漏，Spring具有Transactional批注，以控制我们在代码中定义的每个方法中的事务。

@Repository
public class CarDAO {
    private final NamedParameterJdbcTemplate template;
    private final CarQueries queries;
    private final RowMapper<Car> rowMapper;
    private final SimpleJdbcInsert insert;
    @Autowired
    public CarDAO(NamedParameterJdbcTemplate template, CarQueries queries) {
        this.template = template;
        //this.rowMapper = new BeanPropertyRowMapper<>(Car.class);
        this.rowMapper = new CarRowMapper();
        this.queries = queries;
        this.insert = new SimpleJdbcInsert(template.getJdbcTemplate());
        this.insert.setTableName("car");
        this.insert.usingGeneratedKeyColumns("id");
    }
    @Transactional
    public Car insert(Car car) {
        //Number id = insert.executeAndReturnKey(new BeanPropertySqlParameterSource(car));
        Number id = insert.executeAndReturnKey(car.toMap());
        return findBy(id.longValue()).orElseThrow(() -> new IllegalStateException(""));
    }
    public Optional<Car> findBy(Long id) {
        String sql = queries.getFindById();
        Map<String, Object> parameters = Collections.singletonMap("id", id);
        return template.queryForStream(sql, parameters, rowMapper).findFirst();
    }
    @Transactional
    public boolean delete(Long id) {
        String sql = queries.getDeleteById();
        Map<String, Object> paramMap = Collections.singletonMap("id", id);
        return template.update(sql, paramMap) == 1;
    }
    @Transactional
    public boolean update(Car car) {
        String sql = queries.getUpdate();
        Map<String, Object> paramMap = car.toMap();
        return template.update(sql, paramMap) == 1;
    }
    public Stream<Car> findAll(Page page) {
        String sql = queries.getFindAll();
        Map<String, Object> paramMap = new HashMap<>();
        paramMap.put("limit", page.getLimit());
        paramMap.put("offset", page.getOffset());
        return template.queryForStream(sql, paramMap, rowMapper);
    }
}

代码已准备就绪；让我们测试一下。Yeap是一种TDD技术，其理念是从测试开始，然后创建代码。但这不是本文的目标。在测试范围内，我们将使用H2在内存中生成一个DBMS。Spring具有多项功能，可让我们顺利进行测试。多亏了Spring，我们可以在测试中使用H2，而不会影响将在生产环境中运行的驱动程序。

@ExtendWith(SpringExtension.class)
@SpringBootTest(webEnvironment = SpringBootTest.WebEnvironment.MOCK)
class CarDAOTest {
    @Autowired
    private CarDAO carDAO;
    @Autowired
    private JdbcTemplate template;
    @Test
    public void shouldFindById() {
        Assertions.assertNotNull(carDAO);
        Optional<Car> car = carDAO.findBy(1L);
        Assertions.assertNotNull(car);
    }
    @Test
    public void shouldInsertCar() {
        Car car = Car.builder()
                .city("Salvador")
                .color("Red")
                .name("Fiat")
                .model("Model")
                .build();
        Car insert = carDAO.insert(car);
        Assertions.assertNotNull(insert);
        Assertions.assertNotNull(insert.getId());
    }
    @Test
    public void shouldDelete() {
        Car car = Car.builder()
                .city("Salvador")
                .color("Red")
                .name("Fiat")
                .model("Model")
                .build();
        Car insert = carDAO.insert(car);
        carDAO.delete(insert.getId());
        Optional<Car> empty = carDAO.findBy(insert.getId());
        Assertions.assertTrue(empty.isEmpty());
    }
    @Test
    public void shouldUpdate() {
        Car car = Car.builder()
                .city("Salvador")
                .color("Red")
                .name("Fiat")
                .model("Model")
                .build();
        Car insert = carDAO.insert(car);
        insert.update(Car.builder()
                .city("Salvador")
                .color("Red")
                .name("Fiat")
                .model("Update")
                .build());
        carDAO.update(insert);
    }
    @Test
    public void shouldFindAll() {
        template.execute("DELETE FROM CAR");
        List<Car> cars = new ArrayList<>();
        for (int index = 0; index < 10; index++) {
            Car car = Car.builder()
                    .city("Salvador")
                    .color("Red")
                    .name("Fiat " + index)
                    .model("Model")
                    .build();
            cars.add(carDAO.insert(car));
        }
        Page page = Page.of(1, 2);
        List<Car> result = carDAO.findAll(page).collect(Collectors.toList());
        Assertions.assertEquals(2, result.size());
        MatcherAssert.assertThat(result, Matchers.contains(cars.get(0), cars.get(1)));
        Page nextPage = page.next();
        result = carDAO.findAll(nextPage).collect(Collectors.toList());
        Assertions.assertEquals(2, result.size());
        MatcherAssert.assertThat(result, Matchers.contains(cars.get(2), cars.get(3)));
    }
}

结论

在本教程中，我们介绍了Spring JDBC及其操作。除了测试和配置资源外，我们还讨论了一些映射折衷以及存储查询的位置。Spring具有一些可提高开发人员生产率的功能。在第二部分中，我们将讨论有关Spring MVC及其在数据库中的工作。Java学习群，免费领取资料：3907814

代码：https : //github.com/xgeekshq/spring-boot-jdbc-template-sample