SpringBoot简介及整合数据访问层_springboot数据访问层

Springboot简介

SpringBoot是由Pivotal团队提供的全新框架，其设计目的是用来简化Spring应用的初始搭建以及开发过程。Spring Boot 为简化 Spring 应用开发而生，Spring Boot 中的 Boot 一词，即为快速启动的意思。Spring Boot 可以在零配置情况下一键启动，简洁而优雅。

SpringBoot程序的核心功能及优点：

1. 简化依赖，提供整合的依赖项，告别逐一添加依赖项的烦恼；
2. 简化配置，提供约定俗成的默认配置，告别编写各种配置的繁琐；
3. 简化部署，内置 servlet 容器，开发时一键即运行。可打包为 jar 文件，部署时一行命令即启动；
4. 简化监控，提供简单方便的运行监控方式。

基于以上设计目的，Spring 团队推出了 Spring Boot 。

parent

SpringBoot关注到开发者在进行开发时，往往对依赖版本的选择具有固定的搭配格式，并且这些依赖版本的选择还不能乱搭配。比如A技术的2.0版与B技术的3.5版可以合作在一起，但是和B技术的3.7版合并使用时就有冲突。SpringBoot做了无数个技术版本搭配的列表，这个技术搭配列表的名字叫做parent。
使用parent可以帮助开发者进行版本的统一管理
它在springboot中是通过如下方式实现的：

• 项目中的pom.xml中继承了一个坐标

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-parent</artifactId>
    <version>2.5.4</version>
</parent>
1
2
3
4
5

• 打开后可以查阅到其中又继承了一个坐标

<parent>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-dependencies</artifactId>
    <version>2.5.4</version>
</parent>
1
2
3
4
5

• 这个坐标中定义了两组信息，第一组是各式各样的依赖版本号属性，其中定义了若干个技术的依赖版本号；第二组是各式各样的的依赖坐标信息，依赖坐标定义中没有具体的依赖版本号，而是引用了第一组信息中定义的依赖版本属性值。

总结

1. 开发SpringBoot程序要继承spring-boot-starter-parent
2. spring-boot-starter-parent中定义了若干个依赖管理
3. 继承parent模块可以避免多个依赖使用相同技术时出现依赖版本冲突
4. 继承parent的形式也可以采用引入依赖的形式实现效果

starter

SpringBoot关注到开发者在实际开发时，对于依赖坐标的使用往往都有一些固定的组合方式，比如使用spring-webmvc就一定要使用spring-web。每次都要固定搭配着写，非常繁琐，而且格式固定，没有任何技术含量。starter定义了使用某种技术时对于依赖的固定搭配格式，是一种最佳解决方案，使用starter可以帮助开发者减少依赖配置。

• 项目中的pom.xml定义了使用SpringMVC技术，但是并没有写SpringMVC的坐标，而是添加了一个名字中包含starter的依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>
1
2
3
4

• 在spring-boot-starter-web中又定义了若干个具体依赖的坐标

starter与parent的区别

​ 朦朦胧胧中感觉starter与parent好像都是帮助我们简化配置的，但是功能又不一样，梳理一下。

​ starter是一个坐标中定了若干个坐标，以前写多个的，现在写一个，是用来减少依赖配置的书写量的

​ parent是定义了几百个依赖版本号，以前写依赖需要自己手工控制版本，现在由SpringBoot统一管理，这样就不存在版本冲突了，是用来减少依赖冲突的

总结

1. 开发SpringBoot程序需要导入坐标时通常导入对应的starter
2. 每个不同的starter根据功能不同，通常包含多个依赖坐标
3. 使用starter可以实现快速配置的效果，达到简化配置的目的

引导类

SpringBoot本身是为了加速Spring程序的开发的，而Spring程序运行的基础是需要创建自己的Spring容器对象（IoC容器）并将所有的对象交给Spring的容器管理，也就是一个一个的Bean。在SpringBoot中，当前这个类运行后就会产生一个Spring容器对象，并且可以将这个对象保存起来，通过容器对象直接操作Bean。

@SpringBootApplication
public class Springboot0101QuickstartApplication {
    public static void main(String[] args) {
        ConfigurableApplicationContext ctx = SpringApplication.run(Springboot0101QuickstartApplication.class, args);
        BookController bean = ctx.getBean(BookController.class);
        System.out.println("bean======>" + bean);
    }
}
1
2
3
4
5
6
7
8

​ 通过上述操作不难看出，其实SpringBoot程序启动还是创建了一个Spring容器对象。这个类在SpringBoot程序中是所有功能的入口，称这个类为引导类。

​ 作为一个引导类最典型的特征就是当前类上方声明了一个注解@SpringBootApplication

总结

1. SpringBoot工程提供引导类用来启动程序
2. SpringBoot工程启动后创建并初始化Spring容器

Springboot整合mybatis

1. 导入mybatis-spring-boot-starter以及mysql-connector坐标

