devbox
花生_TL007
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

SpringBoot开发使用篇_springboot德鲁伊数据源配置

作者：花生_TL007 | 2024-05-16 01:24:16

赞

踩

springboot德鲁伊数据源配置

目录

 （一）热部署

1，手动部署

2， 自动部署

3，设置热部署范围配置

4，禁用热部署

application.yml上禁用（级别低）

 ​​​        在引导类上禁用（级别高，防止配置被覆盖，常用）

属性加载优先顺序​编辑

（二）第三方bean属性绑定

1，自动装配

2，解除警告

3，松散绑定

@ConfiguratinProperties注解属性名松散判定 

注意：@Value注解不支持松散绑定

配置文件数据名的各种形式：

（四）常用计量单位应用

@DurationUnit和@DataSizeUnit注解：

可选的单位：​编辑

（五）bean属性校验

1，导入校验api（接口）坐标

2，导入Hibernate校验框架实现校验接口

3，对Bean开启校验功能

4，设置规则

5，其他的规则 

（六） 进制数据转换规则

一，字面值表示

二，注意

 （七）测试

一，加载测试专用属性

方法1：properties属性​编辑

方法2： args属性

二，加载测试专用配置

 三，测试表现层类

1，模拟端口

2，发送虚拟请求

3，匹配响应执行状态

4，匹配响应体

5,匹配请求头

6，总结

 四，业务层测试事务回滚

 五，测试用例数据随机生成数据

 使用例子：

 实例对象：

（七）SpringBoot数据库层解决方法

一，数据源（SpringBoot内置）

 采用boot原始配置数据源，就是使用HiKariCp 

 德鲁伊Druid数据源的配置方式​编辑

 应用场景：

二，持久层技术（SpringBoot提供的持久化技术--JdbcTemplate）

三，数据库（SpringBoot提供的内置数据库）

1，提供三种数据库（都属于内存级别）：

2，H2内嵌数据库的使用

 四，数据库层--12种技术方案​编辑

 （八）Redis的使用

一，简介：

二，启动数据库

三，SpringBoot整合Redis

 1，导入整合坐标

 2，配置Redis

 3，操作Redis数据库

 4，总结

 四，实现SpringBoot操作Redis和Redis客户端操作等效

1，RedisTemplate对象（不能和Redis客户端等效）

 2，StringRedisTemplate对象（和Redis客户端等效，即同步）

五，选择jedis客户端技术实现

1，导坐标​编辑

 2，配置

 3，lettcus和jedis区别

 4，总结​

 （九）MongoDB数据库的使用

 一，简介

1， 定义：

 2，应用场景：

二，启动数据库

四，SpringBoot整合mongoDB

1，导入MongoDb驱动 

 2，配置

3，注入对象，使用CRUD操作

4，总结​编辑

（十）Elasticsearch（ES）

 简介:

 2，安装和启动​编辑

 3，操作

1，请求​编辑

2，创建文档​编辑

3，查询和删除文档 

4， 修改文档 

4，SpringBoot集成ES

1，添加依赖

2，创建索引​编辑

3，添加文档

4，查询文档

 （十一）缓存的使用

 简介：​

 使用步骤（默认缓存技术）

1，导入缓存技术的坐标

2，启用存储（在引导类上加注解@EnableCaching）

3，设置操作结果数据进入缓存（@Cacheable注解）

其他存储技术

1，Ehcache缓存

1，导入坐标

2，创建xml配置文件（一般用ehcache.xml）

3，配置

数据淘汰策略

 2，Redis缓存

1，导入坐标

2，配置

3，启动redis服务器

4，使用

memcached缓存（boot没有其内置的整合方案）

 1，安装 

 2，添加坐标

 3，配置

 4，使用

 （一）热部署

1，手动部署

 和重新部署项目的区别：不加载依赖的jar包，只加在自定义的资源

 2， 自动部署

 按Ctrl+Alt+Shift+/,再选择注册表即可出现下面选项

 

 3，设置热部署范围配置

在application.yml配置文件设置即可,设置不参与热部署的文件或者文件夹

4，禁用热部署

application.yml上禁用（级别低）

 ​​​​

 在引导类上禁用（级别高，防止配置被覆盖，常用）

 属性加载优先顺序

（二）第三方bean属性绑定

1，自动装配

  1. @ConfigurationProperties注解用于指定配置文件中定义的数据，注入到所在类中对应的属性上。
  2. @EnableConfigurationProperties注解,将@ConfigurationProperties注解所在类自动加入Spring容器

2，解除警告

3，松散绑定

