恒哥~Bingo
恒哥~Bingo

使用动态代理+Netty+Zookeeper+Protobuff手撸一个RPC框架

RPC是什么

RPC（Remote Procedure Call）远程过程调用，一种计算机之间的远程调用技术，客户端能够在不知道服务器底层的通信架构的情况下调用服务器端的方法，就像调用自身的方法一样。

举个例子：

老婆自己去超市买瓶酱油，这是本地调用

老婆发微信要我去买瓶酱油回来，不管我是开车、打车、骑车、坐地铁去超市，这就是远程过程调用

RPC可以做什么

现在的软件系统规模越来越大，很多采用了微服务架构，就是将系统拆分成了一个个独立的服务，部署在不同的服务器上，如电商系统一般会有商品服务、库存服务、订单服务、支付服务、物流服务、优惠券服务、售后服务等等。

服务和服务之间需要相互通信，如订单服务就需要商品服务提供订单商品的数据，这时就可以通过RPC进行网络通信。

RPC如何实现

进行RPC通信的两台计算机，提供服务的称为服务提供者，调用服务的称为服务消费者，消费者需要知道服务提供者的地址（IP和端口）才能进行调用，这时我们需要一台服务器来保存服务提供者的地址提供给服务消费者调用，这台服务器就是服务注册中心Registry。

使用动态代理+Netty+Zookeeper+Protobuff手撸一个RPC框架_第1张图片

这就像你要跟一家公司打电话，但是不知道对方的号码，可以去114查询，因为这些公司都在114上注册了自己的电话号码，114告诉你，就可以联系对方了。

使用Dubbo实现RPC

Dubbo简介

Dubbo是阿里的一款高性能、轻量级的开源Java RPC框架

它提供了三大核心能力：

  1. 透明化的远程方法调用，就像调用本地方法一样调用远程方法，只需简单配置，没有任何API侵入。

  2. 软负载均衡及容错机制，可在内网替代F5等硬件负载均衡器，降低成本，减少单点。

  3. 服务自动注册与发现，注册中心基于接口名查询服务提供者的IP地址，并且能够平滑添加或删除服务提供者。

Dubbo的架构

img

  • Provider: 暴露服务的服务提供方。
  • Consumer: 调用远程服务的服务消费方。
  • Registry: 服务注册与发现的注册中心。
  • Monitor: 统计服务的调用次调和调用时间的监控中心。
  • Container: 服务运行容器。

Dubbo简单案例

此案例中的注册中心是Zookeeper，首先需要安装和启动Zookeeper

创建父项目，下面三个子项目：

  • common_api 通用的接口
  • consumer_service 服务消费者
  • provider_service 服务提供者

使用动态代理+Netty+Zookeeper+Protobuff手撸一个RPC框架_第2张图片

父项目的pom.xml



    4.0.0
    
        org.springframework.boot
        spring-boot-starter-parent
        2.6.3
         
    
    org.example
    zookeeper_dubbo_demo
    pom
    1.0-SNAPSHOT
    
        common_api
    
    
        
            org.springframework.boot
            spring-boot-starter
        

        
            org.springframework.boot
            spring-boot-starter-test
            test
        

        
            org.springframework.boot
            spring-boot-starter-web
        

        
            org.apache.dubbo
            dubbo-spring-boot-starter
            2.7.3
        

        
            org.apache.dubbo
            dubbo
            2.7.3
        

        
            org.apache.curator
            curator-framework
            4.0.1
        

        
            org.apache.curator
            curator-recipes
            2.8.0
        

        
            org.apache.zookeeper
            zookeeper
            3.4.14
        

        
            com.101tec
            zkclient
            0.10

通用项目添加接口

使用动态代理+Netty+Zookeeper+Protobuff手撸一个RPC框架_第3张图片

消费者和服务者都继承父项目并引入通用项目


    org.example
    zookeeper_dubbo_demo
    1.0-SNAPSHOT



    com.blb
    common_api
    1.0-SNAPSHOT

服务提供者配置文件

server.port=6606
spring.application.name=provider-service
#Dubbo
dubbo.application.name=provider-service
# dubbo的注册中心协议类型
dubbo.registry.protocol=zookeeper
# zookeeper的地址
dubbo.registry.address=zookeeper://192.168.223.223:2181
# dubbo的协议配置
dubbo.protocol.name=dubbo
dubbo.protocol.port=20880
# dubbo扫描接口的包
dubbo.scan.base-packages=com.blb.provider_service.service

服务提供者实现接口

package com.blb.provider_service.service;

import com.blb.api.HelloService;
import org.apache.dubbo.config.annotation.Service;

/**
 * 接口实现 
 * @Service是Dubbo的注解
 */
@Service(version = "1.0.0",interfaceClass = HelloService.class)
public class HelloServiceImpl implements HelloService {
    @Override
    public String hello(String name) {
        return "Hello,我是服务提供者！" + name;
    }
}

服务消费者的配置文件

server.port=7707
dubbo.application.name=consumer-service
# 服务消费者注册同一个Zookeeper
dubbo.registry.protocol=zookeeper
dubbo.registry.address=zookeeper://192.168.223.223:2181

服务消费者调用服务

@RestController
public class HelloController {

    //实现远程方法调用 RPC
    @Reference(version = "1.0.0")
    private HelloService helloService;

    @RequestMapping("/hello")
    public String hello(String name){
        //调用远程方法
        return helloService.hello(name);
    }
}

手撸RPC框架

案例简介

在前面的案例中使用了Dubbo实现RPC，如果想要更加深入的掌握Dubbo实现RPC底层原理，可以自己完成一个简单的RPC框架

案例使用的技术栈：

  • Netty 基于NIO的网络通信框架，Dubbo底层也是使用此框架
  • Zookeeper 服务注册和发现
  • Protobuf 轻量级的序列化框架，实现通信协议的序列化

基本流程

使用动态代理+Netty+Zookeeper+Protobuff手撸一个RPC框架_第4张图片

执行流程：

  1. 服务端实现被调用的接口，启动后注册地址到Zookeeper上
  2. 客户端调用接口
  3. 接下来的步骤要对用户透明，就像调用本地接口，所以要生成动态代理
  4. 将接口类型、方法、参数等封装成请求协议，使用Protobuf序列化工具序列化
  5. 使用Netty编码器对请求进行编码
  6. 从Zookeeper中查询服务端的IP和端口
  7. 通过Netty发送网络请求
  8. 服务端接收Netty的网络请求
  9. 使用Netty解码器对请求进行解码
  10. 通过Protobuf反序列化获得请求协议
  11. 读取请求协议中的接口类型、方法和参数，通过反射调用服务端接口
  12. 客户端获得返回的结果

** RPC就是将3~11步骤封装起来，对用户透明，减少网络程序调用的复杂性 **

项目结构

使用动态代理+Netty+Zookeeper+Protobuff手撸一个RPC框架_第5张图片

依赖坐标



    org.slf4j
    slf4j-log4j12
    1.7.7




    io.netty
    netty-all
    5.0.0.Alpha1




    io.protostuff
    protostuff-core
    1.6.0


    io.protostuff
    protostuff-runtime
    1.6.0




    org.apache.zookeeper
    zookeeper
    3.4.6




    org.apache.commons
    commons-collections4
    4.0




    org.objenesis
    objenesis
    2.1




    cglib
    cglib
    3.1

通用代码

common/service/IDiff

package com.xray.rpc.common.service;

