文档章节

SpringBoot 学习二:操作数据库

TSMYK
 TSMYK
发布于 2018/09/26 20:48
字数 1929
阅读 620
收藏 34

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

前言

配置数据源

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,来操作数据库。

 

© 著作权归作者所有

TSMYK
粉丝 100
博文 84
码字总数 207005
作品 0
成都
程序员
私信 提问
Spring Boot学习笔记

多模块开发 [SpringBoot学习]-IDEA创建Gradle多Module结构的SpringBoot项目 RabbitMQ RabbitMQ 安装 linux安装RabbitMQ详细教程 Ubuntu 16.04 RabbitMq 安装与运行(安装篇) ubantu安装...

OSC_fly
2018/07/26
0
0
是大三的我对大二的学弟要求高了吗?

目前我大三,学校四年制,在学校的一个校企合作公司实习。 先说一下我这三年都干了什么,然后再说我遇到的问题吧。 写着写着发现写得太长了,就单独提取出来放到另外一篇文章了:https://www...

侯坤林
2018/04/25
6.2K
47
SpringBoot入门-整合H2测试Mybits DAO

声明:原创文章,转载请注明出处。http://www.jianshu.com/p/43ade838dcc0 本文代码地址:https://github.com/hawkingfoo/java-web 一、概述 上一节中,我们分享了SpringBoot快速整合Mybits的...

唐影若凡
2018/07/04
0
0
springboot dubbox 实例

---------------------------------------------------------------------------------------------------------------- springboot 详解 (一) helloworld 下载demo springboot 详解 (二)......

curiousby
2017/01/19
0
0
新项目技术栈落地(二)——SpringMVC+Spring和SpringBoot的选择

使用SpringBoot进行项目开发已经是大势所趋,但在这里还是要说明为什么选择SpringBoot,选择SpringBoot带来的好处和SpringBoot注意的一些问题。 首先SpringBoot并不是一门新技术而是spring开...

Skqing
03/19
226
0

没有更多内容

加载失败,请刷新页面

加载更多

Experts say the weaker pound is drawing investors to the UK tech sector

UK tech companies secured a record £5.5bn in foreign investment in the first seven months of this year, research shows. This was more than the amount invested per capita in th......

wowloop
5分钟前
1
0
Add support for Android 9-patch images in BorderImage

The 9-patch image implementation in Qt Quick Controls 1 is an internal implementation detail of the Android style. It cannot handle .9.png image files out of the box, but takes ......

shzwork
10分钟前
2
0
c/c++日期时间处理函数小结

日期时间处理函数: 日期时间转为字符串 strftime/std::put_time 字符串解析成日期时间 strptime/std::get_time 时间结构转换:time_t->tm localtime:time_t->tm 时间结构转换:tm->time_t ...

chuqq
14分钟前
3
0
Apache Flink 进阶入门(二):Time 深度解析

前言 Flink 的 API 大体上可以划分为三个层次:处于最底层的 ProcessFunction、中间一层的 DataStream API 和最上层的 SQL/Table API,这三层中的每一层都非常依赖于时间属性。时间属性是流处...

大涛学长
15分钟前
2
0
创龙基于Xilinx Artix-7系列FPGA处理器

SOM-TLA7是一款由广州创龙基于Xilinx Artix-7系列FPGA自主研发的核心板,可配套广州创龙Artix-7开发板使用。核心板尺寸仅70mm*50mm,采用沉金无铅工艺的10层板设计,专业的PCB Layout保证信号...

Tronlong创龙
21分钟前
4
0

没有更多内容

加载失败,请刷新页面

加载更多

返回顶部
顶部