1. 用 Interceptor 拦截请求

2. 用ThreadLocal 变量保存 Request

3. 自定义负载均衡器

4. 从 Request 中拿到 FeignClient 注解配置

5. 其他细节

5.1 不要自己声明负载均衡器的 Bean 了

5.2 @LoadBalancerClient 就够用了，还有 @LoadBalancerClients

IDEA 插件可以实现很多功能，自定义语言、更丰富的代码提示和挂高亮、代码生成、通过 PSI 操作源码。而我现在就在通过 PSI 相关方法为 spring cloud 的 api 方法生成 trpc 桩代码。

大家好！2021年的脚步越来越近，我在北京向大家致以新年的美好祝福！

2020年是极不平凡的一年。面对突如其来的新冠肺炎疫情，我们以人民至上、生命至上诠释了人间大爱，用众志成城、坚忍不拔书写了抗疫史诗。在共克时艰的日子里，有逆行出征的豪迈，有顽强不屈的坚守，有患难与共的担当，有英勇无畏的牺牲，有守望相助的感动。从白衣天使到人民子弟兵，从科研人员到社区工作者，从志愿者到工程建设者，从古稀老人到“90后”、“00后”青年一代，无数人以生命赴使命、用挚爱护苍生，将涓滴之力汇聚成磅礴伟力，构筑起守护生命的铜墙铁壁。一个个义无反顾的身影，一次次心手相连的接力，一幕幕感人至深的场景，生动展示了伟大抗疫精神。平凡铸就伟大，英雄来自人民。每个人都了不起！向所有不幸感染的病患者表示慰问！向所有平凡的英雄致敬！我为伟大的祖国和人民而骄傲，为自强不息的民族精神而自豪！

艰难方显勇毅，磨砺始得玉成。我们克服疫情影响，统筹疫情防控和经济社会发展取得重大成果。“十三五”圆满收官，“十四五”全面擘画。新发展格局加快构建，高质量发展深入实施。我国在世界主要经济体中率先实现正增长，预计2020年国内生产总值迈上百万亿元新台阶。粮食生产喜获“十七连丰”。“天问一号”、“嫦娥五号”、“奋斗者”号等科学探测实现重大突破。海南自由贸易港建设蓬勃展开。我们还抵御了严重洪涝灾害，广大军民不畏艰险，同心协力抗洪救灾，努力把损失降到了最低。我到13个省区市考察时欣喜看到，大家认真细致落实防疫措施，争分夺秒复工复产，全力以赴创新创造，神州大地自信自强、充满韧劲，一派只争朝夕、生机勃勃的景象。

2020年，全面建成小康社会取得伟大历史性成就，决战脱贫攻坚取得决定性胜利。我们向深度贫困堡垒发起总攻，啃下了最难啃的“硬骨头”。历经8年，现行标准下近1亿农村贫困人口全部脱贫，832个贫困县全部摘帽。这些年，我去了全国14个集中连片特困地区，乡亲们愚公移山的干劲，广大扶贫干部倾情投入的奉献，时常浮现在脑海。我们还要咬定青山不放松，脚踏实地加油干，努力绘就乡村振兴的壮美画卷，朝着共同富裕的目标稳步前行。

今年，我们隆重庆祝深圳等经济特区建立40周年、上海浦东开发开放30周年。置身春潮涌动的南海之滨、绚丽多姿的黄浦江畔，令人百感交集，先行先试变成了示范引领，探索创新成为了创新引领。改革开放创造了发展奇迹，今后还要以更大气魄深化改革、扩大开放，续写更多“春天的故事”。

大道不孤，天下一家。经历了一年来的风雨，我们比任何时候都更加深切体会到人类命运共同体的意义。我同国际上新老朋友进行了多次通话，出席了多场“云会议”，谈得最多的就是和衷共济、团结抗疫。疫情防控任重道远。世界各国人民要携起手来，风雨同舟，早日驱散疫情的阴霾，努力建设更加美好的地球家园。

2021年是中国共产党百年华诞。百年征程波澜壮阔，百年初心历久弥坚。从上海石库门到嘉兴南湖，一艘小小红船承载着人民的重托、民族的希望，越过急流险滩，穿过惊涛骇浪，成为领航中国行稳致远的巍巍巨轮。胸怀千秋伟业，恰是百年风华。我们秉持以人民为中心，永葆初心、牢记使命，乘风破浪、扬帆远航，一定能实现中华民族伟大复兴。

站在“两个一百年”的历史交汇点，全面建设社会主义现代化国家新征程即将开启。征途漫漫，惟有奋斗。我们通过奋斗，披荆斩棘，走过了万水千山。我们还要继续奋斗，勇往直前，创造更加灿烂的辉煌！

此时此刻，华灯初上，万家团圆。新年将至，惟愿山河锦绣、国泰民安！惟愿和顺致祥、幸福美满！

谢谢大家！

来源：新华社

本期编辑：胡程远、李娜

github地址
https://github.com/zkalan/qiniu-image.git

绘制软件界面

使用Qt Designer绘制程序界面，设置图标，修改控件id等。这个过程还包括几个配置步骤：

• 在pycharm中安装PyQt5
• 在pycharm中安装PyQt5-tools
• 配置pycharm，方便的通过tools界面启动dedigner和其他工具

slots和signals

这是两个PyQt中的概念，signal就是信号，是动作的发出者；slot就是槽，是动作的相应者。代码如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

