外星喵
外星喵

RPC框架原理与实现

前言

什么是RPC?

RPC（Remote Procedure Call）远程过程调用协议，一种通过网络从远程计算机上请求服务，而不需要了解底层网络技术的协议。简单地说就是能使应用像调用本地方法一样的调用远程的过程或服务，可以应用在分布式服务、分布式计算、远程服务调用等许多场景。

业界有很多开源的优秀 RPC 框架，例如 Dubbo、Thrift、gRPC、Hprose 等等。

RPC 协议只规定了 Client 与 Server 之间的点对点调用流程，包括 stub、通信协议、RPC 消息解析等部分，在实际应用中，还需要考虑服务的高可用、负载均衡等问题，除了点对点的 RPC 协议的具体实现外，还可以包括服务的发现与注销、提供服务的多台 Server 的负载均衡、服务的高可用等更多的功能。 目前的 RPC 框架大致有两种不同的侧重方向，一种偏重于服务治理，另一种偏重于跨语言调用 。

RPC框架特点

RPC 调用方式

RPC 调用方式分以下两种：

1. 同步调用  
   客户方等待调用执行完成并返回结果。

2. 异步调用  
   客户方调用后不用等待执行结果返回，但依然可以通过回调通知等方式获取返回结果。 若客户方不关心调用返回结果，则变成单向异步调用，单向调用不用返回结果。

RPC协议的组成

在一个典型的RPC的使用场景中，包含了服务发现，负载，容错，网络传输，序列化等组件，其中RPC协议指明了程序如何进行网络传输和序列化。

![](https://imgconvert.csdnimg.cn/aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy8xMjEzNTMzOS0wNDcxYjM0MGMwOWE3NTczLnBuZz9pbWFnZU1vZ3IyL2F1dG8tb3JpZW50L3N0cmlwfGltYWdlVmlldzIvMi93LzU5Ni9mb3JtYXQvd2VicA?x-oss-
process=image/format,png)

RPC协议主要由以下几部分组成：

  1. 地址:服务提供者地址

  2. 端口:协议指定开放的端口

  3. 报文编码:协议报文编码，分为请求头和请求体两部分

  4. 序列化方式:将请求体序列化成对象，具体的方式有Hessian2Serialization，DubboSerialization，JavaSerialization，JsonSerization等

  5. 运行服务:网络传输实现，实现方式主要有netty，mina，RMI服务，Servlet容器（jetty，tomcat，jboss）

RPC框架原理

![](https://imgconvert.csdnimg.cn/aHR0cHM6Ly91cGxvYWQtaW1hZ2VzLmppYW5zaHUuaW8vdXBsb2FkX2ltYWdlcy8xMjEzNTMzOS1kNDUzOGVhNmQ3ZTJjZWJlLnBuZz9pbWFnZU1vZ3IyL2F1dG8tb3JpZW50L3N0cmlwfGltYWdlVmlldzIvMi93LzkyMS9mb3JtYXQvd2VicA?x-oss-
process=image/format,png)

服务暴露

远程提供者需要以某种形式提供服务调用相关的信息，包括但不限于服务接口定义、数据结构或者中间态的服务定义文件，web
service的WSDL文件；服务调用者需要通过一定的途径获取远程服务调用相关的信息

序列化

得到服务地址后，客户端在发起调用前需要对调用信息进行编码，这就要考虑需要编码些什么信息并以什么格式传输到服务端才能让服务端完成调用。
出于效率考虑，编码的信息越少越好（传输数据少），编码的规则越简单越好（执行效率高）。

需要信息如下：

调用编码

1. 接口方法  
   包括接口名、方法名

2. 方法参数  
   包括参数类型、参数值

3. 调用属性  
   包括调用属性信息，例如调用附件隐式参数、调用超时时间等

返回编码

1. 返回结果  
   接口方法中定义的返回值

2. 返回码  
   异常返回码

3. 返回异常信息  
   调用异常信息

通信

协议编码之后，自然就是需要将编码后的 RPC 请求消息传输到服务方，服务方执行后返回结果消息或确认消息给客户方。 RPC的应用场景实质是一种可靠的请求应答消息流，和 HTTP 类似。 因此选择长连接方式的 TCP 协议会更高效，与 HTTP不同的是在协议层面我们定义了每个消息的唯一 id，因此可以更容易的复用连接。

RPC框架的通信其实与具体的协议无关，RPC可基于HTTP或者TCP协议

远程代理

服务调用者使用的服务实际上是远程服务的本地代理，说白了就是通过动态代理实现 java中至少提供了两种动态代码的生成：

  • 一种是jdk动态代理

  • 一种是字节码生成

动态代理比字节码生成使用起来更加方便，但是性能上没有字节码生成好，字节码生成在代码可读性上要差一些。

RPC 异常处理

无论 RPC 怎样努力把远程调用伪装的像本地调用，但它们依然有很大的不同点，而且有一些异常情况是在本地调用时绝对不会碰到的。
在说异常处理之前，我们先比较下本地调用和 RPC 调用的一些差异：

1. 本地调用一定会执行，而远程调用则不一定，调用消息可能因为网络原因并未发送到服务方。
2. 本地调用只会抛出接口声明的异常，而远程调用还会跑出 RPC 框架运行时的其他异常。
3. 本地调用和远程调用的性能可能差距很大，这取决于 RPC 固有消耗所占的比重。

正是这些区别决定了使用 RPC 时需要更多考量。 当调用远程接口抛出异常时，异常可能是一个业务异常， 也可能是 RPC
框架抛出的运行时异常（如：网络中断等）。 业务异常表明服务方已经执行了调用，可能因为某些原因导致未能正常执行， 而 RPC
运行时异常则有可能服务方根本没有执行，对调用方而言的异常处理策略自然需要区分。

由于 RPC 固有的消耗相对本地调用高出几个数量级，本地调用的固有消耗是纳秒级，而 RPC 的固有消耗是在毫秒级。
那么对于过于轻量的计算任务就并不合适导出远程接口由独立的进程提供服务， 只有花在计算任务上时间远远高于 RPC 的固有消耗才值得导出为远程接口提供服务。

RPC 框架设计与实现

RPC框架功能组件主要分为以下几类：

RpcServer

​ 负责导出（export）远程接口

@Slf4j
public class RpcServer {

	private String serverAddress;
	
	private EventLoopGroup bossGroup = new NioEventLoopGroup();
	
	private EventLoopGroup workerGroup = new NioEventLoopGroup();
	
	private volatile Map handlerMap = new HashMap();
	
	
	public RpcServer(String serverAddress) throws InterruptedException {
		this.serverAddress = serverAddress;
		this.start();
	}

