本文将从以下几个方面介绍：

前言

配置数据源

SpringBoot 整合 Mybatis

SpringBoot 整合 JdbcTemplate

SpringBoot 整合 Redis



前言

在上篇文章 SpringBoot 学习一 中已经学习了 SpringBoot的相关基础知识，今天就来使用 SpringBoot 来操作下数据库，使用 SpringBoot 整合 Mybatis 来操作数据库，使用 Spring 提供的 JdbcTemplate 来操作数据库，使用 SpringBoot 来操作下 Redis等。



配置数据源

使用 SpringBoot 来操作数据库，首先需要进行配置数据源，SpringBoot 配置数据源有两种方式：①：使用 properties 配置文件进行配置默认的数据源；②：使用注解的方式进行配置



1️⃣： properties方式：

使用  properties 方式进行配置数据源的时候，springboot会直接在容器中构建一个dataSource供我们使用。使用方式如下：

a：在 application.properties 配置文件中添加相关的配置项即可，

spring.datasource.url=jdbc:mysql://localhost:3306/tsmyk?userUnicode=true&characterEncoding=utf8
spring.datasource.username=root
spring.datasource.password=root
spring.datasource.driver-class-name=com.mysql.jdbc.Driver

b: 单元测试下：

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = MyspringbootApplication.class)
public class TestDataSource {

    @Autowired
    private ApplicationContext applicationContext;

    @Test
    public void test(){
        DataSource dataSource = applicationContext.getBean(DataSource.class);
        System.out.println(dataSource);
        //[defaultAutoCommit=null; defaultReadOnly=null; defaultTransactionIsolation=-1;
        // defaultCatalog=null; driverClassName=com.mysql.jdbc.Driver; maxActive=100;
        // maxIdle=100; minIdle=10; initialSize=10; maxWait=30000;
        // testOnBorrow=false; testOnReturn=false;
        // timeBetweenEvictionRunsMillis=5000; numTestsPerEvictionRun=0;
        // minEvictableIdleTimeMillis=60000; testWhileIdle=false; testOnConnect=false;
        // password=********;
        // url=jdbc:mysql://localhost:3306/tsmyk?userUnicode=true&characterEncoding=utf8;
        // username=root
        // ................
    }
}



2️⃣：使用注解的方式配置数据源

使用这种方式比较灵活，还可以配置多个数据源，使用方式如下：

a: 创建一个配置类，通过 @Configuration 注解进行配置

@Configuration
public class DataSourceConfig {

    @Bean(name = "firstDataSource")
    @Qualifier("firstDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.first")
    public DataSource firstDataSource(){
        return DataSourceBuilder.create().build();
    }
}

之后在 application.properties 文件中添加相关的值：



spring.datasource.first.url=jdbc:mysql://localhost:3306/tsmyk?userUnicode=true&characterEncoding=utf8 spring.datasource.first.username=root spring.datasource.first.password=root spring.datasource.first.driver-class-name=com.mysql.jdbc.Driver



3️⃣：配置多个数据源：

@Configuration
public class DataSourceConfig {

    /**
     * 第一个数据源
     * @return DataSource
     */
    @Bean(name = "firstDataSource")
    @Qualifier("firstDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.first")
    @Primary // 首先选择该数据源
    public DataSource firstDataSource(){
        return DataSourceBuilder.create().build();
    }

    /**
     * 第二个数据源
     * @return DataSource
     */
    @Bean(name = "secondDataSource")
    @Qualifier("secondDataSource")
    @ConfigurationProperties(prefix = "spring.datasource.second")
    public DataSource secondDataSource(){
        return DataSourceBuilder.create().build();
    }

    /**
     * 配置了第一个数据源的 JdbcTemplate
     * @param dataSource ds
     * @return JdbcTemplate
     */
    @Bean(name = "firstJdbcTemplate")
    public JdbcTemplate firstJdbcTemplate(@Qualifier("firstDataSource") DataSource dataSource){
        return new JdbcTemplate(dataSource);
    }

    /**
     * 配置了第一个数据源的 JdbcTemplate
     * @param dataSource ds
     * @return JdbcTemplate
     */
    @Bean(name = "secondJdbcTemplate")
    public JdbcTemplate secondJdbcTemplate(@Qualifier("secondDataSource") DataSource dataSource){
        return new JdbcTemplate(dataSource);
    }
}

在 application.properties 配置文件中配置多个数据源的相关值：