# -*- coding: utf-8 -*-
import sys, os
if hasattr(sys, 'frozen'):
    os.environ['PATH'] = sys._MEIPASS + ";" + os.environ['PATH']
from ui import mainwindow
from PyQt5 import QtGui, QtCore
from PyQt5.QtWidgets import QMainWindow, QApplication, QMessageBox, QFileDialog
from utils import uploadtoqiniu

class WindowService(QMainWindow, mainwindow.Ui_MainWindow):
    def __init__(self):
        super(WindowService, self).__init__()
        self.setupUi(self)
        # bind slots and signals
        self.pb_select.clicked.connect(self.pb_select_service)

        self.pb_copy_url.clicked.connect(self.pb_copy_url_service)
        self.pb_copy_markdown.clicked.connect(self.pb_copy_markdown_service)
        self.pb_upload.clicked.connect(self.pb_upload_service)

    def pb_select_service(self):
        filename, filetype = QFileDialog.getOpenFileName(self,
                                                         '选择文件',
                                                         os.getcwd(),
                                                         "Images (*.jpg;*.jpeg;*.gif;*.png;*.ico);;All Files (*)")
        if filename == '':
            print('filename is' + filename)
            return
        self.le_selectimage.setText(filename)
        print('filename is' + filename)
        print('文件筛选器类型：', filetype)

    def pb_upload_service(self):
        filepath = self.le_selectimage.text()
        if filepath == '':
            self.maessage_box('select a image')
        else:
            if os.path.exists('settings.cfg'):
                back_url = uploadtoqiniu.upload(filepath)
                self.le_url.setText(back_url)
                self.le_md.setText('![](' + back_url + ')')
                img = QtGui.QImage(filepath)
                scale = img.size().width()/411 if ((img.size().width()/411) > (img.size().height()/201)) else img.size().height()/201
                scale_width = img.size().width()/scale
                scale_height = img.size().height() / scale
                size = QtCore.QSize(scale_width, scale_height)
                image = QtGui.QPixmap.fromImage(img.scaled(size, QtCore.Qt.IgnoreAspectRatio))
                self.l_preview.setPixmap(image)
                print(image.size())
                print(type(image.size()))
                self.maessage_box('Success')
            else:
                self.maessage_box('check setting.cfg')

    def pb_copy_url_service(self):
        clipboard = QApplication.clipboard()
        url = self.le_url.text()
        clipboard.setText(url)
        self.maessage_box('copy to clipkboard')

    def pb_copy_markdown_service(self):
        clipboard = QApplication.clipboard()
        md_url = self.le_md.text()
        clipboard.setText(md_url)
        self.maessage_box('copy to clipkboard')

    def maessage_box(self, message, title='information'):
        box = QMessageBox(self)
        box.setIcon(QMessageBox.Information)
        box.setText(message)
        box.setWindowTitle(title)
        box.setStandardButtons(QMessageBox.Ok)
        box.button(QMessageBox.Ok).animateClick(2*1000)
        box.exec_()

使用pyinstaller打包

pyinstaller打包总是问题百出，PyQt5自己也有不少bug。遇到这些问题

ImportError: unable to find Qt5Core.dll on PATH

解决办法如下

https://blog.csdn.net/zwyact/article/details/99778898
在主程序中pyqt5库import之前就对系统变量进行手动设置

1
2
3

import sys, os
if hasattr(sys, 'frozen'):
    os.environ['PATH'] = sys._MEIPASS + ";" + os.environ['PATH']

NameError: name ‘exit’ is not defined

解决办法就是这样写sys.exit

效果预览

settings.cfg是配置文件，其中需要配置各个字段。可以配置是否使用水印。

主界面

上传图片

上传完图片还能快速获取访问链接。

github地址
https://github.com/zkalan/qiniu-image.git

2011年发布1.0版本，2012年发布稳定版，2013发布2.x版本（Yarn）

缺点

• 基于数据集的计算，所以面向数据。从存储介质中获取数据，然后进行计算，最后将结果存储到介质中。所以主要应用于一次性计算，不适合数据挖掘和机器学习这些迭代计算和图形挖掘计算。
• mapreduce基于文件存储介质的操作，性能差
• mapreduce和hadoop紧密耦合

Yarn版本

ResourceManager、ApplicationMaster、Driver、NodeManager

spark历史

2013年6月正式发布，spark基于hadoop1.x架构思想设计思想。spark计算基于内存，并且基于Scala语法开发，所以天生适合迭代式计算。

HDFS-Yarn-Spark

Spark下载地址

http://spark.apache.org

重要角色

Driver（驱动器）

Executer（执行器）

Spark-Yarn运行模式简图

Standalone模式

RDD

RDD(Resilient Distributed Dataset)称为弹性分布式数据集，是Spark中最基本的数据或计算抽象。代码中是一个抽象类，代表一个不可变、可分区、里面的元素可进行并行计算的集合。

RDD属性

• 一组分区Partition，即数据集的基本组成单位
• 一个计算每个分区的函数
• RDD之间的依赖关系
• 一个Partitioner，即RDD的分片函数
• 一个列表，存储存取每个Partiton的优先位置preferred location

大数据窍门：移动数据不如移动计算

RDD特点

