实用开发篇-SpringBoot 数据层解决方案学习

数据层解决方案

  • 1. SQL解决方案
    • 1.1 数据源配置格式
    • 1.2 内置持久化解决方案——JdbcTemplate**
    • 1.3 内嵌数据库
  • 2. NoSQL解决方案
    • 2.1 Redis
      • SpringBoot整合Redis
        • 客户端:RedisTemplate以对象作为key和value,内部对数据进行序列化
        • 客户端:StringRedisTemplate以字符串作为key和value,与Redis客户端操作等效(常用)
      • SpringBoot整合Redis客户端选择
    • 2.2 Mongodb
      • Mongodb基础CRUD
        • 新增
        • 修改
        • 删除
        • 查询
          • 1.基础查询
          • 2.条件查询
      • SpringBoot整合Mongodb
    • 2.3 Elasticsearch(ES)
      • Elasticsearch增删改查(文档操作)
      • Spring整合Elasticsearch客户端(low)
      • 手动操作客户端初始化
      • Java代码实现

1. SQL解决方案

  • 现有数据层解决方案技术选型

Druid + MyBatis-Plus + MySQL

          ♦数据源:DruidDataSource
          ♦持久化技术:MyBatis-Plus / MyBatis
          ♦数据库: MySQL

实用开发篇-SpringBoot 数据层解决方案学习_第1张图片

1.1 数据源配置格式

  • 格式一
spring:
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/ssm_db?serverTimezone=UTC
    username: root
    password: root
    type: com.alibaba.druid.pool.DruidDataSource
  • 格式二
spring:
  datasource:
    druid:
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://localhost:3306/ssm_db?serverTimezone=UTC
      username: root
      password: root
  • SpringBoot提供了3种内嵌的数据源对象供开发者选择
              ♦ HikariCP:默认内置数据源对象
              ♦ Tomcat提供DataSource:HikariCP不可用的情况下,且在web环境中,将使用Tomcat服务器配置的数据源对象
              ♦ Commons DBCP:HikarI不可用,tomcat数据源也不用,将使用dbcp数据源
spring:
  datasource:
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://localhost:3306/ssm_db?serverTimezone=UTC
      username: root
      password: root
  • 通用配置无法设置具体的数据源配置信息,仅提供基本的连接相关配置,如需配置,在下一级配置中设置具体设定
spring:
  datasource:
      driver-class-name: com.mysql.cj.jdbc.Driver
      url: jdbc:mysql://localhost:3306/ssm_db?serverTimezone=UTC
      username: root
      password: root
      hikari:
        maximum-pool-size: 50

1.2 内置持久化解决方案——JdbcTemplate**

使用JdbcTemplate需要导入

<dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-jdbcartifactId>
dependency>

代码

@Test
    void test() {
        String sql = "select * from tbl_book where id = 1";
        List<Book> qurey = jdbcTemplate.query(sql, new RowMapper<Book>() {

            @Override
            public Book mapRow(ResultSet rs, int rowNum) throws SQLException {
                Book temp = new Book();
                temp.setId(rs.getInt("id"));
                temp.setName(rs.getString("name"));
                temp.setType(rs.getString("type"));
                temp.setDescription(rs.getString("description"));
                return temp;
            }
        });
        System.out.println(qurey);
    }

配置

spring:
  jdbc:
    template:
      query-timeout:  -1 #查询超时时间
      max-rows: 500       #最大行数
      fetch-size: -1      #批处理数量

1.3 内嵌数据库

  • SpringBoot提供了3种内嵌数据库供开发者选择,提高开发测试效率
              ♦ H2
              ♦ HSQL
              ♦ Derby
  • 设置当前项目为web工程,并配置H2管理控制台参数
server:
  port: 80
spring:
  h2:
    console:
      enabled: true
      path: /h2

          ♦ 访问用户名sa,默认密码123456

  • 操作数据库(创建表)
create table tbl_book (id int,name varchar,type varchar,description varchar)
  • 设置访问数据源
server:
  port: 80
spring:
  h2:
    console:
      enabled: true
      path: /h2
  datasource:
    driver-class-name: org.h2.Driver
    url: jdbc:h2:~/test
    username: sa
    password: 123456
  • H2数据库控制台仅用于开发阶段,线上项目请务必关闭控制台功能
