好不容易写出来的，以后做参考！
h5 利用socketchannel发送请求
function shopping_socket_test(sendJson){
var receiveMsgJson = "";
var SocketChannel = plus.android.importClass("java.nio.channels.SocketChannel");
var Selector = plus.android.importClass("java.nio.channels.Selector");
var SelectionKey = plus.android.importClass("java.nio.channels.SelectionKey");
var InetSocketAddress = plus.android.newObject("java.net.InetSocketAddress","192.168.1.135",2001);
var ByteBuffer = plus.android.importClass("java.nio.ByteBuffer");
var Iterator = plus.android.importClass("java.util.Iterator");
var ByteArrayOutputStream = plus.android.importClass("java.io.ByteArrayOutputStream");
var channel = null;
var selector = null;
try{
channel = SocketChannel.open();
plus.android.invoke(channel,"configureBlocking",false);
selector = Selector.open();
plus.android.invoke(channel,"register",selector,SelectionKey.OP_CONNECT);
plus.android.invoke(channel,"connect",InetSocketAddress);
var isOver = false;
while(isOver == false){
plus.android.invoke(selector,"select");
var ite_keys = selector.selectedKeys();
plus.android.importClass(ite_keys);
var ite = ite_keys.iterator();
while(plus.android.invoke(ite,"hasNext")){
var selected_key = plus.android.invoke(ite,"next");
plus.android.invoke(ite,"remove");
if(plus.android.invoke(selected_key,"isConnectable")){
if(plus.android.invoke(channel,"isConnectionPending")){
if(plus.android.invoke(channel,"finishConnect")){
plus.android.invoke(selected_key,"interestOps",SelectionKey.OP_READ);
var sendMessage = plus.android.invoke(sendJson,"getBytes","UTF-8");
plus.android.invoke(channel,"write",ByteBuffer.wrap(sendMessage));
}
}else{
plus.android.invoke(selected_key,"cancel");
console.log("cancel")
}
}else if(plus.android.invoke(selected_key,"isReadable")){
var channel = plus.android.invoke(selected_key,"channel");
var buffer = ByteBuffer.allocate(1024);
var baos = new ByteArrayOutputStream();
var size = 0;
while ((size = plus.android.invoke(channel,"read",buffer)) > 0) {
buffer.flip();
baos.write(buffer.array(),0,size);
buffer.clear();
}
baos.close();
receiveMsgJson = baos.toString();
console.log(receiveMsgJson);
isOver = true;
}
}
}
}catch(e){
//TODO handle the exception
receiveMsgJson = "error:服务器没有开启,请确认!";
console.log(e);
}finally{
if(channel != null){
try {
channel.close();
} catch (e) {
console.log(e);
}
}
if(selector != null){
try {
selector.close();
} catch (e) {
console.log(e);
}
}
}
console.log(receiveMsgJson);
return receiveMsgJson;
}
后台的做法：PosInterfaceSocketThread
package com.ccl.cloud.system.listener;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.Socket;
import java.text.MessageFormat;
import java.util.Date;
import java.util.List;
import org.apache.log4j.Logger;
import org.jeecgframework.core.util.ExceptionUtil;
import org.jeecgframework.p3.core.utils.common.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import com.ccl.cloud.system.entity.TSTouristEntity;
import com.ccl.cloud.system.service.TSTouristServiceI;
import net.sf.json.JSONObject;
public class PosInterfaceSocketThread extends Thread{
private static final Logger logger = Logger.getLogger(PosInterfaceSocketThread.class);
@Autowired
private TSTouristServiceI tSTouristService;
/**erp 地址与port*/
private static final String ERP_IP = "127.0.0.1";
private static final int ERP_PORT = 2000;
private Socket clientSocket;
public PosInterfaceSocketThread(Socket clientSocket){
this.clientSocket = clientSocket;
}
public void run(){
BufferedReader bufferedReader = null;
OutputStreamWriter outputStreamWriter = null;
try {
// 接受客户端的请求,获得输入流,获得客户端的请求
bufferedReader = new BufferedReader(new InputStreamReader(clientSocket.getInputStream()));
String requestMsg = bufferedReader.readLine();
System.out.println("request:" + requestMsg);
// 发送消息给erp,并获得返回的信息
String responseMsg = recAndSendErpSocketMessage(ERP_IP,ERP_PORT,requestMsg);
System.out.println("respone:" + responseMsg);
// 判断是否收银员登录，如果是，则发送"开始"请求，并登录到本地服务器
if(StringUtils.isNotBlank(requestMsg)){
// 收银员登录
if(requestMsg.startsWith("LOGINCERTIFY")){
responseMsg = sendLoginRequest(requestMsg,responseMsg);
}
}
// 将信息返回给pos端
outputStreamWriter = new OutputStreamWriter(clientSocket.getOutputStream(),"UTF-8");
outputStreamWriter.write(responseMsg);
outputStreamWriter.flush();
if (null != outputStreamWriter){
outputStreamWriter.close();
}
if(null != bufferedReader){
bufferedReader.close();
}
} catch (IOException e) {
//e.printStackTrace();
logger.error(ExceptionUtil.getExceptionMessage(e));
}
}
/**
* 发送消息给erp,并获得返回的信息
* @param ip
* @param port
* @param receiveMessage
* @return String
*/
private String recAndSendErpSocketMessage(String ip,int port,String receiveMessage){
String response_json = "";
try{
Socket socket = new Socket(ip,port);
socket.setSoTimeout(60*1000); // 1分钟
// 发送给erp或者客户端
OutputStreamWriter outputStreamWriter = new OutputStreamWriter(socket.getOutputStream(),"UTF-8");
outputStreamWriter.write(receiveMessage);
outputStreamWriter.flush();
// 从erp中接受数据
InputStreamReader inputStreamReader = new InputStreamReader(socket.getInputStream(),"UTF-8");
int msg = 0;
while((msg = inputStreamReader.read()) != -1){
response_json += (char)msg;
}
inputStreamReader.close();
outputStreamWriter.close();
socket.close();
}catch(IOException e){
// e.printStackTrace();
logger.error(ExceptionUtil.getExceptionMessage(e));
response_json = "error:erp服务超时了,请确认!";
}
return response_json;
}
/**
* 判断是否收银员登录，如果是，则发送"开始"请求，并登录到本地服务器
* @param requestMsg
* @param responseMsg
* @return
*/
private String sendLoginRequest(String requestMsg,String responseMsg){
// 判断返回的数据，如果retflag = 0，则登录到本地服务器
JSONObject responseJson = JSONObject.fromObject(responseMsg);
String retflag = responseJson.get("retflag").toString();
if("0".equals(retflag)){
JSONObject requestJson = JSONObject.fromObject(requestMsg);
String posno = requestJson.getString("posno");
String operator = requestJson.getString("operators");
// "开始"请求发送
String startShoppingRequestFormat =
"POSCERTIFY${\"operators\":\"{0}\",\"posno\":\"{1}\",\"flag\":\"0\"}";
String startShoppingRequest =
MessageFormat.format(startShoppingRequestFormat, new Object[]{"["+operator+"]","["+posno+"]"});
System.out.println("startShoppingRequest:" + startShoppingRequest);
// 发送消息给erp,并获得返回的信息
String startShoppingResp = recAndSendErpSocketMessage(ERP_IP,ERP_PORT,startShoppingRequest);
System.out.println("startShoppingResp:" + startShoppingResp);
// 判断返回的数据
JSONObject startShoppingRespJson = JSONObject.fromObject(startShoppingResp);
retflag = startShoppingRespJson.get("retflag").toString();
String flowno = startShoppingRespJson.get("flow_no").toString();
if("1".equals(retflag)){
// 异常
responseMsg = startShoppingResp;
}else{
// 登录本地服务器
boolean isLogin = cashierLogin(posno,flowno);
if(!isLogin){
responseMsg = "LOGININFO${\"operators\":\""+operator+"\",\"retflag\":\"1\",\"retmsg\":\"本地服务器登录异常!\"}";
}
}
}
System.out.println("responseMsg:" + responseMsg);
return responseMsg;
}
/**
*
* @param posno
* @param flowno
* @return
*/
private boolean cashierLogin(String posno,String flowno) {
// 判断当天是否登录
boolean isLogin = false;
String sqlSelect = "select * from t_s_tourist where DATE_ADD(createTime,INTERVAL 1 day) >= now() and isTourist = '2'";
List<TSTouristEntity> selList =
this.tSTouristService.findListbySql(sqlSelect);
if(null != selList && 0 != selList.size()){
isLogin = true;
}
if(isLogin){
// 24h内存在登录
isLogin = true;
}else{
TSTouristEntity tSTourist = new TSTouristEntity();
// 24h内没有登录，则登录
// 创建时间
tSTourist.setCreateTime(new Date());
// 是否是游客
tSTourist.setIsTourist("2");
// posno
tSTourist.setUuid(posno);
// 交易流水号
tSTourist.setFlowno(flowno);
tSTouristService.save(tSTourist);
}
return isLogin;
}
}
PosInterfaceSocketThreadChat.java
package com.ccl.cloud.system.listener;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;
import java.net.Socket;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.SocketChannel;
public class PosInterfaceSocketThreadChat extends Thread{
private SelectionKey key;
private String ERP_IP;
private int ERP_PORT;
public PosInterfaceSocketThreadChat(SelectionKey key,String erp_ip,int erp_port){
this.key = key;
this.ERP_IP = erp_ip;
this.ERP_PORT = erp_port;
}
public void run(){
// 服务器可读取消息:得到事件发生的Socket通道
SocketChannel channel = (SocketChannel) key.channel();
// 创建读取的缓冲区
ByteBuffer buffer = ByteBuffer.allocate(1024);
//把读取到的缓冲区内容存入到流内，到最后一次性取出来，建议定义自定义协议先传内容长度然后再传内容，就可以根据长度建立对应长度缓冲区然后读取数据
ByteArrayOutputStream baos = new ByteArrayOutputStream();
try {
int size = 0;
while ((size = channel.read(buffer)) > 0) {
buffer.flip();
baos.write(buffer.array(),0,size);
buffer.clear();
}
baos.close();
System.out.println("服务器当前处理线程："+Thread.currentThread().getName()+" 服务端收到信息："+baos.toString());
// 发送数据到erp，并从erp服务器中获得数据
String receiveMsg = recAndSendErpSocketMessage(this.ERP_IP,this.ERP_PORT,baos.toString());
byte[] content = receiveMsg.getBytes("UTF-8");
//byte[] content=baos.toByteArray();
System.out.println("content:"+content);
ByteBuffer writeBuf = ByteBuffer.allocate(content.length);
writeBuf.put(content);
writeBuf.flip();
channel.write(writeBuf);// 将消息回送给客户端
if(size==-1){
//System.out.println("客户端断开。。。");
channel.close();
}else{
//没有可用字节,继续监听OP_READ
key.interestOps(key.interestOps()|SelectionKey.OP_READ);
key.selector().wakeup();
}
}catch (Exception e) {
System.out.println(e.getMessage());
}
/*try{
// 获取客户端传输数据可读取消息通道。
SocketChannel channel = (SocketChannel)key.channel();
//创建读取数据缓冲器
ByteBuffer buffer = ByteBuffer.allocate(1024);
channel.read(buffer);
byte[] data = buffer.array();
String message = new String(data);
if(buffer.position() != 0){
// 向pos端发送 从erp返回的消息
sendPortSocketMessage(channel,message);
// 向erp发消息并接受从erp返回的消息
//String receiveMsg = recAndSendErpSocketMessage(ERP_IP,ERP_PORT,message);
// 向pos端发送 从erp返回的消息
//sendPortSocketMessage(channel,receiveMsg);
}
}catch(Exception e){
e.printStackTrace();
}*/
}
/**
* 发送消息给pos
* @param socketChannel
* @param message
* @throws UnsupportedEncodingException
*/
private void sendPortSocketMessage(SocketChannel socketChannel,String message) throws Exception{
byte[] bytes = message.getBytes();
ByteBuffer writeBuffer = ByteBuffer.allocate(bytes.length);
writeBuffer.put(bytes);
writeBuffer.flip();
socketChannel.write(writeBuffer);
System.out.println("writeBuffer:"+writeBuffer);
}
/**
* 发送消息给erp
* @param ip
* @param port
* @param receiveMessage
* @return String
*/
private String recAndSendErpSocketMessage(String ip,int port,String receiveMessage){
String barcode_json = "";
try{
Socket socket = new Socket(ip,port);
//socket.setSoTimeout(60*1000); // 1分钟
// 发送给erp或者客户端
OutputStreamWriter outputStreamWriter = new OutputStreamWriter(socket.getOutputStream(),"UTF-8");
outputStreamWriter.write(receiveMessage);
outputStreamWriter.flush();
// 从erp中接受数据
InputStreamReader inputStreamReader = new InputStreamReader(socket.getInputStream(),"UTF-8");
int msg = 0;
while((msg = inputStreamReader.read()) != -1){
barcode_json += (char)msg;
}
inputStreamReader.close();
outputStreamWriter.close();
socket.close();
}catch(IOException e){
e.printStackTrace();
barcode_json = "error:超时了,请确认!";
}
return barcode_json;
}
}
159
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