RDD表示只读的分区的数据集，对RDD进行改动，只能通过RDD的转换操作，由一个RDD得到一个新的RDD，新的RDD包含了从其他RDD衍生所必须的信息，RDDs之间存在依赖，RDD的执行是按照血缘关系延时计算的。如果血缘关系较长，可以通过持久化RDD来切断血缘关系。

Spark中所有RDD方法都称为算子，共分为两大类，转化算子和行动算子。

缓存

如果应用程序多次使用同一个RDD，可以将该RDD缓存起来。

RDD的创建

Spark中创建RDD的方法有三种：从集合中创建、从外部存储创建、从其他RDD创建。

集合创建

1
2
3

//前者调用后者
sc.makeRDD(List(1, 2, 3, 4))
sc.parallelize(Array(1, 2, 3, 4))

外部存储创建

1
2
3

//默认情况下，可以读取项目路径，也可以读取其他HDFS路径
val value:RDD[String] = sc.textField("in")
//涉及hadoop读取文件的分片规则

RDD的转换

Value类型

map(function)

返回一个新的RDD，该RDD由每一个输入元素经过function函数转换后组成。例如通过一个数组RDD得到一个每个元素被乘以2的新的RDD。

mapPartitions

mapPartitions效率优于map算子，减少了发送到执行器执行交互次数。但是可能会出现内存溢出OOM。一次处理一个分区的数据。

mapPartitionsWithIndex(func)

作用是，func带有一个整数参数表示分片的索引值，因此在类型为T的RDD上运行时，func的函数类型必须是(Int, Interator[T]) -> Iterator[U]。

Driver和Executor关系

Driver就是创建Spark上下文对象的应用程序，Executor就是用于提取任务并执行。

flatMap

glom

将每一个分区形成一个数组，形成新的RDD类型为RDD[Array[T]]。

groupBy & filter

分组，按照传入函数的返回值进行分组，将相同的key对应的值放入一个迭代器。

sample(withRepalcement, fraction, seed)

以指定的随机种子随机抽样出数量为fraction的数据，withReplacement表示抽出的数据是否放回，true表示有放回，seed用于指定随机数生成器种子。

distinct

coalesce

repartition & sortBy

双Value类型交互

union

cartesian

Key-Value类型

partitionBy

groupBykey

reduceBykey

aggregateBykey

foldByKey & combinByKey

sortByKey & mapValueByKey

方法不同，底层实现和代码的执行位置很不同，
是的Driver执行还是在Executor执行？

RDD的依赖

窄依赖

窄依赖指的是每一个父RDD的Partition最多被子RDD的一个Partition使用，窄依赖被比喻为独生子女。

宽依赖

宽依赖指的是每一个父RDD的Partition可以被多个子RDD的Partition使用。

DAG

任务划分

宽依赖放在不同的stage，窄依赖放在同一个stage。

1. Application：初始化一个SparkContext即生成一个Application；
2. Job：一个Action算子就会生成一个Job；
3. Stage：根据RDD依赖关系，将Job划分成不同的Stage，一个宽依赖就划分一个新的Stage；
4. Task：Stage是一个TaskSet，将Stage划分的结果发送到不同Executor执行即为一个Task；
5. 上述四者每一层都是一对n的关系；

RDD的缓存

通过persist方法或cache方法可以将前面的计算结果缓存，默认情况下persist()会把数据以序列化的形式缓存在JVM的堆空间中。但是并不是这两个方法调用时立刻缓存，而是触发后面的action时，该RDD将会被缓存在计算节点的内存中，供后面重用。

此外还有checkpoint功能，通过函数setCheckpointDir(dir)设置。

一般在血缘关系比较长的时候使用。

RDD分区器

Spark三大数据结构

• RDD：分布式数据集
• 广播变量：分布式只读共享变量 broadcast，调优策略
• 累加器：分布式只写共享变量，LongAccumulator

Spark中的数量

• Executor：默认有2个；可以通过提交参数设置；
• partition：默认情况，读取文件采用Hadoop的切片规则，如果读取内存中的数据，可以根据特定的算法设定，可以通过其他算子进行改变；多个阶段的场合，下一个阶段分区的数量受到上一个阶段分区的影响；
• Stage：ResultStage + Shuffle依赖的数量，划分阶段的目的就是为了任务执行的等待，因为Shuffle的过程需要落盘；
• Task：原则上一个分区就是一个任务，但实际中，可以动态调整；

参考链接
https://blog.csdn.net/eguid_1/article/details/52678775

这块内容主要是javaCV基本API的使用，代码非常简单，我将其写在了一个类中，位于
src/main/java/com/zkalan/capture下，然后再demo类中调用测试；需要注意的是，网
上的很多代码将画板canvas的销毁方式设置为EXIT_ON_CLOSE，这会导致java虚拟机直接
推出，资源无法释放。我认为正确的写法应该是DISPOSED_ON_CLOSE。

1

canvas.setDefaultCloseOperation(WindowConstants.DISPOSE_ON_CLOSE);

搭建rtmp推流服务器

通过nginx服务器和nginx-rtmp-module可以简单的搭建一个rtmp服务器，我将使用的nginx
编译版本放在了这里
，这是已经包含了nginx-rtmp-module的版本，使用非常简单，首先在配置文件，例如
nginx-win-rtmp.conf中，添加一段rtmp配置项

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

