我们的CTO给我提出一个这样的难题不知道怎么解决？

Question

我是个java程序员。在做一个项目的服务端开发，客户端为手机app，使用的http协议传输json数据来实现数据交互业务处理，现在又加入了一个C++的视屏监控客户端，需要我提供手机端的用户信息及位置信息，以及各种交互。要求使用tcp协议。请问我该怎么做？C++的客户端也是会有数据获取和修改的操作的，本来我开发的服务端是javaweb整合了SSH框架，事务统一由spring来管理。C++的客户端以及安卓客户端操作的是相同的数据。我不知道会不会出现什么问题。我不懂C++。求大神帮帮忙，我该怎么实现啊？

Answer 1

cto具体都干啥?

Answer 2

rpc 服务 thift跨语言远程访问接口就可以了

Answer 3

要用什么不是CTO定吗？只定功能的话那还是CTO吗？

Answer 4

package com.ennew.api.socket.engine.server;

import com.ennew.api.conf.network.domain.SocketStatus;
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.group.ChannelGroup;
import io.netty.channel.group.ChannelGroupFuture;
import io.netty.channel.group.DefaultChannelGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.util.concurrent.GlobalEventExecutor;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.Date;
import java.util.Map;

public class MySocketServer implements SocketServer {
	
	private static final Logger logger = LoggerFactory.getLogger(MySocketServer.class);
	
	private int port;
	
	private Date startTime;
	
	private SocketStatus status;
	
	private ChannelGroup channelGroup;
	
	private ChannelInitializer<SocketChannel> channelInitalizer;

	private NioEventLoopGroup bossGroup;
	
	private NioEventLoopGroup workerGroup;
	
	private Map<ChannelOption<?>, Object> channelOptions;

	
	public MySocketServer(int port) {
		this.port = port;
		this.startTime = null;
		this.status = SocketStatus.STOP;
		channelGroup = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);
	}
	
	@SuppressWarnings({ "unchecked", "rawtypes" })
	public ServerBootstrap bootstrap() {
		 ServerBootstrap b = new ServerBootstrap();
		 b.group(this.bossGroup, this.workerGroup)
		  .channel(NioServerSocketChannel.class)
		  .childHandler(this.getChannelInitalizer());

		 for (ChannelOption option : channelOptions.keySet()) {
			 b.option(option, channelOptions.get(option));
		 }
		 return b;
	}


	public void run() throws Exception {
		try {
			this.status = SocketStatus.RUNNING;
			this.startTime = new Date();
			
			ServerBootstrap bootstrap = bootstrap();
			ChannelFuture f = bootstrap.bind(port).sync();
			channelGroup.add(f.channel());
			logger.info("Bind() has complete for {}", this.port);
		} catch (Exception ee) {
			logger.error("Bind() error: {}", ee.getMessage());
			this.startTime = null;
			this.status = SocketStatus.ERROR;
		}
	}


	public void shutdown() throws Exception {
		if (channelGroup != null) {
			final ChannelGroupFuture f = channelGroup.close().awaitUninterruptibly();
			f.addListener(ChannelFutureListener.CLOSE);
			this.status = SocketStatus.STOP;
			this.startTime = null;
		}
	}
	
	public SocketStatus getStatus() {
		return this.status;
	}
	
	public void setPort(int port) {
		this.port = port;
	}

	public void setChannelInitalizer(ChannelInitializer<SocketChannel> channelInitalizer) {
		this.channelInitalizer = channelInitalizer;
	}

	public ChannelInitializer<SocketChannel> getChannelInitalizer() {
		return channelInitalizer;
	}

	public void setBossGroup(NioEventLoopGroup bossGroup) {
		this.bossGroup = bossGroup;
	}

	public void setWorkerGroup(NioEventLoopGroup workerGroup) {
		this.workerGroup = workerGroup;
	}

	public int getPort() {
		return port;
	}

	public Date getStartTime() {
		return startTime;
	}

	public void setChannelOptions(Map<ChannelOption<?>, Object> channelOptions) {
		this.channelOptions = channelOptions;
	}

	public ChannelGroup getChannelGroup() {
		return channelGroup;
	}

	public void setChannelGroup(ChannelGroup channelGroup) {
		this.channelGroup = channelGroup;
	}
}