/**
 * 用于测试的减法接口
 */
public interface IDiff {
    double diff(double a, double b);
}

common/service/ISum

package com.xray.rpc.common.service;

/**
 * 用于测试的加法接口
 */
public interface ISum {
    public int sum(int a, int b);
}

common/registry/Constant

package com.xray.rpc.common.registry;

/**
 * 常量接口
 */
public interface Constant {

    //Zookeeper连接超时
    int ZK_SESSION_TIMEOUT = 10000;
    //zk地址
    String ZK_CONNECT = "127.0.0.1:2181";
    //zk保存路径
    String ZK_REGISTRY_PATH = "/registry";
    //zk保存节点
    String ZK_DATA_PATH = ZK_REGISTRY_PATH + "/data";
    //ip和端口的分隔符号
    String ZK_IP_SPLIT = ":";
}

common/registry/ServiceDiscovery

package com.xray.rpc.common.registry;

import io.netty.util.internal.ThreadLocalRandom;
import org.apache.zookeeper.KeeperException;
import org.apache.zookeeper.WatchedEvent;
import org.apache.zookeeper.Watcher;
import org.apache.zookeeper.ZooKeeper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.concurrent.CountDownLatch;

/**
 * 服务发现:连接ZK,添加watch事件
 */
public class ServiceDiscovery {

    private static final Logger LOGGER = LoggerFactory.getLogger(ServiceDiscovery.class);

    private final CountDownLatch latch = new CountDownLatch(1);

    private volatile List dataList = new ArrayList<>();

    private final String registryAddress;

    public ServiceDiscovery(String registryAddress) {
        this.registryAddress = registryAddress;
        //连接Zookeeper
        ZooKeeper zk = connectServer();
        if (zk != null) {
            //监听registry/data节点
            watchNode(zk);
        }
    }

    /**
     * 读取Zookeeper中的服务端地址
     * @return
     */
    public String discover() {
        String data = null;
        int size = dataList.size();
        if (size > 0) {
            if (size == 1) {
                data = dataList.get(0);
                LOGGER.debug("using only data: {}", data);
            } else {
                data = dataList.get(ThreadLocalRandom.current().nextInt(size));
                LOGGER.debug("using random data: {}", data);
            }
        }
        return data;
    }

    /**
     * 连接Zookeeper服务
     * @return
     */
    private ZooKeeper connectServer() {
        ZooKeeper zk = null;
        try {
            zk = new ZooKeeper(registryAddress, Constant.ZK_SESSION_TIMEOUT, new Watcher() {
                @Override
                public void process(WatchedEvent event) {
                    if (event.getState() == Event.KeeperState.SyncConnected) {
                        latch.countDown();
                    }
                }
            });
            latch.await();
        } catch (IOException | InterruptedException e) {
            LOGGER.error("", e);
        }
        return zk;
    }

    /**
     * 监听节点修改
     * @param zk
     */
    private void watchNode(final ZooKeeper zk) {
        try {
            //给注册节点添加监听器
            List nodeList = zk.getChildren(Constant.ZK_REGISTRY_PATH, new Watcher() {
                @Override
                public void process(WatchedEvent event) {
                    if (event.getType() == Event.EventType.NodeChildrenChanged) {
                        watchNode(zk);
                    }
                }
            });
            //一旦节点发生改变，就读取地址到dataList中
            List dataList = new ArrayList<>();
            for (String node : nodeList) {
                byte[] bytes = zk.getData(Constant.ZK_REGISTRY_PATH + "/" + node, false, null);
                dataList.add(new String(bytes));
            }
            LOGGER.debug("node data: {}", dataList);
            this.dataList = dataList;
        } catch (KeeperException | InterruptedException e) {
            LOGGER.error("", e);
        }
    }
}

common/registry/ServiceRegistry

package com.xray.rpc.common.registry;

import org.apache.zookeeper.*;
import org.apache.zookeeper.data.Stat;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;
import java.util.concurrent.CountDownLatch;

/**
 * 连接ZK注册中心，创建服务注册目录
 */
public class ServiceRegistry {

    private static final Logger LOGGER = LoggerFactory.getLogger(ServiceRegistry.class);

    private final CountDownLatch latch = new CountDownLatch(1);

    private ZooKeeper zk;


    public ServiceRegistry() {
    }

    /**
     * 注册服务端地址到Zookeeper中
     * @param data
     */
    public void register(String data) {
        if (data != null) {
            zk = connectServer();
            if (zk != null) {
                try {
                    Stat stat = zk.exists(Constant.ZK_REGISTRY_PATH, false);
                    if (stat == null) {
                        zk.create(Constant.ZK_REGISTRY_PATH, new byte[]{}, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
                    }
                    stat = zk.exists(Constant.ZK_DATA_PATH, false);
                    if (stat == null) {
                        zk.create(Constant.ZK_DATA_PATH, new byte[]{}, ZooDefs.Ids.OPEN_ACL_UNSAFE, CreateMode.EPHEMERAL);
                    }
                    //保存服务端地址
                    zk.setData(Constant.ZK_DATA_PATH, data.getBytes(), -1);
                    LOGGER.info("create zookeeper node ({} => {})", Constant.ZK_DATA_PATH, data);
                } catch (InterruptedException | KeeperException e) {
                    LOGGER.error("Connect Zookeeper Error {}", e);
                }
            }
        }
    }

    /**
     * 连接Zookeeper
     * @return
     */
    private ZooKeeper connectServer() {
        ZooKeeper zk = null;
        try {
            zk = new ZooKeeper(Constant.ZK_CONNECT, Constant.ZK_SESSION_TIMEOUT, new Watcher() {
                @Override
                public void process(WatchedEvent event) {
                    // 判断是否已连接ZK,连接后计数器递减.
                    if (event.getState() == Event.KeeperState.SyncConnected) {
                        latch.countDown();
                    }
                }
            });
            // 若计数器不为0,则等待.
            latch.await();
        } catch (IOException | InterruptedException e) {
            LOGGER.error("Connect Zookeeper Error {}", e);
        }
        return zk;
    }
}

common/codec/RPCRequest

package com.xray.rpc.common.codec;

/**
 * 请求协议
 */
public class RPCRequest {
    //请求id
    private String requestId;
    //接口类型
    private String className;
    //方法名
    private String methodName;
    //方法参数
    private Class[] parameterTypes;
    //参数值
    private Object[] parameters;

    public String getRequestId() {
        return requestId;
    }

    public void setRequestId(String requestId) {
        this.requestId = requestId;
    }

    public String getClassName() {
        return className;
    }

    public void setClassName(String className) {
        this.className = className;
    }

    public String getMethodName() {
        return methodName;
    }

    public void setMethodName(String methodName) {
        this.methodName = methodName;
    }

    public Class[] getParameterTypes() {
        return parameterTypes;
    }

    public void setParameterTypes(Class[] parameterTypes) {
        this.parameterTypes = parameterTypes;
    }

    public Object[] getParameters() {
        return parameters;
    }

    public void setParameters(Object[] parameters) {
        this.parameters = parameters;
    }
}

common/codec/RPCResponse

package com.xray.rpc.common.codec;

/**
 * 请求响应
 */
public class RPCResponse {
    //请求id
    private String requestId;
    //错误对象
    private Throwable error;
    //返回值
    private Object result;

    public String getRequestId() {
        return requestId;
    }

    public void setRequestId(String requestId) {
        this.requestId = requestId;
    }

