SpringBoot 學習二：操做數據庫

本文將從如下幾個方面介紹：

前言

配置數據源

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 中，：

在上述中，使用了  StringRedisTemplate 和 RedisTemplate 兩個類：當redis裏面原本存的是字符串數據或者要存取的數據就是字符串類型數據的時候， 就使用 StringRedisTemplate， 當 redis 存儲的是複雜的對象類型，直接從Redis裏面取出一個對象，使用 RedisTemplate

以上就是使用 SpringBoot 整合 Mybatis，整合 Redis，來操做數據庫。