	/**
	 * 	$start
	 * @throws InterruptedException
	 */
	private void start() throws InterruptedException {
		
		ServerBootstrap serverBootstrap = new ServerBootstrap();
		serverBootstrap.group(bossGroup, workerGroup)
		.channel(NioServerSocketChannel.class)
		//	tpc = sync + accept  = backlog
		.option(ChannelOption.SO_BACKLOG, 1024)
		.childHandler(new ChannelInitializer() {
			@Override
			protected void initChannel(SocketChannel ch) throws Exception {
				ChannelPipeline cp = ch.pipeline();
				cp.addLast(new LengthFieldBasedFrameDecoder(65536, 0, 4, 0, 0));
				cp.addLast(new RpcDecoder(RpcRequest.class));
				cp.addLast(new RpcEncoder(RpcResponse.class));
				cp.addLast(new RpcSeverHandler(handlerMap));
			}
		});
		
		
		String[] array = serverAddress.split(":");
		String host = array[0];
		int port = Integer.parseInt(array[1]);
		
		ChannelFuture channelFuture = serverBootstrap.bind(host, port).sync();
		channelFuture.addListener(new ChannelFutureListener() {
			@Override
			public void operationComplete(ChannelFuture future) throws Exception {
				if(future.isSuccess()) {
					log.info("server success bing to " + serverAddress);
				} else {
					log.info("server fail bing to " + serverAddress);
					throw new Exception("server start fail, cause: " + future.cause());
				}
			}
		});
		
		try {
			channelFuture.await(5000, TimeUnit.MILLISECONDS);	
			if(channelFuture.isSuccess()) {
				log.info("start rapid rpc success! ");
			}
		} catch (InterruptedException e) {
			log.error("start rapid rpc occur Interrupted, ex: " + e);
		}
		
	}
	
	/**
	 * 	$registerProcessor 程序注册器
	 */
	public void registerProcessor(ProviderConfig providerConfig) {
		//key ： providerConfig.insterface (userService接口权限命名)
		//value ： providerConfig.ref (userService接口下的具体实现类 userServiceImpl实例对象)
		handlerMap.put(providerConfig.getInterface(), providerConfig.getRef());
	}
	
	/**
	 * 	$close
	 */
	public void close() {
		bossGroup.shutdownGracefully();
		workerGroup.shutdownGracefully();
	}
	

}

RpcClient

负责导入（import）远程接口的代理实现

public class RpcClient {

	private String serverAddress;
	
	private long timeout;
	
	private final Map, Object> syncProxyIntanceMap = new ConcurrentHashMap, Object>();
	
	private final Map, Object> asyncProxyIntanceMap = new ConcurrentHashMap, Object>();

	
	public void initClient(String serverAddress, long timeout) {
		this.serverAddress = serverAddress;
		this.timeout = timeout;
		connect();
	}
	
	private void connect() {
		RpcConnectManager.getInstance().connect(serverAddress);
	}
	
	public void stop() {
		RpcConnectManager.getInstance().stop();
	}
	
	/**
	 * 	$invokeSync 同步调用方法
	 * @param 
	 * @param interfaceClass
	 * @return
	 */
	@SuppressWarnings("unchecked")
	public  T invokeSync(Class interfaceClass) {
		if(syncProxyIntanceMap.containsKey(interfaceClass)) {
			return (T)syncProxyIntanceMap.get(interfaceClass);
		} else {
			Object proxy = Proxy.newProxyInstance(interfaceClass.getClassLoader(),
					new Class[] {interfaceClass},
					new RpcProxyImpl<>(interfaceClass, timeout));
			syncProxyIntanceMap.put(interfaceClass, proxy);
			return (T)proxy;			
		}
	}
	
	/**
	 * 	$invokeAsync 异步调用方式的方法
	 * @param 
	 * @param interfaceClass
	 * @return
	 */
	public  RpcAsyncProxy invokeAsync(Class interfaceClass) {
		if(asyncProxyIntanceMap.containsKey(interfaceClass)) {
			return (RpcAsyncProxy) asyncProxyIntanceMap.get(interfaceClass);
		} else {
			RpcProxyImpl asyncProxyInstance = new RpcProxyImpl<>(interfaceClass, timeout);
			asyncProxyIntanceMap.put(interfaceClass, asyncProxyInstance);
			return asyncProxyInstance;
		}
	}
	
}

RpcProxy

远程接口的代理实现

public class RpcProxyImpl implements InvocationHandler, RpcAsyncProxy {

	private Class clazz;
	
	private long timeout;
	
	public RpcProxyImpl(Class clazz, long timeout) {
		this.clazz = clazz;
		this.timeout = timeout;
	}
	
	/**
	 * 	invoke代理接口调用方式
	 */
	@Override
	public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
		//1.设置请求对象
		RpcRequest request = new RpcRequest();
		request.setRequestId(UUID.randomUUID().toString());
		request.setClassName(method.getDeclaringClass().getName());
		request.setMethodName(method.getName());
		request.setParamterTypes(method.getParameterTypes());
		request.setParamters(args);
		
		//2.选择一个合适的Client任务处理器
		RpcClientHandler handler = RpcConnectManager.getInstance().chooseHandler();
		
		//3. 发送真正的客户端请求 返回结果
		RpcFuture future = handler.sendRequest(request);
		return future.get(timeout, TimeUnit.SECONDS);
	}

	/**
	 * 	$call 异步的代理接口实现, 真正的抱出去RpcFuture 给业务方做实际的回调等待处理
	 */
	@Override
	public RpcFuture call(String funcName, Object... args) {

		//1.设置请求对象
		RpcRequest request = new RpcRequest();
		request.setRequestId(UUID.randomUUID().toString());
		request.setClassName(this.clazz.getName());
		request.setMethodName(funcName);
		request.setParamters(args);
		//	TODO: 对应的方法参数类型应该通过 类类型 + 方法名称 通过反射得到parameterTypes
		Class[] parameterTypes = new Class[args.length];
		for(int i = 0; i < args.length; i++) {
			parameterTypes[i] = getClassType(args[i]);
		}
		request.setParamterTypes(parameterTypes);
		
		//2.选择一个合适的Client任务处理器
		RpcClientHandler handler = RpcConnectManager.getInstance().chooseHandler();
		RpcFuture future = handler.sendRequest(request);
		return future;
	}
	
    private Class getClassType(Object obj) {
        Class classType = obj.getClass();
        String typeName = classType.getName();
        if (typeName.equals("java.lang.Integer")) {
            return Integer.TYPE;
        } else if (typeName.equals("java.lang.Long")) {
            return Long.TYPE;
        } else if (typeName.equals("java.lang.Float")) {
            return Float.TYPE;
        } else if (typeName.equals("java.lang.Double")) {
            return Double.TYPE;
        } else if (typeName.equals("java.lang.Character")) {
            return Character.TYPE;
        } else if (typeName.equals("java.lang.Boolean")) {
            return Boolean.TYPE;
        } else if (typeName.equals("java.lang.Short")) {
            return Short.TYPE;
        } else if (typeName.equals("java.lang.Byte")) {
            return Byte.TYPE;
        }
        return classType;
    }
}

RpcInvoker

客户方实现：负责编码调用信息和发送调用请求到服务方并等待调用结果返回
服务方实现：负责调用服务端接口的具体实现并返回调用结果

@Slf4j
public class RpcFuture implements Future {

	private RpcRequest request;
	
	private RpcResponse response;
	
	private long startTime;
	
	private static final long TIME_THRESHOLD = 5000;
	
	private List pendingCallbacks = new ArrayList();
	
	private Sync sync ;
	
	private ReentrantLock lock = new ReentrantLock();
	
	private ThreadPoolExecutor executor = new ThreadPoolExecutor(16, 16, 60, TimeUnit.SECONDS, new ArrayBlockingQueue(65536));
	
	public RpcFuture(RpcRequest request) {
		this.request = request;
		this.startTime = System.currentTimeMillis();
		this.sync = new Sync();
	}