@ConfiguratinProperties注解属性名松散判定 

注意：@Value注解不支持松散绑定

 

 配置文件数据名的各种形式：

 P75

 （四）常用计量单位应用

@DurationUnit和@DataSizeUnit注解：

可选的单位：

（五）bean属性校验

1，导入校验api（接口）坐标

  1.         <!--1，导入数据校验坐标（为接口，同jdbc接口，还没有实现）-->
  2.         <dependency>
  3.             <groupId>javax.validation</groupId>
  4.             <artifactId>validation-api</artifactId>
  5.         </dependency>

2，导入Hibernate校验框架实现校验接口

  1.         <!--2,使用hibernate框架提供的校验实现类-->
  2.         <dependency>
  3.             <groupId>org.hibernate.validator</groupId>
  4.             <artifactId>hibernate-validator</artifactId>
  5.         </dependency>

3，对Bean开启校验功能

  1. @Data
  2. @ConfigurationProperties(prefix = "server")
  3. @Validated//2，开启对当前bean的属性注入校验
  4. public class ServerConfig {
  5. }

4，设置规则

  1. @Data
  2. @ConfigurationProperties(prefix = "server")
  3. @Validated//2，开启对当期bean的属性注入校验
  4. public class ServerConfig {
  5.     private String ipAddress;
  6.     @Max(value = 8887,message = "端口最大值不能超8887")
  7.     @Min(value = 202,message = "端口最小值不能小于202")
  8.     private int port;
  9.     private long timeout;
  10.     @DurationUnit(ChronoUnit.DAYS)//声明时间单位为小时
  11.     private Duration serverTimeOut;//时间
  12.     @DataSizeUnit(DataUnit.MEGABYTES)//声明内存单位为M
  13.     private DataSize dataSize;//内存
  14.  
  15. }

5，其他的规则 

（六） 进制数据转换规则

一，字面值表示

二，注意

 （七）测试

一，加载测试专用属性

方法1：properties属性

方法2： args属性

二，加载测试专用配置

 三，测试表现层类

 1，模拟端口

2，发送虚拟请求

3，匹配响应执行状态

4，匹配响应体

 字符串类型：

 json数据类型：

 5,匹配请求头

6，总结

四，业务层测试事务回滚

 五，测试用例数据随机生成数据

 使用例子：

testcase:
  book:
      id: ${random.int}
      id1: ${random.int(1,10)}
      id2: ${random.int[1,10]}
      id3: ${random.int!1,10!}
      name: 司马${random.value}
      uuid: ${random.uuid}
      publishTime: ${random.long}

 实例对象：

@Component
@ConfigurationProperties(prefix = "testcase.book")
@Data
public class BookCase {
    private int id;
    private int id1;
    private int id2;
    private int id3;
    private String name;
    private String uuid;
    private long publishTime;
}

（七）SpringBoot数据库层解决方法

一，数据源（SpringBoot内置）

采用boot原始配置数据源，就是使用HiKariCp 

 德鲁伊Druid数据源的配置方式

 应用场景：

二，持久层技术（SpringBoot提供的持久化技术--JdbcTemplate）

 使用需要导坐标，用到时，百度即可，虽然该技术使用的人少，但是还是由公司在用（编写不快，当运行效率高）

 三，数据库（SpringBoot提供的内置数据库）

1，提供三种数据库（都属于内存级别）：

2，H2内嵌数据库的使用

 导入H2坐标：

配置：

 

详细使用，看黑马boot教程--P91集。

 四，数据库层--12种技术方案

 （八）Redis的使用

一，简介：

属于NoSQL：

二，启动数据库

下面窗口在使用redis数据库过程中不能关闭，关闭表示关闭了redis数据库，此时不能正常使用。

连接失败，解决方案：

  三，SpringBoot整合Redis

1，导入整合坐标

  1.         <!-- redis的整合依赖-->
  2.         <dependency>
  3.             <groupId>org.springframework.boot</groupId>
  4.             <artifactId>spring-boot-starter-data-redis</artifactId>
  5.         </dependency>

 2，配置Redis

 3，操作Redis数据库