rtmp {
    server {
        listen 1935;
        chunk_size 4000;
        #mylive就是直播项目名
        application mylive {
             live on;
 
             # record first 1K of stream
             record all;
             record_path /tmp/av;
             record_max_size 1K;
 
             # append current timestamp to each flv
             record_unique on;
 
             # publish only from localhost
             #allow publish 127.0.0.1;
             #deny publish all;
 
             #allow play all;
        }
    }
}

然后在命令行中启动nginx服务器，例如命令

1

start nginx.exe -c conf\nginx-win-rtmp.conf

最后，启动第一部分写好的demo程序，注意publish address应该是这样的格式
rtmp://localhost:port/mylive/，使用potplayer或者vlc访问该链接，测试推流是否成功。

在网页播放rtmp流

参考链接
https://blog.csdn.net/qq_30152271/article/details/84334734

操作起来很简单，就是创建一个静态网页，放到服务器目录下，启动任何一个静态服务器，例如
上文的nginx，访问该静态网页，只要地址填写正确，就可以观看推流内容了。

Demo地址

javaCV-rtmp-demo

浏览器效果图

环境搭建

1. 创建maven工程并导入坐标；
2. 创建实体类和dao的接口；
3. 创建Mybatis的主配置文件SqlMapConfig.xml
4. 创建映射配置文件；

注意事项

1. 在Mybatis中把持久层的接口名称和映射文件也叫做Mapper；
2. Mybatis的映射配置文件位置必须和dao接口的包结构相同；
3. 映射配置文件的mapper标签namespace属性的取值必须是dao接口的全限定类名；
4. 映射配置文件的操作配置，id属性的取值必须是dao接口的方法名；
5. 遵守3、4和5，不需要自己写dao接口实现类；

Mybatis连接池

提供了三种配置方式。
配置的位置：主配置文件SqlMapConfig.xml中的dataSource标签，type属性就是表示采用哪种连接池。

• POOLED：采用传统的javax.sql.DataSource规范中的连接池，mybatis中有针对规范的实现。
• UNPOOLED：采用传统的获取连接的方式，虽然也实现Javax.sql.DataSource接口，但是并没有使用赤的思想。
• JNDI：采用服务器提供的JNDI技术实现，来获取DataSource对象，不同的服务器能拿到的DataSource不同。web和maven的war工程才可使用。tomcat服务器采用的连接池是dbcp连接池。

Mybatis中的事务

通过sqlsession对象的commit方法和rollback方法实现事务的提交和回滚。

• 清晰的角色划分；
• 分工明确，扩展灵活；
• 等

基本组件

DispatcherServlet前端控制器

用户i请求到达前端控制器，相当于MVC模式中的C，DispatcherServlet是整个流程控制的中心，由它调用其他组件处理用户的请求，DispatcherServlet降低了组件之间的耦合。

HandlerMapping处理器映射器*

HandlerMapping负责根据用户请求找到Handler，SpingMVC提供了不同的映射器实现不同的映射方式，例如配置文件方式、实现接口方式、注解方式等。

Handler处理器

开发中需要编写的具体业务控制器，由DispatcherServlet把用户的请求转发到Handler，由Handler对具体的用户请求进行处理。

HandlerAdapter处理器适配器*

通过HandlerAdapter对处理器进行执行，这是适配器模式的应用，通过扩展适配器可以对更多类型的处理器进行执行。

View Resolver视图解析器*

View Resolver负责将处理结果生成View视图，View Resolver首先根据逻辑视图名解析成物理视图名即具体的页面地址，再生成View视图对象，最后对View进行渲染将处理结果通过页面展示给用户。

View视图

SpringMVC框架提供了很多的View视图类型的支持，包括jstlView, freemarkerView, pdfView等。最常用的是jsp。一般情况下需要通过页面标签或页面模板技术将模型数据通过页面展示给用户。

RequestMapping

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40

package org.springframework.web.bind.annotation;
import java.lang.annotation.Documented;
import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.springframework.core.annotation.AliasFor;