	/**
	 * 	$done 实际的回调处理
	 * @param response
	 */
	public void done(RpcResponse response) {
		this.response = response;
		boolean success = sync.release(1);
		if(success) {
			invokeCallbacks();
		}
		// 整体rpc调用的耗时
		long costTime = System.currentTimeMillis() - startTime;
		if(TIME_THRESHOLD < costTime) {
			log.warn("the rpc response time is too slow, request id = " + this.request.getRequestId() + " cost time: " + costTime);
		}
	}
	
	/**
	 * 	依次执行回调函数处理
	 */
	private void invokeCallbacks() {
		lock.lock();
		try {
			for(final RpcCallback callback : pendingCallbacks) {
				runCallback(callback);
			}			
		} finally {
			lock.unlock();
		}
	}

	private void runCallback(RpcCallback callback) {
		final RpcResponse response = this.response;
		executor.submit(new Runnable() {
			@Override
			public void run() {
				if(response.getThrowable() == null) {
					callback.success(response.getResult());
				} else {
					callback.failure(response.getThrowable());
				}
			}
		});
	}

	@Override
	public boolean cancel(boolean mayInterruptIfRunning) {
		throw new UnsupportedOperationException();
	}

	@Override
	public boolean isCancelled() {
		throw new UnsupportedOperationException();
	}

	@Override
	public boolean isDone() {
		return sync.isDone();
	}

	@Override
	public Object get() throws InterruptedException, ExecutionException {
		sync.acquire(-1);
		if(this.response != null) {
			return this.response.getResult();
		} else {
			return null;
		}
	}

	@Override
	public Object get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
		boolean success = sync.tryAcquireNanos(-1, unit.toNanos(timeout));
		if(success) {
			if(this.response != null) {
				return this.response.getResult();
			} else {
				return null;
			}
		} else {
			throw new RuntimeException("timeout excetion requestId: " 
					+ this.request.getRequestId() 
					+ ",className: " + this.request.getClassName()
					+ ",methodName: " + this.request.getMethodName());
		}
	}
	
	class Sync extends AbstractQueuedSynchronizer {

		private static final long serialVersionUID = -3989844522545731058L;
		
		private final int done = 1;
		
		private final int pending = 0;
		
		protected boolean tryAcquire(int acquires) {
			return getState() == done ? true : false;
		}
		
		protected boolean tryRelease(int releases) {
			if(getState() == pending) {
				if(compareAndSetState(pending, done)) {
					return true;
				}
			}
			return false;
		}
		
		public boolean isDone() {
			return getState() == done;
		}
	}
	
	/**
	 * 	可以在应用执行的过程中添加回调处理函数
	 * @param callback
	 * @return
	 */
	public RpcFuture addCallback(RpcCallback callback) {
		lock.lock();
		try {
			if(isDone()) {
				runCallback(callback);
			} else {
				this.pendingCallbacks.add(callback);
			}
		} finally {
			lock.unlock();
		}
		return this;
	}
	
}
 
  
RpcProtocol
 
  
负责协议编/解码
 
  
public class Serialization {

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

    private static Objenesis objenesis = new ObjenesisStd(true);

    public Serialization() {
    }

    private static  Schema getSchema(Class cls) {
        @SuppressWarnings("unchecked")
		Schema schema = (Schema) cachedSchema.get(cls);
        if (schema == null) {
            schema = RuntimeSchema.createFrom(cls);
            if (schema != null) {
                cachedSchema.put(cls, schema);
            }
        }
        return schema;
    }

    /**
     * 	序列化：对象->字节数组
     */
    public static  byte[] serialize(T obj) {
        @SuppressWarnings("unchecked")
		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 = objenesis.newInstance(cls);
            Schema schema = getSchema(cls);
            ProtostuffIOUtil.mergeFrom(data, message, schema);
            return message;
        } catch (Exception e) {
            throw new IllegalStateException(e.getMessage(), e);
        }
    }
}

 
  
RpcConnector
 
  
负责维持客户方和服务方的连接通道和发送数据到服务方
 
  
@Slf4j
public class RpcConnectManager {

	private static volatile RpcConnectManager  RPC_CONNECT_MANAGER = new RpcConnectManager();
	
	private RpcConnectManager() {
		
	}
	
	public static RpcConnectManager getInstance() {
		return RPC_CONNECT_MANAGER;
	}
	
	/*	一个连接的地址，对应一个实际的业务处理器(client)	*/
	private Map connectedHandlerMap = new ConcurrentHashMap();
	
	/*	所有连接成功的地址 所对应的 任务执行器列表 connectedHandlerList */
	private CopyOnWriteArrayList connectedHandlerList = new CopyOnWriteArrayList();
	
	/*	用于异步的提交连接请求的线程池	*/
	private ThreadPoolExecutor threadPoolExecutor = new ThreadPoolExecutor(16, 16, 60, TimeUnit.SECONDS, new ArrayBlockingQueue(65536));
	
	private EventLoopGroup eventLoopGroup = new NioEventLoopGroup(4);
	
	private ReentrantLock connectedLock = new ReentrantLock();
	
	private Condition connectedCondition = connectedLock.newCondition();
	
	private long connectTimeoutMills = 6000;
	
	private volatile boolean isRunning = true;
	
	private volatile AtomicInteger handlerIdx = new AtomicInteger(0);
	
	//1. 异步连接 线程池 真正的发起连接，连接失败监听，连接成功监听
	//2. 对于连接进来的资源做一个缓存（做一个管理）updateConnectedServer
	/**
	 * 	$connect 发起连接方法
	 * @param serverAddress
	 */
	public void connect(final String serverAddress) {
		List allServerAddress = Arrays.asList(serverAddress.split(","));
		updateConnectedServer(allServerAddress);
	}
	
	/**
	 * 	$更新缓存信息 并 异步发起连接
	 * 	192.168.11.111:8765,192.168.11.112:8765
	 * @param allServerAddress
	 */
	public void updateConnectedServer(List allServerAddress) {
		if(CollectionUtils.isNotEmpty(allServerAddress)) {
			
			//	1.解析allServerAddress地址 并且临时存储到我们的newAllServerNodeSet HashSet集合中
			HashSet newAllServerNodeSet = new HashSet();
			for(int i =0; i < allServerAddress.size(); i++) {
				String[] array = allServerAddress.get(i).split(":");
				if(array.length == 2) {
					String host = array[0];
					int port = Integer.parseInt(array[1]);
					final InetSocketAddress remotePeer = new InetSocketAddress(host, port);
					newAllServerNodeSet.add(remotePeer);
				}
			}
			
			//	2.调用建立连接方法 发起远程连接操作
			for(InetSocketAddress serverNodeAddress : newAllServerNodeSet) {
				if(!connectedHandlerMap.keySet().contains(serverNodeAddress)) {
					connectAsync(serverNodeAddress);
				}
			}
			
			//	3. 如果allServerAddress列表里不存在的连接地址，那么我需要从缓存中进行移除
			for(int i = 0; i< connectedHandlerList.size(); i++) {
				RpcClientHandler rpcClientHandler = connectedHandlerList.get(i);
				SocketAddress remotePeer = rpcClientHandler.getRemotePeer();
				if(!newAllServerNodeSet.contains(remotePeer)) {
					log.info(" remove invalid server node " + remotePeer);
					RpcClientHandler handler = connectedHandlerMap.get(remotePeer);
					if(handler != null) {
						handler.close();
						connectedHandlerMap.remove(remotePeer);
					}
					connectedHandlerList.remove(rpcClientHandler);
				}
			}
			
		} else {
			// 添加告警
			log.error(" no available server address! ");
			// 清除所有的缓存信息
			clearConnected();
		}
	}