<dependency>
     <groupId>org.mybatis.spring.boot</groupId>
     <artifactId>mybatis-spring-boot-starter</artifactId>
     <version>2.1.2</version>
 </dependency>

 <dependency>
     <groupId>com.mysql</groupId>
     <artifactId>mysql-connector-j</artifactId>
     <scope>runtime</scope>
 </dependency>
1
2
3
4
5
6
7
8
9
10
11

2. 编写数据源相关信息

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/fruitdb
spring.datasource.username=root
spring.datasource.password=123456
1
2
3
4

3. 编写实体类（pojo）

public class Fruit {
    private Integer fid;
    private String fname;
    private Integer price;
    private Integer fcount;
    private String remark;
	// constructor
	// getter和setter
}
1
2
3
4
5
6
7
8
9

4. mapper接口类（操作数据）

@Mapper
@Repository
public interface FruitDao {
    @Select("select * from t_fruit where fid = #{fid}")
    public Fruit getFruitById(Integer fid);
}
1
2
3
4
5
6

5. 测试

@SpringBootTest
class SpringbootMybatisApplicationTests {
    @Autowired
    private FruitDao fruitDao;

    @Test
    void contextLoads() {
        System.out.println(fruitDao.getFruitById(2).toString());
    }
}
1
2
3
4
5
6
7
8
9
10

Springboot整合mybatis-plus

1. 导入mybatis-plus坐标

 <dependency>
     <groupId>com.baomidou</groupId>
     <artifactId>mybatis-plus-boot-starter</artifactId>
     <version>3.4.3</version>
 </dependency>
1
2
3
4
5

2. 配置数据源信息

spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.url=jdbc:mysql://localhost:3306/fruitdb
spring.datasource.username=root
spring.datasource.password=123456

# 数据库表名前缀t_（设置所有表名的通用前缀名）
mybatis-plus.global-config.db-config.table-prefix=t_
1
2
3
4
5
6
7

3. 编写映射接口类

@Mapper
public interface BookDao extends BaseMapper<Book> {
}
1
2
3

核心在于Dao接口继承了一个BaseMapper的接口，这个接口中帮助开发者预定了若干个常用的API接口，简化了通用API接口的开发工作。

Springboot整合Druid

1. 导入starter坐标

<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>druid-spring-boot-starter</artifactId>
    <version>1.2.6</version>
</dependency>
1
2
3
4
5

2. 编写配置文件，修改配置

spring.datasource.druid.driver-class-name=com.mysql.cj.jdbc.Driver
spring.datasource.druid.url=jdbc:mysql://localhost:3306/fruitdb
spring.datasource.druid.username=root
spring.datasource.druid.password=123456
1
2
3
4

Springboot整合Redis

1. 导入redis坐标

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>
1
2
3
4

2. 编写redis数据库连接配置

spring:
	redis:
    database: 0
    host: 127.0.0.1
    port: 6379
    password: xxxxx
1
2
3
4
5
6

3. 编写redis核心配置类（返回redisTemplate）

@Configuration
public class RedisConfig {
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {
        RedisTemplate<String, Object> template = new RedisTemplate<>();
        // 创建redis的连接
        template.setConnectionFactory(factory);

        // 设置key的序列化方式
        template.setKeySerializer(RedisSerializer.string());
        // 设置value的序列化方式
        template.setValueSerializer(RedisSerializer.json());
        // 设置hash的key的序列化方式
        template.setHashKeySerializer(RedisSerializer.string());
        // 设置hash的value的序列化方式
        template.setHashValueSerializer(RedisSerializer.json());

		// 确保RedisTemplate对象的正确初始化
        template.afterPropertiesSet();
        return template;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

4. 利用模板类RedisTemplate操作redis

public class RedisTests {
    @Autowired
    private RedisTemplate redisTemplate;

    @Test
    public void testString() {
        String redisKey = "test:count";

        redisTemplate.opsForValue().set(redisKey, 1);

        System.out.println(redisTemplate.opsForValue().get(redisKey));
        System.out.println(redisTemplate.opsForValue().increment(redisKey));
        System.out.println(redisTemplate.opsForValue().decrement(redisKey));
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

yml格式的基本配置

项目基本配置（application.yml）：

server:
  port: 8080
spring:
  application:
    name: springcache_demo
  datasource:
    druid:
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://localhost:3306/fruitdb?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull&useSSL=false&allowPublicKeyRetrieval=true
      username: root
      password: 123456
  redis:
    host: localhost
    port: 6379
    password: 123456
    database: 0
  cache:
    redis:
      time-to-live: 1800000   #设置缓存过期时间，可选
mybatis-plus:
  configuration:
    #在映射实体或者属性时，将数据库中表名和字段名中的下划线去掉，按照驼峰命名法映射
    map-underscore-to-camel-case: true
    log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
  global-config:
    db-config:
      id-type: ASSIGN_ID
#      table-prefix: t_			# 设置表名前缀

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29