SpringBoot开发使用篇

（一）热部署

1，手动部署

2，自动部署

3，设置热部署范围配置

4，禁用热部署

application.yml上禁用（级别低）

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

@ConfiguratinProperties注解属性名松散判定

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

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

（四）常用计量单位应用

@DurationUnit和@DataSizeUnit注解：

可选的单位：编辑

（五）bean属性校验

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

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

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

一，数据源（SpringBoot内置）

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

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

应用场景：

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

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

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

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

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

四，SpringBoot整合mongoDB

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

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

其他存储技术

1，Ehcache缓存

1，导入坐标

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

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

（一）热部署

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（接口）坐标


        
        <dependency>
            <groupId>javax.validationgroupId>
            <artifactId>validation-apiartifactId>
        dependency>

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


        
        <dependency>
            <groupId>org.hibernate.validatorgroupId>
            <artifactId>hibernate-validatorartifactId>
        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，导入整合坐标


        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-data-redisartifactId>
        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 ops = stringRedisTemplate.opsForValue();
        System.out.println(ops.get("name"));
    }
    @Test
    public void set(){
        ValueOperations 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.bootgroupId>
            <artifactId>spring-boot-starter-data-mongodbartifactId>
        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 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，添加依赖


		
		<dependency>
			<groupId>org.elasticsearch.clientgroupId>
			<artifactId>elasticsearch-rest-high-level-clientartifactId>
		dependency>

2，创建索引

3，添加文档

单个添加


	@Test
	void creatDocTest() throws IOException {
		Book book = bookMapper.selectById(3);
		List 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 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.bootgroupId>
            <artifactId>spring-boot-starter-cacheartifactId>
        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.ehcachegroupId>
            <artifactId>ehcacheartifactId>
        dependency>

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


<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"
    />
    
    <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，导入坐标


        
        <dependency>
            <groupId>org.springframework.bootgroupId>
            <artifactId>spring-boot-starter-data-redisartifactId>
        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，安装

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

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

2，添加坐标


        
        <dependency>
            <groupId>com.googlecode.xmemcachedgroupId>
            <artifactId>xmemcachedartifactId>
            <version>2.4.6version>
        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原理篇继续学习。

相关阅读:
二叉搜索树的实现
 centos 通过yum安装nginx
vscode ssh远程连接服务器，一直正在下载vscode服务器的解决办法
 Docker逃逸---SYS_PTRACE浅析
 使用C语言实现散列表中的冲突处理方法
 【无标题】
Vue中过滤器如何使用？
gltf格式数据获取
 微型微控制器托管双直流/直流升压转换器
 Android studio之编译提示Could not find :umeng-asms-v1.2.1
原文地址：https://blog.csdn.net/weixin_51474578/article/details/126129067

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操作

2，自动部署

（六）进制数据转换规则

1，定义：

4，修改文档