	/**
	 * 	$connectAsync 异步发起连接的方法
	 * @param serverNodeAddress
	 */
	private void connectAsync(InetSocketAddress remotePeer) {
		threadPoolExecutor.submit(new Runnable() {
			@Override
			public void run() {
				Bootstrap b = new Bootstrap();
				b
				.group(eventLoopGroup)
				.channel(NioSocketChannel.class)
				.option(ChannelOption.TCP_NODELAY, true)
				.handler(new RpcClientInitializer());
				connect(b, remotePeer);
			}
		});
	}
	
	private void connect(final Bootstrap b, InetSocketAddress remotePeer) {
		
		//	1.真正的建立连接
		final ChannelFuture channelFuture = b.connect(remotePeer);
		
		//	2.连接失败的时候添加监听 清除资源后进行发起重连操作
		channelFuture.channel().closeFuture().addListener(new ChannelFutureListener() {
			
			@Override
			public void operationComplete(ChannelFuture future) throws Exception {
				log.info("channelFuture.channel close operationComplete, remote peer =" + remotePeer);
				future.channel().eventLoop().schedule(new Runnable() {
					
					@Override
					public void run() {
						log.warn(" connect fail, to reconnect! ");
						clearConnected();
						connect(b, remotePeer);
					}
		
				}, 3, TimeUnit.SECONDS);
			}
		});
		
		//	3.连接成功的时候添加监听 把我们的新连接放入缓存中
		channelFuture.addListener(new ChannelFutureListener() {
			@Override
			public void operationComplete(ChannelFuture future) throws Exception {
				if(future.isSuccess()) {
					log.info("successfully connect to remote server, remote peer = " + remotePeer);
					RpcClientHandler handler = future.channel().pipeline().get(RpcClientHandler.class);
					addHandler(handler);
				}
			}
		});
	}
	
	/**
	 * 	$clearConnected
	 * 	连接失败时，及时的释放资源，清空缓存
	 * 	先删除所有的connectedHandlerMap中的数据
	 * 	然后再清空connectedHandlerList中的数据
	 */
	private void clearConnected() {
		for(final RpcClientHandler rpcClientHandler : connectedHandlerList) {
			// 通过RpcClientHandler 找到具体的remotePeer, 从connectedHandlerMap进行移除指定的 RpcClientHandler
			SocketAddress remotePeer = rpcClientHandler.getRemotePeer();
			RpcClientHandler handler = connectedHandlerMap.get(remotePeer);
			if(handler != null) {
				handler.close();
				connectedHandlerMap.remove(remotePeer);
			}
		}
		connectedHandlerList.clear();
	}
	
	
	/**
	 * 	$addHandler 添加RpcClientHandler到指定的缓存中
	 * 	connectedHandlerMap & connectedHandlerList
	 * 	
	 * @param handler
	 */
	private void addHandler(RpcClientHandler handler) {
		connectedHandlerList.add(handler);
		InetSocketAddress remoteAddress = //(InetSocketAddress) handler.getRemotePeer();
				(InetSocketAddress) handler.getChannel().remoteAddress();

		connectedHandlerMap.put(remoteAddress, handler);
		//signalAvailableHandler 唤醒可用的业务执行器
		signalAvailableHandler();
	}

	/**
	 * 	唤醒另外一端的线程(阻塞的状态中) 告知有新连接接入
	 */
	private void signalAvailableHandler() {
		connectedLock.lock();
		try {
			connectedCondition.signalAll();
		} finally {
			connectedLock.unlock();
		}
	}
	
	/**
	 * 	$waitingForAvailableHandler 等待新连接接入通知方法
	 * @return
	 * @throws InterruptedException
	 */
	private boolean waitingForAvailableHandler() throws InterruptedException {
		connectedLock.lock();
		try {
			return connectedCondition.await(this.connectTimeoutMills, TimeUnit.MICROSECONDS);
		} finally {
			connectedLock.unlock();
		}
	}
	
	
	/**
	 * $chooseHandler 选择一个实际的业务处理器
	 * @return RpcClientHandler
	 */
	public RpcClientHandler chooseHandler() {
		CopyOnWriteArrayList handlers = (CopyOnWriteArrayList)this.connectedHandlerList.clone();
		
		int size = handlers.size();
		
		while(isRunning && size <= 0) {
			try {
				boolean available = waitingForAvailableHandler();
				if(available) {
					handlers = (CopyOnWriteArrayList)this.connectedHandlerList.clone();
					size = handlers.size();
				}
			} catch (InterruptedException e) {
				log.error(" wating for available node is interrupted !");
				throw new RuntimeException("no connect any servers!", e);
			}
		}
		if(!isRunning) {
			return null;
		}
		// 最终使用取模方式取得其中一个业务处理器进行实际的业务处理
		return handlers.get(((handlerIdx.getAndAdd(1) + size) % size));
	}
	
	/**
	 * 	$stop 关闭的方法
	 */
	public void stop() {
		isRunning = false;
		for(int i = 0; i< connectedHandlerList.size(); i++) {
			RpcClientHandler rpcClientHandler = connectedHandlerList.get(i);
			rpcClientHandler.close();
		}
		// 在这里要调用一下唤醒操作
		signalAvailableHandler();
		threadPoolExecutor.shutdown();
		eventLoopGroup.shutdownGracefully();
	}
	
	/**
	 * $reconnect 发起重连方法 需要把对应的资源进行释放
	 * @param handler
	 * @param remotePeer
	 */
	public void reconnect(final RpcClientHandler handler , final SocketAddress remotePeer) {
		if(handler != null) {
			handler.close();
			connectedHandlerList.remove(handler);
			connectedHandlerMap.remove(remotePeer);
		}
		connectAsync((InetSocketAddress) remotePeer);
	}
	
}

 
  
RpcAcceptor
 
  
负责接收客户方请求并返回请求结果
 
  
@Slf4j
public class RpcSeverHandler extends SimpleChannelInboundHandler {
	
	private Map handlerMap;
	
	private ThreadPoolExecutor executor = new ThreadPoolExecutor(16, 16, 600L, TimeUnit.SECONDS, new ArrayBlockingQueue<>(65536));
	

	public RpcSeverHandler(Map handlerMap) {
		this.handlerMap = handlerMap;
	}
	
	@Override
	protected void channelRead0(ChannelHandlerContext ctx, RpcRequest rpcRequest) throws Exception {
		executor.submit(new Runnable() {
			@Override
			public void run() {
				RpcResponse response = new RpcResponse();
				response.setRequestId(rpcRequest.getRequestId());
				try {
					Object result = handle(rpcRequest);
					response.setResult(result);
				} catch (Throwable t) {
					response.setThrowable(t);
					log.error("rpc service handle request Throwable: " + t);
				}
				
				ctx.writeAndFlush(response).addListener(new ChannelFutureListener() {
					@Override
					public void operationComplete(ChannelFuture future) throws Exception {
						if(future.isSuccess()) {
							// afterRpcHook
						}
					}
				});
				
			}
		});
	}