server:
  port: 80
spring:
  h2:
    console:
      enabled: flase
      path: /h2
  • SpringBoot可以根据url地址自动识别数据库种类,在保障驱动类存在的情况下,可以省略配置
server:
  port: 80
spring:
  h2:
    console:
      enabled: true
      path: /h2
  datasource:
#    driver-class-name: org.h2.Driver
    url: jdbc:h2:~/test
    username: sa
    password: 123456

2. NoSQL解决方案

  • 市面上常见的NoSQL解决方案
              ♦ Redis
              ♦ Mongo
              ♦ ES

2.1 Redis

  • Redis是一款key-value存储结构的内存级NoSQL数据库
              ♦ 支持多种数据存储格式
              ♦ 支持持久化
              ♦ 支持集群

SpringBoot整合Redis

  • 导入Redis对应的starter
<dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-data-redisartifactId>
dependency>
  • 配置Redis(采用默认配置)
spring:
  redis:
    host: localhost
    port: 6379

          ♦ 主机:localhost(默认)
          ♦ 端口:6379(默认)

  • RedisTemplate提供操作各种数据存储类型的接口API

          ♦ ops*:获取各种数据类型操作接口
实用开发篇-SpringBoot 数据层解决方案学习_第2张图片

客户端:RedisTemplate以对象作为key和value,内部对数据进行序列化

@SpringBootTest
class Springboot16RedisApplicationTests {
    @Test
    void set(@Autowired RedisTemplate redisTemplate) {
        ValueOperations ops = redisTemplate.opsForValue();
        ops.set("age", 41);
    }

    @Test
    void get(@Autowired RedisTemplate redisTemplate) {
        ValueOperations ops = redisTemplate.opsForValue();
        Object age = ops.get("age");
        System.out.println(age);
    }
    @Test
    void hset(@Autowired RedisTemplate redisTemplate) {
        HashOperations hashOperations = redisTemplate.opsForHash();
        hashOperations.put("info", "b", "bb");
    }

    @Test
    void hget(@Autowired RedisTemplate redisTemplate) {
        HashOperations hashOperations = redisTemplate.opsForHash();
        Object val = hashOperations.get("info", "b");
        System.out.println(val);
    }
}

客户端:StringRedisTemplate以字符串作为key和value,与Redis客户端操作等效(常用)

@SpringBootTest
public class StringRedisTemplateTest {
    @Test
    void set(@Autowired StringRedisTemplate stringRedisTemplate) {
        ValueOperations ops = stringRedisTemplate.opsForValue();
        ops.set("testKey","testKey");
    }
    @Test
    void get(@Autowired StringRedisTemplate stringRedisTemplate) {
        ValueOperations<String, String> ops = stringRedisTemplate.opsForValue();
        String name = ops.get("testKey");
        System.out.println(name);
    }
}

SpringBoot整合Redis客户端选择

客户端选择:jedis
导入依赖

        <dependency>
            <groupId>redis.clientsgroupId>
            <artifactId>jedisartifactId>
        dependency>

配置客户端:

spring:
  redis:
    host: localhost	#  127.0.0.1
    port: 6379
    client-type: jedis

lettcus与jedis区别

  • jedis连接Redis服务器是直连模式,当多线程模式下使用jedis
    会存在线程安全问题,解决方案 可以通过配置连接池使每个连接专用,这样整体性能就大受影响。
  • lettcus基于Netty框架进行与Redis服务器连接,底层设计中采用StatefulRedisConnection。StatefulRedisConnection自身是线程安全的,可以保障并发访问安全问题,所以一个连接可以被多线程复用。当然lettcus也支持多连接实例一起工作。(默认)

2.2 Mongodb

Mongodb基础CRUD

  • Mongodb是一个开源、高性能、无模式的文档型数据库。NoSQL数据库产品中的一种,是最像关系型数据库的非关系型数据库
  • 淘宝用户数据

          ♦ 存储位置:数据库
          ♦ 特征:永久性存储,修改频度极低

  • 游戏装备数据、游戏道具数据

          ♦ 存储位置:数据库、Mongdb
          ♦ 特征:永久性存储与临时存储相结合、修改频度较高

  • 直播数据、打赏数据、粉丝数据

          ♦ 存储位置:数据库、Mongdb
          ♦ 特征:永久性存储与临时存储相结合、修改频度较高

  • 物联网数据

          ♦ 存储位置:Mongdb
          ♦ 特征:临时存储,修改频度飞速

