目录
@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/test
3,注入对象,使用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: localhost
3,启动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,安装
下载压缩包后,直接解压到一个安装包即可使用
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原理篇继续学习。