	/**
	 * 	$handle 解析request请求并且去通过反射获取具体的本地服务实例后执行具体的方法
	 * @param request
	 * @return
	 * @throws InvocationTargetException
	 */
	private Object handle(RpcRequest request) throws InvocationTargetException {
		String className = request.getClassName();
		Object serviceRef = handlerMap.get(className);
		Class serviceClass = serviceRef.getClass();
		String methodName = request.getMethodName();
		Class[] paramterTypes = request.getParamterTypes();
		Object[] paramters = request.getParamters();
		
		// JDK relect
		
		// Cglib
		FastClass serviceFastClass = FastClass.create(serviceClass);
		FastMethod servicFastMethod = serviceFastClass.getMethod(methodName, paramterTypes);
		return servicFastMethod.invoke(serviceRef, paramters);
	}

	/**
	 * 	$exceptionCaught 异常处理关闭连接
	 */
	public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
		log.error("server caught Throwable: " + cause);
		ctx.close();
	}
	
}

 
  
RpcRequest
 
  
封装RPC调用客户端请求
 
  
@Data
public class RpcRequest implements Serializable {

	private static final long serialVersionUID = 3424024710707513070L;
	
	private String requestId;
	
	private String className;
	
	private String methodName;
	
	private Class[] paramterTypes;
	
	private Object[] paramters;

}


 
  
RpcResponse
 
  
封装RPC调用服务端返回结果
 
  
@Data
public class RpcResponse implements Serializable {

	private static final long serialVersionUID = -7989400623370901861L;

	private String requestId;
	
	private Object result;
	
	private Throwable throwable;
	
}


 
  
RpcProcessor
 
  
负责在服务方控制调用过程，包括管理调用线程池、超时时间等
 
  
RpcChannel
 
  
数据传输通道
 
  
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(并发编程与网络通信,分布式架构,rpc,netty,序列化,网络通信,远程代理)

        

            

                
    
                    
  • 斤斤计较的婚姻到底有多难？
                        白心之岂必有为

                        
    很多人私聊我会问到在哪个人群当中斤斤计较的人最多？我都会回答他，一般婚姻出现问题的斤斤计较的人士会非常多，以我多年经验，在婚姻落的一塌糊涂的人当中，斤斤计较的人数占比在20～30%以上，也就是说10个婚姻出现问题的斤斤计较的人有2-3个有多不减。在婚姻出问题当中，有大量的心理不平衡的、尖酸刻薄的怨妇。在婚姻中仅斤斤计较有两种类型：第一种是物质上的，另一种是精神上的。在物质与精神上抠门已经严重的影响
    
                    
    • 
                    
  • QQ群采集助手，精准引流必备神器
                        2401_87347160
其他经验分享
                        
    功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
    
                    
    • 
                    
  • 机器学习与深度学习间关系与区别
                        ℒℴѵℯ心·动ꦿ໊ོ꫞
人工智能学习深度学习python
                        
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
    
                    
    • 
                    
  • 随笔 | 仙一般的灵气
                        海思沧海

                        
    仙岛今天，我看了你全部，似乎已经进入你的世界我不知道，这是否是梦幻，还是你仙一般的灵气吸引了我也许每一个人都要有一份属于自己的追求，这样才能够符合人生的梦想，生活才能够充满着阳光与快乐我不知道，我为什么会这样的感叹，是在感叹自己的人生，还是感叹自己一直没有孜孜不倦的追求只感觉虚度了光阴，每天活在自己的梦中，活在一个不真实的世界是在逃避自己，还是在逃避周围的一切有时候我嘲笑自己，嘲笑自己如此的虚无，
    
                    
    • 
                    
  • 一百九十四章. 自相矛盾
                        巨木擎天

                        
    唉！就这么一夜，林子感觉就像过了很多天似的，先是回了阳间家里，遇到了那么多不可思议的事情儿。特别是小伙伴们，第二次与自己见面时，僵硬的表情和恐怖的气氛，让自己如坐针毡，打从心眼里难受！还有东子，他现在还好吗？有没有被人欺负？护城河里的小鱼小虾们，还都在吗？水不会真的干枯了吧？那对相亲相爱漂亮的太平鸟儿，还好吧！春天了，到了做窝、下蛋、喂养小鸟宝宝的时候了，希望它们都能够平安啊！虽然没有看见家人，也
    
                    
    • 
                    
  • 微服务下功能权限与数据权限的设计与实现
                        nbsaas-boot
微服务java架构
                        
    在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
    
                    
    • 
                    
  • 学点心理知识，呵护孩子健康
                        静候花开_7090

                        
    昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
    
                    
    • 
                    
  • 《投行人生》读书笔记
                        小蘑菇的树洞

                        
    《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
    
                    
    • 
                    
  • Long类型前后端数据不一致
                        igotyback
前端
                        
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
    
                    
    • 
                    
  • mysql禁用远程登录
                        igotyback
mysql
                        
    去mysql库中的user表里，将host都改成localhost之后刷新权限FLUSHPRIVILEGES;
    
                    
    • 
                    
  • 店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码
                        说私域
人工智能小程序
                        
    摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
    
                    
    • 
                    
  • 2021-08-26
                        影幽

                        
    在生活中，女人与男人的感悟往往有所不同。人生最大的舞台就是生活，大幕随时都可能拉开，关键是你愿不愿意表演都无法躲避。在生活中，遇事不要急躁，不要急于下结论，尤其生气时不要做决断，要学会换位思考，大事化小小事化了，把复杂的事情尽量简单处理，千万不要把简单的事情复杂化。永远不要扭曲，别人善意，无药可救。昨天是张过期的支票，明天是张信用卡，只有今天才是现金，要善加利用！执着的攀登者不必去与别人比较自己的
    
                    
    • 
                    
  • 高级编程--XML+socket练习题
                        masa010
java开发语言
                        
    1.北京华北2114.8万人上海华东2,500万人广州华南1292.68万人成都华西1417万人（1）使用dom4j将信息存入xml中（2）读取信息，并打印控制台（3）添加一个city节点与子节点（4）使用socketTCP协议编写服务端与客户端，客户端输入城市ID，服务器响应相应城市信息（5）使用socketTCP协议编写服务端与客户端，客户端要求用户输入city对象，服务端接收并使用dom4j
    
                    
    • 
                    
  • 2018-07-23-催眠日作业-#不一样的31天#-66小鹿
                        小鹿_33

                        
    预言日：人总是在逃避命运的路上，与之不期而遇。心理学上有个著名的名词，叫做自证预言；经济学上也有一个很著名的定律叫做，墨菲定律；在灵修派上，还有一个很著名的法则，叫做吸引力法则。这3个领域的词，虽然看起来不太一样，但是他们都在告诉人们一个现象：你越担心什么，就越有可能会发生什么。同样的道理，你越想得到什么，就应该要积极地去创造什么。无论是自证预言，墨菲定律还是吸引力法则，对人都有正反2个维度的影响
    
                    
    • 
                    
  • 回溯 Leetcode 332 重新安排行程
                        mmaerd
Leetcode刷题学习记录leetcode算法职场和发展
                        
    重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
    
                    
    • 
                    
  • 每日一题——第九十题
                        互联网打工人no1
C语言程序设计每日一练c语言
                        
    题目：判断子串是否与主串匹配#include#include#include//////判断子串是否在主串中匹配//////主串///子串///boolisSubstring(constchar*str,constchar*substr){intlenstr=strlen(str);//计算主串的长度intlenSub=strlen(substr);//计算子串的长度//遍历主字符串，对每个可能得
    
                    
    • 
                    
  • Python数据分析与可视化实战指南
                        William数据分析
