Tomcat

Tomcat体系结构（图⽂并茂）

​ Tomcat体系结构（图⽂并茂）

Tomcat 设计了两个核心组件连接器（Connector）和容器（Container）来完成 Tomcat 的两大核心功能。

连接器，负责对外交流： 处理Socket连接，负责⽹络字节流与Request和Response对象的转化；

容器，负责内部处理：加载和管理Servlet，以及具体处理Request请求；

  • EndPoint

EndPoint 是 Coyote 通信端点，即通信监听的接⼝，是具体Socket接收和发送处理器，是对传输层的抽象，因此EndPoint用来实现TCP/IP协议的。

  • Processor

Processor 是Coyote 协议处理接口 ，如果说EndPoint是⽤来实现TCP/IP协议的，那么Processor用来实现HTTP协议，Processor接收来自EndPoint的Socket，读取字节流解析成Tomcat Request和Response对象，并通过Adapter将其提交到容器处理，Processor是对应用层协议的抽象。

  • ProtocolHandler

Coyote 协议接口， 通过Endpoint 和 Processor ， 实现针对具体协议的处理能力。Tomcat 按照协议和I/O 提供6个实现类：AjpNioProtocol ，AjpAprProtocol， AjpNio2Protocol ， Http11NioProtocol，Http11Nio2Protocol ，Http11AprProtocol。

  • Adapter

由于协议不同，客户端发过来的请求信息也不尽相同，Tomcat定义了自己的Request类来封装这些请求信息。ProtocolHandler接口负责解析请求并生成Tomcat Request类。但是这个Request对象不是标准ServletRequest，不能用Tomcat Request作为参数来调⽤容器。Tomcat设计者的解决方⽅案是引入CoyoteAdapter，这是适配器模式的经典运用，连接器调用CoyoteAdapter的Sevice方法，传入的是Tomcat Request对象，CoyoteAdapter负责将Tomcat Request转成ServletRequest，再调用容器。

Tomcat Servlet 容器 Catainlina

Tomcat就是一个Catalina的实例，因为Catalina是Tomcat的核心

Tomcat/Catalina实例

  • Catalina

负责解析Tomcat的配置文件（server.xml） , 以此来创建服务器Server组件并进行管理

1
2
3
4
5
6
7
8
9
10
11
12
 <?xml version='1.0' encoding='utf­8'?>
<Server port="8005" shutdown="SHUTDOWN">
<Service name="Catalina">
<Connector port="8080" protocol="HTTP/1.1" connectionTimeout="20000"
redirectPort="8443" URIEncoding="UTF­8"/>
<Engine name="Catalina" defaultHost="localhost">
<Host name="localhost">
<Context path="" docBase="/" reloadable="true"/>
</Host>
</Engine>
</Service>
</Server>

(1) Server
Server表示整个的Catalina Servlet容器。Tomcat提供了Server接口的一个默认实现，这通常不需要用户自己去实现。在Server容器中，可以包含一个或多个Service组件。
(2) Service
Service是存活在Server内部的中间组件，它将一个或多个连接器（Connector）组件绑定到一个单独的引擎（Engine)上。在Server中，可以包含一个或多个Service组件。Service也很少由用户定制，Tomcat提供了Service接口的默认实现，而这种实现既简单又能满足应用。
(3) Connector
连接器（Connector）处理与客户端的通信，它负责接收客户请求，以及向客户返回响应结果。在Tomcat中，有多个连接 器可以使用。
(4) Engine
在Tomcat中，每个Service只能包含一个Servlet引擎（Engine）。引擎表示一个特定的Service的请求处理流水线。作为一个Service可以有多个连接器，引擎从连接器接收和处理所有的请求，将响应返回给适合的连接器，通过连接器传输给用户。用户允许通过实现Engine接口提供自定义的引擎，但通常不需要这么做。
(5) Host
Host表示一个虚拟主机，一个引擎可以包含多个Host。用户通常不需要创建自定义的
Host，因为Tomcat给出的Host接口的实现（类StandardHost）提供了重要的附加功能。
(6) Context
一个Context表示了一个Web应用程序，运行在特定的虚拟主机中。什么是Web应用程序呢？在Sun公司发布的Java Servlet规范中，对Web应用程序做出了如下的定义：“一个Web应用程序是由一组Servlet、HTML页面、类，以及其他的资源组成的运行在Web服务器上的完整的应用程序。它可以在多个供应商提供的实现了Servlet规范的Web容器中运行”。一个Host可以包含多个Context（代表Web应用程序），每一个Context都有一个唯一的路径。用户 通 常 不 需 要 创 建 自 定 义 的 Context ， 因 为 Tomcat 给 出 的 Context 接 口 的 实 （ 类StandardContext）提供了重要的附加功能。

