目录
@ConfiguratinProperties注解属性名松散判定
@DurationUnit和@DataSizeUnit注解：
二，持久层技术（SpringBoot提供的持久化技术--JdbcTemplate）
四，实现SpringBoot操作Redis和Redis客户端操作等效
1，RedisTemplate对象（不能和Redis客户端等效）
2，StringRedisTemplate对象（和Redis客户端等效，即同步）
简介:
2，启用存储（在引导类上加注解@EnableCaching）
（一）热部署
1，手动部署
和重新部署项目的区别：不加载依赖的jar包，只加在自定义的资源
2， 自动部署
按Ctrl+Alt+Shift+/,再选择注册表即可出现下面选项
3，设置热部署范围配置
在application.yml配置文件设置即可,设置不参与热部署的文件或者文件夹
4，禁用热部署
application.yml上禁用（级别低）
在引导类上禁用（级别高，防止配置被覆盖，常用）
属性加载优先顺序
（二）第三方bean属性绑定
1，自动装配
- @ConfigurationProperties注解用于指定配置文件中定义的数据，注入到所在类中对应的属性上。
- @EnableConfigurationProperties注解,将@ConfigurationProperties注解所在类自动加入Spring容器
2，解除警告
3，松散绑定
@ConfiguratinProperties注解属性名松散判定
注意：@Value注解不支持松散绑定
配置文件数据名的各种形式：
P75
（四）常用计量单位应用
@DurationUnit和@DataSizeUnit注解：
可选的单位：
（五）bean属性校验
1，导入校验api（接口）坐标
<!--1，导入数据校验坐标（为接口，同jdbc接口，还没有实现）-->
<dependency>
<groupId>javax.validation</groupId>
<artifactId>validation-api</artifactId>
</dependency>2，导入Hibernate校验框架实现校验接口
<!--2,使用hibernate框架提供的校验实现类-->
<dependency>
<groupId>org.hibernate.validator</groupId>
<artifactId>hibernate-validator</artifactId>
</dependency>3，对Bean开启校验功能
@Data
@ConfigurationProperties(prefix = "server")
@Validated//2，开启对当前bean的属性注入校验
public class ServerConfig {
}4，设置规则
@Data
@ConfigurationProperties(prefix = "server")
@Validated//2，开启对当期bean的属性注入校验
public class ServerConfig {
private String ipAddress;
@Max(value = 8887,message = "端口最大值不能超8887")
@Min(value = 202,message = "端口最小值不能小于202")
private int port;
private long timeout;
@DurationUnit(ChronoUnit.DAYS)//声明时间单位为小时
private Duration serverTimeOut;//时间
@DataSizeUnit(DataUnit.MEGABYTES)//声明内存单位为M
private DataSize dataSize;//内存
}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，导入整合坐标
<!-- redis的整合依赖-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>2，配置Redis
3，操作Redis数据库
前提：已启动Redis数据库（启动redis命令窗口不能关闭）
测试：
@SpringBootTest
class Springboot0102QuickstartApplicationTests {
@Autowired//获取redis操作对象
private RedisTemplate redisTemplate;
//--------------------键值对---------
@Test
void set() {
ValueOperations ops = redisTemplate.opsForValue();
//存入值
ops.set("age",41);
}
@Test
void get() {
ValueOperations ops = redisTemplate.opsForValue();
//获取值
System.out.println(ops.get("age"));
}
//--------------------哈希值---------
@Test
void set1() {
HashOperations ops = redisTemplate.opsForHash();
//存入值
ops.put("info","a","aa");
}
@Test
void get1() {
HashOperations ops = redisTemplate.opsForHash();
//获取值
System.out.println(ops.get("info","a"));
}
}4，总结
四，实现SpringBoot操作Redis和Redis客户端操作等效
1，RedisTemplate对象（不能和Redis客户端等效）
客户端获取RedisTemplate对象设置的键值对：
2，StringRedisTemplate对象（和Redis客户端等效，即同步）
@SpringBootTest
public class StringRedisTemplateTest {
//字符串
@Autowired
public StringRedisTemplate stringRedisTemplate;//---可以拿到redis客户端存入的值
@Test
public void get(){
ValueOperations<String, String> ops = stringRedisTemplate.opsForValue();
System.out.println(ops.get("name"));
}
@Test
public void set(){
ValueOperations<String, String> ops = stringRedisTemplate.opsForValue();
ops.set("type","sabi");
}
}五，选择jedis客户端技术实现
SpringBoot默认选择lettcus技术。
1，导坐标
2，配置
spring:
redis:
port: 6379
host: localhost
#选择客户端技术实现：jedis
client-type: jedis
jedis:
pool:
#最大连接数
max-active: 16配完配置后，后自动转成所配置的技术，即选择jedis技术完成。
3，lettcus和jedis区别
4，总结
（九）MongoDB数据库的使用
一，简介
1， 定义：
2，应用场景：
二，启动数据库
三，增删改查等
四，SpringBoot整合mongoDB
1，导入MongoDb驱动
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>2，配置
spring:
data:
mongodb:
#test为在mongoDB创建的数据库
uri: mongodb://localhost/test3，注入对象，使用CRUD操作
@SpringBootTest
class Springboot0112MongodbApplicationTests {
@Autowired
private MongoTemplate mongoTemplate;
//添加数据
@Test
void contextLoads() {
Book book = new Book();
book.setType("2");
book.setName("测试");
book.setDescription("啥都不是");
book.setId(1);
mongoTemplate.save(book);
}
//查询数据
@Test
void get(){
List<Book> books = mongoTemplate.findAll(Book.class);
System.out.println(books);
}
}4，总结
（十）Elasticsearch（ES）
一，简介
倒排索引（根据其他信息，得到记录的id）是ES核心技术实现方法
2，安装和启动
3，操作
1，请求
IK分词器安装
放在es文件包plugin中
设置索引创建规则
2，创建文档
3，查询和删除文档
4， 修改文档
4，SpringBoot集成ES
1，添加依赖
<!--es依赖-->
<dependency>
<groupId>org.elasticsearch.client</groupId>
<artifactId>elasticsearch-rest-high-level-client</artifactId>
</dependency> 2，创建索引
3，添加文档
单个添加
@Test
void creatDocTest() throws IOException {
Book book = bookMapper.selectById(3);
List<Book> bookList = bookMapper.selectList(null);
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 creatDocTest1() throws IOException {
List<Book> bookList = bookMapper.selectList(null);
BulkRequest bulkRequest = new BulkRequest();
String json = null;
for (Book book : bookList) {
IndexRequest request = new IndexRequest("books").id(book.getId().toString());//创建文档
json = JSON.toJSONString(book);
request.source(json,XContentType.JSON);
bulkRequest.add(request);
}
client.bulk(bulkRequest,RequestOptions.DEFAULT);
}4，查询文档
按id查询：
//按id查询
@Test
void getTest() 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 getTest1() throws IOException {
SearchRequest request = new SearchRequest("books");
SearchSourceBuilder builder = new SearchSourceBuilder();
//设置查询条件
builder.query(QueryBuilders.termQuery("all","123"));
//放在请求中
request.source(builder);
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
//获取命中的对象
SearchHits hits = response.getHits();
for (SearchHit hit : hits) {
//获取source部分数据
String json = hit.getSourceAsString();
//转成对象
Book book = JSON.parseObject(json, Book.class);
System.out.println(book);
}
}
（十一）缓存的使用
简介：
使用步骤（默认缓存技术）
1，导入缓存技术的坐标
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-cache</artifactId>
</dependency>2，启用存储（在引导类上加注解@EnableCaching）
@SpringBootApplication
//开启缓存功能
@EnableCaching
public class SSMPApplication {
public static void main(String[] args) {
SpringApplication.run(SSMPApplication.class, args);
}
}3，设置操作结果数据进入缓存（@Cacheable注解）
//value值表示声明一块空间，用于存储缓存的数据，key表示某个数据的标识，需要具有唯一性
@Cacheable(value = "cacheSpace",key = "#id")
public Book getBookById(Integer id) {
return bookMapper.getBookById(id);
}其他存储技术
SpringBoot不管是使用默认的Simple缓存技术，还是Ehcache和Redis其在使用的使用使用的注解都是一样的，即统一接口，当它们的配置各有差异。
案例
1，Ehcache缓存
1，导入坐标
<!-- 其他的缓存技术-->
<dependency>
<groupId>net.sf.ehcache</groupId>
<artifactId>ehcache</artifactId>
</dependency>2，创建xml配置文件（一般用ehcache.xml）
<?xml version="1.0" encoding="UTF-8"?>
<ehcache xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:noNamespaceSchemaLocation="http://ehcache.org/ehcache.xsd"
updateCheck="false">
<defaultCache
maxElementsInMemory="1000"
overflowToDisk="false"
diskPersistent="false"
timeToIdleSeconds="3600"
timeToLiveSeconds="3600"
memoryStoreEvictionPolicy="LRU"
/>
<!--
name:缓存名称。
maxElementsInMemory：缓存最大个数。
eternal:对象是否永久有效，一但设置了，timeout将不起作用。
timeToIdleSeconds：设置对象在失效前的允许闲置时间（单位：秒）。仅当eternal=false对象不是永久有效时使用，可选属性，默认值是0，也就是可闲置时间无穷大。
timeToLiveSeconds：设置对象在失效前允许存活时间（单位：秒）。最大时间介于创建时间和失效时间之间。仅当eternal=false对象不是永久有效时使用，默认是0.，也就是对象存活时间无穷大。
overflowToDisk：当内存中对象数量达到maxElementsInMemory时，Ehcache将会对象写到磁盘中。
diskSpoolBufferSizeMB：这个参数设置DiskStore（磁盘缓存）的缓存区大小。默认是30MB。每个Cache都应该有自己的一个缓冲区。
maxElementsOnDisk：硬盘最大缓存个数。
diskPersistent：是否缓存虚拟机重启期数据 Whether the disk store persists between restarts of the Virtual Machine. The default value is false.
diskExpiryThreadIntervalSeconds：磁盘失效线程运行时间间隔，默认是120秒。
memoryStoreEvictionPolicy：当达到maxElementsInMemory限制时，Ehcache将会根据指定的策略去清理内存。默认策略是LRU（最近最少使用）。你可以设置为FIFO（先进先出）或是LFU（较少使用）。
clearOnFlush：内存数量最大时是否清除。
-->
<cache
name = "smsCode"
eternal = "false"
maxElementsInMemory="100"
overflowToDisk="false"
diskPersistent="false"
timeToIdleSeconds="10"
timeToLiveSeconds="60"
memoryStoreEvictionPolicy="LRU"/>
</ehcache>3，配置
spring:
cache:
type: ehcache #配置使用的缓存技术为ehcache
ehcache:
config: ehcache.xml #指定配置文件数据淘汰策略
2，Redis缓存
1，导入坐标
<!--redis-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>2，配置
spring:
cache:
type: redis
redis:
time-to-live: 20s #缓存有效时间
use-key-prefix: true #保留前缀
key-prefix: sms_ #添加前缀
cache-null-values: true #是否保存空值null
#redis服务器的启动配置
redis:
port: 6379
host: localhost3，启动redis服务器
4，使用
存入缓存
@CachePut(value = "smsCode",key = "#tele")//只放入缓存
public String sendCodeToSMS(String tele) {
return codeUtil.generator(tele);
}从缓存中取出数据
//根据key，获取缓存中的数据------要放在归Spring管理的对象中才能正常获取（@Cacheable注解被正常启动加载）
@Cacheable(value = "smsCode",key = "#tele")
public String get(String tele){
return null;
}P114
memcached缓存（boot没有其内置的整合方案）
1，安装
下载压缩包后，直接解压到一个安装包即可使用
https://www.runoob.com/memcached/window-install-memcached.html
2，添加坐标
<!--xmemcached -->
<dependency>
<groupId>com.googlecode.xmemcached</groupId>
<artifactId>xmemcached</artifactId>
<version>2.4.6</version>
</dependency>3，配置
application.yml定义的配置信息：
#memcached的配置信息
memcached:
#memcached服务器地址
servers: localhost:11211
#连接池的数量
poolSize: 10
#设置默认操作超时
opTimeOut: 10000配置信息类：
@Component
@Data
@ConfigurationProperties(prefix = "memcached")
public class XMemcachedProperties {
private String servers;
private Integer poolSize;
private Long opTimeOut;
}配置类：
@Configuration
public class XMemcachedConfig {
@Autowired
private XMemcachedProperties xMemcachedProperties;
@Bean
public MemcachedClient getMemcachedClient() throws IOException {
XMemcachedClientBuilder memcachedClientBuilder = new XMemcachedClientBuilder(xMemcachedProperties.getServers());
//线程池数量
memcachedClientBuilder.setSelectorPoolSize(xMemcachedProperties.getPoolSize());
//设置默认超时间
memcachedClientBuilder.setOpTimeout(xMemcachedProperties.getOpTimeOut());
MemcachedClient memcachedClient = memcachedClientBuilder.build();
return memcachedClient;
}
}4，使用
往缓存写入数据：
@Override
public String sendCodeToSMS(String tele) {
String code = codeUtil.generator(tele);
try {
//写入缓存
memcachedClient.set(tele,10,code);//0表示永不过期
} catch (Exception e) {
e.printStackTrace();
}
return code;
}从缓存读出数据：
@Override
public boolean checkCode(SMSCode smsCode) {
String code = null;
try {
//从缓存中获取去数据
code = memcachedClient.get(smsCode.getTele()).toString();
} catch (Exception e) {
e.printStackTrace();
}
return smsCode.getCode().equals(code);
}基于目前用到不黑马教程上面的第三方整合技术，所以在这里结束实用开发篇的学习。P115--P142的视频先不看。跳到P143原理篇继续学习。
2783
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