    public Throwable getError() {
        return error;
    }

    public void setError(Throwable error) {
        this.error = error;
    }

    public Object getResult() {
        return result;
    }

    public void setResult(Object result) {
        this.result = result;
    }
}

common/codec/SerializationUtil

package com.xray.rpc.common.codec;

import io.protostuff.LinkedBuffer;
import io.protostuff.ProtostuffIOUtil;
import io.protostuff.Schema;
import io.protostuff.runtime.RuntimeSchema;
import org.objenesis.Objenesis;
import org.objenesis.ObjenesisStd;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

/**
 * 基于Protobuff的序列化工具类
 */
public class SerializationUtil {

    private static Map, Schema> cachedSchema = new ConcurrentHashMap<>();

    private static Objenesis objenesis = new ObjenesisStd(true);

    private SerializationUtil() {
    }

    /**
     * 返回协议类型
     */
    @SuppressWarnings("unchecked")
    private static  Schema getSchema(Class cls) {
        Schema schema = (Schema) cachedSchema.get(cls);
        if (schema == null) {
            schema = RuntimeSchema.createFrom(cls);
            if (schema != null) {
                cachedSchema.put(cls, schema);
            }
        }
        return schema;
    }

    /**
     * 序列化方法
     */
    @SuppressWarnings("unchecked")
    public static  byte[] serialize(T obj) {
        Class cls = (Class) obj.getClass();
        LinkedBuffer buffer = LinkedBuffer.allocate(LinkedBuffer.DEFAULT_BUFFER_SIZE);
        try {
            Schema schema = getSchema(cls);
            return ProtostuffIOUtil.toByteArray(obj, schema, buffer);
        } catch (Exception e) {
            throw new IllegalStateException(e.getMessage(), e);
        } finally {
            buffer.clear();
        }
    }

    /**
     * 反序列化方法
     */
    public static  T deserialize(byte[] data, Class cls) {
        try {
            T message = (T) objenesis.newInstance(cls);
            Schema schema = getSchema(cls);
            ProtostuffIOUtil.mergeFrom(data, message, schema);
            return message;
        } catch (Exception e) {
            throw new IllegalStateException(e.getMessage(), e);
        }
    }
}

common/codec/RPCDecoder

package com.xray.rpc.common.codec;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.ByteToMessageDecoder;

import java.util.List;

/**
 * 请求解码器
 */
public class RPCDecoder extends ByteToMessageDecoder {

    //泛型类型
    private Class genericClass;

    public RPCDecoder(Class genericClass) {
        this.genericClass = genericClass;
    }

    @Override
    protected void decode(ChannelHandlerContext ctx, ByteBuf in, List out) throws Exception {
        final int length = in.readableBytes();
        final byte[] bytes = new byte[length];
        //读取字节
        in.readBytes(bytes, 0, length);
        //反序列化读取请求协议
        Object obj = SerializationUtil.deserialize(bytes, genericClass);
        out.add(obj);
    }
}


common/codec/RPCEncoder


package com.xray.rpc.common.codec;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToByteEncoder;

/**
 * 请求编码器
 */
public class RPCEncoder extends MessageToByteEncoder {

    //泛型类型
    private Class genericClass;

    public RPCEncoder(Class genericClass) {
        this.genericClass = genericClass;
    }

    @Override
    public void encode(ChannelHandlerContext ctx, Object in, ByteBuf out) throws Exception {
        if (genericClass.isInstance(in)) {
            //序列化请求协议
            byte[] data = SerializationUtil.serialize(in);
            //发送字节
            out.writeBytes(data);
        }
    }
}


服务端代码


server/impl/DiffImpl


package com.xray.rpc.server.impl;

import com.xray.rpc.common.service.IDiff;

/**
 * 接口实现 减法
 */
public class DiffImpl implements IDiff {
    @Override
    public double diff(double a, double b) {
        return a - b;
    }
}



server/impl/SumImpl


package com.xray.rpc.server.impl;

import com.xray.rpc.common.service.ISum;

/**
 * 加法实现
 */
public class SumImpl implements ISum {
    @Override
    public int sum(int a, int b) {
        return a + b;
    }
}



rpc/server/RPCServer


package com.xray.rpc.server;

/**
 * RPC服务端
 */
public class RPCServer {

    /**
     * 将可调用的接口名和实现类包装到Map集合中
     * @return
     */
    private Map getServices() {
        Map services = new HashMap();
        services.put(ISum.class.getName(), new SumImpl());
        services.put(IDiff.class.getName(), new DiffImpl());
        return services;
    }

    /**
     * 绑定监听某个端口
     * @param port
     */
    private void bind(int port) {
        //创建线程组
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            //创建启动对象
            ServerBootstrap b = new ServerBootstrap();
            //配置参数
            b.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class).option(ChannelOption.SO_BACKLOG, 100)
                    .childHandler(new ChannelInitializer() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline()
                                    .addLast(new LengthFieldBasedFrameDecoder(65535, 0, 2, 0, 2))
                                    //添加RPC解码器
                                    .addLast(new RPCDecoder(RPCRequest.class))
                                    .addLast(new LengthFieldPrepender(2))
                                    //添加RPC编码器
                                    .addLast(new RPCEncoder(RPCResponse.class))
                                    //添加RPC处理器
                                    .addLast(new RPCServerHandler(getServices()));
                        }
                    });
            //绑定端口
            ChannelFuture f = b.bind(port).sync();
            f.channel().closeFuture().sync();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }

    /**
     * 获取本机ip
     * @return
     */
    public static String getAddress(){
        InetAddress host = null;
        try {
            host = InetAddress.getLocalHost();
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
        String address = host.getHostAddress();
        return address;
    }

    /**
     * 初始化服务器
     * @param port
     */
    public void initService(int port)  {
        ServiceRegistry serviceRegistry = new ServiceRegistry();
        String ip = getAddress();
        //向zookeeper注册服务地址
        serviceRegistry.register(ip + Constant.ZK_IP_SPLIT+port);
        bind(port);
    }
}



rpc/server/RPCServerHandler


package com.xray.rpc.server;

/**
 * RPC处理器
 */
public class RPCServerHandler extends ChannelHandlerAdapter {

    private static final Logger LOGGER = LoggerFactory.getLogger(RPCServerHandler.class);
    //本地接口Map
    private final Map handlerMap;

    public RPCServerHandler(Map handlerMap) {
        this.handlerMap = handlerMap;
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        RPCResponse response = new RPCResponse();
        //解码得到RPC协议
        RPCRequest request = (RPCRequest) msg;
        response.setRequestId(request.getRequestId());
        try {
            //调用本地方法
            Object result = handle(request);
            response.setResult(result);
        } catch (Throwable t) {
            response.setError(t);
        }
        //返回响应结果
        ctx.writeAndFlush(response);
    }

    /**
     * 调用本地方法
     */
    private Object handle(RPCRequest request) throws Throwable {
        //获得接口类型名
        String className = request.getClassName();
        //获得接口类型对应的实现对象
        Object serviceBean = handlerMap.get(className);
        //获得接口类型、方法名、参数、参数值
        Class serviceClass = serviceBean.getClass();
        String methodName = request.getMethodName();
        Class[] parameterTypes = request.getParameterTypes();
        Object[] parameters = request.getParameters();
        FastClass serviceFastClass = FastClass.create(serviceClass);
        //获得方法
        FastMethod serviceFastMethod = serviceFastClass.getMethod(methodName, parameterTypes);
        //调用本地方法
        return serviceFastMethod.invoke(serviceBean, parameters);
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        LOGGER.error("server caught exception", cause);
        ctx.close();
    }
}



