GitBook: No commit message

README.md

@@ -1,2 +1,21 @@
-# Page
+---
+description: Java 全栈式微服务开源框架
+---
+
+# 简介
+
+         Redkale(中文名: 红菜苔，湖北特产蔬菜)是基于Java 11全新的微服务开源框架， 包含HTTP、WebSocket、TCP/UDP、数据序列化、数据缓存、依赖注入等功能。 本框架致力于简化集中式和微服务架构的开发，在增强开发敏捷性的同时保持高性能。 
+
+  Redkale 有如下主要特点： \
+      1、大量使用Java 8新特性（接口默认值、Stream、Lambda、JDk8内置的ASM等） \
+      2、提供HTTP服务，同时内置JSON功能与限时缓存功能 \
+      3、TCP层使用NIO，并统一TCP与UDP的接口 \
+      4、提供分布式与集中式部署的无缝切换 \
+      5、提供类似JPA功能，包含数据缓存自动同步、分表分库与简洁的数据层操作接口 \
+      6、支持依赖注入的资源的动态修改 \
+      7、Servlet、Service、Source组件均支持异步接口 
+
+\
+        作为一个全新的微服务框架，Redkale在接口定义上使用了Java 8大量的新语法，接口有默认实现、接口带静态方法、重复注解等特性，同时在设计上与主流框架有很大不同。Redkale是按组件形式设计的，而非以容器为主，几乎每个子包都是能提供独立功能的组件。如Tomcat是按容器设计的，所有web资源/配置由Tomcat控制，开发者很能难控制到Tomcat内部，而Redkale的HTTP服务只是个组件，开发者既可以自己启动和配置HttpServer，也可以把Redkale当成容器通过Redkale进程来初始化服务。Spring的Ioc容器也是如此，Redkale提供的依赖注入仅通过ResouceFactory一个类来控制，非常轻量，并且可动态更改已注入的资源。Spring提倡控制反转思想，而自身的容器却让开发者很难控制。Redkale是一个既能以组件形式也能以容器形式存在的框架。从整体上看，Redkale的架构分两层：接口和默认实现。开发者若想替换掉Redkale内置的HTTP服务而使用符合JavaEE规范的HttpServlet, 可以采用自定义协议基于JSR 340(Servlet 3.1)来实现自己的HTTP服务；若想使用Hibernate作为数据库操作，可以写一个自己的DataSource实现类；JSON的序列化和反序列化也可以使用第三方的实现；Memcached或Redis也可以作为另一个CacheSource的实现替换Redkale的默认实现。这其实包含了控制反转的思想，让框架里的各个组件均可让开发者控制。    \
+        与主流框架比，功能上Redkale显得很简单，这体现了Redkale的简易性，而并非是不足，从一个良好的设计习惯或架构上来看，有些常用功能是不需要提供的，如Redkale的HTTP服务不支持HTTPS和JSP，HTTPS比HTTP多了一层加密解密，这种密集型的计算不是Java的专长，通常提供HTTP服务的架构不会将Java动态服务器放在最前端，而是在前方会放nginx或apache，除了负载均衡还能静动分离，因此HTTPS的加解密应交给nginx这样的高性能服务器处理。Redkale再提供HTTPS服务就显得鸡肋。JSP其实算是一个落后的技术，现在是一个多样化终端的时代，终端不只局限于桌面程序和PC浏览器，还有原生App、混合式App、微信端、移动H5、提供第三方接口等各种形式的终端，这些都不是JSP能方便兼顾的，而HTTP+JSON作为通用性接口可以避免重复开发，模版引擎的功能加上各种强大的JS框架足以取代JSP。Redkale在功能上做了筛选，不会为了迎合主流而提供，而是以良好的设计思想为指导。这是Redkale的主导思维。
 

SUMMARY.md

@@ -1,3 +1,17 @@
 # Table of contents
 
-* [Page](README.md)
+* [简介](README.md)
+* [快速入门](quick-start.md)
+* [Service 组件](service-zu-jian.md)
+* [Convert 组件](convert-zu-jian.md)
+* [HTTP 服务](http-fu-wu.md)
+* [SNCP 服务](sncp-fu-wu.md)
+* [WATCH 服务](watch-fu-wu.md)
+* [CacheSource缓存组件](cachesource-huan-cun-zu-jian.md)
+* [DataSource数据库组件](datasource-shu-ju-ku-zu-jian.md)
+* [Client 组件](client-zu-jian.md)
+* [PropertiesAgent 配置中心](propertiesagent-pei-zhi-zhong-xin.md)
+* [ClusterAgent 服务注册中心](clusteragent-fu-wu-zhu-ce-zhong-xin.md)
+* [MessageAgent  MQ中心](messageagent-mq-zhong-xin.md)
+* [配置文件](readme.md)
+* [版本更新](ban-ben-geng-xin.md)