前提：已启动Redis数据库（启动redis命令窗口不能关闭）

 测试：

  1. @SpringBootTest
  2. class Springboot0102QuickstartApplicationTests {
  3. 	@Autowired//获取redis操作对象
  4. 	private RedisTemplate redisTemplate;
  5. 	//--------------------键值对---------
  6. 	@Test
  7. 	void set() {
  8. 		ValueOperations ops = redisTemplate.opsForValue();
  9. 		//存入值
  10. 		ops.set("age",41);
  11. 	}
  12. 	@Test
  13. 	void get() {
  14. 		ValueOperations ops = redisTemplate.opsForValue();
  15. 		//获取值
  16. 		System.out.println(ops.get("age"));
  17. 	}
  18. 	//--------------------哈希值---------
  19. 	@Test
  20. 	void set1() {
  21. 		HashOperations ops = redisTemplate.opsForHash();
  22. 		//存入值
  23. 		ops.put("info","a","aa");
  24. 	}
  25. 	@Test
  26. 	void get1() {
  27. 		HashOperations ops = redisTemplate.opsForHash();
  28. 		//获取值
  29. 		System.out.println(ops.get("info","a"));
  30. 	}
  31. }

 4，总结

 四，实现SpringBoot操作Redis和Redis客户端操作等效

1，RedisTemplate对象（不能和Redis客户端等效）

 客户端获取RedisTemplate对象设置的键值对：

 2，StringRedisTemplate对象（和Redis客户端等效，即同步）

  1. @SpringBootTest
  2. public class StringRedisTemplateTest {
  3.     //字符串
  4.     @Autowired
  5.     public StringRedisTemplate stringRedisTemplate;//---可以拿到redis客户端存入的值
  6.     @Test
  7.     public void get(){
  8.         ValueOperations<String, String> ops = stringRedisTemplate.opsForValue();
  9.         System.out.println(ops.get("name"));
  10.     }
  11.     @Test
  12.     public void set(){
  13.         ValueOperations<String, String> ops = stringRedisTemplate.opsForValue();
  14.         ops.set("type","sabi");
  15.     }
  16. }

五，选择jedis客户端技术实现

SpringBoot默认选择lettcus技术。

1，导坐标

 2，配置

  1. spring:
  2.   redis:
  3.     port: 6379
  4.     host: localhost
  5.     #选择客户端技术实现：jedis
  6.     client-type: jedis
  7.     jedis:
  8.       pool:
  9.         #最大连接数
  10.         max-active: 16

配完配置后，后自动转成所配置的技术，即选择jedis技术完成。

 3，lettcus和jedis区别

 4，总结

 （九）MongoDB数据库的使用

一，简介

1， 定义：

 2，应用场景：

二，启动数据库

 三，增删改查等

 

四，SpringBoot整合mongoDB

1，导入MongoDb驱动 

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

 2，配置

  1. spring:
  2.   data:
  3.     mongodb:
  4.       #test为在mongoDB创建的数据库
  5.       uri: mongodb://localhost/test

3，注入对象，使用CRUD操作

  1. @SpringBootTest
  2. class Springboot0112MongodbApplicationTests {
  3.  
  4.     @Autowired
  5.     private MongoTemplate mongoTemplate;
  6.     //添加数据
  7.     @Test
  8.     void contextLoads() {
  9.         Book book = new Book();
  10.         book.setType("2");
  11.         book.setName("测试");
  12.         book.setDescription("啥都不是");
  13.         book.setId(1);
  14.         mongoTemplate.save(book);
  15.     }
  16.     //查询数据
  17.     @Test
  18.     void get(){
  19.         List<Book> books = mongoTemplate.findAll(Book.class);
  20.         System.out.println(books);
  21.     }
  22. }

4，总结

（十）Elasticsearch（ES）

 一，简介

倒排索引（根据其他信息，得到记录的id）是ES核心技术实现方法

 2，安装和启动

 3，操作

1，请求

IK分词器安装

 放在es文件包plugin中

 设置索引创建规则

 2，创建文档

3，查询和删除文档 

4， 修改文档 

4，SpringBoot集成ES

1，添加依赖

  1. 		<!--es依赖-->
  2. 		<dependency>
  3. 			<groupId>org.elasticsearch.client</groupId>
  4. 			<artifactId>elasticsearch-rest-high-level-client</artifactId>
  5. 		</dependency>

 2，创建索引

3，添加文档

单个添加

  1. 	@Test
  2. 	void creatDocTest() throws IOException {
  3. 		Book book = bookMapper.selectById(3);
  4. 		List<Book> bookList = bookMapper.selectList(null);
  5. 		IndexRequest request = new IndexRequest("books").id(book.getId().toString());//创建文档
  6. 		String json = JSON.toJSONString(book);
  7. 		request.source(json,XContentType.JSON);
  8. 		client.index(request,RequestOptions.DEFAULT);
  9. 	}