# 多数据源配置 spring.datasource.first.url=jdbc:mysql://localhost:3306/tsmyk?userUnicode=true&characterEncoding=utf8 spring.datasource.first.username=root spring.datasource.first.password=root spring.datasource.first.driver-class-name=com.mysql.jdbc.Driver spring.datasource.second.url=jdbc:mysql://localhost:3306/tsmyk2?userUnicode=true&characterEncoding=utf8 spring.datasource.second.username=root spring.datasource.second.password=root spring.datasource.second.driver-class-name=com.mysql.jdbc.Driver



SpringBoot 整合 Mybatis

在上面配置了数据源之后，接下来整合 SpringBoot 和 Mybatis，SpringBoot 通过 Mybatis 操作数据也有两种方式：①：通过注解的方式；②：通过配置文件的方式，具体操作如下：



1️⃣：通过注解的方式

通过注解的方式，SQL 通过注解写在对应的方法上面，不在需要额外的 mapper 文件，个人感觉，使用这种方式，书写简单的 SQL 还是不错的，如果遇到一些复杂的 SQL ，就有点不太灵活，不美观，可读性比较差，对于以后不太好维护，使用方式如下：

通过 @Mapper 注解标注在对于的接口上，也可以在配置类上使用 @MapperScan 来配置扫描路径扫描所有的接口，而不用在每个接口上标注 @Mapper 注解

@Mapper
public interface PersonMapper {

    @Insert("insert into person (id, name, age, job) values (#{id}, #{name}, #{age}, #{job})")
    void add(Person person);

    @Delete("delete from person where id = #{id}")
    void delete(@Param("id") int id);

    @Update("update person set name = #{name} where id = #{id}")
    void update(@Param("id") int id, @Param("name") String name);

    @Select("select * from person where name = #{name}")
    Person queryByName(@Param("name") String name);

    @Select("select * from person")
    List<Person> queryAll();
}

使用：

@Autowired
    private PersonMapper personMapper;

    @Test
    public void testAdd(){
        Person person = new Person(13, "RRR", "会计", 22);
        personMapper.add(person);
    }

    @Test
    public void testDelete(){
        personMapper.delete(12);
    }

    @Test
    public void testUpdate(){
        personMapper.update(13, "TTT");
    }

    @Test
    public void testQuery(){
        Person person = personMapper.queryByName("TTT");
        System.out.println(person);
    }

    @Test
    public void testQueryAll(){
        List<Person> persons = personMapper.queryAll();
        persons.stream().forEach((p) -> System.out.println(p));
    }



2️⃣：使用配置文件的方式

使用配置文件的方式，对于个人来说，可读性要好些，SQL 和代码分开，便于维护，使用方式如下：

首先还是需要定义接口：也是使用 @Mapper 或 @MapperScan 标注

@Mapper
public interface PersonMapper2 {

    void add(Person person);

    void delete(@Param("id") int id);

    void update(Person person);

    Person queryByName(@Param("name") String name);

    List<Person> queryAll();
}

然后定义配置文件：