新增

db.集合名称.insert/save/insertOne(文档)

修改

db.集合名称.remove(条件)

删除

db.集合名称.update(条件,{操作种类:{文档}})

查询

1.基础查询

          ♦ 查询全部:db.集合.find();
          ♦ 查第一条:db.集合.findOne();
          ♦ 查询指定数量文档:db.集合.find().limit(10) //查10条文档
          ♦ 跳过指定数量文档:db.集合.find().skip(20) //跳过20条文档
          ♦ 统计:db.集合.count()
          ♦ 排序:db.集合.sort({age:1}) //按age升序排序
          ♦ 投影:db.集合名称.find(条件,{name:1,age:1}) //仅保留name与age域

2.条件查询

          ♦ 基本格式:db.集合.find({条件})

          ♦ 模糊查询:db.集合.find({域名:/正则表达式/}) //等同SQL中的like,比like强大,可以执行正则所有规则

          ♦ 条件比较运算:db.集合.find({域名:{$gt:值}}) //等同SQL中的数值比较操作,例如:name>18

          ♦ 包含查询:db.集合.find({域名:{$in:[值1,值2]}}) //等同于SQL中的in

          ♦ 条件连接查询:db.集合.find({$and:[{条件1},{条件2}]}) //等同SQL中的and、or

SpringBoot整合Mongodb

  • 导入Mongodb驱动
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-data-mongodbartifactId>
        dependency>
  • 配置客户端
spring:
  data:
    mongodb:
      uri: mongodb://localhost/itheima

  • 客户端读写Mongodb
@SpringBootTest
class Springboot17MongodbApplicationTests {
    @Autowired
    private MongoTemplate mongoTemplate;

    @Test
    void contextLoads() {
        Book book = new Book();
        book.setId(2 );
        book.setName("spring1");
        book.setType("spring1");
        book.setDescription("spring1");
        mongoTemplate.save(book);
    }

    @Test
    void find() {
        List<Book> all = mongoTemplate.findAll(Book.class);
        System.out.println(all);
    }

}

2.3 Elasticsearch(ES)

  • Elasticsearch是一个分布式全文搜索引擎
  • Windows版本ES安装与启动

运行 elasticsearch.bat
运行失败修改bin目录下elasticsearch-env.bat的JDK路径
安装ik分词器解压到plugins目录下

Elasticsearch增删改查(文档操作)

  • 创建/查询/删除索引
PUT http:/localhost:9200/books
GET http:/localhost:9200/books
DELETE http:/localhost:9200/books
  • 使用索引并指定规则
{
    "mappings" : {
            "properties":{
                "id":{
                    "type":"keyword"
                },
                "name":{
                    "type":"text",
                    "analyzer":"ik_max_word",
                    "copy_to":"all"
                },
                "type":{
                    "type":"keyword"
                },
                "description":{
                    "type":"text",
                    "analyzer":"ik_max_word" ,
                    "copy_to":"all"
                },
                "all":{
                    "type":"text",
                    "analyzer":"ik_max_word" 
                }

            }
    }
}
  • 创建文档
POST http:/localhost:9200/books/_doc		#使用系统生成的id
POST http:/localhost:9200/books/_create/1	#使用指定id
POST http:/localhost:9200/books/_doc/1		#使用指定id,不存在创建,存在更新(版本递增)
{
	"name" : "springboot",
	"type" : "springboot",
	"description" : "springboot"
}
  • 查询文档
GET http:/localhost:9200/books/_doc/1		#查询单个文档
GET http:/localhost:9200/books/_search		#查询全部文档
  • 条件查询
Get http:/localhost:9200/books/_search?q=name:springboot
  • 删除文档
DELETE http:/localhost:9200/books/_doc/1
  • 修改文档
PUT http:/localhost:9200/books/_doc/1
{
	"name" : "springboot",
	"type" : "springboot",
	"description" : "springboot";
}
  • 修改文档(部分修改)
PUT http:/localhost:9200/books/_update/1
{
	"doc" : {
		"name" : "springboot"
	}
}