//可以作用于类和方法，支持分级映射
@Target({ElementType.METHOD, ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Mapping
public @interface RequestMapping {

String name() default "";
    
    //别名path和value通用，用于指定url
@AliasFor("path")
String[] value() default {};

@AliasFor("value")
String[] path() default {};
    
    
    //public enum RequestMethod {
    //GET, HEAD, POST, PUT, PATCH, DELETE, OPTIONS, TRACE
    //}
    RequestMethod[] method() default {};
    
    //限定传递的请求参数
String[] params() default {};

    //用于指定限制请求的头条件
String[] headers() default {};

String[] consumes() default {};

String[] produces() default {};
}

请求参数的绑定

支持简单数据类型、对象、列表等。@RequestMapping(param={username=””})

自定义类型转换器

1. 首先实现Converter接口；
2. 在spring配置文件中配置自定义类型转换器；

Servlet原生API

HttpServletRequest、HttpServletResponse、HttpSession、ServletContext。

常用注解

1. @RequestParam
2. @RequestBody get方法不适用
3. @PathVariable RESTful风格 WebClient模拟发送请求
4. @RequestHeader
5. @CookieValue 获取cookie的值
6. @ModelAttribute
7. @SessionAttributes 用于多次执行控制器方法间的参数共享

ResponseBody相应json数据

DispatcherServlet会拦截所有资源，导致静态资源，如image、css、js等也会被拦截，解决方法就是需要配置静态资源不拦截。

Docker核心概念

Docker主机Host

一个物理或虚拟的机器，用于执行Docker守护进程和容器；

Docker镜像Images

Docker镜像是用于创建Docker容器的模板；

Docker容器Container

容器是独立运行的一个或一组应用；

Docker客户端Client

客户端通过命令行或者其他工具使用Docker API和Docker的守护进程通信；

Docker仓库Registry

Docker仓库用来保存镜像，可以理解为代码控制中的代码仓库，Docker Hub提供了庞大的镜像集合使用；

使用Docker

基本命令

1
2
3
4

yum install docker
docker -v
systemctl start docker
systemctl enable docker

1
2
3
4

docker search mysql #搜索mysql image
docker pull mysql #拉取镜像
docker images #查看镜像列表
docker rmi images-id #移除镜像

容器操作

1
2
3
4
5
6
7

docker run --name mymysql -d mysql:TAG #启动容器
docker ps #查看运行中的容器
docker ps -a #查看所有容器
docker stop container-id #停止容器
docker rm -a # 删除所有容器
docker run --name container-name iamge-name -d -p 1008:8080 #-p进行端口映射
docker logs container-id/container-name

其他命令

如何使用spring boot：

1. 创建spring boot应用，选中需要的模块；
2. spring boot已经默认将这些场景配置好，只需要在配置文件中指定少量配置就可与运行；
3. 编写业务代码；

自动配置原理

webjars和静态资源映射规则

1. 所有/webjars/**，都去classpath:/META-INF/resources/webjars查找资源；
   webjars：以jar包方式引入静态资源。

2. “/**”访问当前项目的任何资源，静态资源文件夹

   1 2 3 4 5

   "classpath:/MEAT-INF/resources/", "classpath:/resources/", "calsspath:/static/", "calsspath:/puclic/", "/":当前目录的根目录

3. 欢迎页：静态资源文件夹下的所有index.html页面，被”/**”映射；

4. 所有的**/favicon.ico都是在静态资源文件夹下查找；

模板引擎

JSP、

1
2
3
4
5
6
7
8

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-thymeleaf</artifactId>
</dependency>
<properties>
    <thymeleaf.version>3.0.9.RELEASE</thymeleaf.version>
    <thymeleaf-layout-dialect.version>2.3.0</thymeleaf-layout-dialect.version>
</properties>

thymeleaf

导入语法空间

thymeleaf语法规则

• 片段包含：jsp:include
  • th:insert
  • th:replace
• 遍历:c:forEach
  • th:each
• 条件判断c:if
  • th:if
  • th:unless
  • th:switch
  • th:case
• 声明变量c:set
  • th:object
  • th:with
• 任意属性修改支持prepend,append
  • th:attr
  • th:attrprepend
  • th:attrappend
• 修改指定属性默认值
  • th:value
  • th:href
  • th:src
• 修改标签体内容
  • th:text不转义
  • th:utext转义
• 声明片段
  • th:fragment
• …

thymeleaf表达式

• Simple expressions:
  • Variable Expressions: ${…}
  • Selection Variable Expressions: *{…}
  • Message Expressions: #{…}
  • Link URL Expressions: @{…}
  • Fragment Expressions: ~{…}
• Literals
  • Text literals: ‘one text’ , ‘Another one!’ ,…
  • Number literals: 0 , 34 , 3.0 , 12.3 ,…
  • Boolean literals: true , false
  • Null literal: null
  • Literal tokens: one , sometext , main ,…
• Text operations:
  • String concatenation: +
  • Literal substitutions: |The name is ${name}|
• Arithmetic operations:
  • Binary operators: + , - , * , / , %
  • Minus sign (unary operator): -
• Boolean operations:
  • Binary operators: and , or
  • Boolean negation (unary operator): ! , not
• Comparisons and equality:
  • Comparators: > , < , >= , <= ( gt , lt , ge , le )
  • Equality operators: == , != ( eq , ne )
• Conditional operators:
  • If-then: (if) ? (then)
  • If-then-else: (if) ? (then) : (else)
  • Default: (value) ?: (defaultvalue)
• Special tokens:
  • No-Operation: _

Spring Boot自动配置Spring MVC

• Inclusion of ContentNegotiatingViewResolver and BeanNameViewResolver beans;
• Support for serving static resourcces, including support for Webjars;
• Automatic registration of Converter, GenericConverter, Formatter beans;
• Support for HttpMessageConerters;
• Automatic registration of MessageCodeResolver;
• Static index.html support;
• Custom Favicon support;
• Automatic use of a ConfigurableWebBindingInitializer bean;

修改Spring Boot默认配置

扩展Spring MVC

Tips

国际化

默认的区域信息是通过浏览器请求报文获取的。可以通过链接提交区域信息。
自己的信息解析器需要实现Localeresolver。

1. 编写国际化配置文件，抽取页面需要配置的国际化信息；
2. 使用ResourceBundleMessageSource管理国际化资源信息；
3. 在页面使用fml:message获取国际化内容；
4. 可以自己编写区域信息解析器，替换Spring Boot默认的解析器ResourceBundleMessageSource；

模板引擎要实时生效，需要禁用模板缓存，页面修改要ctrl+F9重新编译

登陆状态检查需要拦截器

thymeleaf公共页面元素抽取

1. 抽取公共片段
2. 引入公共片段
3. 不同替换效果有th:insert、th:replace、th:include

错误处理的自动配置

可以参照ErrorMVCAutoConfiguration；容器中有如下组件：

1. DefaultErrorAttributes
2. BasicErrorController
3. ErrorPageCustomizer
4. DefaultErrorViewResolver

注册Servlet、Filter、Linstener

Spring Boot默认是以jar包的方式启动嵌入式的Servlet容器来启动Spring Boot的web应用，没有web.xml文件；
注册三大组件使用ServletRegistrationBean, FilterRegistrationBean, ServletListenerRegistrationBean。

其他嵌入式Servlet容器

Jetty

适合长连接

Undertow

后置处理器会获取所有容器中的定制器，以此配置Servlet容器，自己定义容器就是将自定义的定制器加到Bean工厂中。

嵌入式Servlet容器启动原理

1. Spring Boot应用启动运行run方法；
2. refreshContext(context);Spring Boot刷新IOC容器，创建IOC容器对象，并初始化容器，创建容器中的每一个组件，还判断了是否是web应用；
3. refresh(context);刷新刚才创建好的ioc容器；
4. onRefresh();web的IOC容器重写了onRefresh方法；
5. web IOC容器会创建嵌入式的Servlet容器；createEmbeddedServletContainer();
6. 获取嵌入式的Servlet容器工厂；TomcatEmbeddedServletContainerFactory创建对象，后置处理器随后获取所有的定制器来定制Servlet容器的相关配置；
7. 使用容器工厂获取嵌入式的Servlet容器；
8. 嵌入式的Servlet容器创建对象并启动Servlet容器；先启动嵌入式的Servlet容器，再将IOC容器中剩下的对象获取；

使用外置的Servlet容器

嵌入式Servlet容器优点在于简单、便携，缺点在于默认不支持JSP，优化定制不够复杂；使用定制器、自己编写嵌入式Servlet容器的创建工厂；

1. 必须创建一个war项目，利用idea创建目录结构；
2. 将嵌入式的Tomcat指定为provided；
3. 必须编写一个SpringBootServletInitializer的子类，并调用configure方法；
4. 启动tomcat；

.yml是YAML语言的文件，以数据为中心，比json、xml更适合做配置文件。

参考语法规范http://www.yaml.org

1
2

server:
    port: 8081

基本语法

key:(空格)value：表示一对键值对，空格是必须的；

以空格的缩进来控制层级关系，只要左对齐，就认为是同一层级。

值的写法

字面值（普通的值，数字、字符串、布尔）

key:(空格)value：字面直接写

• 字符串默认不用引号
• 双引号和单引号有区别，前者会对特殊字符转义，后者只会当作普通字符

数组（list、set）

用-值表示数组中的一个元素

1
2
3
4

pets:
 - cat
 - dog
 - pig

行内写法

1

pets: [cat,dog,pig]

对象、Map（属性和值）

方法和前文一致

1
2
3
4

friend:
    firstname: zhang
    lastname： san
    telphone: 136545646

行内写法

1

friend: {firstname: zhang,lastname： san,telphone: 136545646}

解析yml配置文件

spring-boot解析yml文件需要使用注解@ConfigurationProperties(prefix = “index-id””)

ConfigurationProperties和value有区别

默认从全局配置文件中获取值

@PropertySource

解析非全局配置文件

@PropertySource(value = “calsspath:example.properties”)

@ImportResource

@ImportResource导入spring配置文件，使配置文件内容生效。

@ImportResource(location = “classpath:beans.xml”)

springboot推荐的像容器中添加组件的方式：
使用全注解的方式。
使用@Configuration指明一个配置类。

• 和maven一样基于约定优于配置的构建框架
• 强大的多工程构建支持
• 强大的依赖管理，基于apachelvy
• 支持已有的maven和ivy仓库
• 支持传递性依赖管理，不需要远程仓库或pom.xml等配置文件

gradle安装

先决条件

• gradle需要1.5或更高版本的JDK；
• gradle自带groovy库，忽略已安装grooy

配置环境变量

• 将GRADLE_HOME/bin添加到PATH变量中
• 使用命令gradle -v命令测试

构建基础

task

project

groovy中的闭包

就是一段代码块，在gradle中，主要将闭包作为参数使用。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

//定义一个闭包
def bb = {
    println "hello, bb" 
}
//定义一个方法，方法的参数是闭包类型
def method(Closure closure){
    closure()
}
//调用该方法
method(bb)

//定义一个闭包，带参数
def closure2 = {
    v -> println "hello, ${v}"
}

//定义一个需要闭包的方法
def method2(Closure closure){
    closure("world")
}

method2(closure2)

拆分

聚合

1
2
3

allproject{

}

1. 一个项目就是一个工程
   如果项目非常庞大，就不适用package来划分模块，最好每一个模块对应一个工程，利于分工协作。借助于maven就可以将一个项目拆分为多个工程。
2. 项目中需要的jar包需要手动管理
   同样的文件出现在不同的工程中，浪费存储，让文件结构冗余。
3. jar包来源复杂，难以维护
4. jar包依赖的其他文件仍需手动管理

什么是maven

是一款服务于java平台的自动化构建工具。

什么是构建

以“java源文件”、“框架配置文件”、JSP、HTML、图片等资源为原材料产生一个可运行的项目的过程。

• 清理：将之前编译生成的字节码文件删除，为下一次编译做准备
• 编译：将java源程序编程为class字节码文件
• 测试：自动测试，自动调用junit程序
• 报告：测试程序执行的结果
• 打包：动态web工程war包，java工程jar包
• 安装：maven特定的概念，将打包得到的文件复制到仓库中指定位置
• 部署：将动态web工程生成的war包复制到servlet容器的指定目录下

安装maven核心程序

• 检查JAVA_HOME环境变量
• 解压maven核心程序压缩包，英文无空格目录
• 配置maven相关环境变量
  • MAVEN_HOME或M2_HOME（bin目录上一级）
  • path（通常带bin目录）
• 运行mvn -v验证配置

maven核心概念

约定的目录

• 根目录：工程名
  • 以配置的方式告诉框架自定义文件：classpath:spring-content.xml
• src目录：存放源码
• pom.xml：maven工程核心配置文件
• main目录：存放主程序
• test目录：存放测试程序
• java目录：存放java源码
• resources目录：存放框架或其他工具的配置文件

约定大于配置，配置大于编码

POM

含义：project object model项目对象模型

坐标（gav）

• groupid：公司组织域名倒序+项目名
• artifactid：模块名
• version：版本

依赖

• 对于自己的maven工程，使用install命令将其安装到仓库。
• 依赖的范围
  • compile：对主程序有效，对测试程序有效，参与打包
  • test：对主程序无效，对测试程序有效，不参与打包
  • provided：对主程序有效，对测试程序有效，不参与打包，不参与部署，例如servlet-api.jar
• scope
• 只有compile范围的依赖可以传递
• exclusions用于排除依赖

依赖的原则

• 作用：解决模块工程之间的jar包冲突
  • 最短路路径优先
  • 路径相同时先声明者优先，指的是dependency标签的声明顺序

统一管理依赖的版本号

• properties标签，后跟依赖的id
• 通过${依赖的id}访问版本号
• 由于test范围的依赖不能传递，所以必然分散在各个模块工程中，导致不一致问题
  • 解决思路：将依赖统一提取到父工程中，在子工程中声明依赖时不指定版本，以父工程中统一的设定为准，方便维护
  1. 创建一个maven工程为父工程，注意打包方式为pom
  2. 在子工程中声明对父工程的引用
  3. 将子工程中的坐标中与父工程坐标中重复的内容删除
  4. 在父工程中统一管理依赖
  5. 子工程中删除依赖的版本号

子工程要首先install父工程

仓库

生命周期/插件/目标

• 各个构建环节执行的顺序是既定的；
• maven核心程序中定义了抽象的生命周期；
• 不论执行哪个命令，maven都会从生命周期最开始的位置执行；

继承

聚合

一键安装各个模块工程
在一个总的聚合工程中配置各个参与聚合的模块

1
2
3
4
5

<modules>
    <module></module>
    <module></module>
    <module></module>
</modules>

常用maven命令

首先进入pom.xml目录

• mvn clean：清理
• mvn compile：编译主程序
• mvn test-compile：编译测试程序
• mvn test：执行测试
• mvn package：打包
• mvn install：安装
• mvn site：生成站点

自动部署

通过build标签配置当前工程的构建过程中的特殊设置，cargo插件。

简化spring开发流程，J2EE开发的一站式解决方案。

优点

• 快速创建独立运行spring项目以及与主流框架集成
• 使用嵌入式servlet容器，应用无需达成war包
• starters自动依赖与版本控制
• 大量的自动配置，简化开发，也可以修改默认值
• 无需配置XML，无代码生成
• 准生产环境的运行时应用监控
• 与云计算天然集成

微服务

是一种架构风格，其认为一个应用应该是一组小型服务，可以用过HTTP的方式通信。

每一个功能元素最终都是一个可独立替换和独立升级的软件单元。

环境配置

spring-boot-starter

启动器，spring-boot官方提供了一系列启动器。将所有的功能场景抽取出来，只要在项目里面引入这些starter，相关依赖就会自动导入。

主程序类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

/**
 * @SpringBootApplication标注这是spring boot应用
 */
@SpringBootApplication
public class HelloWorldMainApplication {

    public static void main(String[] args){
        //spring应用启动
        SpringApplication.run(HelloWorldMainApplication.class, args);
    }
}

@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Documented
@Inherited
@SpringBootConfiguration//表示这是一个Spring Boot的配置类
@EnableAutoConfiguration//开启自动配置功能
@ComponentScan(
    excludeFilters = {@Filter(
    type = FilterType.CUSTOM,
    classes = {TypeExcludeFilter.class}
), @Filter(
    type = FilterType.CUSTOM,
    classes = {AutoConfigurationExcludeFilter.class}
)}
)
public @interface SpringBootApplication

@SpringBootConfiguration:表示这是一个Spring Boot的配置类；
@Configuration：配置类上，表示配置类也是容器中的一个组件@Component

1
2

@AutoConfigurationPackage//自动配置包
@Import(EnableAutoConfigurationImportSelector.class)

spring-boot的注释没事可以看看。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

<!--配置步骤-->
<!--配置事务管理器-->
<bean id="tansactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
    <property name="dataSource" ref="dataSource"></property>
</bean>
<!--配置事务的通知，此时需要导入事务的约束-->
<tx:advice id="txAdvice" transaction-manager="transactionManger"></tx:advice>
    <!--配置事务的属性
        isolation：用于指定事务的隔离等级，默认是DEFAULT，表示使用数据库的默认隔离等级；
        propagation：用于指定事务的
    -->
    <tx:attributes>
        <tx:method name="*" propagation="REQUIRED" read-only="false"/></tx:method>
        <tx:method name="find*" propagation="SUPPORTS" read-only="true"/></tx:method>
    </tx:attributes>
</tx:advice>
<!--配置AOP-->
<!--配置AOP中的通用切入点表达式-->
<!--建立食物通知和切入点表达式的对应关系-->
<!--配置事务的属性，在事物的通知tx:advice标签内-->
<aop:config>
    <!--配置切入点表达式-->
    <aop:pointcout id="pt1" execution(* com.service.impl.*.*(..))"></aop:pointcut>
    <!--建立切入点表达式和事务通知的对应关系-->
    <aop:advisor advice-ref="txAdvice" pointcut-ref="pt1"></aop:advisor>
</aop:config>

基于纯注解的声明式事务控制

1. 配置事务管理器；
2. 开启spring对注解事务的支持；
   • <tx:annotation-driven transaction-manager=”transactionManager”>
3. 在需要事物支持的地方使用@Transactional

基于编程式事务控制

不够灵活

spring5新特性

• 与JDK相关升级；
• 核心容器更新；
• JetBrains Kotlin语言支持；
  • 运行于在JVM上，独立语言；
• 响应式编程风格；
• Junit5支持；
• 依赖类库的更新；

• 操作关系型数据
  • JdbcTemplate
  • HibernateTemplate
• 操作nosql数据库
  • RedisTemplate
• 操作消息队列
  • JmsTemplate

JdbcTemplate作用

和数据库交互的模板类

JdbcTemplate基本用法

首先通过XML文件配置必要信息，这块是spring框架必要的IOC手法；

1
2
3
4
5
6
7
8
9
10
11

<!--配置JdbcTemplate-->
<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate">
    <property name="dataSource" ref="dataSource"></property>
</bean>
<!--配置数据源-->
<bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource">
    <property name="driverClassName" value="com.mysql.jdbc.Driver"></property>
    <property name="url" value="jdbc:mysql://localhost:3306/databasename"></property>
    <property name="username" value="username"></property>
    <property name="password" value="password"></property>
</bean>

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

//获取容器
ApplicationContext ac = new ClassPathXmlApplicationContext("bean.xml");
//获取对象
JdbcTemplate jt = ac.getBean("jdbcTemplate", JdbcTemplate.class);
//执行操作
jt.execute("insert into account(name, money) values ('name', 222)");
//保存
jt.update("insert into account(name, money) values (?, ?)", "name", 333);
//更新
jt.update("update account set name=?, money=?, where id=?","test",2345,3);
//删除
jt.update("delete from account where id=?", 3);
//查询所有
List<Account> accounts = jt.query("select * from account where money > ?", new AccountRowMapper(), 1000f);
List<Account> accounts = jt.query("select * from account where money > ?", new BeanPropertyRowMapper<Account>(Account.class), 1000f);
for(Account account : accounts){
    System.out.println(account);
}
//查询一个
List<Account> accounts = jt.query("select * from account where id = ?", new BeanPropertyRowMapper<Account>(Account.class), 1);
//查询返回一行一列（使用聚合函数，但是不加group by子句
Long count = jt.queryForObject("select count(*) from account where money > ?", Long.class, 1000f);

1. 把通知bean也交给spring管理；
2. 使用aop:config标签表明开始AOP配置；
3. 使用aop:aspect标签表明配置切面；
   • id属性：给切面提供一个唯一标识
   • ref属性：指定通知类bean的id
4. 在aop:aspect标签的内部使用对应标签配置通知的类型；
   • aop:before：表示配置前置通知
     • method：用于指定切面中哪个方法是前置通知；
     • pointcut：用于指定切入点表达式，该表达式的含义是指对业务层中哪些方法进行增强
   • 切入点表达式的写法：
     • 关键字：execution(表达式)
     • 表达式：访问修饰符 返回值 类名.方法名(参数列表)
       • 访问修饰符可以省略
       • 返回值可以使用通配符，表示任意返回类型
       • 包名可以使用通配符，但包的层级需要和通配符一致
       • 包名可以使用..表示包名及其子包
       • 类名和方法名可以使用通配符
       • 全通配写法：* *..*.*(..)

1
2
3
4
5
6
7
8
9

<beans>
    <bean id="accountService" class="com.service.impl.AccountServiceImpl></bean>
    <bean id="logger" class="com.utils.Logger"></bean>
    <aop:config>
        <aop:aspect id="logAdvice" ref="logger">
            <aop:before method="printlog" pointcut="execution(public void com.service.AccountServiceImpl.saveAccount())"></aop:before>
        </aop:aspect>
    </aop:config>
</beans>

四种常用通知类型

• aop:before：前置通知，再切入点方法之前执行；
• aop:after-returning：后置通知，在切入点方法正确执行之后执行，它和异常通知永远只有一个执行；
• aop:after-throwing：异常通知，在切入点方法执行产生异常之后执行，它和后置通知永远只能执行一个；
• aop:after：最终通知，无论切入点方法是否正确执行它都会在其后面执行；
• aop:pointcut：配置切入点表达式，id属性用于指定表达式的唯一标识，expression属性用于指定表达式的内容；此标签写在aop:aspect内部时只能当前切面使用，将其写在aop:aspect外面时，所有前面可用；
• aop:around：配置环绕通知；