个人网页

NioEndpoint 是 Tomcat 中负责使用 NIO 方式进行网络通信功能的模块，它负责监听处理请求连接，并将解析出的字节流传递给 Processor 进行后续的处理

下面梳理一下主要的处理流程，如下图

这里主要介绍一下 Tomcat 的整体设计结构

整体结构

Tomcat 的整体结构如下

主要分为两大部分，连接器和容器

我们都知道java实现跨平台靠的是虚拟机技术，将源文件编译成与操作系统无关的，只有虚拟机能识别并执行的字节码文件，由各个操作系统上的jvm来负责执行，屏蔽了底层具体的操作系统。这里我们就来认识一下这个只有jvm才认识的字节码文件的真实样子。

为了节省空间，类文件中没有任何分隔符，各个数据项都是一个挨着一个紧凑排列的，所以其中无论是顺序还是数量等都是严格规定的，哪个字节代表什么含义，长度是多少，先后顺序如何，都不允许改变。下面我们先看一下类文件的整体结构：

Spring 不仅为我们提供了IOC , AOP功能外，还在这个基础上提供了许多的功能，我们用的最多的可能就是 Spring MVC了吧，但是让我们来看下spring-context包，其中包含了缓存、调度、校验功能等等

这里主要想介绍一下Spring提供的观察者模式实现(事件发布监听)及异步方法执行，这些功能也都是基于AOP实现的

看过了前面的Spring Beans相关的 IOC 功能, 接下来我们来看看 AOP 是如何实现的

我们都知道 AOP 是通过动态代理来实现的, 但是代理这一步是如何实现的呢? 其实就是之前提到过的, 在Spring Bean的创建过程中, 实现BeanPostProcessor的接口可以对创建好的Bean进行修改替换等操作

1
2
3
4
5
6
7
8
9

protected Object initializeBean(String beanName, Object bean, RootBeanDefinition mbd) {
    invokeAwareMethods(beanName, bean);
    Object wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    invokeInitMethods(beanName, wrappedBean, mbd);
  
    // 依次执行beanFactory中所有实现BeanPostProcessor的后置方法,对Bean进行修改(*AOP创建返回代理处*)
    wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    return wrappedBean;
}

一种被设计来处理无穷数据集的数据处理系统引擎

对实时产生的数据进行实时统计分析

• 电商大促时，统计当前下单量、金额
• 实时统计 App 中的埋点数据等

流计算相比批处理需要切分为窗口才能进行分组聚合处理

同时需要解决如下两个问题

1. 正确性/完整性 exactly-once

2. 处理无序、延迟数据的能力

扩展点加载机制主要是为了实现接口和实现的解耦，接口的具体实现并不在代码中指定，而是通过通过外部配置实现，Dubbo的扩展点加载是对JDK的SPI扩展点加强而来，大家如果不了解JDK的SPI也没有关系，这里我们主要来看一下Dubbo的实现

在Dubbo的实现中，主要有三个注解，@SPI、@Adaptive和@Activate，下面我们来结合例子分别看一下它们的使用

线程池的基本使用

Executors框架提供的创建线程池的方法

1
2
3
4
5
6

// 固定线程数量的线程池
Executors.newFixedThreadPool(5);
// 对于添加的任务，如果有线程可用则使用其执行，否则就创建新线程
Executors.newCachedThreadPool();
// 创建只有一个线程的线程池
Executors.newSingleThreadExecutor();

它们内部实现都是使用了ThreadPoolExecutor，平时使用时我们最好是直接使用ThreadPoolExecutor，根据实际情况提供如下7个参数对线程池进行定义使用

配置参数

1
2
3
4
5
6
7

int corePoolSize,                     // 核心线程数
int maximumPoolSize,                  // 最大线程数
long keepAliveTime,                   // 超出核心数线程的最大空闲存活时间
TimeUnit unit,                        // 空闲存活时间的时间单位
BlockingQueue<Runnable> workQueue,    // 任务队列
ThreadFactory threadFactory,          // 线程工厂，可以在此设置线程是否为守护线程等
RejectedExecutionHandler handler      // 饱和策略，任务队列满且线程数达到最大线程数时触发

在介绍状态模式之前，我们先看个简单的例子

比如我们正常的网上购物的订单，对于订单它有许多个不同的状态，在不同状态下会有不同的行为能力，如状态有待支付、已支付待发货、待收货、订单完成等等，在整个订单流转过程中，由不同的事件行为导致它状态的变更，可以看下它简单的状态图

这些状态虽然不同，但是都是属于订单的状态，对应的行为也是订单的行为，在编码的过程中，一种写法是将这些行为(方法)都写到订单这个类或者类似OrderService这种类中，如

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

public class OrderService {
  	private OrderDao orderDao;

    public void pay(Long orderId) {
        Order order = orderDao.findById(orderId);
        // 下面逻辑也可以改成使用switch
        if (order.getStatus() == OrderStatus.WAIT_PAY) {
            // 待支付，则进行支付
        } else if (order.getStatus() == OrderStatus.PAYING) {
            // 支付中，则进行相应提示
        } else if (order.getStatus() == OrderStauts.PART_PAID) {
            // 部分支付，则进行相应处理
        } else {
            // 其他状态进行对应处理
        }
    }
}

这样每次进行操作时，我们要先进行一下当前状态的判断，如用户支付时，我们要判断一下当前订单的状态，如果是待支付，则进行支付操作后，将状态改为已支付；如果当前状态是已支付时，就要提示用户当前订单已支付，不能再次支付等等，如果订单状态比较复杂时就会导致这个类中充斥大量的if、switch等判断逻辑，维护不便

而状态模式则提供了另一种解决方案，它将与特定状态相关的行为局部化，也使得状态转换现实化，下面我我们来具体看一下

Drools是一款基于Java语言的开源规则引擎，通过drools特定的语法，将复杂多变的业务规则统一管理。

环境配置

一、使用maven创建项目

添加相关依赖，pom.xml如下

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

<?xml version="1.0" encoding="UTF-8"?>
<project ...>
    <packaging>kjar</packaging>

    <dependencies>
        <dependency>
            <groupId>org.drools</groupId>
            <artifactId>drools-compiler</artifactId>
            <version>7.27.0.Final</version>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.kie</groupId>
                <artifactId>kie-maven-plugin</artifactId>
                <version>7.27.0.Final</version>
                <extensions>true</extensions>
            </plugin>
        </plugins>
    </build>

</project>