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

颖辉小居 发布于 2015/12/05 17:32
阅读 824
收藏 0
我是个java程序员。在做一个项目的服务端开发,客户端为手机app,使用的http协议传输json数据来实现数据交互业务处理,现在又加入了一个C++的视屏监控客户端,需要我提供手机端的用户信息及位置信息,以及各种交互。要求使用tcp协议。请问我该怎么做?C++的客户端也是会有数据获取和修改的操作的,本来我开发的服务端是javaweb整合了SSH框架,事务统一由spring来管理。C++的客户端以及安卓客户端操作的是相同的数据。我不知道会不会出现什么问题。我不懂C++。求大神帮帮忙,我该怎么实现啊?
加载中
1
东向利
东向利
能写的就这么多了。你要搞清楚Spring,Netty就没有问题了。我一直在用Netty4.x,多动手,少犹豫
1
蛋看江湖
蛋看江湖

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

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

0
颖辉小居
颖辉小居

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

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

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

我不会用netty 没有其他的办法了吗?我对TCP的了解还是简单的使用soket 以及ECHO,可以使用TCP提供各种服务借口吗?我了解到的TCP只能客户端和服务端连接起来打个招呼,传个文件什么的。感觉很笨只能完成一个功能。怎么能实现各种不同的业务与交互呢?

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

引用来自“东向利”的评论

如楼上所说,使用Netty实现短连接还是很方便的。简单配置就可以实现TCP通信,你只要负责报文解析和业务处理,网络通信层实现Netty已经完整封装。由Netty调用sping bean (scopt=pro)这样就可以保证事务。TCP不是一个笨东西,它要比HTTP更灵活,更具性能。HTTP是在TCP基础上封装的应用协议。与C++客户端通信时,注意字节顺的问题,还有编码统一。
我看了Netty的样例,是写在main方法里的,我的服务端是基于servlet的要在tomcat 里启动运行。我不知道怎么把Netty相关的东西整合到tomcat里。还有关于SSH框架不能管理Netty相关服务的事务。也不受过滤器 拦截器管理吧
清风傲剑
清风傲剑
用netty就根本不需要用tomcat了
东向利
东向利
写一个Server类,当Bean来处理,使用spring的prePost和Destroy注解,完成服务的启动与停止。
0
公孙二狗
公孙二狗

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

0
东向利
东向利
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>






0
淡淡的幽情
淡淡的幽情
rpc 服务 thift跨语言远程访问接口就可以了
0
yak
yak
cto具体都干啥?
返回顶部
顶部