SpringBoot 整合 JdbcTemplate（配置多数据源）

数据持久化有几个常见的方案，有 Spring 自带的 JdbcTemplate 、有 MyBatis，还有 JPA，在这些方案中，最简单的就是 Spring 自带的 JdbcTemplate 了，这个东西虽然没有 MyBatis 那么方便，但是比起最开始的 Jdbc 已经强了很多了，它没有 MyBatis 功能那么强大，当然也意味着它的使用比较简单，事实上，JdbcTemplate 算是最简单的数据持久化方案了

一、创建一个 SpringBoot 项目

选择基本的 Web 依赖，再记得选上 Jdbc 依赖，以及数据库驱动依赖即可

项目创建成功之后，记得添加 Druid 数据库连接池依赖（注意这里可以添加专门为 Spring Boot 打造的 druid-spring-boot-starter，而不是我们一般在 SSM 中添加的 Druid），所有添加的依赖如下：

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.1.10</version>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.27</version>
    <scope>runtime</scope>
</dependency>

在 application.properties 中提供数据的基本配置

spring.datasource.type=com.alibaba.druid.pool.DruidDataSource
spring.datasource.username=root
spring.datasource.password=123
spring.datasource.url=jdbc:mysql:///test01?useUnicode=true&characterEncoding=UTF-8

二、CRUD测试

①、创建Bean

public class User {
    private Long id;
    private String username;
    private String address;
    //省略getter/setter
}

②、创建Service，注入JdbcTemplate

@Service
public class UserService {
    @Autowired
    JdbcTemplate jdbcTemplate;
}

③、CRUD

JdbcTemplate 中，除了查询有几个 API 之外，增删改统一都使用 update 来操作，自己来传入 SQL 即可。
update 方法的返回值就是 SQL 执行受影响的行数

//简单添加
public int addUser(User user){
	return jdbcTemplate.update("insert into user (username,address) values (?,?);", user.getUsername(), user.getAddress());
}

/**
	复杂添加：相当于完全使用了 JDBC 中的解决方案
	构建 PreparedStatement 时传入 Statement.RETURN_GENERATED_KEYS，然后传入 KeyHolder，
	最终从 KeyHolder 中获取刚刚插入数据的 id 保存到 user 对象的 id 属性中去
*/
public int addUser2(){
	
	KeyHolder keyHolder = new GeneratedKeyHolder();
	int update = jdbcTemplate.update(new PreparedStatementGreator(){
		@Override
		public PreparedStatement createPreparedStatement(Connection connection) throws SQLException {
			PreparedStatement ps = connection.prepareStatement("insert into user (username,address) values (?,?);",
																 Statement.RETURN_GENERATED_KEYS);
            ps.setString(1, user.getUsername());
            ps.setString(2, user.getAddress());
            return ps;
		}
	},keyHolder);
	
	user.setId(keyHolder.getKey().longValue());
	System.out.println(user);
	return update;
}

//删除
public int deleteUserById(Long id){
	return jdbcTemplate.update("delete from user where id = ?",id);
}

//改
public int updateUserById(User user){
	return jdbcTemplate.update("update user set username=?,address=? where id=?",
		user.getUsername(),user.getAddress(),user.getId());
}

/**
	查询的时候需要提供一个 RowMapper，就是需要自己手动映射，将数据库中的字段和对象的属性一一对应起来
*/
public List<User> getAllUsers(){
	
	return jdbcTemplate.query("select * from user",new RowMapper<User>(){
		@Override
		public User mapRow(ResultSet resultSet, int i) throws SQLException {
			String username = resultSet.getString("username");
            String address = resultSet.getString("address");
            long id = resultSet.getLong("id");
            User user = new User();
            user.setAddress(address);
            user.setUsername(username);
            user.setId(id);
            return user;
		}
	});
}