批量添加

  1. 	@Test
  2. 	void creatDocTest1() throws IOException {
  3. 		List<Book> bookList = bookMapper.selectList(null);
  4. 		BulkRequest bulkRequest = new BulkRequest();
  5. 		String json = null;
  6. 		for (Book book : bookList) {
  7. 			IndexRequest request = new IndexRequest("books").id(book.getId().toString());//创建文档
  8. 			json = JSON.toJSONString(book);
  9. 			request.source(json,XContentType.JSON);
  10. 			bulkRequest.add(request);
  11. 		}
  12. 		client.bulk(bulkRequest,RequestOptions.DEFAULT);
  13. 	}

 4，查询文档

 按id查询：

  1. 	//按id查询
  2. 	@Test
  3. 	void getTest() throws IOException {
  4. 		GetRequest request = new GetRequest("books", "1");
  5. 		GetResponse response = client.get(request, RequestOptions.DEFAULT);
  6. 		String json = response.getSourceAsString();
  7. 		System.out.println(json);
  8. 	}

 按条件查询：

  1. 	//按条件查询
  2. 	@Test
  3. 	void getTest1() throws IOException {
  4. 		SearchRequest request = new SearchRequest("books");
  5. 		SearchSourceBuilder builder = new SearchSourceBuilder();
  6. 		//设置查询条件
  7. 		builder.query(QueryBuilders.termQuery("all","123"));
  8. 		//放在请求中
  9. 		request.source(builder);
  10. 		SearchResponse response = client.search(request, RequestOptions.DEFAULT);
  11. 		//获取命中的对象
  12. 		SearchHits hits = response.getHits();
  13. 		for (SearchHit hit : hits) {
  14. 			//获取source部分数据
  15. 			String json = hit.getSourceAsString();
  16. 			//转成对象
  17. 			Book book = JSON.parseObject(json, Book.class);
  18. 			System.out.println(book);
  19. 		}
  20. 	}

 （十一）缓存的使用

 简介：

使用步骤（默认缓存技术）

 1，导入缓存技术的坐标

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

2，启用存储（在引导类上加注解@EnableCaching）

  1. @SpringBootApplication
  2. //开启缓存功能
  3. @EnableCaching
  4. public class SSMPApplication {
  5.     public static void main(String[] args) {
  6.         SpringApplication.run(SSMPApplication.class, args);
  7.     }
  8. }

3，设置操作结果数据进入缓存（@Cacheable注解）

  1. //value值表示声明一块空间，用于存储缓存的数据，key表示某个数据的标识，需要具有唯一性
  2. @Cacheable(value = "cacheSpace",key = "#id")
  3. public Book getBookById(Integer id) {
  4.      return bookMapper.getBookById(id);
  5. }

其他存储技术

SpringBoot不管是使用默认的Simple缓存技术，还是Ehcache和Redis其在使用的使用使用的注解都是一样的，即统一接口，当它们的配置各有差异。

案例 

1，Ehcache缓存

1，导入坐标

  1. <!--        其他的缓存技术-->
  2.         <dependency>
  3.             <groupId>net.sf.ehcache</groupId>
  4.             <artifactId>ehcache</artifactId>
  5.         </dependency>

2，创建xml配置文件（一般用ehcache.xml）

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.          xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
  4.          updateCheck="false">
  5.     <defaultCache
  6.             maxElementsInMemory="1000"
  7.             overflowToDisk="false"
  8.             diskPersistent="false"
  9.             timeToIdleSeconds="3600"
  10.             timeToLiveSeconds="3600"
  11.             memoryStoreEvictionPolicy="LRU"
  12.     />
  13.     <!--
  14.        name:缓存名称。
  15.        maxElementsInMemory：缓存最大个数。
  16.        eternal:对象是否永久有效，一但设置了，timeout将不起作用。
  17.        timeToIdleSeconds：设置对象在失效前的允许闲置时间（单位：秒）。仅当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大。
  18.        timeToLiveSeconds：设置对象在失效前允许存活时间（单位：秒）。最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用，默认是0.，也就是对象存活时间无穷大。
  19.        overflowToDisk：当内存中对象数量达到maxElementsInMemory时，Ehcache将会对象写到磁盘中。
  20.        diskSpoolBufferSizeMB：这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。
  21.        maxElementsOnDisk：硬盘最大缓存个数。
  22.        diskPersistent：是否缓存虚拟机重启期数据 Whether the disk store persists between restarts of the Virtual Machine. The default value is false.
  23.        diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认是120秒。
  24.        memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。默认策略是LRU（最近最少使用）。你可以设置为FIFO（先进先出）或是LFU（较少使用）。
  25.        clearOnFlush：内存数量最大时是否清除。
  26.        -->
  27.     <cache
  28.             name = "smsCode"
  29.             eternal = "false"
  30.             maxElementsInMemory="100"
  31.             overflowToDisk="false"
  32.             diskPersistent="false"
  33.             timeToIdleSeconds="10"
  34.             timeToLiveSeconds="60"
  35.             memoryStoreEvictionPolicy="LRU"/>
  36. </ehcache>