rpc/server/RPCServiceTest


package com.xray.rpc.server;

public class RPCServiceTest {
    
    public static void main(String[] args) {
        //启动服务器测试
        int port = 9090;
        new RPCServer().initService(port);
    }
}



客户端代码


rpc/client/RPCProxy


package com.xray.rpc.client;

import com.xray.rpc.common.codec.RPCRequest;
import com.xray.rpc.common.codec.RPCResponse;
import com.xray.rpc.common.registry.Constant;
import com.xray.rpc.common.registry.ServiceDiscovery;
import net.sf.cglib.proxy.InvocationHandler;
import net.sf.cglib.proxy.Proxy;

import java.lang.reflect.Method;
import java.util.UUID;

/**
 * RPC动态代理类
 */
public class RPCProxy {
    private String serverAddress;
    private ServiceDiscovery serviceDiscovery;

    public RPCProxy(ServiceDiscovery serviceDiscovery) {
        this.serviceDiscovery = serviceDiscovery;
    }

    /**
     * 创建RPC代理对象
     */
    @SuppressWarnings("unchecked")
    public  T create(Class interfaceClass) {
        return (T) Proxy.newProxyInstance(interfaceClass.getClassLoader(), new Class[] { interfaceClass },
                new InvocationHandler() {
                    @Override
                    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                        // 创建并初始化 RPC 请求
                        RPCRequest request = new RPCRequest();
                        request.setRequestId(UUID.randomUUID().toString());
                        request.setClassName(method.getDeclaringClass().getName());
                        request.setMethodName(method.getName());
                        request.setParameterTypes(method.getParameterTypes());
                        request.setParameters(args);
                        // 通过Zookeeper查询服务端地址
                        if (serviceDiscovery != null) {
                            serverAddress = serviceDiscovery.discover();
                        }
                        // 分割出IP和端口  "123.23.213.23:9090"
                        String[] array = serverAddress.split(Constant.ZK_IP_SPLIT);
                        String host = array[0];
                        int port = Integer.parseInt(array[1]);
                        // 初始化 RPC客户端
                        RPCClient client = new RPCClient(host, port);
                        // 发送网络请求
                        RPCResponse response = client.send(request);
                        // 返回结果或错误信息
                        if (response.getError() != null) {
                            throw response.getError();
                        } else {
                            return response.getResult();
                        }
                    }
                });
    }
}



rpc/client/RPCClient


package com.xray.rpc.client;

/**
 * RPC客户端
 */
public class RPCClient {
    private final String host;
    private final int port;
    private final CountDownLatch latch;
    public RPCClient(String host,int port) {
        this.host = host;
        this.port = port;
        this.latch = new CountDownLatch(1);
    }

    /**
     * 发出RPC请求
     * @param request
     * @return
     */
    public RPCResponse send(RPCRequest request){
        //自定义RPC客户端处理器
        RPCClientHandler handler = new RPCClientHandler(request,latch);
        //创建netty启动对象
        EventLoopGroup group = new NioEventLoopGroup();
        RPCResponse response = null;
        try {
            Bootstrap b = new Bootstrap().group(group)
                    //配置参数
                    .channel(NioSocketChannel.class).option(ChannelOption.TCP_NODELAY, true)
                    .option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 3000)
                    //设置处理器
                    .handler(new ChannelInitializer() {

                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline()
                                    .addLast(new LengthFieldBasedFrameDecoder(65535, 0, 2, 0, 2))
                                    //设置RPC解码器
                                    .addLast(new RPCDecoder(RPCResponse.class))
                                    .addLast(new LengthFieldPrepender(2))
                                    //设置RPC编码器
                                    .addLast(new RPCEncoder(RPCRequest.class))
                                    //设置RPC请求处理器
                                    .addLast(handler);
                        }
                    });
            //连接服务端
            ChannelFuture f = b.connect(host, port).sync();
            //阻塞线程，直到处理器读取到服务端数据为止
            latch.await();
            //获得服务端响应
            response = handler.getResponse();
            if(response != null) {
                f.channel().close();
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        }finally{
            group.shutdownGracefully();
        }
        return response;
    }
}



rpc/client/RPCClientHandler


package com.xray.rpc.client;

import com.xray.rpc.common.codec.RPCRequest;
import com.xray.rpc.common.codec.RPCResponse;
import io.netty.channel.ChannelHandlerAdapter;
import io.netty.channel.ChannelHandlerContext;

import java.util.concurrent.CountDownLatch;

/**
 * 客户端处理器
 */
public class RPCClientHandler extends ChannelHandlerAdapter {

    //请求对象
    private RPCRequest request;
    //响应对象
    private RPCResponse response;
    //RPCClient传来的latch
    private final CountDownLatch latch;

    public RPCClientHandler(RPCRequest request, CountDownLatch latch) {
        this.request = request;
        this.latch = latch;
    }

    public RPCResponse getResponse() {
        return response;
    }

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        ctx.writeAndFlush(request);
    }

    //读取服务端消息
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        //获得消息，并解码为响应结果
        response = (RPCResponse) msg;
        //让client阻塞的线程继续执行
        latch.countDown();
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        ctx.flush();
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.getCause().printStackTrace();
        ctx.close();
    }
}



rpc/client/RPCTest


package com.xray.rpc.client;

import com.xray.rpc.common.service.IDiff;
import com.xray.rpc.common.service.ISum;
import com.xray.rpc.common.registry.Constant;
import com.xray.rpc.common.registry.ServiceDiscovery;

public class RPCTest {

    public static void main(String[] args) {
        //创建动态代理对象
        RPCProxy rpcProxy = new RPCProxy(new ServiceDiscovery(Constant.ZK_CONNECT));
        //创建接口的动态代理
        IDiff diff = rpcProxy.create(IDiff.class);
        //通过动态代理调用远程方法
        double result = diff.diff(1321, 32.2);
        //同上
        ISum sum = rpcProxy.create(ISum.class);
        int result2 = sum.sum(1000, 1000);
        System.out.println(result+":"+result2);
    }
}



总结


通过文章我们了解到RPC是一种计算机的远程调用技术，能够像调用本地方法那样，简单的调用远程服务器上的方法，大大减少了服务器之间数据通信的复杂性。


但是RPC的内部实现是比较复杂的，需要掌握Netty、Zookeeper、Protobuff、动态代理等技术，总而言之是“把简单留给用户，把复杂留给自己”。通过本文最后的案例，我们也大致了解了RPC框架底层的总体逻辑，不过该案例只实现了基本的RPC功能，如果需要像Dubbo那样通过配置注解实现，还需要在后面的版本中进行完善。

























你可能感兴趣的:(分布式,rpc,zookeeper,Netty,Zookeeper,动态代理)






    

  • Spring Cloud全解析：网关之GateWay简介
拾光师
springcloudjava

    GateWay简介由于zuul升级为zuul2时，netflix公司内部出现了分歧，所以springcloud自己研发了一套网关gateway，提供一种简单有效的方式来对API进行路由，以及提供一些强大的过滤器功能，如：熔断、限流、重试等，基于WebFlux框架实现的，底层使用了高性能的Reactor模式通信框架Netty特性基于spring5和springboot2构建动态路由：能够匹配任何请求
    

    • 

  • Kylin的工作原理及使用分享操作指南