<mapper namespace = "myspringboot.myspringboot.db.mybatis.PersonMapper2">

    <insert id="add" parameterType="myspringboot.myspringboot.pojo.Person">
        insert into person (id, name, age, job) values (#{id}, #{name}, #{age}, #{job})
    </insert>

    <delete id="delete" parameterType="int">
        delete from person where id = #{id}
    </delete>

    <update id="update" parameterType="myspringboot.myspringboot.pojo.Person">
        update person set name = #{name} where id = #{id}
    </update>

    <select id = "queryByName" resultMap = "result">
        SELECT * FROM person where name = #{name}
    </select>

    <select id="queryAll" resultMap = "result">
        select * from person
    </select>

</mapper>

之后，需要在 application.properties 配置文件中配置配置文件所在的路径：



# mybatis mybatis.mapperLocations=classpath:mapper/*.xml mybatis.typeAliasesPackage=myspringboot.myspringboot.pojo



注意，可能需要在 pom.xml 添加如下信息：

<build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>mapper/*.xml</include>
                </includes>
                <filtering>false</filtering>
            </resource>
        </resources>
    </build>

通过以上两种方法，可以通过 SpringBoot 整合 Mybatis 来操作数据库。



SpringBoot 整合 JdbcTemplate

还可以使用 Spring 自带的 JdbcTemplate 来操作数据库，在上面配置数据源小节中，已经配置的 JdbcTemplate，之后可以通过如下方式进行使用：

@Service
public class PersonServiceImpl implements PersonService {

    @Autowired
    @Qualifier("firstJdbcTemplate")
    private JdbcTemplate jdbcTemplate;

    @Override
    public void addPerson(Person person) {
        jdbcTemplate.update("insert into person (id, name, age, job) values (?, ?, ?, ?)",
                person.getId(), person.getName(), person.getAge(), person.getJob());
    }
}



SpringBoot 整合 Redis

还可以使用 SpringBoot 整合 Redis，对 Redis 进行操作：具体方式如下：

首先，需要在的 application.properties 配置文件中配置 redis 一些配置项：

# redis
# Redis数据库索引（默认为0）
spring.redis.database=0
# Redis服务器地址
spring.redis.host=localhost
# Redis服务器连接端口
spring.redis.port=6379
# Redis服务器连接密码（默认为空）
spring.redis.password=
# 连接池最大连接数（使用负值表示没有限制）
spring.redis.pool.max-active=8
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.pool.max-wait=-1
# 连接池中的最大空闲连接
spring.redis.pool.max-idle=8
# 连接池中的最小空闲连接
spring.redis.pool.min-idle=0
# 连接超时时间（毫秒）
spring.redis.timeout=0

然后，如果 Redis 中存储的数据有对象的话，需要对对象进行序列化和反序列化，所以可以定义一个序列化和反序列化的操作：

/**
 * redis 对象序列化
 */
public class RedisObjectSerializer implements RedisSerializer<Object> {

    @Override
    public byte[] serialize(Object o) throws SerializationException {
        if(o == null){
            return new byte[0];
        }
        try {
            return new SerializingConverter().convert(o);
        }catch (Exception e){
            return new byte[0];
        }
    }

    @Override
    public Object deserialize(byte[] bytes) throws SerializationException {
        if (bytes == null || bytes.length == 0){
            return null;
        }
        try {
            return new DeserializingConverter().convert(bytes);
        }catch (Exception e){
            throw new SerializationException("反序列化失败.", e);
        }
    }
}

之后，配置 Redis 数据源，使用 RedisTemplate 来操作 Redis 

@Configuration
public class RedisConfig {

    @Bean
    JedisConnectionFactory jedisConnectionFactory(){
        return new JedisConnectionFactory();
    }

    @Bean
    public RedisTemplate<String, Person> redisTemplate(RedisConnectionFactory factory){
        RedisTemplate<String, Person> template = new RedisTemplate<>();
        template.setConnectionFactory(jedisConnectionFactory());
        template.setKeySerializer(new StringRedisSerializer());
        template.setValueSerializer(new RedisObjectSerializer());
        return template;
    }
}

最后，单元测试下：

@RunWith(SpringJUnit4ClassRunner.class)
@SpringBootTest(classes = MyspringbootApplication.class)
public class RedisTest {

    @Autowired
    private StringRedisTemplate stringRedisTemplate;

    @Autowired
    private RedisTemplate<String, Person> redisTemplate;

    @Test
    public void test(){
        // 保存字符串
        stringRedisTemplate.opsForValue().set("myk", "tsmyk0715");
        String val = stringRedisTemplate.opsForValue().get("myk");
        System.out.println(val); // tsmyk0715
        Assert.assertEquals("tsmyk0715", val);

        // 保存对象
        Person person1 = new Person(100, "tsmyk1", "java dev1", 25);
        redisTemplate.opsForValue().set(String.valueOf(person1.getId()), person1);

        Person person2= new Person(200, "tsmyk2", "java dev2", 26);
        redisTemplate.opsForValue().set(String.valueOf(person2.getId()), person2);

        Person dbVal = redisTemplate.opsForValue().get("100");
        System.out.println(dbVal); //Person(id=100, name=tsmyk1, job=java dev1, age=25)
        Assert.assertEquals("tsmyk1", dbVal.getName()); 

        dbVal = redisTemplate.opsForValue().get("200");
        System.out.println(dbVal); // Person(id=200, name=tsmyk2, job=java dev2, age=26)
        Assert.assertEquals(26, dbVal.getAge());
    }
}

看下 redis 中的数据，数据已经被存入 redis 中，：

springboot设置mysql数据库 springboot如何操作数据库_数据库

在上述中，使用了  StringRedisTemplate 和 RedisTemplate 两个类：当redis里面本来存的是字符串数据或者要存取的数据就是字符串类型数据的时候， 就使用 StringRedisTemplate， 当 redis 存储的是复杂的对象类型，直接从Redis里面取出一个对象，使用 RedisTemplate

以上就是使用 SpringBoot 整合 Mybatis，整合 Redis，来操作数据库。