pythonpython数据
                        
    在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
    
                    
    • 
                    
  • 《庄子.达生9》
                        钱江潮369

                        
    【原文】孔子观于吕梁，县水三十仞，流沫四十里，鼋鼍鱼鳖之所不能游也。见一丈夫游之，以为有苦而欲死也，使弟子并流而拯之。数百步而出，被发行歌而游于塘下。孔子从而问焉，曰：“吾以子为鬼，察子则人也。请问，‘蹈水有道乎’”曰：“亡，吾无道。吾始乎故，长乎性，成乎命。与齐俱入，与汩偕出，从水之道而不为私焉。此吾所以蹈之也。”孔子曰：“何谓始乎故，长乎性，成乎命？”曰：“吾生于陵而安于陵，故也；长于水而安于
    
                    
    • 
                    
  • git常用命令笔记
                        咩酱-小羊
git笔记
                        
    ###用习惯了idea总是不记得git的一些常见命令，需要用到的时候总是担心旁边站了人~~~记个笔记@_@，告诉自己看笔记不丢人初始化初始化一个新的Git仓库gitinit配置配置用户信息gitconfig--globaluser.name"YourName"gitconfig--globaluser.email"[email protected]"基本操作克隆远程仓库gitclone查看
    
                    
    • 
                    
  • 水泥质量纠纷案代理词
                        徐宝峰律师

                        
    贵州领航建设有限公司诉贵州纳雍隆庆乌江水泥有限公司产品质量纠纷案代理词尊敬的审判长、审判员：贵州千里律师事务所接受被告贵州纳雍隆庆乌江水泥有限公司的委托，指派我担任其诉讼代理人，参加本案的诉讼活动。下面，我结合本案事实和相关法律规定发表如下代理意见，供合议庭评议案件时参考：原告应当举证证明其遭受的损失与被告生产的水泥质量的因果关系。首先水泥是一种粉状水硬性无机胶凝材料。加水搅拌后成浆体，能在空气中
    
                    
    • 
                    
  • Goolge earth studio 进阶4——路径修改与平滑
                        陟彼高冈yu
Googleearthstudio进阶教程旅游
                        
    如果我们希望在大约中途时获得更多的城市鸟瞰视角。可以将相机拖动到这里并创建一个新的关键帧。camera_target_clip_7EarthStudio会自动平滑我们的路径，所以当我们通过这个关键帧时，不是一个生硬的角度，而是一个平滑的曲线。camera_target_clip_8路径上有贝塞尔控制手柄，允许我们调整路径的形状。右键单击，我们可以选择“平滑路径”，这是默认的自动平滑算法，或者我们可
    
                    
    • 
                    
  • 使用 FinalShell 进行远程连接（ssh 远程连接 Linux 服务器）
                        编程经验分享
开发工具服务器sshlinux
                        
    目录前言基本使用教程新建远程连接连接主机自定义命令路由追踪前言后端开发，必然需要和服务器打交道，部署应用，排查问题，查看运行日志等等。一般服务器都是集中部署在机房中，也有一些直接是云服务器，总而言之，程序员不可能直接和服务器直接操作，一般都是通过ssh连接来登录服务器。刚接触远程连接时，使用的是XSHELL来远程连接服务器，连接上就能够操作远程服务器了，但是仅用XSHELL并没有上传下载文件的功能
    
                    
    • 
                    
  • 18-115 一切思考不能有效转化为行动，都TM是扯淡！
                        成长时间线

                        
    7月25号写了一篇关于为什么会断更如此严重的反思，然而，之后日更仅仅维持了一周，又出现了这次更严重的现象。从8月2号到昨天8月6号，5天！又是5天没有更文！虽然这次断更时间和上次一样，那为什么说这次更严重？因为上次之后就分析了问题的原因，以及应该如何解决，按理说应该会好转，然而，没过几天严重断更的现象再次出现，想想，经过反思，问题依然没有解决与改变，这让我有些担忧。到底是哪里出了问题，难道我就真的
    
                    
    • 
                    
  • 山东大学小树林支教调研团青青仓木队——翟晓楠
                        山东大学青青仓木队

                        
    过了半年，又一次启程，又一次回到支教的初心之地。比起上一次的试探与不安，我更多了一丝稳重与熟练。心境、处境也都随着半个学期的过去而变得不同，半个学期中，身体上的，心理上的，太多的逆境让我变得步履维艰，曲曲折折，弯弯绕绕，我仿佛打不起精神，没有胃口，没有动力。感觉走的不顺畅的时候，支教这个旅程，给了我力量。自告奋勇承担起队长这一职务的我，从组织时的复杂和困难的经历，协调各种问题，从无到有，和校长和队
    
                    
    • 
                    
  • 直返最高等级与直返APP：无需邀请码的返利新体验
                        古楼

                        
    随着互联网的普及和电商的兴起，直返模式逐渐成为一种流行的商业模式。在这种模式下，消费者通过购买产品或服务，获得一定的返利，并可以分享给更多的人。其中，直返最高等级和直返APP是直返模式中的重要概念和工具。本文将详细介绍直返最高等级的概念、直返APP的使用以及与邀请码的关系。【高省】APP（高佣金领导者）是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，运行三年，稳定可靠。高省APP，
    
                    
    • 
                    
  • Git常用命令－修改远程仓库地址
                        猿大师
LinuxJavagitjava
                        
    查看远程仓库地址gitremote-v返回结果originhttps://git.coding.net/＊＊＊＊＊.git(fetch)originhttps://git.coding.net/＊＊＊＊＊.git(push)修改远程仓库地址gitremoteset-urloriginhttps://git.coding.net/＊＊＊＊＊.git先删除后增加远程仓库地址gitremotermori
    
                    
    • 
                    
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
                        STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
                        
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
    
                    
    • 
                    
  • 2020-04-12每天三百字之连接与替代
                        冷眼看潮

                        
    不知道是不是好为人师，有时候还真想和别人分享一下我对某些现象的看法或者解释。人类社会不断发展进步的过程，就是不断连接与替代的过程。人类发现了火并应用火以后，告别了茹毛饮血的野兽般的原始生活（火烧、烹饪替代了生食）人类用石器代替了完全手工，工具的使用使人类进步一大步。类似这样的替代还有很多，随着科技的发展，有更多的原始的事物被替代，代之以更高效、更先进的技术。在近现代，汽车替代了马车，高速公路和铁路
    
                    
    • 
                    
  • 探索OpenAI和LangChain的适配器集成：轻松切换模型提供商
                        nseejrukjhad
langchaineasyui前端python
                        
    #探索OpenAI和LangChain的适配器集成：轻松切换模型提供商##引言在人工智能和自然语言处理的世界中，OpenAI的模型提供了强大的能力。然而，随着技术的发展，许多人开始探索其他模型以满足特定需求。LangChain作为一个强大的工具，集成了多种模型提供商，通过提供适配器，简化了不同模型之间的转换。本篇文章将介绍如何使用LangChain的适配器与OpenAI集成，以便轻松切换模型提供商
    
                    
    • 
                    
  • 利用Requests Toolkit轻松完成HTTP请求
                        nseejrukjhad