ban-ben-geng-xin.md

@@ -0,0 +1,39 @@
+# 版本更新
+
+## v2.7.0 - 2022-07-07
+
+### Fixed
+
+* 修复 HttpResponse.finish 结果 status=404 时按 200 输出的 bug 
+* 修复 HttpMessageLocalClient 创建 request 时没有赋值给 currentUserid 值 
+* 修复 Rest.createRestServlet 带特定泛型问题 
+* 修复 Convert 模块中父类含 public field，subclass 不传父类会导致 NoSuchFieldError 的 bug 
+* 修复 ApiDocCommand 在没有运行时不能生成 doc 的 bug 
+* 修复 JsonWriter.writeWrapper 按 latin1 编码写的 bug 
+* 修复 JsonDynEncoder 在定制字段情况下会被全量字段的动态类覆盖的 bug
+
+### Changed
+
+* 优化 PrepareServlet 中 HttpRender 的初始化顺序 
+* 日志支持 java.util.logging.ConsoleHandler.denyreg 配置 
+* FilterColumn 支持 least=0 时空字符串也参与过滤 
+* HttpRequest 兼容参数名为空字符串 
+* 移除 CryptColumn、CryptHandler 功能 
+* PrepareServlet 更名为 DispatcherServlet 
+* @WebServlet 合并 url
+
+### Added
+
+* 增加 ConvertCoder 功能，可以自定义字段的序列化 
+* 增加 JsonMultiDecoder、JsonMultiObjectDecoder、OneOrList 功能 
+* JsonConvert 全面兼容 JSON5 
+* 增加 redkale 命令行 
+* 增加 HttpRpcAuthenticator 功能 
+* MessageAgent 增加配置 MessageCoder 功能 
+* 实现 LoggingSearchHandler 功能 
+* ConvertFactory 增加 mapFieldFunc、ignoreMapColumns 功能 
+* 增加 PropertiesAgent 功能
+* 增加链路 ID Traces 
+* 增加 ResourceListener.different 功能 
+* 增加 Environment 类 
+* 增加 RestLocale 功能

cachesource-huan-cun-zu-jian.md

@@ -0,0 +1,2 @@
+# CacheSource缓存组件
+

client-zu-jian.md

@@ -0,0 +1,2 @@
+# Client 组件
+

clusteragent-fu-wu-zhu-ce-zhong-xin.md

@@ -0,0 +1,2 @@
+# ClusterAgent 服务注册中心
+

convert-zu-jian.md

@@ -0,0 +1,2 @@
+# Convert 组件
+

datasource-shu-ju-ku-zu-jian.md

@@ -0,0 +1,2 @@
+# DataSource数据库组件
+

http-fu-wu.md

@@ -0,0 +1,2 @@
+# HTTP 服务
+

messageagent-mq-zhong-xin.md

@@ -0,0 +1,2 @@
+# MessageAgent  MQ中心
+

propertiesagent-pei-zhi-zhong-xin.md

@@ -0,0 +1,2 @@
+# PropertiesAgent 配置中心
+

quick-start.md