<bean id="utilities_4567" class="com.ennew.api.socket.engine.server.MySocketServer"
		init-method="run" destroy-method="shutdown">
		<constructor-arg name="port" value="4567" />
		<property name="bossGroup" ref="bossGroup" />
		<property name="workerGroup" ref="workerGroup" />
		<property name="channelOptions" ref="channelOptions" />
		<property name="channelInitalizer" ref="chrLengthFieldChannelInitializer" />
	</bean>

	<bean id="chrLengthFieldChannelInitializer" scope="prototype" class="com.ennew.api.socket.engine.channel.ChrLengthFieldChannelInitializer">
		<property name="timeout" value="120" />
		<property name="charsetName" value="GBK" />
		<property name="lengthFieldOffset" value="0" />
		<property name="lengthFieldLength" value="6" />
		<property name="lengthAdjustment" value="-6" />
		<property name="initialBytesToStrip" value="0" />
		<property name="byteOrder" ref="little_order" />
		<property name="failFast" value="true" />
	</bean>
	
	<bean id = "little_order" class="org.springframework.beans.factory.config.FieldRetrievingFactoryBean">
		<property name="staticField" value="java.nio.ByteOrder.LITTLE_ENDIAN" />
	</bean>

	<bean id="workerGroup" class="io.netty.channel.nio.NioEventLoopGroup" destroy-method="shutdownGracefully">
		<constructor-arg type="int" index="0" value="10" />
	</bean>
	
	<bean id="bossGroup" class="io.netty.channel.nio.NioEventLoopGroup" destroy-method="shutdownGracefully">
		<constructor-arg type="int" index="0" value="2" /> 
	</bean>

	<util:map id="channelOptions" map-class="java.util.HashMap"> 
		<entry> 
			<key>
				<util:constant static-field="io.netty.channel.ChannelOption.SO_REUSEADDR"/>
			</key> 
			<value type="java.lang.Boolean">true</value> 
		</entry>
		<entry> 
			<key>
				<util:constant static-field="io.netty.channel.ChannelOption.SO_KEEPALIVE"/>
			</key> 
			<value type="java.lang.Boolean">true</value> 
		</entry> 
		<entry> 
			<key>
				<util:constant static-field="io.netty.channel.ChannelOption.TCP_NODELAY"/>
			</key> 
			<value type="java.lang.Boolean">true</value>
		</entry> 
	</util:map>

Answer 5

写一个Server类，当Bean来处理，使用spring的prePost和Destroy注解，完成服务的启动与停止。

Answer 6

用netty就根本不需要用tomcat了

Answer 7

如楼上所说，使用Netty实现短连接还是很方便的。简单配置就可以实现TCP通信，你只要负责报文解析和业务处理，网络通信层实现Netty已经完整封装。由Netty调用sping 
bean （scopt=pro）这样就可以保证事务。TCP不是一个笨东西，它要比HTTP更灵活，更具性能。HTTP是在TCP基础上封装的应用协议。与C++客户端通信时，注意字节顺的问题，还有编码统一。

Answer 8

引用来自“蛋看江湖”的评论

1,把你们CTO揍一顿，然后统一网络协议为Http＋Json

2,用netty 和C++客户端做长连接，作为网关，每次接收到C++客户端的交互请求直接翻译转发给javaweb服务

Answer 9

1,把你们CTO揍一顿，然后统一网络协议为Http＋Json

2,用netty 和C++客户端做长连接，作为网关，每次接收到C++客户端的交互请求直接翻译转发给javaweb服务

Answer 10

能写的就这么多了。你要搞清楚Spring，Netty就没有问题了。我一直在用Netty4.x，多动手，少犹豫