//如果数据库中的字段和对象属性的名字一模一样的话，有另外一个简单的方案
//查询时候传参也是使用占位符，这个和前文的一致
public List<User> getAllUser2(){
	return jdbcTemplate.query("select * from user",new BeanPropertyRowMapper<>(User.class));
}

==========================================================

多数据源

一、创建工程（选择 Web、Jdbc 以及 MySQL 驱动）

手动添加 Druid 依赖，由于这里一会需要开发者自己配置 DataSoruce，所以这里必须要使用 druid-spring-boot-starter 依赖，而不是传统的那个 druid 依赖。
因为 druid-spring-boot-starter 依赖提供了 DruidDataSourceBuilder 类，这个可以用来构建一个 DataSource 实例，而传统的 Druid 则没有该类。

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-jdbc</artifactId>
</dependency>
<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
<dependency>
    <groupId>mysql</groupId>
    <artifactId>mysql-connector-java</artifactId>
    <version>5.1.28</version>
    <scope>runtime</scope>
</dependency>
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.1.10</version>
</dependency>

二、配置数据源

配置两个数据源

spring.datasource.one.url=jdbc:mysql:///test01?useUnicode=true&characterEncoding=utf-8
spring.datasource.one.username=root
spring.datasource.one.password=root
spring.datasource.one.type=com.alibaba.druid.pool.DruidDataSource

spring.datasource.two.url=jdbc:mysql:///test02?useUnicode=true&characterEncoding=utf-8
spring.datasource.two.username=root
spring.datasource.two.password=root
spring.datasource.two.type=com.alibaba.druid.pool.DruidDataSource

加了 one 和 two 之后，这里的配置就没法被 SpringBoot 自动加载了（因为前面的 key 变了）
需要我们自己去加载 DataSource 了，此时，需要自己配置一个 DataSourceConfig，用来提供两个 DataSource Bean

@Configuration
public class DataSourceConfig{
	
	@Bean
	@ConfigurationProperties(prefix="spring.datasource.one")//@ConfigurationProperties 是 Spring Boot 提供的类型安全的属性绑定
	DataSource dsOne(){ //表示使用 spring.datasource.one 前缀的数据库配置去创建一个 DataSource
		return DruidDataSourceBuilder.create().build();
	}

	@Bean
	@ConfigurationProperties(prefix="spring.datasource.two")
	DataSource dsTwo(){
		return DruidDataSourceBuilder.create().build();
	}
}

三、配置JdbcTemplate实例

每一个 JdbcTemplate 的创建都需要一个 DataSource，由于 Spring 容器中现在存在两个 DataSource，默认使用类型查找，会报错，因此加上 @Qualifier 注解，表示按照名称查找

@Configuration
public class JdbcTemplate{
	
	@Bean
	JdbcTemplate jdbcTemplateOne(@Qualifier("dsOne") DataSource dsOne){
		return new JdbcTemplate(dsOne);
	}

	@Bean
	JdbcTemplate jdbcTemplateTwo(@Qualifier("dsTwo") DataSource dsTwo){
		return new JdbcTemplate(dsTwo);
	}
}

四、测试

@RestController
public class HelloController{
	
	// @Autowired 注解加上 @Qualifier 注解，两者联合起来，实际上也是 byName
	@Autowired
	@Qualifier("jdbcTemplateOne")
	JdbcTemplate jdbcTemplateOne;

	//使用 @Resource 注解，直接通过 byName 的方式注入进来
	@Resource(name="jdbcTemplateTwo")
	JdbcTemplate jdbcTemplateTwo;

	@GetMapping("/user")
	public List<User> getAllUser(){
		List<User> list = jdbcTemplateOne.query("select * from t_user", new BeanPropertyRowMapper<>(User.class));
        return list;
	}

	@GetMapping("/user2")
    public List<User> getAllUser2() {
        List<User> list = jdbcTemplateTwo.query("select * from t_user", new BeanPropertyRowMapper<>(User.class));
        return list;
    }
}