@@ -0,0 +1,104 @@
+# 快速入门
+
+## 安装
+
+使用maven:
+
+```markup
+<dependency>
+    <groupId>org.redkale</groupId>
+    <artifactId>redkale</artifactId>
+    <version>2.7.0</version>
+</dependency>
+```
+
+{% hint style="info" %}
+&#x20;Super-powers are granted randomly so please submit an issue if you're not happy with yours.
+{% endhint %}
+
+如果工程需要用到Redis、Kafka、Elasticsearch、SQL模板、模板引擎等，可使用redkale的官方插件:
+
+```markup
+<dependency>
+    <groupId>org.redkalex</groupId>
+    <artifactId>redkale-plugins</artifactId>
+    <version>2.7.0</version>
+</dependency>
+```
+
+
+
+## 创建工程
+
+在IDE中使用ant或maven方式创建工程，增加redkale的依赖。然后下载 <mark style="color:blue;">˚</mark> 解压并覆盖到工程目录下。\
+
+
+![](<.gitbook/assets/image (19).png>)
+
+&#x20;  bin： 存放启动/关闭脚本(start.sh、shutdown.sh、redkale.sh等)\
+conf ： 存放服务器所需配置文件: \
+&#x20;               application.xml：     服务配置文件 (必需)； \
+&#x20;               logging.properties：日志配置文件 (可选)； \
+&#x20;               source.properties： 数据库配置文件 (可选)； \
+&#x20;   lib ： 存放服务所依赖jar \
+&#x20;logs ： logging.properties 配置中默认的日志存放目录。&#x20;
+
+## Hello World
+
+演示工程：
+
+![](<.gitbook/assets/image (23).png>)
+
+![](<.gitbook/assets/image (17).png>)
+
+![](<.gitbook/assets/image (6).png>)
+
+下载 [redkale-2.7.0.tar.gz ](https://repo1.maven.org/maven2/org/redkale/redkale/2.7.0/redkale-2.7.0.tar.gz)解压并覆盖到工程目录下
+
+![](<.gitbook/assets/image (2).png>)
+
+![](<.gitbook/assets/image (21).png>)
+
+编写HelloService:
+
+```java
+package org.redkalex.example;
+
+import org.redkale.net.http.*;
+import org.redkale.service.Service;
+
+@RestService(automapping = true)
+public class HelloService implements Service {
+
+    public String sayHello() {
+        return "Hello World!";
+    }
+
+    public String hi(String name) {
+        return "Hi, " + name + "!";
+    }
+}
+```
+
+调试运行:&#x20;
+
+![](<.gitbook/assets/image (4).png>)
+
+![选择 Application 模式](<.gitbook/assets/image (16).png>)
+
+![](<.gitbook/assets/image (10).png>)
+
+运行日志:
+
+![](<.gitbook/assets/image (1).png>)
+
+在浏览器输入: http://127.0.0.1:6060/pipes/hello/say 可以看到结果：
+
+![](<.gitbook/assets/image (5).png>)
+
+在浏览器输入: http://127.0.0.1:6060/pipes/hello/hi?name=Redkale 可以看到结果：
+
+![](.gitbook/assets/image.png)
+
+
+

readme.md

@@ -0,0 +1,449 @@
+# 配置文件
+
+## application.xml 
+
+系统**必不可少**的配置文件， 包含了核心配置信息。.
+
+```
+<?xml version="1.0" encoding="UTF-8"?>
+<!-- 
+    文件说明:
+        ${APP_HOME} 指当前程序的根目录APP_HOME
+        没注明唯一的节点可多个存在
+        required： 被声明required的属性值不能为空
+        
+                                            group
+                                         /  /  \  \  
+                                      /    /    \   \   
+                                   /     /       \    \                      
+                               node1   node2   node3  node4
+                             /       \                             
+                          /             \
+                       /                   \
+                    /                         \
+             serviceid1                       serviceid2
+            /       \                        /           \
+  serviceid1_name1  serviceid1_name2   serviceid2_name1  serviceid2_name2    
+-->
+<!--     
+    nodeid: int     进程的节点ID，用于分布式环境，一个系统中节点ID必须全局唯一，使用cluster时框架会进行唯一性校验
+    name:           进程的名称，用于监控识别，命名规则: 字母、数字、下划线、短横、点
+    address:        本地局域网的IP地址， 默认值为默认网卡的ip，当不使用默认值需要指定值，如192.168.1.22
+    port: required  程序的管理Server的端口，用于关闭或者与监管系统进行数据交互
+    lib:            加上额外的lib路径,多个路径用分号;隔开； 默认为空。  例如: ${APP_HOME}/lib/a.jar;${APP_HOME}/lib2/b.jar;
+-->
+<application nodeid="1000" port="6560" lib="">  
+    
+    <!--
+       【节点全局唯一】 @since 2.3.0
+        全局Serivce执行的线程池， Application.workExecutor, 没配置该节点将自动创建一个。
+        threads： 线程数，为0表示不启用workExecutor，只用IO线程。默认: CPU核数, 核数=1的情况下默认值为2
+        hash:     是否使用ThreadHashExecutor作为线程池，默认值为：false
+    -->
+    <executor threads="4" hash="false"/>
+        
+    <!--
+       【节点全局唯一】
+        自动扫描时排除部分包路径
+        value：    排除lib.path与excludes中的正则表达式匹配的路径, 多个正则表达式用分号;隔开
+    -->
+    <excludelibs value="^.*mysql.*$;^.*kafka.*$"/>
+        
+    <!--
+       【节点全局唯一】
+        第三方服务发现管理接口
+        type：          类名，必须是org.redkale.cluster.ClusterAgent的子类
+        waits:          注销服务后是否需要等待检查周期时间后再进行Service销毁，默认值为：false
+                        当一个Service进行服务注销后，不能立刻销毁Service，因为健康检测是有间隔时间差的，
+                        需要等待一个健康检测周期时间，让其他进程都更新完服务列表。
+                        如果使用MQ，可以设置为false，如果对服务健壮性要求高，建议设置为true
+        protocols:      服务发现可以处理的协议， 默认值为: SNCP, 多个协议用分号;隔开
+        ports:          服务发现可以处理的端口， 多个端口用分号;隔开
+        ttls:           心跳频率，多少秒一次
+        xxxx:           自定义的字段属性，例如：CacheClusterAgent有source字段; ConsulClusterAgent有apiurl字段;
+    -->
+    <cluster type="org.redkalex.cluster.consul.ConsulClusterAgent" waits="false" protocols="SNCP" ports="7070;7071" xxx="xxx" />
+
+    <!--
+        MQ管理接口配置
+        不同MQ节点所配置的MQ集群不能重复。
+        MQ跟着协议走，所以mq的属性值需要被赋值在rest节点上, 由于SncpServlet是自动生成的，故SNCP协议下，mq属性值被赋值在service/services节点上
+        name:   服务的名称，用于监控识别，多个mq节点时只能有一个name为空的节点，mq.name不能重复,命名规则: 字母、数字、下划线
+        type： 实现类名，必须是org.redkale.mq.MessageAgent的子类
+        coder: MessageRecord的解析器类，必须是org.redkale.mq.MessageCoder<MessageRecord>的实现类, 
+               可对数据包进行加密解密，默认值：org.redkale.mq.MessageRecordCoder
+        MQ节点下的子节点配置没有固定格式, 根据MessageAgent实现方的定义来配置
+    -->
+    <mq name="" type="org.redkalex.mq.kafka.KafkaMessageAgent">
+        <servers value="127.0.0.1:9101"/>
+        <consumer>
+            <property name="xxxxxx" value="XXXXXXXX"/>
+        </consumer>
+        <producer>
+            <property name="xxxxxx" value="XXXXXXXX"/>
+        </producer>
+    </mq>
+        
+    <!--
+        一个组包含多个node， 同一Service服务可以由多个进程提供，这些进程称为一个GROUP，且同一GROUP内的进程必须在同一机房或局域网内
+        name:       服务组ID，长度不能超过11个字节. 默认为空字符串。 注意: name不能包含$符号。
+        protocol：  值范围：UDP TCP， 默认TCP
+        注意: 一个node只能所属一个group。只要存在protocol=SNCP的Server节点信息， 就必须有group节点信息。
+    -->
+    <group name="" protocol="TCP">
+        <!--
+            需要将本地node的addr与port列在此处。
+            同一个<node>节点值只能存在一个<group>节点内，即同一个addr+port只能属于一个group。
+            addr: required IP地址
+            port: required 端口
+        -->
+        <node addr="127.0.0.1" port="7070"/>
+    </group>
+
+    <!--
+       Application启动的监听事件,可配置多个节点
+       value: 类名，必须是ApplicationListener的子类
+    -->
+    <listener value="org.redkalex.xxx.XXXApplicationListener"/>
+        
+    <!-- 
+        【节点全局唯一】
+        全局的参数配置, 可以通过@Resource(name="property.xxxxxx") 进行注入<property>的信息, 被注解的字段类型只能是String、primitive class
+        如果name是system.property.开头的值将会在进程启动时进行System.setProperty("yyyy", "YYYYYY")操作。
+        如果name是mimetype.property.开头的值将会在进程启动时进行MimeType.add("yyyy", "YYYYYY")操作。
+        先加载子节点property，再加载load文件， 最后加载agent的实现子类。
+        load:  加载文件，多个用;隔开。
+        其他属性: 供org.redkale.boot.PropertiesAgentProvider使用判断
+        默认置入的system.property.的有：
+           System.setProperty("redkale.convert.pool.size", "128");
+           System.setProperty("redkale.convert.writer.buffer.defsize", "4096");
+           System.setProperty("redkale.trace.enable", "false");
+           
+        <properties>节点下也可包含非<property>节点.
+        非<property>其节点可以通过@Resource(name="properties.xxxxxx")进行注入, 被注解的字段类型只能是AnyValue、AnyValue[]
+    -->
+    <properties load="config.properties">
+        <property name="system.property.yyyy" value="YYYYYY"/>
+        <property name="xxxxxx" value="XXXXXXXX"/>
+        <property name="xxxxxx" value="XXXXXXXX"/>
+        <property name="xxxxxx" value="XXXXXXXX"/>
+    </properties>
+        
+    <!--
+        protocol: required   server所启动的协议，Redkale内置的有HTTP、SNCP、WATCH。协议均使用TCP实现; WATCH服务只能存在一个。
+        name:                服务的名称，用于监控识别，一个配置文件中的server.name不能重复,命名规则: 字母、数字、下划线
+        host:                服务所占address ， 默认: 0.0.0.0
+        port:                required 服务所占端口 
+        root:                如果是web类型服务，则包含页面  默认:{APP_HOME}/root
+        lib:                 server额外的class目录， 默认为${APP_HOME}/libs/*; 
+        excludelibs:         排除lib.path与excludes中的正则表达式匹配的路径, 多个正则表达式用分号;隔开
+        charset:             文本编码， 默认: UTF-8
+        backlog:             默认10K
+        maxconns：           最大连接数, 小于1表示无限制， 默认: 0
+        maxbody:             request.body最大值， 默认: 64K
+        bufferCapacity:      ByteBuffer的初始化大小， TCP默认: 32K;  (HTTP 2.0、WebSocket，必须要16k以上); UDP默认: 8K
+        bufferPoolSize：     ByteBuffer池的大小，默认: 线程数*4
+        responsePoolSize：   Response池的大小，默认: 1024
+        aliveTimeoutSeconds: KeepAlive读操作超时秒数， 默认30， 0表示永久不超时; -1表示禁止KeepAlive
+        readTimeoutSeconds:  读操作超时秒数， 默认0， 0表示永久不超时
+        writeTimeoutSeconds: 写操作超时秒数， 默认0， 0表示永久不超时
+        interceptor:         启动/关闭NodeServer时被调用的拦截器实现类，必须是org.redkale.boot.NodeInterceptor的子类，默认为null
+    -->
+    <server protocol="HTTP" host="127.0.0.1" port="6060" root="root" lib=""> 
+        
+        <!-- 
+           【节点在<server>中唯一】
+           builder:             创建SSLContext的实现类, 可自定义，必须是org.redkale.net.SSLBuilder的子类
+           sslProvider:         java.security.Provider自定义的实现类，如第三方: org.conscrypt.OpenSSLProvider、org.bouncycastle.jce.provider.BouncyCastleProvider
+           jsseProvider:        java.security.Provider自定义的实现类，如第三方: org.conscrypt.JSSEProvider、   org.bouncycastle.jce.provider.BouncyCastleJsseProvider
+           protocol:            TLS版本，默认值: TLS
+           protocols:           设置setEnabledProtocols, 多个用,隔开 如: TLSv1.2,TLSv1.3
+           clientAuth:          WANT/NEED/NONE, 默认值: NONE
+           ciphers:             设置setEnabledCipherSuites, 多个用,隔开 如: TLS_RSA_WITH_AES_128_CBC_SHA256,TLS_RSA_WITH_AES_256_CBC_SHA256
+           keystorePass:        KEY密码
+           keystoreFile:        KEY文件 .jks
+           keystoreType:        KEY类型， 默认值为JKS
+           keystoreAlgorithm:   KEY文件的algorithm， 默认值为SunX509
+           truststorePass:      TRUST密码
+           truststoreFile:      TRUST文件
+           truststoreType:      TRUST类型， 默认值为JKS
+           truststoreAlgorithm: TRUST文件的algorithm， 默认值为SunX509
+        -->
+        <ssl builder=""/>
+        
+        <!-- 
+           加载所有的Service服务;
+           在同一个进程中同一个name同一类型的Service将共用同一个实例
+           autoload="true"  默认值. 自动加载classpath下所有的Service类  
+           autoload="false" 需要显著的指定Service类
+           mq:        所属的MQ管理器，当 protocol == SNCP 时该值才有效, 存在该属性表示Service的SNCP协议采用消息总线代理模式
+           includes： 当autoload="true"， 拉取类名与includes中的正则表达式匹配的类, 多个正则表达式用分号;隔开
+           excludes： 当autoload="true"， 排除类名与excludes中的正则表达式匹配的类, 多个正则表达式用分号;隔开           
+           group:     所属组的节点, 不能指定多个group, 如果配置文件中存在多个SNCP协议的Server节点，需要显式指定group属性.
+                         当 protocol == SNCP 时 group表示当前Server与哪些节点组关联。
+                         当 protocol != SNCP 时 group只能是空或者一个group的节点值。
+                         特殊值"$remote", 视为通过第三方服务注册发现管理工具来获取远程模式的ip端口信息
+        -->
+        <services autoload="true" includes="" excludes="">
+
+            <!-- 显著加载指定的Service的接口类 -->
+            <service value="com.xxx.XXX1Service"/>
+            <!-- 
+               name:   显式指定name，覆盖默认的空字符串值。 注意: name不能包含$符号。
+               mq:     所属的MQ管理器，当 protocol == SNCP 时该值才有效, 存在该属性表示Service的SNCP协议采用消息总线代理模式
+               group:  显式指定group，覆盖<services>节点的group默认值。
+               ignore: 是否禁用， 默认为false。
+            -->
+            <service value="com.xxx.XXX2Service" name="" group="xxx"/>
+            <!--   给Service增加配置属性 -->
+            <service value="com.xxx.XXX1Service"> 
+                <!-- property值在public void init(AnyValue conf)方法中可以通过AnyValue properties=conf.getAnyValue("properties")获取 -->
+                <property name="xxxxxx" value="XXXXXXXX"/>  
+                <property name="xxxxxx" value="XXXXXXXX"/>
+            </service>
+        </services>
+        
+        <!-- 
+           加载所有的Filter服务;
+           autoload="true"  默认值.  
+           autoload="false" 需要显著的指定Filter类
+           includes：       当autoload="true"， 拉取类名与includes中的正则表达式匹配的类, 多个正则表达式用分号;隔开
+           excludes：       当autoload="true"， 排除类名与excludes中的正则表达式匹配的类, 多个正则表达式用分号;隔开    
+        -->
+        <filters autoload="true" includes="" excludes="">
+            
+            <!-- 
+               显著加载指定的Filter类
+               value=: Filter类名。必须与Server的协议层相同，HTTP必须是HttpFilter
+               ignore: 是否禁用， 默认为false。
+            -->
+            <!-- 显著加载指定的Filter类 -->
+            <filter value="com.xxx.XXX1Filter"/>
+            
+            <!--   给Filter增加配置属性 -->
+            <filter value="com.xxx.XXX12Filter"> 
+                <!-- property值在public void init(AnyValue conf)方法中可以通过AnyValue properties=conf.getAnyValue("properties")获取 -->
+                <property name="xxxxxx" value="XXXXXXXX"/>  
+                <property name="xxxxxx" value="XXXXXXXX"/>
+            </filter>
+        </filters>
+        
+        <!-- 
+           REST的核心配置项
+           当Server为HTTP协议时, rest节点才有效。存在[rest]节点则Server启动时会加载REST服务, 节点可以多个,(WATCH协议不需要设置，系统会自动生成)
+           path:     servlet的ContextPath前缀 默认为空 【注: 开启MQ时,该字段失效】
+           base:     REST服务的BaseServlet，必须是 org.redkale.net.http.HttpServlet 的子类，且子类必须标记@HttpUserType。
+           mq:        所属的MQ管理器, 存在该属性表示RestService的请求来自于消息总线 【注: 开启MQ时,path字段失效】
+           autoload：默认值"true"  默认值. 加载当前server所能使用的Servce对象;    
+           includes：当autoload="true"， 拉取类名与includes中的正则表达式匹配的类, 多个正则表达式用分号;隔开
+           excludes：当autoload="true"， 排除类名与excludes中的正则表达式匹配的类, 多个正则表达式用分号;隔开
+        -->
+        <rest path="/pipes" base="org.redkale.net.http.HttpServlet" autoload="true" includes="" excludes="">
+            <!-- 
+               value:  Service类名，列出的表示必须被加载的Service对象
+               ignore: 是否忽略，设置为true则不会加载该Service对象，默认值为false
+            -->
+            <service value="com.xxx.XXXXService"/>
+            <!-- 
+               value:  WebSocket类名，列出的表示必须被加载且标记为@RestWebSocket的WebSocket对象
+               ignore: 是否忽略，设置为true则不会加载该RestWebSocket对象，默认值为false
+            -->
+            <websocket value="com.xxx.XXXXRestWebSocket"/>
+        </rest>
+        
+        <!--
+           【节点在<server>中唯一】
+           当Server为HTTP协议时, request节点才有效。
+           remoteaddr 节点: 替换请求方节点的IP地址， 通常请求方是由nginx等web静态服务器转发过的则需要配置该节点。
+           且value值只能是以request.headers.开头，表示从request.headers中获取对应的header值。
+           locale value值必须是request.headers.或request.parameters.开头。
+           例如下面例子获取request.getRemoteAddr()值，如果header存在X-RemoteAddress值则返回X-RemoteAddress值，不存在返回getRemoteAddress()。
+        -->
+        <request>
+            <remoteaddr value="request.headers.X-RemoteAddress"/>
+            <locale value="request.headers.locale" /> 
+            <rpc authenticator="org.redkale.net.http.HttpRpcAuthenticator的实现类"/>
+        </request>
+        
+        <!--
+           【节点在<server>中唯一】
+           当Server为HTTP协议时, response节点才有效。
+           contenttype: plain值为调用finish时的ContentType; 默认值: text/plain; charset=utf-8
+                        json值为调用finishJson时的ContentType; 默认值: application/json; charset=utf-8
+           defcookie 节点: 当response里输出的cookie没有指定domain 和path时，使用该节点的默认值。
+           addheader、setheader 的value值以request.parameters.开头则表示从request.parameters中获取对应的parameter值
+           addheader、setheader 的value值以request.headers.开头则表示从request.headers中获取对应的header值
+           例如下面例子是在Response输出header时添加两个header（一个addHeader， 一个setHeader）。
+           options 节点: 设置了该节点且auto=true，当request的method=OPTIONS自动设置addheader、setheader并返回200状态码
+           date 节点: 设置了该节点且period有值(单位：毫秒);返回response会包含Date头信息，默认为period=0
+                      period=0表示实时获取当前时间;
+                      period<0表示不设置date;
+                      period>0表示定时获取时间; 设置1000表示每秒刷新Date时间
+        -->
+        <response>
+            <content-type plain="text/plain; charset=utf-8" json="application/json; charset=utf-8"/>            
+            <defcookie domain="" path=""/>  
+            <addheader name="Access-Control-Allow-Origin" value="request.headers.Origin" />  <!-- 可多节点 -->
+            <setheader name="Access-Control-Allow-Headers" value="request.headers.Access-Control-Request-Headers"/>  <!-- 可多节点 -->
+            <setheader name="Access-Control-Allow-Credentials" value="true"/>
+            <options auto="true" />
+            <date period="0" />
+        </response>
+        <!-- 
+           【节点在<server>中唯一】
+           当Server为HTTP协议时，render才有效. 指定输出引擎的实现类
+           value: 输出引擎的实现类, 必须是org.redkale.net.http.HttpRender的子类
+           suffixs: 引擎文件名后缀，多个用;隔开，默认值为: .htel
+        -->
+        <render value="org.redkalex.htel.HttpTemplateRender" suffixs=".htel"/>
+        <!-- 
+           【节点在<server>中唯一】
+           当Server为HTTP协议时，ResourceServlet才有效. 默认存在一个有默认属性的resource-servlet节点
+           webroot: web资源的根目录, 默认取server节点中的root值
+           servlet: 静态资源HttpServlet的实现，默认使用HttpResourceServlet
+           index :  启始页，默认值：index.html
+        -->
+        <resource-servlet webroot="root" index="index.html">
+            <!--
+                【节点在<resource-servlet>中唯一】
+                资源缓存的配置, 默认存在一个含默认属性的caches节点
+                limit:     资源缓存最大容量， 默认: 0, 为0表示不缓存， 单位可以是B、K、M、G，不区分大小写
+                lengthmax: 可缓存的文件大小上限， 默认: 1M（超过1M的文件不会被缓存）
+                watch:     是否监控缓存文件的变化， 默认为false，不监控
+            -->
+            <cache  limit="0M" lengthmax="1M" watch="false"/>
+            <!--
+               支持类似nginx中的rewrite， 目前只支持静态资源对静态资源的跳转。
+               type:    匹配的类型, 目前只支持location(匹配requestURI), 默认: location
+               match:   匹配的正则表达式
+               forward: 需跳转后的资源链接
+               例如下面例子是将/xxx-yyy.html的页面全部跳转到/xxx.html
+            -->
+            <rewrite type="location" match="^/([^-]+)-[^-\.]+\.html(.*)" forward="/$1.html"/>
+        </resource-servlet>
+        <!-- 
+           加载所有的Servlet服务;
+           path:            servlet的ContextPath前缀 默认为空
+           autoload="true"  默认值. 自动加载classpath下所有的Servlet类 
+           autoload="false" 需要显著的指定Service类
+           includes：       当autoload="true"， 拉取类名与includes中的正则表达式匹配的类, 多个正则表达式用分号;隔开
+           excludes：       当autoload="true"， 排除类名与excludes中的正则表达式匹配的类, 多个正则表达式用分号;隔开
+        -->
+        <servlets path="/pipes" autoload="true" includes="" excludes="">
+            <!-- 
+               显著加载指定的Servlet类
+               value=: Servlet类名。必须与Server的协议层相同，HTTP必须是HttpServlet
+               ignore: 是否禁用， 默认为false。
+            -->
+            <servlet value="com.xxx.XXX1Servlet" />
+            <servlet value="com.xxx.XXX2Servlet" />
+            <servlet value="com.xxx.XXX3Servlet" >
+                <property name="xxxxxx" value="XXXXXXXX"/>
+                <property name="yyyyyy" value="YYYYYYYY"/>
+            </servlet>
+        </servlets>
+    </server>
+    
+    <server protocol="SNCP" host="127.0.0.1" port="7070" root="root" lib=""> 
+        <!-- 参数完全同上 -->
+        <services autoload="true" includes="" excludes="" />
+    </server>
+    
+</application>
+
+```
+
+## source.properties
+
+数据源(含数据库、缓存)配置文件
+
+```
+
+# CacheSource   @Resource(name="usersession")
+# type可以不用设置，框架会根据url判断使用哪个CacheSource实现类
+redkale.cachesource.usersession.type = org.redkalex.cache.redis.RedisCacheSource
+# 最大连接数
+redkale.cachesource.usersession.maxconns = 16
+# 节点地址
+redkale.cachesource.usersession.node[0].url = redis://127.0.0.1:6363
+# 节点密码
+redkale.cachesource.usersession.node[0].password = 12345678
+# 节点db
+redkale.cachesource.usersession.node[0].db = 0
+
+#简化写法: 可以不用.node[0], 将参数都合并到url中
+redkale.cachesource.usersession.url = redis://user:123456@127.0.0.1:6363?db=0
+
+
+# DataSource   @Resource(name="platf")
+# type可以不用设置，框架会根据url判断使用哪个DataSource实现类，默认值: org.redkale.source.DataJdbcSource
+redkale.datasource.platf.type = org.redkale.source.DataJdbcSource
+# 是否开启缓存(标记为@Cacheable的Entity类)，值目前只支持两种： ALL: 所有开启缓存。 NONE: 关闭所有缓存， 非NONE字样统一视为ALL
+redkale.datasource.platf.cachemode = ALL
+# 是否自动建表当表不存在的时候， 目前只支持mysql、postgres， 默认为false
+redkale.datasource.platf.table-autoddl = false
+# 用户
+redkale.datasource.platf.user = root
+# 密码
+redkale.datasource.platf.password = 12345678
+# 多个URL用;隔开，如分布式SearchSource需要配多个URL
+redkale.datasource.platf.url = jdbc:mysql://127.0.0.1:3306/platf?allowPublicKeyRetrieval=true&rewriteBatchedStatements=true&serverTimezone=UTC&characterEncoding=utf8
+# 最大连接数，默认值：CPU数
+redkale.datasource.platf.maxconns = 16
+# 包含的SQL模板，相当于反向LIKE，不同的JDBC驱动的SQL语句不一样，Redkale内置了MySQL的语句
+redkale.datasource.platf.contain-sqltemplate = LOCATE(${keystr}, ${column}) > 0
+# 包含的SQL模板，相当于反向LIKE，不同的JDBC驱动的SQL语句不一样，Redkale内置了MySQL的语句
+redkale.datasource.platf.notcontain-sqltemplate = LOCATE(${keystr}, ${column}) = 0
+# 复制表结构的SQL模板，Redkale内置了MySQL的语句
+redkale.datasource.platf.tablenotexist-sqlstates = 42000;42S02
+# 复制表结构的SQL模板，Redkale内置了MySQL的语句
+redkale.datasource.platf.tablecopy-sqltemplate = CREATE TABLE IF NOT EXISTS ${newtable} LIKE ${oldtable}
+
+
+# DataSource 读写分离
+redkale.datasource.platf.read.url = jdbc:mysql://127.0.0.1:3306/platf_r?allowPublicKeyRetrieval=true&rewriteBatchedStatements=true&serverTimezone=UTC&characterEncoding=utf8
+redkale.datasource.platf.read.user = root
+redkale.datasource.platf.read.password = 12345678
+
+redkale.datasource.platf.write.url = jdbc:mysql://127.0.0.1:3306/platf_w?allowPublicKeyRetrieval=true&rewriteBatchedStatements=true&serverTimezone=UTC&characterEncoding=utf8
+redkale.datasource.platf.write.user = root
+redkale.datasource.platf.write.password = 12345678
+```
+
+## logging.properties
+
+日志配置文件
+
+```
+
+handlers = java.util.logging.ConsoleHandler,java.util.logging.FileHandler
+.handlers = java.util.logging.ConsoleHandler,java.util.logging.FileHandler
+
+############################################################
+.level = FINE
+
+sun.level = INFO
+java.level = INFO
+javax.level = INFO
+com.sun.level = INFO
+
+#java.util.logging.FileHandler.level = FINE
+
+java.util.logging.FileHandler.limit = 20M
+java.util.logging.FileHandler.count = 100
+java.util.logging.FileHandler.encoding = UTF-8
+java.util.logging.FileHandler.pattern = ${APP_HOME}/logs-%tY%tm/log-%tY%tm%td.log
+#java.util.logging.FileHandler.unusual 属性表示将 WARNING、SEVERE 级别的日志复制写入单独的文件中
+java.util.logging.FileHandler.unusual = ${APP_HOME}/logs-%tY%tm/log-warnerr-%tY%tm%td.log
+#需要屏蔽消息内容的正则表达式
+java.util.logging.FileHandler.denyreg = 
+java.util.logging.FileHandler.append = true
+
+#java.util.logging.ConsoleHandler.level = FINE
+
+#将日志写进SearchSource, 必须指定source资源名，在source.properties中定义
+#java.util.logging.SearchHandler.source = platfsearch
+#指定写进SearchSource的表名，默认值为log-record
+#java.util.logging.SearchHandler.tag = log-${APP_NAME}-%tY%tm%td
+
+```

service-zu-jian.md

@@ -0,0 +1,6 @@
+---
+description: Service是Redkale最核心的类， 几乎所有组件都是围绕Service来服务。
+---
+
+# Service 组件
+

sncp-fu-wu.md

@@ -0,0 +1,2 @@
+# SNCP 服务
+

watch-fu-wu.md

@@ -0,0 +1,2 @@
+# WATCH 服务
+