<img src="/img/9e9e9246d996491f80a83a38e9e7f575.jpg" width="723" />


关键接口预览

### 1、Filter, 过滤器（环绕式）

```java
@FunctionalInterface
public interface Filter {
    /**
     * 过滤
     * */
    void doFilter(Context ctx, FilterChain chain) throws Throwable;
}
```

### 2、RouterInterceptor, 路由拦截器（环绕式）

```java
public interface RouterInterceptor {
    /**
     * 路径匹配模式（控制拦截的路径区配）
     * */
    default PathRule pathPatterns(){
        //null 表示全部
        return null;
    }
    
    /**
     * 拦截
     */
    void doIntercept(Context ctx,
                     @Nullable Handler mainHandler,
                     RouterInterceptorChain chain) throws Throwable;

    /**
     * 提交结果（action / render 执行前调用）
     */
    default Object postResult(Context ctx, @Nullable Object result) throws Throwable {
        return result;
    }
}
```

在路由拦截阶段，已经从路由器里找出 Main Handler（并作为拦截时的参数）：

* 可能是 null
* 可能是 Handler 或它的扩展类（Actoin、Gateway 等）

同时也产生默认状态码：

* 可能是 404
* 可能是 405（有路由记录，但是 http mehtod 不匹配）


### 3、EntityConverter（实体转换器）、MethodArgumentResolver（方法参数分析器）


EntityConverter 的作用有两个（一般使用 Solon Serialization 插件即可）：

* 把 `Request Body`（form、json 等） 转换成 `@Mapping` 方法的参数。
* 把 `@Mapping` 方法的返回结果（或 `ctx.returnValue()`），输出到 `Reponse Body`。(会自动转换为 Render)


```java
public interface EntityConverter {
    //实例检测（移除时用）
    default boolean isInstance(Class<?> clz) {
        return clz.isInstance(this);
    }

    //名字
    default String name() {
        return this.getClass().getSimpleName();
    }

    //关系映射
    default String[] mappings() {
        return null;
    }

    //是否允许写
    boolean allowWrite();

    //是否能写
    boolean canWrite(String mime, Context ctx);

    //写入并返回（渲染并返回（默认不实现））
    String writeAndReturn(Object data, Context ctx) throws Throwable;

    //写入
    void write(Object data, Context ctx) throws Throwable;

    //是否允许读
    boolean allowRead();

    //是否能读
    boolean canRead(Context ctx, String mime);

    //读取（参数分析）
    Object[] read(Context ctx, Object target, MethodWrap mWrap) throws Throwable;
}
```


MethodArgumentResolver 的作用，是为`@Mapping` 方法的某一个参数提供分析支持。

```java
public interface MethodArgumentResolver {
    //是否匹配
    boolean matched(Context ctx, ParamWrap pWrap);

    //参数分析
    Object resolveArgument(Context ctx, Object target, MethodWrap mWrap, ParamWrap pWrap, int pIndex, LazyReference bodyRef) throws Throwable;
}
```

### 4、MethodInterceptor, 拦截器（环绕式）

被代理的托管对象，在执行方法时，会先执行 MethodInterceptor。

```java
@FunctionalInterface
public interface MethodInterceptor {
    /**
     * 拦截
     * */
    Object doIntercept(Invocation inv) throws Throwable;
}

//绑定 MethodInterceptor 接口实现
@Around(MethodInterceptor.class)
```


### 5、ReturnValueHandler，返回值处理

比如返回 `Flux<String>`（响应式流）、`SseEmitter`（SSE发射器），是在扩展插件实现的。通过注册 ReturnValueHandler 实现扩展处理。

```java
public interface ReturnValueHandler {
    //是否匹配
    boolean matched(Context ctx, Class<?> returnType);

    //返回处理
    void returnHandle(Context ctx, Object returnValue) throws Throwable;
}
```


### 6、Render 渲染器

负责渲染输出。比如模板渲染并输出，序列化渲染并输出。

```java
@FunctionalInterface
public interface Render {
    //名字
    default String name() {
        return this.getClass().getSimpleName();
    }

    //映射
    default String[] mappings() {
        return null;
    }

    //是否匹配
    default boolean matched(Context ctx, String mime) {
        return false;
    }

    //渲染并返回（默认不实现）
    default String renderAndReturn(Object data, Context ctx) throws Throwable {
        return null;
    }

    //渲染
    void render(Object data, Context ctx) throws Throwable;
}
```