vvvae1234
kylin

    ApacheKylin是一个分布式的分析引擎，专为大数据环境中的快速分析和查询而设计。它通过构建OLAP（联机分析处理）立方体，使得对海量数据的实时分析成为可能，极大地提升了数据查询的效率。本文将详细介绍Kylin的工作原理，结合实际操作案例，分享如何有效使用Kylin进行大数据分析。1.Kylin概述Kylin是一个开源项目，支持SQL查询，兼容与Hive和MapReduce等大数据技术的集成。
    

    • 

  • java实用工具类hutool
华木公子

    cn.hutoolhutool-all5.5.8Hutool工具详细教程地址:###模块介绍1.hutool-aopJDK动态代理封装，提供非IOC下的切面支持；2.hutool-bloomFilter布隆过滤，提供一些Hash算法的布隆过滤；3.hutool-cache简单缓存实现；4.hutool-core核心，包括Bean操作,日期，各种Util等等；5.hutool-cron定时任务模块，
    

    • 

  • Netty+WebSocket实现高并发网络编程
Sunny_yiyi
Java精英阶级JavaWebSocket网络websocket网络协议

    我们来实现一个Netty+WebSocket集成案例，由于Netty+WebSocket集成代码比较麻烦，我们可以利用目前开源的项目netty-websocket-spring-boot-starter轻松实现Netty和WebSocket的集成。我们搭建一个项目，项目叫seckill-message，用于处理通知用户抢单状态。1)pom.xmlorg.yeauty</groupId
    

    • 

  • Metasploit漏洞利用系列（九）：MSF渗透测试 - DistCC后门漏洞实战
Alfadi联盟 萧瑶
网络安全

    在本系列的第九篇文章中，我们将深入探讨如何利用MetasploitFramework(MSF)对DistCC中存在的后门漏洞进行渗透测试。DistCC是一个分布式编译系统，旨在通过网络分发编译任务以加速编译过程。然而，不当的配置或特定版本的漏洞可能为攻击者留下可乘之机，使其能够利用DistCC服务作为跳板，入侵目标系统。本文将通过一个实例，展示如何识别并利用DistCC中的漏洞来实现远程代码执行。
    

    • 

  • 分布式唯一id的7种方案
木小同
面试分布式分布式id雪花算法

    背景为什么需要使用分布式唯一id？如果我们的系统是单体的，数据库是单库，那无所谓，怎么搞都行。但是如果系统是多系统，如果id是和业务相关，由各个系统生成的情况下，那每个主机生成的主键id就是不可控的，多个主机就有可能会造成主键冲突的问题。方案1、数据库自增1024表，不是依赖每一张表的自增主键，不同的表都从1开始累加id专门搞一个库，搞一个表，专门用于生成全局唯一id，insertinto插入一条
    

    • 

  • Hdfs的机架感知与副本放置策略
sheansavage
hdfshadoop大数据

    1.介绍Apachehadoop机架感知Hadoop分布式文件系统(Hdfs)作为ApacheHadoop生态系统的的核心组件之一,通过机架感知和副本放置策略来优化数据的可靠性,可用和性能.Hdfs的机架感知和副本放置策略是其设计的关键组成部分,有效地提高了数据的可靠性,可用性和性能,使其成为处理大规模数据的理想选择.2.机架感知2.1什么是机架感知Hadoop组件时机架感知的.例如,hdfs块放
    

    • 

  • JMS 原理
LynnGuo

    为什么需要JMS用RPC中间件技术已广泛应用于分布式系统之间的通信，但是这些技术也显示出了局限性：同步通信：客户发出调用后，必须等待服务对象完成处理并返回结果后才能继续执行客户和服务对象的生命周期紧密耦合，客户端进程和服务端进程都必须正常运行，如果由于服务对象崩溃或者网络故障导致客户的请求不可达，客户会接收到异常。点对点通信：客户的一次调用只发送给某个单独的目标对象。面向消息的中间件较好的解决了以
    

    • 

  • ROS Node
GYHlf
操作系统ROSLLM_RoboticsROSRobot操作系统

    ROSNodeROS（RobotOperatingSystem）节点是指在ROS中运行的基本单元，它们是一个独立的进程，执行特定的任务，并与其他节点进行通信以完成更复杂的功能。ROS节点是ROS中实现模块化、分布式和可扩展性的关键组件之一。在ROS中，节点是通过ROS核心（ROSMaster）进行通信和协调的。每个节点都可以执行不同的功能，例如传感器数据采集、运动控制、路径规划、图像处理等。节点之
    

    • 

  • 详解 gRPC 客户端长连接机制实现
a...Z
后端

    本文作者：熊喵君，原文链接：https://pandaychen.github.io/2020/09/01/GRPC-CLIENT-CONN-LASTING/转载Go语言中文网公众号Golang爱好者社区，这里有精选的网站上数千篇优秀文章供你学习，内容涵盖Golang基础系列教程、实战教程等优秀开源项目实践，同时会分享职场经验。每周获取Golang一周资讯等值得关注的内容0x00前言HTTP2是一
    

    • 

  • 39-nacos eureka zookeeper区别
weixin_41775999
eurekazookeeper云原生

    Nacos,Eureka,Zookeeper都是服务发现和配置管理的工具，但是它们之间有一些区别：Nacos设计目标是以更简单的方式来实现服务发现和配置管理。支持服务发现和服务元数据的注册与发现。支持DNS-based服务发现。支持RPC和服务间调用。支持配置的动态更新。支持集群部署和高可用。Eureka是Netflix开源的一款提供服务注册和发现的产品。设计思路是AP（可用性和分区容忍性）。不支
    

    • 

  • XML-RPC-1概述
weixin_30340775

    XML-RPC是一个远程过程调用（远端程序呼叫）（remoteprocedurecall，RPC)的分布式计算协议，通过XML将调用函数封装，并使用HTTP协议作为传送机制。中文名XML-RPC外文名XMLRemoteProcedureCall属于标准通用标记语言类型一个子集目录1关于XML-RPC▪基本介绍▪Requestexample▪Responseexample2XML-RPC入门程序▪基
    

    • 

  • RPC框架之Dubbo
猫猫桑
Java

    问题1：为什么要把系统拆分成分布式的？为啥要用dubbo？1.为什么要将系统进行拆分？要是不拆分系统，一个大系统几十万行代码，很多人共同维护一份代码，简直是悲剧；拆分了以后，一个大系统拆分成很多小服务，平均每个系统也就几万行代码，每个服务部署到单独的机器2.如何进行服务拆分？大部分系统，是要进行多轮拆分的，第一次拆分就可能将原来的多个模块拆分开来。但是后来可能每个系统都变得很复杂了，每个模块拆分出
    

    • 

  • 37-RPC HTTP区别是什么
weixin_41775999
rpchttp网络协议

    ‌RPC和HTTP的主要区别在于它们的通信方式、数据传输格式、应用场景、状态管理以及性能上。‌‌通信方式‌：‌RPC‌（远程过程调用）是一种进程间通信方式，允许一个程序调用远程服务器上的函数或方法，就像调用本地函数一样。在RPC中，客户端和服务器之间建立一条持久的连接，使得通信更加可靠。‌HTTP‌是一种客户端和服务器之间的请求-响应模式，每次请求后连接立即断开，采用无连接的传输协议。HTTP主要
    

    • 

  • 为什么搜索引擎可以检索到网站？