3，配置

  1. spring:
  2.   cache:
  3.     type: ehcache #配置使用的缓存技术为ehcache
  4.     ehcache:
  5.       config: ehcache.xml #指定配置文件

数据淘汰策略

 2，Redis缓存

1，导入坐标

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

2，配置

  1. spring:
  2.  
  3.   cache:
  4.     type: redis
  5.     redis:
  6.       time-to-live: 20s #缓存有效时间
  7.       use-key-prefix: true #保留前缀
  8.       key-prefix: sms_  #添加前缀
  9.       cache-null-values: true #是否保存空值null
  10.   #redis服务器的启动配置
  11.   redis:
  12.     port: 6379
  13.     host: localhost

3，启动redis服务器

 4，使用

存入缓存

  1.     @CachePut(value = "smsCode",key = "#tele")//只放入缓存
  2.     public String sendCodeToSMS(String tele) {
  3.         return codeUtil.generator(tele);
  4.     }

 从缓存中取出数据

  1.     //根据key，获取缓存中的数据------要放在归Spring管理的对象中才能正常获取（@Cacheable注解被正常启动加载）
  2.     @Cacheable(value = "smsCode",key = "#tele")
  3.     public String get(String tele){
  4.         return null;
  5.     }

P114

memcached缓存（boot没有其内置的整合方案）

1，安装 

下载压缩包后，直接解压到一个安装包即可使用

Windows 下安装 Memcached | 菜鸟教程 (runoob.com)https://www.runoob.com/memcached/window-install-memcached.html

 2，添加坐标

  1.         <!--xmemcached -->
  2.         <dependency>
  3.             <groupId>com.googlecode.xmemcached</groupId>
  4.             <artifactId>xmemcached</artifactId>
  5.             <version>2.4.6</version>
  6.         </dependency>

 3，配置

application.yml定义的配置信息：

  1. #memcached的配置信息
  2. memcached:
  3.   #memcached服务器地址
  4.   servers: localhost:11211
  5.   #连接池的数量
  6.   poolSize: 10
  7.   #设置默认操作超时
  8.   opTimeOut: 10000

配置信息类：

  1. @Component
  2. @Data
  3. @ConfigurationProperties(prefix = "memcached")
  4. public class XMemcachedProperties {
  5.     private String servers;
  6.     private Integer poolSize;
  7.     private Long opTimeOut;
  8. }

配置类：

  1. @Configuration
  2. public class XMemcachedConfig {
  3.     @Autowired
  4.     private XMemcachedProperties xMemcachedProperties;
  5.     @Bean
  6.     public MemcachedClient getMemcachedClient() throws IOException {
  7.         XMemcachedClientBuilder memcachedClientBuilder = new XMemcachedClientBuilder(xMemcachedProperties.getServers());
  8.         //线程池数量
  9.         memcachedClientBuilder.setSelectorPoolSize(xMemcachedProperties.getPoolSize());
  10.         //设置默认超时间
  11.         memcachedClientBuilder.setOpTimeout(xMemcachedProperties.getOpTimeOut());
  12.         MemcachedClient memcachedClient = memcachedClientBuilder.build();
  13.         return memcachedClient;
  14.     }
  15. }

4，使用

往缓存写入数据：

  1.     @Override
  2.     public String sendCodeToSMS(String tele) {
  3.         String code = codeUtil.generator(tele);
  4.         try {
  5.             //写入缓存
  6.             memcachedClient.set(tele,10,code);//0表示永不过期
  7.         } catch (Exception e) {
  8.             e.printStackTrace();
  9.         }
  10.         return code;
  11.     }

从缓存读出数据：

  1.     @Override
  2.     public boolean checkCode(SMSCode smsCode) {
  3.         String code = null;
  4.         try {
  5.             //从缓存中获取去数据
  6.             code = memcachedClient.get(smsCode.getTele()).toString();
  7.         } catch (Exception e) {
  8.             e.printStackTrace();
  9.         }
  10.         return smsCode.getCode().equals(code);
  11.     }

基于目前用到不黑马教程上面的第三方整合技术，所以在这里结束实用开发篇的学习。P115--P142的视频先不看。跳到P143原理篇继续学习。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/花生_TL007/article/detail/576063
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号