©2020-2024 ioDraw All rights reserved,
Privacy Policy
扑街前言：前面说了netty的基本运用、Java的NIO等一系列的知识，这些知识已经可以做一个简单的rpc框架，本篇和下篇我们一起了解一个怎么完成一个rpc框架，当然个只是为了更好的了解rpc框架的基本逻辑，并不是真的可以用于业务使用。（认识到自己是菜鸟的第47天，今天突然记起来是多少天了）
在编写具体代码之前，我们要了解什么是rpc框架，它是由什么结构组成的，而最常见RPC框架就是Dubbo。
RPC
的主要功能目标是让构建分布式计算（应用）更容易，是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议规范，简单的来说就是像调用本地服务一样调用远程服务，对开发者而言是透明的。
RPC的优势
* RPC框架一般使用长链接，不必每次通信都要3次握手，减少网络开销。
* RPC框架一般都有注册中心，有丰富的监控管理。
* 发布、下线接口、动态扩展等，对调用方来说是无感知、统一化的操作。
* 协议私密，安全性较高。
* rpc 能做到协议更简单内容更小，效率更高。
* rpc是面向服务的更高级的抽象，支持服务注册发现，负载均衡，超时重试，熔断降级等高级特性。
RPC架构设计
一幅图片解释整个rpc的架构设计
上述简单描述一下rpc的一些简单概念，那么首先来编写服务端的代码，因为服务端的编写难度要小于客户端。从上面图片可以看出服务端主要是：服务注册（这里用zookeeper作为注册中心）、监听端口接收连接（包括请求解码、响应编码、请求处理，而编码和解码又有一次编、解码和二次编、解码）。当然这是简单的基本功能，比如限流、健康监测之类的后续再说，先迈出第一步很重要。
zookeeper
在代码开始之前，还需要简单的了解zookeeper的安装和使用，安装就是在zookeeper的官网下载一下最新的稳定版本，然后解压，打开bin目录，运行zkServer.cmd即可。具体的详细下篇文章再说，本篇文章重点是rpc框架的基本编写。至于Java中使用zookeeper，可以类比Redis的使用，Redis为Java提供了两个客户端
Jedis 和 Redisson，下面代码我们也是使用zookeeper了一个客户端 zkclient。
代码逻辑示例
上述内容结合之前文章的相关的网络编程内容，可以先写一个服务端，代码如下。
首先结合上面的流程图，大致说一下逻辑。1、需要一个引导类，用于引导整个rpc服务的启动；2、有一个启动器，在启动器中完成服务注册和基于netty的监听；3、需要一个服务注册的server，基于zookeeper实现服务注册，需要封装zookeeper的连接和调用；4、需要一个netty的server，实现一次、二次编解码，并且实现请求处理调用具体的业务逻辑。
引导类
这里单独说明一下@PostConstruct注解，这个具体作用是当这个类被注册bean的时候，会运行一次被修饰的方法，但是在jdk9之后就去除了。
import org.springframework.beans.factory.annotation.Autowired; import
org.springframework.context.annotation.Configuration; import
javax.annotation.PostConstruct; @Configuration public class RpcServerBootstrap
{ @Autowired private RpcServerRnner rpcServerRnner; @PostConstruct public void
initRpcServer (){ // 运行启动器 rpcServerRnner.run(); } }
启动器
import com.rpc.server.registry.RpcRegistry; import
org.springframework.beans.factory.annotation.Autowired; import
org.springframework.stereotype.Component; import javax.annotation.Resource;
@Component public class RpcServerRnner { @Autowired private RpcRegistry
rpcRegistry; @Resource private RpcServer rpcServer; /** * 用于服务注册和netty监听 */
public void run () { // 服务注册 rpcRegistry.serviceRegistry(); // 启动服务，监听端口，接收连接请求
rpcServer.start(); } }
配置信息对象
import lombok.Data; import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component; @Data @Component public class
RpcServerConfiguration { /** * ZK根节点名称 */ @Value("${rpc.server.zk.root}")
private String zkRoot; /** * ZK地址信息 */ @Value("${rpc.server.zk.addr}") private
String zkAddr; /** * RPC通讯端口 */ @Value("${rpc.network.port}") private int
rpcPort; /** * Spring Boot 服务端口 */ @Value("${server.port}") private int
serverPort; /** * ZK连接超时时间配置 */ @Value("${rpc.server.zk.timeout:10000}")
private int connectTimeout; }
zookeeper客户端连接
import org.I0Itec.zkclient.ZkClient; import
org.springframework.beans.factory.annotation.Autowired; import
org.springframework.context.annotation.Bean; import
org.springframework.context.annotation.Configuration; @Configuration public
class ServerZkClientConfig { /** * RPC服务端配置 */ @Autowired private
RpcServerConfiguration rpcServerConfiguration; /** * 声音ZK客户端 * @return */ @Bean
public ZkClient zkClient() { return new
ZkClient(rpcServerConfiguration.getZkAddr(),
rpcServerConfiguration.getConnectTimeout()); } }
zookeeper连接操作接口
import org.I0Itec.zkclient.ZkClient; import
org.springframework.beans.factory.annotation.Autowired; import
org.springframework.stereotype.Component; /** * Zookeeper连接操作接口 */ @Component
public class ServerZKit { @Autowired private ZkClient zkClient; @Autowired
private RpcServerConfiguration rpcServerConfiguration; /*** * 根节点创建 */ public
void createRootNode() { boolean exists =
zkClient.exists(rpcServerConfiguration.getZkRoot()); if (!exists) {
zkClient.createPersistent(rpcServerConfiguration.getZkRoot()); } } /*** *
创建其他节点 * @param path */ public void createPersistentNode(String path) { String
pathName = rpcServerConfiguration.getZkRoot() + "/" + path; boolean exists =
zkClient.exists(pathName); if (!exists) { zkClient.createPersistent(pathName);
} } /*** * 创建节点 * @param path */ public void createNode(String path) { String
pathName = rpcServerConfiguration.getZkRoot() + "/" + path; boolean exists =
zkClient.exists(pathName); if (!exists) { zkClient.createEphemeral(pathName); }
} }
用于服务请求连接的注解
import org.springframework.core.annotation.AliasFor; import
org.springframework.stereotype.Component; import java.lang.annotation.*;
@Component @Target(ElementType.TYPE) @Retention(RetentionPolicy.RUNTIME)
@Documented public @interface HrpcService { /** * 等同于@Component的value * @return
*/ @AliasFor(annotation = Component.class) String value() default ""; /** *
服务接口Class * @return */ Class<?> interfaceClass() default void.class; /** *
服务接口名称 * @return */ String interfaceName() default ""; /** * 服务版本号 * @return */
String version() default ""; /** * 服务分组 * @return */ String group() default "";
}
创建一个Spring的Bean工厂，用于封装获取IOC容器中的bean信息
import org.springframework.beans.BeansException; import
org.springframework.beans.factory.support.DefaultListableBeanFactory; import
org.springframework.context.ApplicationContext; import
org.springframework.context.ApplicationContextAware; import
org.springframework.stereotype.Component; import
java.lang.annotation.Annotation; import java.util.Map; @Component public class
SpringBeanFactory implements ApplicationContextAware { /** * ioc容器 */ private
static ApplicationContext context; @Override public void
setApplicationContext(ApplicationContext applicationContext) throws
BeansException { context = applicationContext; } /*public static
ApplicationContext getApplicationContext() { return context; }*/ /** *
根据Class获取bean * @param cls * @param <T> * @return */ public static <T> T
getBean(Class<T> cls) { return context.getBean(cls); } /** * 根据beanName获取bean *
@param beanName * @return */ public static Object getBean(String beanName) {
return context.getBean(beanName); } /*** * 获取有指定注解的对象 * @param annotationClass
* @return */ public static Map<String, Object>
getBeanListByAnnotationClass(Class<? extends Annotation> annotationClass) {
return context.getBeansWithAnnotation(annotationClass); } /** * 向容器注册单例bean *
@param bean */ public static void registerSingleton(Object bean) {
DefaultListableBeanFactory beanFactory = (DefaultListableBeanFactory)
context.getAutowireCapableBeanFactory(); //
让bean完成Spring初始化过程中所有增强器检验，只是不重新创建bean
beanFactory.applyBeanPostProcessorsAfterInitialization(bean,bean.getClass().getName());
//将bean以单例的形式入驻到容器中，此时通过bean.getClass().getName()或bean.getClass()都可以拿到放入Spring容器的Bean
beanFactory.registerSingleton(bean.getClass().getName(),bean); } }
服务注册
上面的准备工作基本上就做完了，下面开始正式的逻辑代码。这里提一点，当spring
boot整合这个自定义框架的时候，可以有很多方式，这个不再细说，可以参考文章spring boot的自动配置，这里可以直接粗暴一点在spring
boot项目的启动类上@SpringBootApplication(scanBasePackages ={"包路径","包路径"})。
再说一下@component 注解，这是由spring 提供，被其修饰的类被声明为spring
的组件，简单来说就是创建bean并放置IOC容器中。
/** * 服务注册接口 */ public interface RpcRegistry { /** * 服务注册 */ void
serviceRegistry(); } import com.rpc.annotation.HrpcService; import
com.rpc.server.config.RpcServerConfiguration; import
com.rpc.server.registry.RpcRegistry; import com.rpc.spring.SpringBeanFactory;
import com.rpc.util.IpUtil; import lombok.extern.slf4j.Slf4j; import
org.springframework.stereotype.Component; import java.util.Map; @Component
@Slf4j public class ZkRegistry implements RpcRegistry { /** * 封装的bean工厂 */
@Autowired private SpringBeanFactory springBeanFactory; /** * 封装的zookeeper的客户端
*/ @Autowired private ServerZKit zKitClient; /** * 配置信息对象 */ @Autowired private
RpcServerConfiguration rpcServerConfiguration; @Override public void
serviceRegistry() { /* * 1、首先要获取被HrpcService 注解修饰的，IOC中的所有的bean信息 *
2、拿到bean之后，再获取bean上的HrpcService 注解对象 * 3、拿到HrpcService 注解上面的接口信息 *
4、创建zookeeper上的根节点，并获取服务端ip和配置文件中的zookeeper端口，创建以接口名称为key，ip+端口为value的子节点 *
5、注册成功 */ // 获取被HrpcService 注解修饰的，IOC中的所有的bean信息 Map<String, Object>
annotationClass =
springBeanFactory.getBeanListByAnnotationClass(HrpcService.class); //
没被注册信息，直接结束 if (annotationClass == null || annotationClass.size() < 0){ return;
} // 迭代所有的bean for (Object bean : annotationClass.values()) { // 获取HrpcService
注解信息 HrpcService hrpcService =
bean.getClass().getAnnotation(HrpcService.class); // 获取HrpcService
注解的interfaceClass属性，也就是接口对象 Class<?> interfaceClass =
hrpcService.interfaceClass(); // 获取接口的名称 String name =
interfaceClass.getName(); /* * 开始往zookeeper添加节点 */ // 根节点
zKitClient.createRootNode(); // 子节点，用于接口名称
zKitClient.createPersistentNode(name); // 获取ip String ip = IpUtil.getRealIp();
// ip + 端口 String node = ip + rpcServerConfiguration.getZkAddr(); // 子节点对应下级节点
zKitClient.createNode(name + "/" + node); // 打印日志 log.info("服务{}-{}注册成功", name,
node); } } }
序列化工具
import io.protostuff.LinkedBuffer; import io.protostuff.ProtostuffIOUtil;
import io.protostuff.Schema; import io.protostuff.runtime.RuntimeSchema; import
lombok.extern.slf4j.Slf4j; import java.util.*; import
java.util.concurrent.CopyOnWriteArrayList; /** * @description * @author: ts *
@create:2021-04-08 10:31 */ @Slf4j public class ProtostuffUtil {
//存储因为无法直接序列化/反序列化 而需要被包装的类型Class private static final Set<Class<?>>
WRAPPER_SET = new HashSet<Class<?>>(); static { WRAPPER_SET.add(List.class);
WRAPPER_SET.add(ArrayList.class); WRAPPER_SET.add(CopyOnWriteArrayList.class);
WRAPPER_SET.add(LinkedList.class); WRAPPER_SET.add(Stack.class);
WRAPPER_SET.add(Vector.class); WRAPPER_SET.add(Map.class);
WRAPPER_SET.add(HashMap.class); WRAPPER_SET.add(TreeMap.class);
WRAPPER_SET.add(LinkedHashMap.class); WRAPPER_SET.add(Hashtable.class);
WRAPPER_SET.add(SortedMap.class); WRAPPER_SET.add(Object.class); }
//注册需要使用包装类进行序列化的Class对象 public static void registerWrapperClass(Class<?>
clazz) { WRAPPER_SET.add(clazz); } /** * 将对象序列化为字节数组 * @param t * @param
useWrapper 为true完全使用包装模式 为false则选择性的使用包装模式 * @param <T> * @return */ public
static <T> byte[] serialize(T t,boolean useWrapper) { Object serializerObj = t;
if (useWrapper) { serializerObj = SerializeDeserializeWrapper.build(t); }
return serialize(serializerObj); } /** * 将对象序列化为字节数组 * @param t * @param <T> *
@return */ public static <T> byte[] serialize(T t) { //获取序列化对象的class Class<T>
clazz = (Class<T>) t.getClass(); Object serializerObj = t; if
(WRAPPER_SET.contains(clazz)) { serializerObj =
SerializeDeserializeWrapper.build(t);//将原始序列化对象进行包装 } return
doSerialize(serializerObj); } /** * 执行序列化 * @param t * @param <T> * @return */
public static <T> byte[] doSerialize(T t) { //获取序列化对象的class Class<T> clazz =
(Class<T>) t.getClass(); //获取Schema // RuntimeSchema<T> schema =
RuntimeSchema.createFrom(clazz);//根据给定的class创建schema /** * this is lazily
created and cached by RuntimeSchema * so its safe to call
RuntimeSchema.getSchema() over and over The getSchema method is also
thread-safe */ Schema<T> schema = RuntimeSchema.getSchema(clazz);//内部有缓存机制 /**
* Re-use (manage) this buffer to avoid allocating on every serialization */
LinkedBuffer buffer = LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE);
byte[] protostuff = null; try { protostuff = ProtostuffIOUtil.toByteArray(t,
schema, buffer); } catch (Exception e){ log.error("protostuff serialize
error,{}",e.getMessage()); }finally { buffer.clear(); } return protostuff; }
/** * 反序列化 * @param data * @param clazz * @param <T> * @return */ public static
<T> T deserialize(byte[] data,Class<T> clazz) { //判断是否经过包装 if
(WRAPPER_SET.contains(clazz)) { SerializeDeserializeWrapper<T> wrapper = new
SerializeDeserializeWrapper<T>();
ProtostuffIOUtil.mergeFrom(data,wrapper,RuntimeSchema.getSchema(SerializeDeserializeWrapper.class));
return wrapper.getData(); }else { Schema<T> schema =
RuntimeSchema.getSchema(clazz); T newMessage = schema.newMessage();
ProtostuffIOUtil.mergeFrom(data,newMessage,schema); return newMessage; } }
private static class SerializeDeserializeWrapper<T> { //被包装的数据 T data; public
static <T> SerializeDeserializeWrapper<T> build(T data){
SerializeDeserializeWrapper<T> wrapper = new SerializeDeserializeWrapper<T>();
wrapper.setData(data); return wrapper; } public T getData() { return data; }
public void setData(T data) { this.data = data; } } }
一次编码
import io.netty.handler.codec.LengthFieldBasedFrameDecoder; /** * 一次解码 */
public class FrameDecoder extends LengthFieldBasedFrameDecoder { public
FrameDecoder() { super(Integer.MAX_VALUE, 0, 4, 0, 4); } }
二次编码
import com.rpc.util.ProtostuffUtil; import io.netty.buffer.ByteBuf; import
io.netty.channel.ChannelHandlerContext; import
io.netty.handler.codec.MessageToMessageEncoder; import
lombok.extern.slf4j.Slf4j; import java.util.List; /** * 服务端的二次编码 */ @Slf4j
public class RpcResponseEncoder extends MessageToMessageEncoder<ByteBuf> {
@Override protected void encode(ChannelHandlerContext ctx, ByteBuf msg,
List<Object> out) throws Exception { /* * 首先将传入的ByteBuf 序列化为一个byte 数组 *
然后用ChannelHandlerContext 构建一个buffer对象 * 最后写入buffer，添加out写出 */ try { //
使用序列化工具，将msg序列化 byte[] bytes = ProtostuffUtil.serialize(msg); //
由ctx分配构建一个buffer对象 ByteBuf buffer = ctx.alloc().buffer(bytes.length); //
将数据交给buffer buffer.writeBytes(bytes); // 添加写出 out.add(buffer); } catch
(Exception e) { // 异常 log.error("RpcResponseEncoder exception
,msg={}",e.getMessage()); } } }
一次解码
import io.netty.handler.codec.LengthFieldPrepender; /** * 一次解码 */ public class
FrameEncoder extends LengthFieldPrepender { public FrameEncoder() { super(4); }
}
二次解码
import com.itheima.rpc.util.ProtostuffUtil; import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext; import
io.netty.handler.codec.MessageToMessageEncoder; import
lombok.extern.slf4j.Slf4j; import java.util.List; /** * 服务端的二次编码 */ @Slf4j
public class RpcResponseEncoder extends MessageToMessageEncoder<ByteBuf> {
@Override protected void encode(ChannelHandlerContext ctx, ByteBuf msg,
List<Object> out) throws Exception { /* * 首先将传入的ByteBuf 序列化为一个byte 数组 *
然后用ChannelHandlerContext 构建一个buffer对象 * 最后写入buffer，添加out写出 */ try { //
使用序列化工具，将msg序列化 byte[] bytes = ProtostuffUtil.serialize(msg); //
由ctx分配构建一个buffer对象 ByteBuf buffer = ctx.alloc().buffer(bytes.length); //
将数据交给buffer buffer.writeBytes(bytes); // 添加写出 out.add(buffer); } catch
(Exception e) { // 异常 log.error("RpcResponseEncoder exception
,msg={}",e.getMessage()); } } }
响应对象
import lombok.AllArgsConstructor; import lombok.Builder; import lombok.Data;
import lombok.NoArgsConstructor; @Data @Builder @NoArgsConstructor
@AllArgsConstructor public class RpcResponse { private String requestId;
private Object result; private Throwable cause; public boolean isError() {
return cause != null; } }
请求对象
import lombok.AllArgsConstructor; import lombok.Builder; import lombok.Data;
import lombok.NoArgsConstructor; @Data @Builder @NoArgsConstructor
@AllArgsConstructor public class RpcRequest { private String requestId; private
String className; private String methodName; private Class<?>[] parameterTypes;
private Object[] parameters; }
业务逻辑调用Handler
import com.itheima.rpc.data.RpcRequest; import
com.itheima.rpc.data.RpcResponse; import
com.itheima.rpc.spring.SpringBeanFactory; import
io.netty.channel.ChannelHandlerContext; import
io.netty.channel.SimpleChannelInboundHandler; import lombok.extern.slf4j.Slf4j;
import java.lang.reflect.InvocationTargetException; import
java.lang.reflect.Method; /** * 客户端请求业务调用 */ @Slf4j public class
RpcRequestHandler extends SimpleChannelInboundHandler<RpcRequest> { @Override
protected void channelRead0(ChannelHandlerContext ctx, RpcRequest rpcRequest)
throws Exception { /* * 先创建请求对应的响应对象 * 从请求对象中获取相关接口信息，接口名称、方法名称、参数类型、参数 *
根据接名称从容器中获取bean * 用反射，根据方法和参数类型拿到Method 对象 * 将参数传入Method 对象，然后运行，拿到返回值 *
将返回值给到响应对象 * 一定要将响应对象回写给客户端 */ log.info("服务端收到的请求是:{}",rpcRequest); // 构建响应对象
RpcResponse rpcResponse = new RpcResponse(); // 于请求对象关联
rpcResponse.setRequestId(rpcRequest.getRequestId()); try { // 接口名称 String
interfaceName = rpcRequest.getClassName(); // 方法名称 String methodName =
rpcRequest.getMethodName(); // 参数类型 Class<?>[] parameterTypes =
rpcRequest.getParameterTypes(); // 实际参数 Object[] parameters =
rpcRequest.getParameters(); // 从容器中获取bean实例 Object bean =
SpringBeanFactory.getBean(Class.forName(interfaceName)); // 反射获取method 对象
Method method = bean.getClass().getMethod(methodName, parameterTypes); //
执行对应方法，拿到返回值 Object result = method.invoke(bean, parameters); // 添加到响应对象
rpcResponse.setResult(result); } catch (Exception e) {
log.error("RpcRequestHandler exception,msg={}",e.getMessage());
rpcResponse.setCause(e); } finally { // 将结果写回
log.info("向客户端发送响应,{}",rpcResponse); ctx.writeAndFlush(rpcResponse); } } }
netty代码实现
import com.rpc.netty.codec.FrameDecoder; import
com.rpc.netty.codec.FrameEncoder; import com.rpc.netty.codec.RpcRequestDecoder;
import com.rpc.netty.codec.RpcResponseEncoder; import
com.rpc.netty.handler.RpcRequestHandler; import com.rpc.server.boot.RpcServer;
import com.rpc.server.config.RpcServerConfiguration; import
io.netty.bootstrap.ServerBootstrap; import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer; import
io.netty.channel.ChannelOption; import io.netty.channel.ChannelPipeline; import
io.netty.channel.nio.NioEventLoopGroup; import
io.netty.channel.socket.SocketChannel; import
io.netty.channel.socket.nio.NioServerSocketChannel; import
io.netty.util.NettyRuntime; import
io.netty.util.concurrent.DefaultThreadFactory; import
org.springframework.beans.factory.annotation.Autowired; public class NettServer
implements RpcServer { @Autowired private RpcServerConfiguration
rpcServerConfiguration; @Override public void start() { /* *
首先要获取三个线程池，用于注册serverSocketChannel、socketChannel 还有业务逻辑处理（即请求调用） *
再构建引导类，并配置先关信息，将注册请求和处理读写的线程池配置到引导类中，然后配置好相关的
handler（第一、二次编解码，请求调用），注意请求调用使用线程池做处理 * 最后启动引导类，绑定监听端口，设置同步 * 监控等待关闭 * 优雅的关闭线程池
*/ // 构建注册serverSocketChannel 的线程池 NioEventLoopGroup boss = new
NioEventLoopGroup(1, new DefaultThreadFactory("boss")); // 构建注册socketChannel
的线程池 NioEventLoopGroup worker = new NioEventLoopGroup(0, new
DefaultThreadFactory("worker")); // 构建业务调用的线程池 NioEventLoopGroup
rpcRequestHandler = new NioEventLoopGroup(NettyRuntime.availableProcessors() *
2, new DefaultThreadFactory("reqRequestHandler")); // 业务逻辑调用 RpcRequestHandler
requestHandler = new RpcRequestHandler(); try { // 构建引导类 ServerBootstrap
serverBootstrap = new ServerBootstrap(); // 配置引导类 serverBootstrap.group(boss,
worker) .channel(NioServerSocketChannel.class)
.option(ChannelOption.SO_BACKLOG,1024)
.childOption(ChannelOption.TCP_NODELAY,true)
.childOption(ChannelOption.SO_KEEPALIVE,true) .childHandler(new
ChannelInitializer<SocketChannel>() { @Override protected void
initChannel(SocketChannel socketChannel) throws Exception { // 获取 pipeline
ChannelPipeline pipeline = socketChannel.pipeline(); /* * 配置 handler */ // 一级编码
pipeline.addLast("FrameEncoder", new FrameEncoder()); // 二级编码
pipeline.addLast("RpcResponseEncoder", new RpcResponseEncoder()); // 一级解码
pipeline.addLast("FrameDecoder", new FrameDecoder()); // 二级解码
pipeline.addLast("RpcRequestDecoder", new RpcRequestDecoder()); // 业务线程池调用
pipeline.addLast(rpcRequestHandler, "requestHandler", requestHandler); } }); //
启动引导类，监听端口，设置同步 ChannelFuture future =
serverBootstrap.bind(rpcServerConfiguration.getRpcPort()).sync(); // 监控等待关闭
future.channel().closeFuture().sync(); } catch (Exception e) { // 异常
e.printStackTrace(); } finally { /* * 优雅的关闭各个线程池 */ boss.shutdownGracefully();
worker.shutdownGracefully(); rpcRequestHandler.shutdownGracefully(); } } }
上述内容就已经完成了一个服务端的创建，后续文章在说客户端，本次结束。