程序员T哥
搜索引擎爬虫网络安全网络爬虫网络协议javapython

    搜索引擎和爬虫，基于百度举例为什么搜索引擎可以快速检索到所有对应页面？搜索引擎能够快速检索到所有对应页面，主要归功于以下几个方面：爬虫技术：自动遍历互联网上的网页。索引：将爬取的网页内容转换成数据结构存储。关键词匹配：检索包含用户输入关键词的网页。页面排名：使用复杂算法对搜索结果排序。数据库技术：处理和存储大量数据。分布式计算：提高处理速度。缓存机制：快速返回热门查询结果。用户行为分析：优化搜索结
    

    • 

  • springboot整合aop实现日志记录
walkerShen

    知识概况定义：在软件业，AOP为AspectOrientedProgramming的缩写，意为：面向切面编程，通过预编译方式和运行期间动态代理实现程序功能的统一维护的一种技术。AOP是OOP的延续，是软件开发中的一个热点，也是Spring框架中的一个重要内容，是函数式编程的一种衍生范型。利用AOP可以对业务逻辑的各个部分进行隔离，从而使得业务逻辑各部分之间的耦合度降低，提高程序的可重用性，同时提高
    

    • 

  • 教程：在Spring Boot应用中集成OAuth 2.0认证
微赚淘客系统开发者@聚娃科技
springboot后端java

    教程：在SpringBoot应用中集成OAuth2.0认证大家好，我是免费搭建查券返利机器人省钱赚佣金就用微赚淘客系统3.0的小编，也是冬天不穿秋裤，天冷也要风度的程序猿！OAuth2.0是一种广泛使用的授权框架，用于安全地授权第三方应用程序访问HTTP服务，而无需将用户的用户名和密码暴露给第三方。在现代的分布式系统中，使用OAuth2.0认证可以有效地保护API端点和用户数据。本文将介绍如何在S
    

    • 

  • Java高级技术day75：Zookeeper与Dubbo
开源oo柒

    一、Zookeeper的介绍1.Zookeeper介绍：顾名思义zookeeper就是动物园管理员，他是用来管hadoop（大象）、Hive(蜜蜂)、pig(小猪)的管理员，ApacheHbase和ApacheSolr的分布式集群都用到了zookeeper；Zookeeper:是一个分布式的、开源的程序协调服务，是hadoop项目下的一个子项目。他提供的主要功能包括：配置管理、名字服务、分布式锁、
    

    • 

  • SpringBoot 集成gRPC高性能微服务框架
一碗情深
Javaspringboot微服务后端gRPC

    文章目录一、gRPC简介二、gRPC特点三、相关资源1.gRPC文档2.Github地址3.protobuf序列化协议4.本教程源码四、功能实现1.定义proto接口规范1.1引入依赖1.2添加生成protobuf插件1.3定义.proto文件1.4生成代码2.创建gRPC服务器2.1定义注解类，用于扫描gRPC相关接口服务2.2定义添加gRPC服务组件2.3实现gRPC服务3.创建gRPC客户端
    

    • 

  • clickhouse集群部署
林鸟鸟
clickhouseclickhouse服务器

    单节点设置为了延迟演示分布式环境的复杂性，我们将首先在单个服务器或虚拟机上部署ClickHouse。ClickHouse通常是从deb或rpm包安装，但对于不支持它们的操作系统也有其他方法。例如，您选择deb安装包，执行:sudoapt-getinstall-yapt-transport-httpsca-certificatesdirmngrsudoapt-keyadv--keyserverhkp
    

    • 

  • k8s上的clickhouse集群部署并创建分布式表（附详细参数说明和参考链接）
KirutoCode
开发技能

    k8s上的clickhouse集群部署并创建分布式表制作docker镜像创建configmap创建clickhouseservicepod创建clickhouseclientpod创建Service创建分布式表部署总体参考：https://blog.csdn.net/tototuzuoquan/article/details/111305125clickhouse的配置文件相关解读：https:/
    

    • 

  • k8s必知必会
小卒曹阿瞒
八股文分布式网络bigdata

    目录1、简述etcd及其特点etcd是CoreOS团队发起的开源项目，是一个管理配置信息和服务发现（servicediscovery）的项目，它的目标是构建一个高可用的分布式键值（key-value）数据库，基于Go语言实现。特点：简单：支持REST风格的HTTP+JSONAPI安全：支持HTTPS方式的访问快速：支持并发1k/s的写操作可靠：支持分布式结构，基于Raft的一致性算法，Raft是一
    

    • 

  • CentOS(7.x、8)上安装EMQX
功夫熊猫ok88
CentOScentoslinux运维

    EMQX是一个高度可扩展的分布式MQTT消息服务器，适用于IoT、M2M和移动应用程序。以下是在CentOS系统上安装EMQX的基本步骤：在CentOS上安装EMQX步骤1:添加EMQXYUM源首先，你需要添加EMQX的官方YUM源到你的CentOS系统中。打开终端并运行以下命令：sudotee/etc/yum.repos.d/emqx.repo:18083来查看Dashboard。以上步骤适用于
    

    • 

  • Spring Boot 一个极简且完整的后台框架
搬砖养女人
数据库架构javaspringsqltomcat

    一个完整的极简后台框架，方便做小项目的时候可以快速开发。这里面多贴图片和代码，做个参考吧，代码可以下载下来自己看看，里面这套后台模板不错，喜欢的拿去。先放几张图imageimageimage项目介绍SpringBoot，实现了一个极简单的后台框架image小编提供免费的Java架构学习资料（里面有高可用、高并发、高性能及分布式、Jvm性能调优、Spring源码，MyBatis，Netty,Redi
    

    • 

  • AOP大致流程
阿立聊代码
springjava开发语言AOP

    AOP大致流程AOP就是进行动态代理，在创建一个Bean的过程中，Spring在最后一步会去判断当前正在创建的这个Bean是不是需要进行AOP，如果需要则会进行动态代理。如何判断当前Bean对象需不需要进行AOP:找出所有的切面Bean遍历切面中的每个方法，看是否写了@Before、@After等注解如果写了，则判断所对应的Pointcut是否和当前Bean对象的类是否匹配如果匹配则表示当前Bea
    

    • 

  • 图数据库之ArangoDB
james二次元
图数据库数据库图数据库arangodb推荐系统社交网络

    ArangoDB是一个多模型、开源的分布式数据库，支持文档、图和键值存储三种数据模型。它以其灵活性和强大的查询能力而著称，特别是在需要处理复杂数据关系的场景下。ArangoDB的设计目标是提供一个统一的、高效的数据存储解决方案，适合于各种应用场景，如实时分析、内容管理系统、物联网（IoT）和社交网络等。官方地址：ArangoDB:Multi-ModelDatabaseforYourModernAp
    

    • 

  • golang微服务框架特性分析及选型
谬了个大也
解决方案go微服务云原生

    目录一、微服务框架特性（10个）包括：Istio、go-zero、go-kit、go-kratos、go-micro、rpcx、kitex、goa、jupiter、dubbo-go、tarsgo1、特性及使用场景2、比较二、web框架特性（7个）包括：gin、fiber、beego、echo、iris、mux、goa1、特性及使用场景2、比较（以下框架均为go框架）一、微服务框架特性（10个）包括
    

    • 

  • 如何使用 Go 语言开发微服务