http网络协议网络python
                        
    RequestsToolkit的力量：轻松构建HTTP请求Agent在现代软件开发中，API请求是与外部服务交互的核心。RequestsToolkit提供了一种便捷的方式，帮助开发者构建自动化的HTTP请求Agent。本文旨在详细介绍RequestsToolkit的设置、使用和潜在挑战。引言RequestsToolkit是一个强大的工具包，可用于构建执行HTTP请求的智能代理。这对于想要自动化与外
    
                    
    • 
                                
  • Java 并发包之线程池和原子计数
                                    lijingyao8206
Java计数ThreadPool并发包java线程池
                                    
    对于大数据量关联的业务处理逻辑，比较直接的想法就是用JDK提供的并发包去解决多线程情况下的业务数据处理。线程池可以提供很好的管理线程的方式，并且可以提高线程利用率，并发包中的原子计数在多线程的情况下可以让我们避免去写一些同步代码。 
    这里就先把jdk并发包中的线程池处理器ThreadPoolExecutor 以原子计数类AomicInteger 和倒数计时锁C
    
                                
    • 
                                
  • java编程思想 抽象类和接口
                                    百合不是茶
java抽象类接口
                                    
    接口c++对接口和内部类只有简介的支持,但在java中有队这些类的直接支持 
  
1 ,抽象类 :  如果一个类包含一个或多个抽象方法,该类必须限定为抽象类(否者编译器报错) 
  
抽象方法 : 在方法中仅有声明而没有方法体  
  
 
package com.wj.Interface;


    
                                
    • 
                                
  • [房地产与大数据]房地产数据挖掘系统
                                    comsci
数据挖掘
                                    
     
       随着一个关键核心技术的突破,我们已经是独立自主的开发某些先进模块,但是要完全实现,还需要一定的时间... 
 
       所以,除了代码工作以外,我们还需要关心一下非技术领域的事件..比如说房地产 
 
    &nb
    
                                
    • 
                                
  • 数组队列总结
                                    沐刃青蛟
数组队列
                                    
      
    数组队列是一种大小可以改变，类型没有定死的类似数组的工具。不过与数组相比，它更具有灵活性。因为它不但不用担心越界问题，而且因为泛型（类似c++中模板的东西）的存在而支持各种类型。 
  
   以下是数组队列的功能实现代码： 
  
import List.Student;

public class
    
                                
    • 
                                
  • Oracle存储过程无法编译的解决方法
                                    IT独行者
oracle存储过程　
                                    
    今天同事修改Oracle存储过程又导致2个过程无法被编译，流程规范上的东西，Dave 这里不多说，看看怎么解决问题。 
   


1.     查看无效对象  
XEZF@xezf(qs-xezf-db1)> select object_name,object_type,status from all_objects where status='IN
    
                                
    • 
                                
  • 重装系统之后oracle恢复
                                    文强chu
oracle
                                    
    前几天正在使用电脑，没有暂停oracle的各种服务。 
突然win8.1系统奔溃，无法修复，开机时系统 提示正在搜集错误信息，然后再开机，再提示的无限循环中。 
无耐我拿出系统u盘 准备重装系统，没想到竟然无法从u盘引导成功。 
晚上到外面早了一家修电脑店，让人家给装了个系统，并且那哥们在我没反应过来的时候， 
直接把我的c盘给格式化了 并且清理了注册表，再装系统。 
然后的结果就是我的oracl
    
                                
    • 
                                
  • python学习二（ 一些基础语法）
                                    小桔子
pthon基础语法
                                    
    紧接着把！昨天没看继续看django 官方教程，学了下python的基本语法 与c类语言还是有些小差别： 
1.ptyhon的源文件以UTF-8编码格式 
2. 
 /   除 结果浮点型 
 //  除 结果整形 
 %   除 取余数 
 *   乘 
 **  乘方 eg 5**2 结果是5的2次方25 
 _&
    
                                
    • 
                                
  • svn 常用命令
                                    aichenglong
SVN版本回退
                                    
    1 svn回退版本 
  1)在window中选择log,根据想要回退的内容,选择revert this version或revert chanages from this version 
 两者的区别: 
  revert this version:表示回退到当前版本(该版本后的版本全部作废) 
  revert chanages from this versio
    
                                
    • 
                                
  • 某小公司面试归来
                                    alafqq
面试
                                    
    先填单子，还要写笔试题，我以时间为急，拒绝了它。。时间宝贵。 
老拿这些对付毕业生的东东来吓唬我。。 
 
面试官很刁难，问了几个问题，记录下； 
 
1，包的范围。。。public,private,protect. --悲剧了 
2，hashcode方法和equals方法的区别。谁覆盖谁.结果，他说我说反了。 
3，最恶心的一道题，抽象类继承抽象类吗？（察，一般它都是被继承的啊） 
4，stru
    
                                
    • 
                                
  • 动态数组的存储速度比较 集合框架
                                    百合不是茶
集合框架
                                    
    集合框架： 
自定义数据结构(增删改查等) 
package 数组;

/**
 * 创建动态数组
 * @author 百合
 *
 */

public class ArrayDemo{
	
	//定义一个数组来存放数据
	
	String[] src = new String[0];
	
