springboot学习笔记--雷云龙
SpringBoot学习笔记
一、环境搭建
JDK版本1.8
1、添加父类
<parent>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-parentartifactId>
<version>2.2.1.RELEASEversion>
<relativePath/>
parent>
2，添加start启动器
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starterartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-webartifactId>
dependency>
3，写main方法以及添加注解(可自动生成)
@SpringBootApplication
public class DemoApplication {
public static void main(String[] args) {
SpringApplication.run(DemoApplication.class, args);
}
}
4、编写Controller
@RestController
public class Hello {
@RequestMapping("hello")
public String hello() {
return "hello";
}
}
二、基本知识
1, java配置主要靠java类和一些注解，比较常用的注解有（麻烦不可取）：
· @Configuration：声明一个类作为配置类，代替xml文件
· @Bean：声明在方法上，将方法的返回值加入Bean容器，代替
· @value：属性注入
· @PropertySource：指定外部属性文件
2，属性注入区别
| @configractionperproties | @value | |
|---|---|---|
| 功能 | 批量注入配置文件中的属性 | 一个一个注入 |
| 支持松散语法 | 支持 | 不支持 |
| spEL | 不支持 | 支持 |
| JSR303数据校验 | 支持 | 不支持 |
如果只是在业务逻辑中使用某一项值，使用@value
如果专门编写了javaBean 来和配置文件映射，则@configreactionperproties
@PropertyResource (value ={classpath : xxx.properties})
加载指定的资源配置文件
@ImportRespurce (location = {classpath:xxx.xml})
导入Spring 的配置文件 并使其生效(boot 推荐使用配置bean)
3,多Profile文件
1、 主配置文件编写的时候 可以使用 application-{profile}.peoperties
默认applicatio.Properties的配置
2、 激活指定profile
在配置文件中指定 spring.profiles.active = dev
命令行方式激活
虚拟机参数激活
3、 yaml 文件支持文档块
server:
port: 8080
spring:
profiles:
active: dev
---
server:
port: 8081
spring:
profiles: dev
---
server:
port: 8082
spring:
profiles: prod
4，自动配置(SpringBoot精髓)
@Data
@NoArgsConstructor
@AllArgsConstructor
@ConfigurationProperties(prefix = "spring.datasource")
@Component
public class JdbcProperties {
private String url;
private String driverClassName;
private String username;
private String password;
}
@Configuration // 指明当前类是配置类
@EnableConfigurationProperties
public class JdbcConfig {
@Bean //将该方法的返回值返回到组件中 组件默认id就是方法名
public DataSource dataSource(JdbcProperties datasource) {
DruidDataSource dataSource = new DruidDataSource();
dataSource.setUrl(datasource.getUrl());
dataSource.setDriverClassName(datasource.getDriverClassName());
dataSource.setUsername(datasource.getUsername());
dataSource.setPassword(datasource.getPassword());
return dataSource;
}
}
XxxConfig类是给容器中添加组件的。组件的ID就是方法名，组件的属性就是从XxxProperties中获取的。这些类中的每一个属性又是从yaml配置文件绑定的。
三，日志
1、日志框架
一个日志门面（抽象层） 对应一个实现
SLF4j --------------- logf4j logf4j2 Logback
… …
2、SLF4j 的使用
导入 SLF4j-jar log4j -jar 底层实现的Logback-jar
后续。。。。
四，Spring Boot 与Web 开发
1、Spring Boot 自动配置
2、SpringBoot 静态资源映射
1）可从webjars 引入需要的坐标,访问时候只需写 webjars下面的名称即可
<dependency>
<groupId>org.webjarsgroupId>
<artifactId>jqueryartifactId>
<version>3.3.0version>
dependency>
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-57fFYdFo-1576460502093)(C:\Users\雷云龙\AppData\Roaming\Typora\typora-user-images\1573976919713.png)]
2）自己的静态资源
“ / ** ” 可访问
“classpath : /resource ”
“classpath : /public ”
“classpath : /static ”
" / "当前跟路径
3、模板引擎Thymeleaf
1.对自动对 / templates / 下的xx.html文件自动渲染
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-thymeleafartifactId>
dependency>
2. Thymeleaf 使用和语法
1.导入名称空间
<html lang="en" xmlns:th="http://www.thymeleaf.org">
2.语法
-
tht : text 改变当前元素里的文本内容；
-
后续。。
-
技巧：
1>：禁用模板引擎的缓存
spring.thymeleaf.cache = false
2>：开发期间 模板引擎要实时生效，ctrl + F9
五，SpringBoot 整合JDBC
1. 引入jar
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-jdbcartifactId>
dependency>
<dependency>
<groupId>mysqlgroupId>
<artifactId>mysql-connector-javaartifactId>
dependency>
2.yml
server:
port: 8080
spring:
datasource:
driver-class-name: com.mysql.jdbc.Driver
url: jdbc:mysql://localhost:3306/mybookshop
username: root
password: root
六,SpringBoot 整合mybatis
1、整合mybatis
SpringBoot官方并没有提供Mybatis的启动器，不过Mybatis官网自己实现了：
<dependency>
<groupId>org.mybatis.spring.bootgroupId>
<artifactId>mybatis-spring-boot-starterartifactId>
<version>1.3.2version>
dependency>
需要注意，给每一个Mapper接口添加@Mapper注解，才能被识别。
@Mapper
public interface UserMapper {
@Select("select * from user_info")
public List<User> findAll();
@Update("update user_info set name=#{name} where id=#{id}")
public void update(User user);
@Delete("delete from user_info where id=#{id}")
public void delete(Integer id);
}
如果是针对单表的CURD操作，可以使用通用Mapper，更加简化Mapper操作。
2、通用mapper
通用Mapper的作者也为自己的插件编写了启动器，我们直接引入即可：
<dependency>
<groupId>tk.mybatisgroupId>
<artifactId>mapper-spring-boot-starterartifactId>
<version>2.0.2version>
dependency>
不需要做任何配置就可以使用了。
@Mapper
public interface UserMapper extends tk.mybatis.mapper.common.Mapper<User>{
}
注意事项：
1，实体类中需要添加如下注解：
@Table(name=“user_info”) 关联表操作
@Data 生成getter/setter方法
@Id 标识主键
2，使用Mapper提供的方法进行CURD操作（其中obj为需要操作的实体类）
增：insert(obj)
删：deleteByPrimaryKey(user);
改：updateByPrimaryKeySelective(obj)
查：selectAll()
七,SpringBoot整合缓存
1、注解（可以点进去看源码）
| Cache | 缓存接口，定义缓存操作。实现有：RedisCache、EhCacheCache、 ConcurrentMapCache等 |
|---|---|
| CacheManager | 缓存管理器，管理各种缓存（Cache）组件 |
| @Cacheable | 主要针对方法配置，能够根据方法的请求参数对其结果进行缓存 |
| @CacheEvict | 清空缓存 |
| @CachePut | 保证方法被调用，又希望结果被缓存。 |
| @EnableCaching | 开启基于注解的缓存 |
| keyGenerator | 缓存数据时key生成策略 |
| serialize | 缓存数据时value序列化策略 |
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-PKgn4BKO-1576460502094)(C:\Users\雷云龙\AppData\Roaming\Typora\typora-user-images\1574922687770.png)]
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-6RyiljtG-1576460502094)(C:\Users\雷云龙\AppData\Roaming\Typora\typora-user-images\1574922708913.png)]
2、编写
一、写好 entity dao service controller
二、快速体验缓存
步骤：
- 1、开启基于注解的缓存 @EnableCaching
- 2、标注缓存注解即可
- @Cacheable
- @CacheEvict
- @CachePut
- 默认使用的是ConcurrentMapCacheManager==ConcurrentMapCache；将数据保存在 ConcurrentMap
- 开发中使用缓存中间件；redis、memcached、ehcache；
yml
server:
port: 8080
spring:
datasource:
driver-class-name: com.mysql.cj.jdbc.Driver
url: jdbc:mysql://localhost:3306/mybookshop?serverTimezone=UTC
username: root
password: root
mybatis:
check-config-location: true #开启驼峰
#Mybatis打印语句的方式
configuration:
log-impl: org.apache.ibatis.logging.stdout.StdOutImpl
logging:
level:
com:
tydic:
dao: debug
3、在service中配置缓存
@Cacheable 将查询到的返回结果 存入缓存中
运行时机：在方法调用之前先按照key在redis查询，如果么有，则调用方法
/**
* Service层
* @author: tydic 雷云龙
* @time: 2019/11/20
*/
//业务类上加@CacheConfig注解，cacheNames为自定义的缓存名称，必须配置哦！
@CacheConfig(cacheNames = "Book")
@Service("bookService")
public class serviceImpl implements BookService {
@Autowired
private IBookDao bookDao;
@Override
@Cacheable
public List<Book> findAll() {
System.out.println("查询数据库了");
return bookDao.findAll();
}
@CachPut 既要调用方法，也更新缓存，达到同步更新的效果
运行时机：先调用方法，然后把方法返回值保存redis 中
@Override
@CachePut(key = "#book.id")
public boolean update(Book book) {
return bookDao.updateBook(book);
}
@CachEvict缓存清除
//,beforeInvocation = true 是否在缓存之前清除
在方法之后 则方法出问题，缓存不清除，如果在之前，不管方法执行不执行，都会清除缓存
@Override
@CacheEvict(key = "# id" ) // allEntries = true 清除缓存中 所有数据 //,beforeInvocation = true 是否在缓存之前清除
public boolean delete(Integer id) {
return bookDao.deleteBook(id);
}
4、在SpringBoot的启动类上开启缓存
@SpringBootApplication
@MapperScan("com.tydic.dao")
@EnableCaching //开启缓存
public class SpringBoot_redisAppliaction {
public static void main(String[] args) {
SpringApplication.run(SpringBoot_redisAppliaction.class,args);
}
}
5、SpringBoot 整合Redis
1,安装redis 使用docker(我用的Windows免安装的)
2,整合redis作为缓存
Redis 是一个开源（BSD许可）的，内存中的数据结构存储系统，它可以用作数据库、缓存和消息中间件。
-
1、安装redis：使用docker；
-
2、引入redis的starter
-
3、配置redis
-
4、测试缓存
-
原理：CacheManager===Cache 缓存组件来实际给缓存中存取数据
-
1）、引入redis的starter，容器中保存的是 RedisCacheManager；
<dependency> <groupId>org.springframework.bootgroupId> <artifactId>spring-boot-starter-data-redisartifactId> dependency> <dependency> <groupId>org.springframework.bootgroupId> <artifactId>spring-boot-starter-cacheartifactId> dependency>server: port: 8080 spring: datasource: driver-class-name: com.mysql.cj.jdbc.Driver url: jdbc:mysql://localhost:3306/mybookshop?serverTimezone=UTC username: root password: root #Redis配置 ## Redis数据库索引（默认为0） redis: database: 0 host: 127.0.0.1 #Redis服务器地址 port: 6379 #Redis服务器连接端口 password: timeout: 1200 # 连接超时时间（毫秒） mybatis: check-config-location: true #开启驼峰 #Mybatis打印语句的方式 configuration: log-impl: org.apache.ibatis.logging.stdout.StdOutImpl logging: level: com: tydic: dao: debug /* 视情况选择*/ #Redis配置 ## Redis数据库索引（默认为0） spring.redis.database=0 ## Redis服务器地址 spring.redis.host=127.0.0.1 ## Redis服务器连接端口 spring.redis.port=6379 ## Redis服务器连接密码（默认为空） spring.redis.password= ## 连接池最大连接数（使用负值表示没有限制） spring.redis.pool.max-active=8 ## 连接池最大阻塞等待时间（使用负值表示没有限制） spring.redis.pool.max-wait=-1 ## 连接池中的最大空闲连接 spring.redis.pool.max-idle=8 ## 连接池中的最小空闲连接 spring.redis.pool.min-idle=0 ## 连接超时时间（毫秒） spring.redis.timeout=1200 -
2）、RedisCacheManager 帮我们创建 RedisCache 来作为缓存组件；RedisCache通过操作redis缓存数据的
-
3）、默认保存数据 k-v 都是Object；利用序列化保存；如何保存为json
-
1、引入了redis的starter，cacheManager变为 RedisCacheManager；
-
2、默认创建的 RedisCacheManager 操作redis的时候使用的是 RedisTemplate
-
3、RedisTemplate
-
4）、自定义CacheManager；
package com.tydic.config;
import com.fasterxml.jackson.annotation.JsonAutoDetect;
import com.fasterxml.jackson.annotation.PropertyAccessor;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.tydic.entity.Book;
import org.springframework.cache.CacheManager;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.cache.RedisCacheConfiguration;
import org.springframework.data.redis.cache.RedisCacheManager;
import org.springframework.data.redis.connection.RedisConnectionFactory;
import org.springframework.data.redis.serializer.*;
import java.time.Duration;
/**
* 自定义Redis 配置存储为Json
*
* @author: tydic lyl
* @time: 2019/11/28
*/
@Configuration
public class MyRedisConfig {
private Duration timeToLive = Duration.ZERO;
public void setTimeToLive(Duration timeToLive) {
this.timeToLive = timeToLive;
}
@Bean
public CacheManager cacheManager(RedisConnectionFactory factory) {
RedisSerializer<String> redisSerializer = new StringRedisSerializer();
Jackson2JsonRedisSerializer<Object> jackson2JsonRedisSerializer = new Jackson2JsonRedisSerializer<>(Object.class);
//解决查询缓存转换异常的问题
ObjectMapper om = new ObjectMapper();
om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
om.enableDefaultTyping(ObjectMapper.DefaultTyping.NON_FINAL);
jackson2JsonRedisSerializer.setObjectMapper(om);
// 配置序列化（解决乱码的问题）
RedisCacheConfiguration config = RedisCacheConfiguration.defaultCacheConfig()
.entryTtl(timeToLive)
.serializeKeysWith(RedisSerializationContext.SerializationPair.fromSerializer(redisSerializer))
.serializeValuesWith(RedisSerializationContext.SerializationPair.fromSerializer(jackson2JsonRedisSerializer))
.disableCachingNullValues();
return RedisCacheManager.builder(factory)
.cacheDefaults(config)
.build();
}
}
八 、SpringBoot整合docker
1、简介
Docker是一个开源的应用容器引擎；是一个轻量级容器技术；
Docker支持将软件编译成一个镜像；然后在镜像中各种软件做好配置，将镜像发布出去，其他使用者可以直接使用这个镜像；
运行中的这个镜像称为容器，容器启动是非常快速的。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-DUUNV2bB-1576460502095)(E:/BaiduNetdiskDownload/springboot%E5%9F%BA%E7%A1%80%E6%BA%90%E7%A0%81/%E6%BA%90%E7%A0%81%E3%80%81%E8%B5%84%E6%96%99%E3%80%81%E8%AF%BE%E4%BB%B6/%E6%96%87%E6%A1%A3/Spring%20Boot%20%E7%AC%94%E8%AE%B0/images/%E6%90%9C%E7%8B%97%E6%88%AA%E5%9B%BE20180303145531.png)]
2、核心概念
docker主机(Host)：安装了Docker程序的机器（Docker直接安装在操作系统之上）；
docker客户端(Client)：连接docker主机进行操作；
docker仓库(Registry)：用来保存各种打包好的软件镜像；
docker镜像(Images)：软件打包好的镜像；放在docker仓库中；
docker容器(Container)：镜像启动后的实例称为一个容器；容器是独立运行的一个或一组应用
3、安装docker
linux环境 ：CentOS7 (内核需要3.10 以上 uname -r)
安装docker： yum install docker
启动docker：systemctl start docker
关闭docker：systemctl stop docker
开机自启动：systemctl enable docker
4、常用操作
1.镜像操作
需要操作谁(mysql) 就用 docker search mysql（可在docker hub 找所需版本 ）
拉取下载：docker pull mysql : 5.5( tag ) （默认：latest最新版）
列表：docker images 查看所有本地镜像
删除：docker rmi image-id 删除本地的镜像
2.容器操作
运行镜像，产生容器，真正操作的是容器
根据镜像启动容器：docker run --name sql(自定义名字) -d (后台运行) mysql:5.5（latest最新版）
查看运行中的 ：docker ps
查看所有容器 ：ps - a
停止运行中的容器：docker stop sql（NAMES容器名）或者 docker stop 6913cbc551f6(CONTAINER ID)
启动容器：docker start 6913cbc551f6
删除容器：docker rm 6913cbc551f6
端口映射：-p 3306 : 3306 将虚拟机主机的 端口映射到容器的端口 主机：容器
docker run -d -p 3306:3306 mysql
容器日志：docker logs 6913cbc551f6
5、后期环境准备
（MySQL Tomcat redis rabbitmq elasticsearch）
1.mysql(命令)
[root@localhost ~]# docker pull mysql :5.5 //下载
[root@localhost ~]# systemctl start docker
[root@localhost ~]# docker run -p 3307:3306 --name mysql002 -e MYSQL_ROOT_PASSWORD=123456 -d mysql
f6d30a345e257774e1f023ba5bbf8e62688718e5c28d4c55b9a7985676e3a248
[root@localhost ~]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
f6d30a345e25 mysql “docker-entrypoint…” 23 seconds ago Up 22 seconds 33060/tcp, 0.0.0.0:3307->3306/tcp mysql002
启动成功 ！（注意：mysql 高版本需要设置编码规则）
2.Tomcat
3.redis
[root@localhost ~]# docker pull redis
[root@localhost ~]# docker run -d -p 6379:6379 --name reids01 redis:latest
[root@localhost ~]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
a94e1922d911 redis:latest “docker-entrypoint…” 7 seconds ago Up 6 seconds 0.0.0.0:6379->6379/tcp reids01
启动成功！
九、SpringBoot整合dubbo
1、下载安装zkp
docker环境下
[root@localhost ~]# docker pull zookeeper
[root@localhost ~]# docker run -d -p 2181:2181 --name zookeeper:latest
67ca8135f2b4a00f4e7c68886e3ea507f179af42c99dd70513a8dfd45c70ca02
[root@localhost ~]# docker ps
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
67ca8135f2b4 zookeeper:latest “/docker-entrypoin…” 10 seconds ago Up 8 seconds 2888/tcp, 3888/tcp, 0.0.0.0:2181->2181/tcp, 8080/tcp zookeeper01
2、创建springboot项目
将服务注册到注册中心 整合dubbo
provider pom
<dependency>
<groupId>com.alibaba.bootgroupId>
<artifactId>dubbo-spring-boot-starterartifactId>
<version>0.2.0version>
dependency>
<dependency>
<groupId>com.github.sgroschupfgroupId>
<artifactId>zkclientartifactId>
<version>0.1version>
dependency>
yml
dubbo:
application:
name: dubbo-book-provider #服务名
registry:
address: zookeeper://192.168.177.129:2181 #注册中心的地址
scan:
base-packages: com.tydic.service #扫描服务包
serviceimpl 注意导的包
import com.alibaba.dubbo.config.annotation.Service;
import org.springframework.stereotype.Component;
/**
* @author: tydic lyl
* @time: 2019/12/11
*/
@Component //将服务放到spring容器中
@Service //将服务发布出去 注意导的包
public class ProviderServiceImpl implements ProviderService {
@Override
public String getName() {
return "三国";
}
}
后续。。。