springboot学习笔记--雷云龙

最新推荐文章于 2022-06-05 21:07:15 发布

猫腻0303

最新推荐文章于 2022-06-05 21:07:15 发布

阅读量446

点赞数

文章标签： java

本文链接：https://blog.csdn.net/qwd_as_dsd_as/article/details/103557326

版权

SpringBoot学习笔记

在这里插入图片描述

一、环境搭建

JDK版本1.8

1、添加父类

   <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.2.1.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>

2，添加start启动器

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter</artifactId>
        </dependency>
        <!--web启动器-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
 </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容器，代替<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下面的名称即可

       <!--引入jquery jar-->
        <dependency>
            <groupId>org.webjars</groupId>
            <artifactId>jquery</artifactId>
            <version>3.3.0</version>
        </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.boot</groupId>
            <artifactId>spring-boot-starter-thymeleaf</artifactId>
        </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

    <!--整合jdbc-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-jdbc</artifactId>
        </dependency>
        <!--mysql数据驱动-->
        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
        </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官网自己实现了：

<!--mybatis -->
<dependency>
    <groupId>org.mybatis.spring.boot</groupId>
    <artifactId>mybatis-spring-boot-starter</artifactId>
    <version>1.3.2</version>
</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的作者也为自己的插件编写了启动器，我们直接引入即可：

<!-- 通用mapper -->
<dependency>
    <groupId>tk.mybatis</groupId>
    <artifactId>mapper-spring-boot-starter</artifactId>
    <version>2.0.2</version>
</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<Object, Object>中
开发中使用缓存中间件；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；

 <!--redis缓存-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-cache</artifactId>
        </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<Object, Object>
3、RedisTemplate<Object, Object> 是默认使用jdk的序列化机制
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

<!--dubbo依赖-->
<!-- https://mvnrepository.com/artifact/com.alibaba.boot/dubbo-spring-boot-starter -->
<dependency>
    <groupId>com.alibaba.boot</groupId>
    <artifactId>dubbo-spring-boot-starter</artifactId>
    <version>0.2.0</version>
</dependency>
<!--zookeeper 客户端依赖-->
<!-- https://mvnrepository.com/artifact/com.github.sgroschupf/zkclient -->
<dependency>
    <groupId>com.github.sgroschupf</groupId>
    <artifactId>zkclient</artifactId>
    <version>0.1</version>
</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 "三国";
    }
}

后续。。。

猫腻0303

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
springboot学习笔记--雷云龙

SpringBoot学习笔记一、环境搭建JDK版本1.81、添加父类 <parent> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-parent</artifactId> ...
复制链接

扫一扫