Spring整合Elasticsearch客户端(low)

  • 导入坐标
        <dependency>
            <groupId>org.elasticsearch.clientgroupId>
            <artifactId>spring-boot-start-data-elasticsearchartifactId>
        dependency>
  • 配置
spring:
  elasticsearch:
   =rest:
    uris: http://localhost:9200
  • 客户端
@SpringBootTest
class Springboot18EsApplicationTests{
	@Autowired
	private ElasticsearchRestTemplate template;
}

手动操作客户端初始化

  • SpringBoot平台没有跟随ES的更新速度进行同步更新,ES提供了Hight Level Client操作ES
  • 导入坐标
        <dependency>
            <groupId>org.elasticsearch.clientgroupId>
            <artifactId>elasticsearch-rest-high-level-clientartifactId>
        dependency>
  • 配置(无)
  • 客户端
    @Test
    void testCreateClient() throws IOException {
        HttpHost host = HttpHost.create("http://localhost:9200");
        RestClientBuilder builder = RestClient.builder(host);
        RestHighLevelClient = new RestHighLevelClient(builder);
        //客户端操作
		CreateIndexRequest request = new CreateIndexRequest("books");
		//获取操作索引的客户端对象,调用创建索引操作
        client.indices().create(request, RequestOptions.DEFAULT);
		//关闭客户端
        client.close();
    }
  • 客户端改进
@SpringBootTest
class Springboot18EsApplicationTests {
    @Autowired
    private BookDao bookDao;
    @Autowired
    RestHighLevelClient client;

    @BeforeEach
    void setUp() {
        this.client = new RestHighLevelClient(RestClient.builder(HttpHost.create("http://localhost:9200")));
    }

    @AfterEach
    void tearDown() throws IOException {
        this.client.close();
    }
}

Java代码实现

  • 创建索引
    @Test
    void testCreateByIk() throws IOException {
    	HttpHost host = HttpHost.create("http://localhost:9200");
    	RestClientBuilder builder = RestClient.builder(host);
    	RestClientBuilder client = new RestHighLevelClient(builder);
    	//客户端操作
        CreateIndexRequest request = new CreateIndexRequest("books");
        //设置要执行的操作
        String json = " ";
        //设置请求中的参数,参数类型json数据
        request.source(json, XContentType.JSON);
        //获取操作索引的客户端对象,调用创建索引操作
        client.indices().create(request, RequestOptions.DEFAULT);
		//关闭客户端
        client.close();
    }
  • 添加文档
    @Test
        //添加文档
    void testCreateDoc() throws IOException {
        Book book = bookDao.selectById(1);
        IndexRequest request = new IndexRequest("books").id(book.getId().toString());
        String json = JSON.toJSONString(book);
        request.source(json, XContentType.JSON);
        client.index(request, RequestOptions.DEFAULT);
    }
  • 批量添加文档
@Test
    void testCreateDocAll() throws IOException {
        List<Book> bookList = bookDao.selectList(null);
        BulkRequest bulkRequest = new BulkRequest();
        for (Book book : bookList) {
            IndexRequest request = new IndexRequest("books").id(book.getId().toString());
            String json = JSON.toJSONString(book);
            request.source(json, XContentType.JSON);
            bulkRequest.add(request);
        }

        client.bulk(bulkRequest, RequestOptions.DEFAULT);
    }
  • 按ID查
    //按id查询
    @Test
    void testGet() throws IOException {
        GetRequest request = new GetRequest("books", "1");
        GetResponse response = client.get(request, RequestOptions.DEFAULT);
        String json = response.getSourceAsString();
        System.out.println(json);
    }
  • 按条件查
    //按条件查询
    @Test
    void testSearch() throws IOException {
        SearchRequest request = new SearchRequest("books");
        SearchSourceBuilder builder = new SearchSourceBuilder();
        builder.query(QueryBuilders.termQuery("name", "java"));
        request.source(builder);

        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
        SearchHits hits = response.getHits();
        for (SearchHit hit : hits) {
            String sourceAsString = hit.getSourceAsString();
            Book book = JSON.parseObject(sourceAsString, Book.class);
            System.out.println(book);
        }
    }

你可能感兴趣的:(Spring,Boot,java)