Mindfulness code
Go语言开发开发语言Go微服务

    微服务是一种非常热门的架构设计理念，其主张将单个应用程序拆分为一组小型服务，每个服务都单独部署运行，并且这些服务之间通过轻量级的方式进行通信。1.Go语言RPC标准库Go语言自带一个RPC标准库，通过该标准库，我们可以很方便地实现RPC服务端与客户端程序。1.1使用入门Go语言原生的RPC标准库在rpc包中，该包定义了RPC相关的结构体。其中，rpc.Server表示RPC服务端，rpc.Clie
    

    • 

  • Django后端架构开发：Django 与 Celery 的深度集成
Switch616
PythonWebdjango架构sqlite中间件后端python

    Django后端架构开发：Django与Celery的深度集成Celery概述与异步处理原理在现代Web应用中，处理异步任务已成为优化性能、提升用户体验的关键。Django项目中使用Celery可以帮助我们实现异步任务处理，显著提高系统的响应速度和扩展性。Celery是一个简单、灵活且可靠的分布式任务队列系统，它支持任务的实时处理和定时任务调度。Celery的工作原理非常简单：它将任务发送到消息队
    

    • 

  • 如何使用 Redis 实现分布式锁？
喵呜刷题
分布式消息队列redis分布式lua

    分析&回答分布式锁一般有三种实现方式：1.数据库乐观锁；2.基于Redis的分布式锁；3.基于ZooKeeper的分布式锁。Redis分布式锁SETNXRedis提供了一个只有在某个key不存在的情况下才会设置key的值的原子命令SETNX。该命令为：SETmy_keymy_valueNXPXmilliseconds其中，NX表示只有当键key不存在的时候才会设置key的值，PX表示设置键key的
    

    • 

  • Java序列化进阶篇
g21121
java序列化

            1.transient
        类一旦实现了Serializable 接口即被声明为可序列化，然而某些情况下并不是所有的属性都需要序列化，想要人为的去阻止这些属性被序列化，就需要用到transient 关键字。

    

    • 

  • escape()、encodeURI()、encodeURIComponent()区别详解 
aigo
JavaScriptWeb

    原文：http://blog.sina.com.cn/s/blog_4586764e0101khi0.html
 
JavaScript中有三个可以对字符串编码的函数，分别是： escape,encodeURI,encodeURIComponent，相应3个解码函数：,decodeURI,decodeURIComponent 。
下面简单介绍一下它们的区别
1 escape()函
    

    • 

  • ArcgisEngine实现对地图的放大、缩小和平移
Cb123456
添加矢量数据对地图的放大、缩小和平移Engine

    ArcgisEngine实现对地图的放大、缩小和平移:
 个人觉得是平移，不过网上的都是漫游，通俗的说就是把一个地图对象从一边拉到另一边而已。就看人说话吧.
 具体实现:
一、引入命名空间
   using ESRI.ArcGIS.Geometry;
   using ESRI.ArcGIS.Controls;
二、代码实现.
    

    • 

  • Java集合框架概述
天子之骄
Java集合框架概述

       集合框架
集合框架可以理解为一个容器，该容器主要指映射(map)、集合(set)、数组(array)和列表(list)等抽象数据结构。
从本质上来说，Java集合框架的主要组成是用来操作对象的接口。不同接口描述不同的数据类型。
 
简单介绍：
 
Collection接口是最基本的接口，它定义了List和Set，List又定义了LinkLi
    

    • 

  • 旗正4.0页面跳转传值问题
何必如此
javajsp

    跳转和成功提示
a)        成功字段非空forward
成功字段非空forward，不会弹出成功字段，为jsp转发，页面能超链接传值,传输变量时需要拼接。接拼接方式list.jsp?test="+strweightUnit+"或list.jsp?test="+weightUnit+&qu
    

    • 

  • 全网唯一:移动互联网服务器端开发课程
cocos2d-x小菜
web开发移动开发移动端开发移动互联程序员

        移动互联网时代来了！     App市场爆发式增长为Web开发程序员带来新一轮机遇，近两年新增创业者，几乎全部选择了移动互联网项目！传统互联网企业中超过98%的门户网站已经或者正在从单一的网站入口转向PC、手机、Pad、智能电视等多端全平台兼容体系。据统计，AppStore中超过85%的App项目都选择了PHP作为后端程
    

    • 

  • Log4J通用配置|注意问题 笔记
7454103
DAOapachetomcatlog4jWeb

    关于日志的等级 那些去 百度就知道了！
这几天 要搭个新框架  配置了 日志 记下来 ！做个备忘！
#这里定义能显示到的最低级别,若定义到INFO级别,则看不到DEBUG级别的信息了~!
log4j.rootLogger=INFO,allLog
# DAO层 log记录到dao.log 控制台 和 总日志文件
log4j.logger.DAO=INFO,dao,C
    

    • 

  • SQLServer TCP/IP 连接失败问题 ---SQL Server Configuration Manager
darkranger
sqlcwindowsSQL ServerXP

    当你安装完之后,连接数据库的时候可能会发现你的TCP/IP 没有启动..
发现需要启动客户端协议 : TCP/IP 
需要打开 SQL Server Configuration Manager...
却发现无法打开 SQL Server Configuration Manager..??
解决方法:  C:\WINDOWS\system32目录搜索framedyn.
    

    • 

  • [置顶] 做有中国特色的程序员
aijuans
程序员

    从出版业说起 网络作品排到靠前的，都不会太难看，一般人不爱看某部作品也是因为不喜欢这个类型，而此人也不会全不喜欢这些网络作品。究其原因，是因为网络作品都是让人先白看的，看的好了才出了头。而纸质作品就不一定了，排行榜靠前的，有好作品，也有垃圾。 许多大牛都是写了博客，后来出了书。这些书也都不次，可能有人让为不好，是因为技术书不像小说，小说在读故事，技术书是在学知识或温习知识，有些技术书读得可
    

    • 

  • document.domain 跨域问题
avords
document

    document.domain用来得到当前网页的域名。比如在地址栏里输入：javascript:alert(document.domain); //www.315ta.com我们也可以给document.domain属性赋值，不过是有限制的，你只能赋成当前的域名或者基础域名。比如：javascript:alert(document.domain = "315ta.com"); 
    

    • 

  • 关于管理软件的一些思考
houxinyou
管理

    
工作好多看年了,一直在做管理软件,不知道是我最开始做的时候产生了一些惯性的思维,还是现在接触的管理软件水平有所下降.换过好多年公司,越来越感觉现在的管理软件做的越来越乱.
在我看来,管理软件不论是以前的结构化编程,还是现在的面向对象编程,不管是CS模式,还是BS模式.模块的划分是很重要的.当然,模块的划分有很多种方式.我只是以我自己的划分方式来说一下.
做为管理软件,就像现在讲究MVC这
    

    • 

  • NoSQL数据库之Redis数据库管理(String类型和hash类型)
bijian1013
redis数据库NoSQL

    一.Redis的数据类型
1.String类型及操作
        String是最简单的类型，一个key对应一个value，string类型是二进制安全的。Redis的string可以包含任何数据，比如jpg图片或者序列化的对象。
        Set方法：设置key对应的值为string类型的value 
    

    • 

  • Tomcat 一些技巧
征客丶
javatomcatdos

    以下操作都是在windows 环境下