总结 :凡是实现了Servlet规范的都可以成为Servlet容器 。

​ 一个 Catalina 容器中 是有多个Server组成 而每个Server可以有多个Service,每个Service中包含 一个Engine组件，多个Connector 组件，多个Host 组件，多个Context组件 构成。

SpringBoot

SpringBoot学习笔记

SpringBoot学习笔记

1 约定大于配置
2 实现自动配置

  1. springboot应用启动
  2. @ Spring Bootapplication起作用
  3. @Enableauto Configuration
  4. @ AutoConfigurationpackage：这个组合注解主要是@ import( Autoconfigurationpackages. Registrar. class),它通过将 Registrar类导入到容器中，而registrar类作用是扫描主配置类同级目录以及子包，并将相应的组件导入到springboote创建管理的容器中
  5. @ import( AutoConfigurationlmportselector. class):它通过将
    Autoconfigurationlmportselector类导入到容器中， AutoConfigurationlmportselector类作用是
    通过selectlmports方法执行的过程中，会使用内部工具类 Springfactoriesloader，查找
    classpath上所有jar包中的META-INF/spring.factories进行加载，实现将配置类信息交给
    Springfactory加载器进行一系列的容器创建过程

easypoi导出动态表头excel

categories: easypoi

easypoi导出动态表头excel

注：文章转载来自 https://blog.csdn.net/ajax_yan/article/details/82289240 

1
2
3
4
5
6

<dependency>
            <groupId>cn.afterturn</groupId>
            <artifactId>easypoi-base</artifactId>
            <version>3.2.0</version>
        </dependency>
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
@Test
public void dynaCol() {
    try {
        List<ExcelExportEntity> colList = new ArrayList<ExcelExportEntity>();
        ExcelExportEntity colEntity = new ExcelExportEntity("商品名称", "title");
        colEntity.setNeedMerge(true);
        colList.add(colEntity);

        colEntity = new ExcelExportEntity("供应商", "supplier");
        colEntity.setNeedMerge(true);
        colList.add(colEntity);

        ExcelExportEntity deliColGroup = new ExcelExportEntity("得力", "deli");
        List<ExcelExportEntity> deliColList = new ArrayList<ExcelExportEntity>();
        deliColList.add(new ExcelExportEntity("市场价", "orgPrice"));
        deliColList.add(new ExcelExportEntity("专区价", "salePrice"));
        deliColGroup.setList(deliColList);
        colList.add(deliColGroup);

        ExcelExportEntity jdColGroup = new ExcelExportEntity("京东", "jd");
        List<ExcelExportEntity> jdColList = new ArrayList<ExcelExportEntity>();
        jdColList.add(new ExcelExportEntity("市场价", "orgPrice"));
        jdColList.add(new ExcelExportEntity("专区价", "salePrice"));
        jdColGroup.setList(jdColList);
        colList.add(jdColGroup);


        List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
        for (int i = 0; i < 10; i++) {
            Map<String, Object> valMap = new HashMap<String, Object>();
            valMap.put("title", "名称." + i);
            valMap.put("supplier", "供应商." + i);

            List<Map<String, Object>> deliDetailList = new ArrayList<Map<String, Object>>();
            for (int j = 0; j < 3; j++) {
                Map<String, Object> deliValMap = new HashMap<String, Object>();
                deliValMap.put("orgPrice", "得力.市场价." + j);
                deliValMap.put("salePrice", "得力.专区价." + j);
                deliDetailList.add(deliValMap);
            }
            valMap.put("deli", deliDetailList);

            List<Map<String, Object>> jdDetailList = new ArrayList<Map<String, Object>>();
            for (int j = 0; j < 2; j++) {
                Map<String, Object> jdValMap = new HashMap<String, Object>();
                jdValMap.put("orgPrice", "京东.市场价." + j);
                jdValMap.put("salePrice", "京东.专区价." + j);
                jdDetailList.add(jdValMap);
            }
            valMap.put("jd", jdDetailList);

            list.add(valMap);
        }

        Workbook workbook = ExcelExportUtil.exportExcel(new ExportParams("价格分析表", "数据"), colList,
                list);
        FileOutputStream fos = new FileOutputStream("D:/价格分析表.tt.xls");
        workbook.write(fos);
        fos.close();
    } catch (FileNotFoundException e) {
        e.printStackTrace();
    } catch (IOException e) {
        e.printStackTrace();
    }


}

效果

SpringMVC

SpringMVC流程图

SpringMvc流程图

流程说明

第⼀步：⽤户发送请求⾄前端控制器DispatcherServlet

第⼆步：DispatcherServlet收到请求调⽤HandlerMapping处理器映射器

第三步：处理器映射器根据请求Url找到具体的Handler（后端控制器），⽣成处理器对象及处理器拦截