	/**
	 * 增加元素加入容器 
	 * @param s要加入容器
    
                                
    • 
                                
  • 用JS实现一个JS对象，对象里有两个属性一个方法
                                    bijian1013
js对象
                                    
    <html> 
  <head> 
  </head> 
  <body> 
    用js代码实现一个js对象，对象里有两个属性，一个方法 
  </body> 
  <script> 
        var obj={a:'1234567',b:'bbbbbbbbbb',c:function(x){ 
 
    
                                
    • 
                                
  • 探索JUnit4扩展：使用Rule
                                    bijian1013
java单元测试JUnitRule
                                    
            在上一篇文章中，讨论了使用Runner扩展JUnit4的方式，即直接修改Test Runner的实现(BlockJUnit4ClassRunner)。但这种方法显然不便于灵活地添加或删除扩展功能。下面将使用JUnit4.7才开始引入的扩展方式——Rule来实现相同的扩展功能。 
1. Rule 
      &n
    
                                
    • 
                                
  • [Gson一]非泛型POJO对象的反序列化
                                    bit1129
POJO
                                    
    当要将JSON数据串反序列化自身为非泛型的POJO时，使用Gson.fromJson(String, Class)方法。自身为非泛型的POJO的包括两种： 
1. POJO对象不包含任何泛型的字段 
2. POJO对象包含泛型字段，例如泛型集合或者泛型类 
 Data类 a.不是泛型类， b.Data中的集合List和Map都是泛型的 c.Data中不包含其它的POJO   
 
    
                                
    • 
                                
  • 【Kakfa五】Kafka Producer和Consumer基本使用
                                    bit1129
kafka
                                    
    0.Kafka服务器的配置 
一个Broker， 
一个Topic 
Topic中只有一个Partition（）   1. Producer： 
package kafka.examples.producers;


import kafka.producer.KeyedMessage;
import kafka.javaapi.producer.Producer;
impor
    
                                
    • 
                                
  • lsyncd实时同步搭建指南——取代rsync+inotify
                                    ronin47

                                    
    1. 几大实时同步工具比较 1.1 inotify + rsync 
最近一直在寻求生产服务服务器上的同步替代方案，原先使用的是 inotify + rsync，但随着文件数量的增大到100W+，目录下的文件列表就达20M，在网络状况不佳或者限速的情况下，变更的文件可能10来个才几M，却因此要发送的文件列表就达20M，严重减低的带宽的使用效率以及同步效率；更为要紧的是，加入inotify
    
                                
    • 
                                
  • java-9. 判断整数序列是不是二元查找树的后序遍历结果
                                    bylijinnan
java
                                    
    

public class IsBinTreePostTraverse{
	
	static boolean isBSTPostOrder(int[] a){
		if(a==null){
			return false;
		}
		/*1.只有一个结点时，肯定是查找树
		 *2.只有两个结点时，肯定是查找树。例如{5,6}对应的BST是   6		{6,5}对应的BST是
    
                                
    • 
                                
  • MySQL的sum函数返回的类型
                                    bylijinnan
javaspringsqlmysqljdbc
                                    
    今天项目切换数据库时，出错 
 
访问数据库的代码大概是这样： 
 

String sql =  "select sum(number) as sumNumberOfOneDay from tableName";
List<Map> rows = getJdbcTemplate().queryForList(sql);
for (Map row : rows
    
                                
    • 
                                
  • java设计模式之单例模式
                                    chicony
java设计模式
                                    
      
在阎宏博士的《JAVA与模式》一书中开头是这样描述单例模式的： 
　　作为对象的创建模式，单例模式确保某一个类只有一个实例，而且自行实例化并向整个系统提供这个实例。这个类称为单例类。  单例模式的结构
  
　　单例模式的特点： 
 
 单例类只能有一个实例。 
 单例类必须自己创建自己的唯一实例。 
 单例类必须给所有其他对象提供这一实例。 
 　　饿汉式单例类 
  
publ
    
                                
    • 
                                
  • javascript取当月最后一天
                                    ctrain
JavaScript
                                    
    
<!--javascript取当月最后一天-->
<script   language=javascript>  
  var current = new Date();
  var year = current.getYear();
  var month = current.getMonth();
  showMonthLastDay(year, mont
    
                                
    • 
                                
  • linux tune2fs命令详解
                                    daizj
linuxtune2fs查看系统文件块信息
                                    
    一.简介： 
tune2fs是调整和查看ext2/ext3文件系统的文件系统参数，Windows下面如果出现意外断电死机情况，下次开机一般都会出现系统自检。Linux系统下面也有文件系统自检，而且是可以通过tune2fs命令，自行定义自检周期及方式。 
二.用法： 
Usage: tune2fs [-c max_mounts_count] [-e errors_behavior] [-g grou
    
                                
    • 
                                
  • 做有中国特色的程序员
                                    dcj3sjt126com
程序员
                                    
      
从出版业说起  网络作品排到靠前的，都不会太难看，一般人不爱看某部作品也是因为不喜欢这个类型，而此人也不会全不喜欢这些网络作品。究其原因，是因为网络作品都是让人先白看的，看的好了才出了头。而纸质作品就不一定了，排行榜靠前的，有好作品，也有垃圾。   许多大牛都是写了博客，后来出了书。这些书也都不次，可能有人让为不好，是因为技术书不像小说，小说在读故事，技术书是在学知识或温习知识，有
    
                                
    • 
                                
  • Android：TextView属性大全
                                    dcj3sjt126com
textview
                                    
    android:autoLink    设置是否当文本为URL链接/email/电话号码/map时，文本显示为可点击的链接。可选值(none/web/email/phone/map/all)  android:autoText    如果设置，将自动执行输入值的拼写纠正。此处无效果，在显示输入法并输
    
                                
    • 
                                
  • tomcat虚拟目录安装及其配置
                                    eksliang
tomcat配置说明tomca部署web应用tomcat虚拟目录安装
                                    
    转载请出自出处：http://eksliang.iteye.com/blog/2097184 
1.-------------------------------------------tomcat  目录结构 
 
 config：存放tomcat的配置文件 
 temp  ：存放tomcat跑起来后存放临时文件用的 
 work   ： 当第一次访问应用中的jsp
    
                                
    • 
                                
  • 浅谈：APP有哪些常被黑客利用的安全漏洞
                                    gg163
APP
                                    
    首先，说到APP的安全漏洞，身为程序猿的大家应该不陌生；如果抛开安卓自身开源的问题的话，其主要产生的原因就是开发过程中疏忽或者代码不严谨引起的。但这些责任也不能怪在程序猿头上，有时会因为BOSS时间催得紧等很多可观原因。由国内移动应用安全检测团队爱内测（ineice.com）的CTO给我们浅谈关于Android 系统的开源设计以及生态环境。 
1. 应用反编译漏洞：APK 包非常容易被反编译成可读
    
                                
    • 
                                
  • C#根据网址生成静态页面
                                    hvt
Web.netC#asp.nethovertree
                                    
    HoverTree开源项目中HoverTreeWeb.HVTPanel的Index.aspx文件是后台管理的首页。包含生成留言板首页，以及显示用户名，退出等功能。根据网址生成页面的方法： 
  
bool CreateHtmlFile(string url, string path)
{ 
//http://keleyi.com/a/bjae/3d10wfax.htm

stri
    
                                
    • 
                                
  • SVG 教程 （一）
                                    天梯梦
svg
                                    
    SVG 简介   
SVG 是使用 XML 来描述二维图形和绘图程序的语言。  学习之前应具备的基础知识： 
继续学习之前，你应该对以下内容有基本的了解： 
 
 HTML 
 XML 基础 
 
如果希望首先学习这些内容，请在本站的首页选择相应的教程。  什么是SVG？ 
 
 SVG 指可伸缩矢量图形 (Scalable Vector Graphics) 
 SVG 用来定义用于网络的基于矢量
    
                                
    • 
                                
  • 一个简单的java栈
                                    luyulong
java数据结构栈
                                    
    
public class MyStack {
	private long[] arr;

	private int top;

	public MyStack() {
		arr = new long[10];
		top = -1;
	}

	public MyStack(int maxsize) {
		arr = new long[maxsize];
		top 
    
                                
    • 
                                
  • 基础数据结构和算法八：Binary search
                                    sunwinner
AlgorithmBinary search
                                    
    Binary search needs an ordered array so that it can use array indexing to dramatically reduce the number of compares required for each search, using the classic and venerable binary search algori
    
                                
    • 
                                
  • 12个C语言面试题，涉及指针、进程、运算、结构体、函数、内存，看看你能做出几个！
                                    刘星宇
c面试
                                    
    12个C语言面试题，涉及指针、进程、运算、结构体、函数、内存，看看你能做出几个！ 
1.gets()函数 
问：请找出下面代码里的问题： 
#include<stdio.h> 
int main(void) 
{ 
    char buff[10]; 
    memset(buff,0,sizeof(buff)); 
 

    
                                
    • 
                                
  • ITeye 7月技术图书有奖试读获奖名单公布
                                    ITeye管理员
活动ITeye试读
                                    
    ITeye携手人民邮电出版社图灵教育共同举办的7月技术图书有奖试读活动已圆满结束，非常感谢广大用户对本次活动的关注与参与。 
 
 
7月试读活动回顾： 
http://webmaster.iteye.com/blog/2092746 
 
 
本次技术图书试读活动的优秀奖获奖名单及相应作品如下（优秀文章有很多，但名额有限，没获奖并不代表不优秀）： 
 
 
《Java性能优化权威指南》 
 
 
    
                                
    •