一、Tomcat 启动时配置 JAVA_HOME
在 tomcat 安装目录，bin 文件夹下的 catalina.bat 或 setclasspath.bat 中添加
set JAVA_HOME=JAVA 安装目录
set JRE_HOME=JAVA 安装目录/jre
即可；
二、查看Tomcat 版本
在 tomcat 安装目
    

    • 

  • 【Spark七十二】Spark的日志配置
bit1129
spark

    在测试Spark Streaming时，大量的日志显示到控制台，影响了Spark Streaming程序代码的输出结果的查看(代码中通过println将输出打印到控制台上)，可以通过修改Spark的日志配置的方式，不让Spark Streaming把它的日志显示在console
 
在Spark的conf目录下，把log4j.properties.template修改为log4j.p
    

    • 

  • Haskell版冒泡排序
bookjovi
冒泡排序haskell

    面试的时候问的比较多的算法题要么是binary search，要么是冒泡排序，真的不想用写C写冒泡排序了，贴上个Haskell版的，思维简单，代码简单，下次谁要是再要我用C写冒泡排序，直接上个haskell版的，让他自己去理解吧。
 
 
sort [] = []
sort [x] = [x]
sort (x:x1:xs)
| x>x1 = x1:so
    

    • 

  • java 路径 配置文件读取
bro_feng
java

    这几天做一个项目，关于路径做如下笔记，有需要供参考。
取工程内的文件，一般都要用相对路径，这个自然不用多说。
在src统计目录建配置文件目录res,在res中放入配置文件。
读取文件使用方式：
1. MyTest.class.getResourceAsStream("/res/xx.properties")
2. properties.load(MyTest.
    

    • 

  • 读《研磨设计模式》-代码笔记-简单工厂模式
bylijinnan
java设计模式

    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/
package design.pattern;
/*
* 个人理解：简单工厂模式就是IOC;
* 客户端要用到某一对象，本来是由客户创建的，现在改成由工厂创建，客户直接取就好了
*/
interface IProduct {

    

    • 

  • SVN与JIRA的关联
chenyu19891124
SVN

    SVN与JIRA的关联一直都没能装成功，今天凝聚心思花了一天时间整合好了。下面是自己整理的步骤：
一、搭建好SVN环境，尤其是要把SVN的服务注册成系统服务
二、装好JIRA，自己用是jira-4.3.4破解版
三、下载SVN与JIRA的插件并解压，然后拷贝插件包下lib包里的三个jar，放到Atlassian\JIRA 4.3.4\atlassian-jira\WEB-INF\lib下，再
    

    • 

  • JWFDv0.96 最新设计思路
comsci
数据结构算法工作企业应用公告

                      
随着工作流技术的发展，工作流产品的应用范围也不断的在扩展，开始进入了像金融行业(我已经看到国有四大商业银行的工作流产品招标公告了)，实时生产控制和其它比较重要的工程领域，而
    

    • 

  • vi 保存复制内容格式粘贴
daizj
vi粘贴复制保存原格式不变形

        vi是linux中非常好用的文本编辑工具，功能强大无比，但对于复制带有缩进格式的内容时，粘贴的时候内容错位很严重，不会按照复制时的格式排版，vi能不能在粘贴时，按复制进的格式进行粘贴呢？ 答案是肯定的，vi有一个很强大的命令可以实现此功能 。
    在命令模式输入:set paste，则进入paste模式，这样再进行粘贴时
    

    • 

  • shell脚本运行时报错误：/bin/bash^M: bad interpreter 的解决办法
dongwei_6688
shell脚本

    出现原因：windows上写的脚本，直接拷贝到linux系统上运行由于格式不兼容导致
解决办法：
1. 比如文件名为myshell.sh，vim myshell.sh
2. 执行vim中的命令 : set ff?查看文件格式，如果显示fileformat=dos，证明文件格式有问题
3. 执行vim中的命令 :set fileformat=unix 将文件格式改过来就可以了，然后:w
    

    • 

  • 高一上学期难记忆单词
dcj3sjt126com
wordenglish

    honest 诚实的；正直的
argue 争论
classical 古典的
hammer 锤子
share  分享；共有
sorrow 悲哀；悲痛
adventure 冒险
error 错误；差错
closet 壁橱；储藏室
pronounce 发音；宣告
repeat 重做；重复
majority 大多数；大半
 
native 本国的，本地的，本国
    

    • 

  • hibernate查询返回DTO对象，DTO封装了多个pojo对象的属性
frankco
POJOhibernate查询DTO

          DTO-数据传输对象；pojo-最纯粹的java对象与数据库中的表一一对应。
      简单讲：DTO起到业务数据的传递作用，pojo则与持久层数据库打交道。
 
      有时候我们需要查询返回DTO对象，因为DTO
    

    • 

  • Partition List
hcx2013
partition

    Given a linked list and a value x, partition it such that all nodes less than x come before nodes greater than or equal to x.
You should preserve the original relative order of th
    

    • 

  • Spring MVC测试框架详解——客户端测试
jinnianshilongnian

    上一篇《Spring MVC测试框架详解——服务端测试》已经介绍了服务端测试，接下来再看看如果测试Rest客户端，对于客户端测试以前经常使用的方法是启动一个内嵌的jetty/tomcat容器，然后发送真实的请求到相应的控制器；这种方式的缺点就是速度慢；自Spring 3.2开始提供了对RestTemplate的模拟服务器测试方式，也就是说使用RestTemplate测试时无须启动服务器，而是模拟一
    

    • 

  • 关于推荐个人观点
liyonghui160com
推荐系统关于推荐个人观点

        回想起来，我也做推荐了3年多了，最近公司做了调整招聘了很多算法工程师，以为需要多么高大上的算法才能搭建起来的，从实践中走过来，我只想说【不是这样的】
    第一次接触推荐系统是在四年前入职的时候，那时候，机器学习和大数据都是没有的概念，什么大数据处理开源软件根本不存在，我们用多台计算机web程序记录用户行为，用.net的w
    

    • 

  • 不间断旋转的动画
pangyulei
动画

    
CABasicAnimation* rotationAnimation;
rotationAnimation = [CABasicAnimation animationWithKeyPath:@"transform.rotation.z"];
rotationAnimation.toValue = [NSNumber numberWithFloat: M
    

    • 

  • 自定义annotation
sha1064616837
javaenumannotationreflect

    对象有的属性在页面上可编辑，有的属性在页面只可读，以前都是我们在页面上写死的，时间一久有时候会混乱，此处通过自定义annotation在类属性中定义。越来越发现Java的Annotation真心很强大，可以帮我们省去很多代码，让代码看上去简洁。
下面这个例子 主要用到了
1.自定义annotation：@interface，以及几个配合着自定义注解使用的几个注解
2.简单的反射
3.枚举 
    

    • 

  • Spring 源码
up2pu
spring

    1.Spring源代码
https://github.com/SpringSource/spring-framework/branches/3.2.x
注：兼容svn检出
2.运行脚本
import-into-eclipse.bat
注：需要设置JAVA_HOME为jdk 1.7
build.gradle
compileJava {
sourceCompatibilit
    

    • 

  • 利用word分词来计算文本相似度
yangshangchuan
wordword分词文本相似度余弦相似度简单共有词

    word分词提供了多种文本相似度计算方式：
方式一：余弦相似度，通过计算两个向量的夹角余弦值来评估他们的相似度
实现类：org.apdplat.word.analysis.CosineTextSimilarity
用法如下：
String text1 = "我爱购物";
String text2 = "我爱读书";
String text3 = 
    

    •