器(如果 有则⽣成)⼀并返回DispatcherServlet

第四步：DispatcherServlet调⽤HandlerAdapter处理器适配器去调⽤Handler

第五步：处理器适配器执⾏Handler

第六步：Handler执⾏完成给处理器适配器返回ModelAndView

第七步：处理器适配器向前端控制器返回 ModelAndView，ModelAndView 是SpringMVC 框架的⼀个

底层对 象，包括 Model 和 View

第⼋步：前端控制器请求视图解析器去进⾏视图解析，根据逻辑视图名来解析真正的视图。

第九步：视图解析器向前端控制器返回View

第⼗步：前端控制器进⾏视图渲染，就是将模型数据（在 ModelAndView 对象中）填充到 request 域

第⼗⼀步：前端控制器向⽤户响应结果

numpy矩阵入门操作

numpy矩阵

矩阵是numpy.matrix类型的对象，该类继承自numpy.ndarray，任何针对多维数组的操作，对矩阵同样有效，但是作为子类矩阵又结合其自身的特点，做了必要的扩充，比如：乘法计算、求逆等。

1. 矩阵对象的创建

  1. 通过ndarray创建matrix对象
1
2
3
4
numpy.matrix(
    ary,		# 任何可被解释为矩阵的二维容器
  	copy=True	# 是否复制数据(缺省值为True，即复制数据)
)
  1. numpy.mat()
    1
    2
    3
    4
    5
    6
    7
    # 等价于：numpy.matrix(..., copy=False)
    # 由该函数创建的矩阵对象与参数中的源容器一定共享数据，无法拥有独立的数据拷贝
    numpy.mat(任何可被解释为矩阵的二维容器)

    # 该函数可以接受字符串形式的矩阵描述：
    # 数据项通过空格分隔，数据行通过分号分隔。例如：'1 2 3; 4 5 6'
    numpy.mat(拼块规则)

示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 创建matrix操作
import numpy as np

arr = np.arange(1, 10).reshape(3, 3)
print(arr)

# 第一种方式
m = np.matrix(arr, copy=True)
print(m, m.shape, type(m))

# 第二种方式:共享方式
m2 = np.mat(arr)

# 第三种方式
m3 = np.mat("1 2 3;4 5 6.0")

2. 矩阵的乘法运算

1
2
3
4
5
6
7
8
9
10
11
12
13
# 矩阵乘法
import numpy as np

arr = np.array([[1, 1, 1],
                [2, 2, 2],
                [3, 3, 3]])
# 数组相乘, 各对应位置元素相乘
print(arr * arr)

# 矩阵相乘，第n行乘m列之和，作为结果的n,m个元素
# 矩阵相乘，第一个矩阵行数必须等于第二个矩阵列数
m = np.mat(arr)
print(m * m)

3. 矩阵的逆矩阵

若两个矩阵A、B满足：AB = E （E为单位矩阵），则称B为A的逆矩阵。

单位矩阵

  • 在矩阵的乘法中，有一种矩阵起着特殊的作用，如同数的乘法中的1，这种矩阵被称为单位矩阵。
  • 它是个方阵，从左上角到右下角的对角线（称为主对角线）上的元素均为1，除此以外全都为0，记为$I_n$或$E_n$ ，通常用I或E来表示。
  • 根据单位矩阵的特点，任何矩阵与单位矩阵相乘都等于本身，而且单位矩阵因此独特性有广泛用途。
    $$
    E_3 =
    \left[ \begin{array}{ccc}
    1 & 0 & 0\
    0 & 1 & 0\
    0 & 0 & 1\
    \end{array}
    \right ]
    $$

Read More

知识

缓存穿透

缓存穿透

概念：是指查询数据库中一定不存在的数据。

栗子：一个数据库中不存在的数据 每次查询为空，每次不进行缓存。

解决：1 采用缓存空值的方式 设定缓存过期时间较短 比如设置60s

​ 2 采用布隆过滤器 （Google ,Redis 都可以实现）

Read More

git 忽略文件

categories: git

.gitignore忽略已提交的文件

描述 ：需要忽略的文件已经提交

解决方案

1
2
3
git  rm -r --cache .
git  add .
git  commit -m ".gitignore now work"

执行后 会发现.gitignore 文件起作用了。

SpringBoot

SpringBoot经典学习笔记

跟武哥一起学习Spring Boot

作者信息

本课程首发于 CSDN GitChat 达人课《跟武哥一起学Spring Boot》，该文档为课程详细笔记。
作者：倪升武（武哥）
微信公众号：武哥聊编程
武哥聊编程

版权申明：本课程已经免费，但版权属于 CSDN 和作者，未经允许，不得将该笔记用于商业用途和其他不正当用途，否则追究法律责任。

Read More