精华内容
下载资源
问答
  • 串口通信通过Tcp传到服务器实现串口数据转发

    千次阅读 热门讨论 2018-10-29 18:52:39
    主要目的:通过串口获取外设的数据转发服务器进行处理并在Web端显示设备的信息。 主要用到的知识点: 第一:串口通信相关的知识。 1.串口通信用到的两个头文件: #include <QtSerialPort/QSerialPort>...

    主要目的:通过串口获取外设的数据,转发到服务器进行处理并在Web端显示设备的信息。

    主要用到的知识点:

    第一:串口通信相关的知识。

    1.串口通信用到的两个头文件:

    #include <QtSerialPort/QSerialPort>
    #include <QtSerialPort/QSerialPortInfo>
    

    QSerialPort:用于访问串口,并对串口进行操作。

    QSerialPortInfo:提供了系统中存在的串口的信息。

    2.工程文件(.pro)中加下面一行代码:

    QT       += serialport
    

    注意:工程文件中添加上述代码后,要保存后才能生效,方法:在QT Creator中文件—保存所有文件。

    第二:Tcp通信相关知识。

    1.Tcp通信用到的头文件:

    #include <QTcpSocket>
    

    2.需要.pro文件中加入下面代码:

    QT       += network
    

     代码实现:

    第一:设计模块截图

              下面的红色是各个控件的QbjectNname,在代码要用到,为了方便读者方便阅读所以都标记出来了。下面“发送”按钮是预留按钮,在代码中没有用到,准备在后面的更新中再优化用到此按钮哦。

    第二:代码展示

    #-------------------------------------------------
    #
    # Project created by QtCreator 2019-09-30T15:51:56
    #
    #-------------------------------------------------
    
    QT       += core gui network serialport
    
    greaterThan(QT_MAJOR_VERSION, 4): QT += widgets
    
    TARGET = qianxunSerialPort
    TEMPLATE = app
    
    
    SOURCES += main.cpp\
            widget.cpp
    
    HEADERS  += widget.h
    
    FORMS    += widget.ui
    

    注意:QT += core gui network serialport,一定要添加后在文件中保存,不然会出问题的哦。

    widget.h:
    
    #ifndef WIDGET_H
    #define WIDGET_H
    
    #include <QWidget>
    #include <QTcpSocket>
    #include<QHostAddress>
    #include<QDebug>
    #include<QSerialPort>
    #include<QSerialPortInfo>
    #include<QTextCodec>
    #include<QByteArray>
    namespace Ui {
    class Widget;
    }
    
    class Widget : public QWidget
    {
        Q_OBJECT
    
    public:
        explicit Widget(QWidget *parent = 0);
        ~Widget();
        void InitTcp();
        void InitPort();
        void doProcessWrite();
        void doProcessTcpWrite();
        void writeByteArray();
    private slots:
        void doProssConnected();
        void doProcessReadyRead();
        void doProssDisconnected();
        void doProcessSerialRead();
    
    private slots:
        void on_pushButton_clicked();
    
        void on_ConnectBtn_clicked();
    
        //void on_SendBtn_clicked();
    
        void on_ClearBtn_clicked();
    
        void on_CheckBtn_clicked();
    
    private:
        Ui::Widget *ui;
        QTcpSocket *myTcpSocket;
        bool pushBtnFlag=false;
        QSerialPort *mySerial;
        QByteArray tempStr;//保存的从服务器获取的字节流
        QByteArray readComDataMsg;//保存从串口获取的字节流
    };
    
    #endif // WIDGET_H
    
    main.cpp:
    
    #include "widget.h"
    #include <QApplication>
    
    int main(int argc, char *argv[])
    {
        QApplication a(argc, argv);
        Widget w;
        w.show();
        w.setWindowTitle("串口转Tcp工具");
        return a.exec();
    }
    
    widget.cpp:
    
    #include "widget.h"
    #include "ui_widget.h"
    #include<QFile>
    Widget::Widget(QWidget *parent) :
        QWidget(parent),
        ui(new Ui::Widget)
    {
        ui->setupUi(this);
        //初始化端口
        InitPort();
        //初始化Tcp
        InitTcp();
       // ui->SendBtn->setEnabled(false);
    
    }
    Widget::~Widget()
    {
        delete ui;
    }
    void Widget::InitTcp()
    {
        myTcpSocket=new QTcpSocket(this);
        //由于connectToHost没有返回值,所以通过三个connect来判断和服务器的状态
        connect(myTcpSocket,SIGNAL(disconnected()),this,SLOT(doProssDisconnected()));
        connect(myTcpSocket,SIGNAL(connected()),this,SLOT(doProssConnected()));
        connect(myTcpSocket,SIGNAL(readyRead()),this,SLOT(doProcessReadyRead()));
    }
    //点击打开Tcp连接服务器
    void Widget::on_pushButton_clicked()
    {
        if(ui->pushButton->text()=="打开TCP")
        {
            QString ServceIp=ui->lineEdit_IP->text();
            QString ServcePort=ui->lineEdit_Port->text();
            myTcpSocket->connectToHost(QHostAddress(ServceIp),ServcePort.toUInt());
            ui->pushButton->setText("关闭TCP");
        }
        else if(ui->pushButton->text()=="关闭TCP")
        {
          myTcpSocket->close();
          ui->pushButton->setText("打开TCP");
          ui->textEdit_Client->append("TCP关闭成功!");
        }
    }
    void Widget::doProssConnected()
    {
        QString str="打开服务器成功";
        ui->textEdit_Client->append(str);
    }
    void Widget::doProcessReadyRead()
    {
        QTcpSocket *myTcpSocket=(QTcpSocket *)this->sender();
        //读取服务器向缓冲区的存储数据
        while (!myTcpSocket->atEnd())
        {
         tempStr= myTcpSocket->readAll();
       // tempStr=QString::fromLocal8Bit(tempMsg);
         qDebug()<<"服务器向缓冲区存储字节数据";
        }
        //处理向串口写入数据
        doProcessWrite();
        writeByteArray();
    
    }
    void Widget::doProssDisconnected()
    {
    //    QString msg="服务器断开";
    //    ui->textEdit_Client->append(msg);
        ui->pushButton->setText("关闭TCP");
    
    }
    //向服务器写入数据。
    void Widget::doProcessTcpWrite()
    {
        if(!readComDataMsg.isEmpty())
        {
         int ret= myTcpSocket->write(readComDataMsg);
         readComDataMsg.clear();
           if(ret<0)
           {
               return;
           }
        }
        else{
             qDebug()<<"向服务器写入数据失败";
        }
    
    }
    
    
    //........................................................................
    //.............................串口.......................................
    void Widget::InitPort()
    {
        mySerial = new QSerialPort(this);
        foreach (const QSerialPortInfo&info,QSerialPortInfo::availablePorts())
        {
    
            QSerialPort serial;
            serial.setPort(info);
            //串口每打开一次就要close一次,不然下次打不开。
            qDebug()<<"#######";
            if(serial.open(QIODevice::ReadWrite))
            {
            ui->ComBC->addItem(info.portName());
            serial.close();
            }
        }
    
        QStringList baudList;//波特率
        baudList<<"115200"<<"57600"<<"38400"<<"19200"<<"9600"<< "4800"<<"2400"<<"1200";
        ui->BaudCB->addItems(baudList);
        QStringList dataBitsList;
        dataBitsList<<"8"<<"7"<<"6"<<"5";
        ui->DataBitsCB->addItems(dataBitsList);
        QStringList parityList;
        parityList<<"无校验"<<"奇校验"<<"偶校验";
        ui->ParityCB->addItems(parityList);
        QStringList stopBitsList;
        stopBitsList<<"1"<<"1.5"<<"2";
        ui->StopCB->addItems(stopBitsList);
        QStringList setFlowCtrl;
        setFlowCtrl<<"off"<<"RTS/CTS"<<"XON/XOFF";
        ui->FlowsCB->addItems(setFlowCtrl);
        //ui->SendBtn->setEnabled(false);
    }
    void Widget::on_ConnectBtn_clicked()
    {
        if(ui->ConnectBtn->text()=="串口连接")
          {
           mySerial->setPortName(ui->ComBC->currentText());
           qDebug()<<"***********";
           bool openSerial= mySerial->open(QIODevice::ReadWrite);
    
           if(openSerial)
            {
                //设置波特率
                if ( ui->BaudCB->currentText()=="115200")
                {
                    mySerial->setBaudRate(QSerialPort::Baud115200);
                }
                    //qDebug()<<"115200";
                else if ( ui->BaudCB->currentText()==" 9600")
                {
                     mySerial->setBaudRate(QSerialPort::Baud9600);
                }
                else if ( ui->BaudCB->currentText()==" 1200")
                {
                    mySerial->setBaudRate(QSerialPort::Baud1200);
                   }
                 else if ( ui->BaudCB->currentText()==" 2400")
                  {
                     mySerial->setBaudRate(QSerialPort::Baud2400);
                    }
                else if ( ui->BaudCB->currentText()==" 4800")
                {
    
                    mySerial->setBaudRate(QSerialPort::Baud4800);
                 }
                 else if ( ui->BaudCB->currentText()==" 19200")
                {
                     mySerial->setBaudRate(QSerialPort::Baud19200);
                 }
                else if ( ui->BaudCB->currentText()==" 38400")
                {
                    mySerial->setBaudRate(QSerialPort::Baud38400);
                 }
                else if ( ui->BaudCB->currentText()==" 57600")
                {
                    mySerial->setBaudRate(QSerialPort::Baud57600);
                 }
    
                //设置数据位
                if (ui->DataBitsCB->currentText()=="8")
    
                      mySerial->setDataBits(QSerialPort::Data8);
                else if (ui->DataBitsCB->currentText()=="7")
    
                     mySerial->setDataBits(QSerialPort::Data7);
                else if (ui->DataBitsCB->currentText()=="6")
    
                     mySerial->setDataBits(QSerialPort::Data6);
                else if (ui->DataBitsCB->currentText()=="5")
    
                    mySerial->setDataBits(QSerialPort::Data5);
    
                //设置校验位
                if (ui->ParityCB->currentText()=="0")
                     mySerial->setParity(QSerialPort::NoParity);
                else  if (ui->ParityCB->currentText()=="2")
                    mySerial->setParity(QSerialPort::EvenParity);
                else if (ui->ParityCB->currentText()=="3")
                     mySerial->setParity(QSerialPort::OddParity);
    
                //停止位
                if (ui->StopCB->currentText()=="1")
    
                    mySerial->setStopBits(QSerialPort::OneStop);
                 else if (ui->StopCB->currentText()=="3")
                      mySerial->setStopBits(QSerialPort::OneAndHalfStop);
                 else if (ui->StopCB->currentText()=="2")
                    mySerial->setStopBits(QSerialPort::TwoStop);
                //流控制
                if (ui->FlowsCB->currentText()=="0")
    
                     mySerial->setFlowControl(QSerialPort::NoFlowControl);
                else if (ui->FlowsCB->currentText()=="1")
                    mySerial->setFlowControl(QSerialPort::HardwareControl);
                else if (ui->FlowsCB->currentText()=="2")
                    mySerial->setFlowControl(QSerialPort::SoftwareControl);
            }
           connect(mySerial,SIGNAL(readyRead()),this,SLOT(doProcessSerialRead()));
           QString msg1="log gpgga ontime 5\r\n";
           QString msg2="interfacemode auto auto on\r\n";
           //mySerial->write(msg1+msg2);
           mySerial->write(msg1.toLatin1());
           mySerial->write(msg2.toLatin1());
            ui->ConnectBtn->setText("串口关闭");
            ui->BaudCB->setEnabled(false);
            ui->DataBitsCB->setEnabled(false);
            ui->FlowsCB->setEnabled(false);
            ui->ParityCB->setEnabled(false);
            ui->StopCB->setEnabled(false);
            ui->ComBC->setEnabled(false);
          }
        else if(ui->ConnectBtn->text()=="串口关闭")
            {
              mySerial->close();
              ui->ConnectBtn->setText("串口连接");
              ui->BaudCB->setEnabled(true);
              ui->DataBitsCB->setEnabled(true);
              ui->FlowsCB->setEnabled(true);
              ui->ParityCB->setEnabled(true);
              ui->StopCB->setEnabled(true);
              ui->ComBC->setEnabled(true);
            }
    }
    //读取串口的数据
    void Widget::doProcessSerialRead()
    {
         readComDataMsg = mySerial->readAll();
    
         QString str=QString::fromLocal8Bit(readComDataMsg);
         QString strTemp=str.replace(QString("\r\n"),QString(" "));
         ui->textEdit_Servce->append(strTemp);
         //ui->textEdit_Servce->setText(readComDataMsg);
    //     }
           doProcessTcpWrite();
          // readComData.clear();
    
    }
    //void Widget::on_SendBtn_clicked()
    //{
    //    //QString serialTemp=ui->textEdit_Client->toPlainText();
    //   QString serialTemp="log versionb ontime 1\r\n";
    //    //QString serialTemp="log gpgga ontime 1 \r\n";
    //    //qDebug()<<serialTemp;
    //   int ret= mySerial->write(serialTemp.toLatin1());
    //   qDebug()<<ret;
    //   qDebug()<<serialTemp;
    //   if(ret<0)
    //   {
    //       qDebug()<<ret;
    //   }
    //}
    void Widget::on_ClearBtn_clicked()
    {
        ui->textEdit_Servce->clear();
        ui->textEdit_Client->clear();
    }
    //向串口写入数据
    void Widget::doProcessWrite()
    {
    
        if(!tempStr.isEmpty())
        {
            qDebug()<<"向串口写入数据正确";
    //        char *ch=tempStr.data();
    //    int ret= mySerial->write(ch);
          mySerial->write(tempStr);
          int byteLen= mySerial->bytesToWrite();
          qDebug()<<"写数据的大小:"<<byteLen;
          //qDebug()<<"这个是向串口写入数据:"<<mySerial;
    //       if(tempStr.size()<0)
    //       {
    //           return;
    //       }
        }
        else{
             qDebug()<<"向串口写入数据错误";
            return;
        }
        QString str=QString::fromLocal8Bit(tempStr);
        QString strReplace= str.replace(QString("\r\n"),QString(""));
        if(!strReplace.isEmpty())
        {
        ui->textEdit_Client->append(strReplace);
        //qDebug()<<strReplace;
        }
        else {
             return;
        }
        //tempStr.clear();
    }
    
    void Widget::writeByteArray()
    {
        //写二进制文件
           QFile file("D://testBase.txt");
           if(!file.open(QIODevice::WriteOnly | QIODevice::Append))
           {
               qDebug() << "Can't open file for writing";
           }
    //       QDataStream out(&file);
    //       out.setVersion(QDataStream::Qt_5_6);
    //       out << tempStr;
           qDebug()<<"向文件写入数据正确";
           file.write(tempStr);
           file.close();
           tempStr.clear();
    }
    //刷新串口
    void Widget::on_CheckBtn_clicked()
    {
        ui->ComBC->clear();
        foreach (const QSerialPortInfo&info,QSerialPortInfo::availablePorts())
        {
    
            QSerialPort serial;
            serial.setPort(info);
            if(serial.open(QIODevice::ReadWrite))
            {
            ui->ComBC->addItem(info.portName());
            serial.close();
            }
        }
    }
    

     

    代码思路梳理:从服务器获取字节流保存在tempStr全局变量中,然后写入到串口,从串口中获取的数据保存在readComDataMsg全局变量中,写入到服务器和在界面上显示。

    继续优化的问题:

    1.进行大量串口数据的转发,运行一天软件正常运行,数据转发正常,可以优化成多线程间通信,拓展知识。

    2.doProcessWrite()/doProcessTcpWrite()这两个函数时直接调用的,应该使用Qt的风格,用emit发送信号,使用信号和槽函数模式。

           欢迎有问题的小伙伴或者对代码有见解的,多多交流哦。

     

     

     

     

     

     

    展开全文
  • 数据转发服务器

    2013-01-25 15:04:37
    本地游戏只能连接127.0.0.1,转发服务作为虚拟的游戏服务器,接收本地游戏客户端发来的数据,并模拟了一个客户端发送到服务器服务器接收到消息后,再回复到虚拟服务中,虚拟服务器再次将内容转发给本地游戏客户端 ...
  • 应用SOCKS服务器实现P2P转发

    千次阅读 2009-03-19 10:40:00
    服务器转发是解决两个子网内主机直接通信的最后办法,在STUN协议当中定义了相关规范,不过看了一下SOCKS代理服务器协议,觉得也可以实现,具体方法如下:需要被连接的一方首先通过BIND操作在代理服务器上面开辟一个...

    服务器转发是解决两个子网内主机直接通信的最后办法,在STUN协议当中定义了相关规范,不过看了一下SOCKS代理服务器协议,觉得也可以实现,具体方法如下:

    需要被连接的一方首先通过BIND操作在代理服务器上面开辟一个监听端口,然后通过外部数据通道将代理服务器上的监听地址传给peer,peer就可以连接上了。

    展开全文
  • 实现该通信的基本思路是:利用servlet服务器进行数据转发,利用android设备(手机)长连接本文已定时器来模拟长连接,实现了两部android手机内网通信。 1、作为终端的设备的设备主要是一个开机启动后就启动的一...

    实现该通信的基本思路是:利用servlet服务器进行数据转发,利用android设备(手机)长连接本文已定时器来模拟长连接,实现了两部android手机内网通信。


    1、作为终端的设备的设备主要是一个开机启动后就启动的一个服务,按照一定的时间间隔用http协议去请求服务器,查询服务器的状态,如果连接服务器,获得的相应是开启GPS信息收集,则在这个服务里开启已经安装在该android手机上的GPS信息收集APP,然后通过Http的GET方式源源不断的向服务器传递GPS信息。

    关键代码如下:

    public class RunningServiceByPowerOn extends Service {
    	private SharedPreferences mPreferences;
    	public RunningServiceByPowerOn() {
    		// TODO Auto-generated constructor stub
    	}
    
    	@Override
    	public IBinder onBind(Intent intent) {
    		// TODO Auto-generated method stub
    		return null;
    	}
    	@Override
    	public void onCreate() {
    		// TODO Auto-generated method stub
    		super.onCreate();
    		mPreferences=getSharedPreferences("Config",MODE_PRIVATE);
    		 timerTaskforGpsSwitch();
    	}
    	
    	/**
    	 * 每隔5s查询一次
    	 */
    	private void timerTaskforGpsSwitch(){
    		  Timer timer = new Timer();
    		  Date d2 = new Date(System.currentTimeMillis());	
    		  timer.schedule(new TimerTask() {
    			
    			@Override
    			public void run() {
    				Log.i("是否开启GPS收集","定时器开启");
    				String spec="http://"+ConentValues.serverIp+":8080/MyServer/StartAction?mAction=find_gps_switcher1";
    				URL url;
    				 String str=null;
    				try {
    					url = new URL(spec);
    					 str=HttpToServierUtils.connect(url);
    					 if(str!=null&&str.equals("GPS_start")){
    							//开启GPS服务
    						 Log.i("是否开启GPS收集","开启GPS信息收集服务");
    							//Toast.makeText(getApplicationContext(),"开启GPS信息收集服务",0).show();
    						 //开启一个应用
    						 if(mPreferences.getBoolean("isStop", true)){
    							 Intent intent = new Intent(Intent.ACTION_MAIN);
    							 intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
    							 intent.addCategory(Intent.CATEGORY_LAUNCHER);            
    							 ComponentName cn = new ComponentName("com.yqq.gpsinfolocationstartreceiver", "com.yqq.gpsinfolocationstartreceiver.MainActivity");            
    							 intent.setComponent(cn);
    							 startActivity(intent);
    							 mPreferences.edit().putBoolean("isStop", false).commit();
    						 }
    						 
    						
    						}
    					 if(str!=null&&str.equals("GPS_stop")){
    						 mPreferences.edit().putBoolean("isStop",true).commit();
    					 }
    						
    				} catch (MalformedURLException e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
    				
    			
    				
    			}
    		},d2, 5000);
    	}
    
    }

    Gps信息收集的关键代码:

    public class GpsInfoCollectionService extends Service {
    	
    	private Boolean D=true;
    	private GPSinfoDao mGpSinfoDao;
    	private LocationManager mLocationManager;
    	private Location mLocation;
    	Criteria criteria;
    	private String provider;
    	public GpsInfoCollectionService() {
    		
    	}
    
    	@Override
    	public IBinder onBind(Intent intent) {
    		if(D){
    			Log.i("GPS服务数据收集","IBinder()");
    		}
    		return null;
    	}
    	@Override
    	public void onCreate() {
    		if(D){
    			Log.i("GPS服务数据收集","onCreate()");
    		}
    		super.onCreate();
     mLocationManager=(LocationManager)getSystemService(Context.LOCATION_SERVICE);  
     criteria = new Criteria();
     criteria.setAccuracy(Criteria.ACCURACY_FINE);//获取精确的位置.
     criteria.setAltitudeRequired(true);
     criteria.setBearingRequired(true);
     criteria.setCostAllowed(true);
     criteria.setPowerRequirement(Criteria.POWER_LOW);
     criteria.setSpeedRequired(true);
            //判断GPS是否正常启动  
            if(!mLocationManager.isProviderEnabled(LocationManager.GPS_PROVIDER)){  
                Toast.makeText(this, "请开启GPS导航...", Toast.LENGTH_SHORT).show();  
              
                //返回开启GPS导航设置界面  
                Intent intent = new Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS);
                intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
                startActivity(intent);   
    		
    	
            }
        	mGpSinfoDao=new GPSinfoDao(getApplicationContext());
        	timerTaskforGpsSwitch();
    		
    	}
    	@Override
    	public int onStartCommand(Intent intent, int flags, int startId) {
    		if(D){
    			Log.i("GPS服务数据收集","onStartCommand()");
    		}
    		  
    	        
    	         provider = mLocationManager.getBestProvider(criteria, true);
    	         Log.i("<<<<",provider);
    		
    	     		
    	        mLocationManager.requestLocationUpdates(provider, 300, 0.01f, new LocationListener() {
    				
    				@Override
    				public void onStatusChanged(String provider, int status, Bundle extras) {
    					// TODO Auto-generated method stub
    					
    				}
    				
    				@Override
    				public void onProviderEnabled(String provider) {
    					// TODO Auto-generated method stub
    					
    				}
    				
    				@Override
    				public void onProviderDisabled(String provider) {
    					// TODO Auto-generated method stub
    					
    				}
    				
    				@Override
    				public void onLocationChanged(Location location) {
    					if(location==null){
    						return;
    					}
    					//updateLocation(location);
    					mLocation=location;
    					new AsyncTask<Void, Void, Void>() {
    						private String str=null;
    						@Override
    						protected Void doInBackground(Void... params) {
    							
    							String height=mLocation.getAltitude()+"";
    							String longitude=mLocation.getLongitude()+"";
    							String latitude=mLocation.getLatitude()+"";
    							String name="Test";
    							//http://172.22.122.1:8080/MyServer/MyTest?longitude=111&latitude=222&height=1000&name=Test
    							//通过http向服务器传递数据
    							String spec="http://"+ConentValues.serverIp+":8080/MyServer/MyTest?longitude="+longitude+"&latitude="+latitude+"&height="+height+"&name="+name;
    							URL url;
    							try {
    								url = new URL(spec);
    								 str=HttpToServierUtils.connect(url);
    							} catch (MalformedURLException e) {
    								// TODO Auto-generated catch block
    								e.printStackTrace();
    							}
    						
    							/*GpsInfo info=new GpsInfo();
    								info.setLongitude(longitude+"");
    								info.setLatitude(latitude+"");
    								info.setHeight(height+"");
    								mGpSinfoDao.addGpsInfo(info);
    								info=null;*/
    							return null;
    						}
    						@Override
    						protected void onPostExecute(Void result) {
    							
    							
    							Toast.makeText(getApplicationContext(), str,0).show();
    							
    						};
    						
    					}.execute();
    	        
    	    
    				}
    				
    	        });
    		return super.onStartCommand(intent, flags, startId);
    	}
    	
    	@Override
    	public void onDestroy() {
    		if(D){
    			Log.i("GPS服务数据收集","onDestroy()");
    		}
    		mGpSinfoDao=null;
    		mLocationManager=null;
    		mLocation=null;
    		super.onDestroy();
    	}
    	
    	/**
    	 * 每隔5s查询一次
    	 */
    	private void timerTaskforGpsSwitch(){
    		  Timer timer = new Timer();
    		  Date d2 = new Date(System.currentTimeMillis());	
    		  timer.schedule(new TimerTask() {
    			
    			@Override
    			public void run() {
    				Log.i("终端信息收集","定时器开启");
    				String spec="http://"+ConentValues.serverIp+":8080/MyServer/MyTest?mAction=find_gps_switcher";
    				URL url;
    				 String str=null;
    				try {
    					url = new URL(spec);
    					 str=HttpToServierUtils.connect(url);
    					/* if(str!=null&&str.equals("GPS_start")){
    							//开启GPS服务
    						 Log.i("终端信息收集","开启GPS信息收集服务");
    							//Toast.makeText(getApplicationContext(),"开启GPS信息收集服务",0).show();
    						}*/
    						if(str!=null&&str.equals("GPS_stop")){
    							Log.i("终端信息收集","停止GPS信息收集服务");
    							//Toast.makeText(getApplicationContext(),"关闭GPS信息收集服务",0).show();
    							//关闭GPS服务
    							//getSharedPreferences("Config",MODE_PRIVATE).edit().putBoolean("isStarted", false).commit();
    							stopSelf();
    							System.exit(0);
    							
    						}
    				} catch (MalformedURLException e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				}
    				
    			
    				
    			}
    		},d2, 5000);
    	}
    
    }

    2、服务端利用servlet来处理各自的请求和响应

    关键代码:

    (1)处理GPS信息上传到服务器的servlet

    public class MyTest extends HttpServlet {
    	//private List<GpsInfo> infos;
    	
    	private GpsInfo info;
    	@Override
    	protected void doGet(HttpServletRequest req, HttpServletResponse resp)
    			throws ServletException, IOException {
    		doPost(req, resp);
    	
    	}
    
    	@Override
    	protected void doPost(HttpServletRequest req, HttpServletResponse resp)
    			throws ServletException, IOException {
    		req.setCharacterEncoding("UTF-8");
    		resp.setContentType("text/html;charset=utf-8");
    		resp.setCharacterEncoding("utf-8");
    		PrintWriter  out=resp.getWriter();
    		String nameAction=(String)req.getAttribute("nameAction");
    		
    		
    		//String spec="http://"+ConentValues.serverIp+":8080/MyServer/MyTest?longitude="+longitude+"&latitude="+latitude+"&height="+height;			
    		String longitude=req.getParameter("longitude");
    		String latitude=req.getParameter("latitude");
    		String height=req.getParameter("height");
    		String name=req.getParameter("name");
    		
    		String mAction=req.getParameter("mAction");
    		//查询服务器端数据库并获得返回值
    		
    		
    	
    		if(mAction!=null&&mAction.equals("find_gps_switcher")){
    			System.out.println("定时器服务查询:"+mAction);
    		try {
    			
    			String result=DbUtis.getGPSStaus();
    			if(result!=null&&result.equals("start_gps")){
    				out.write("GPS_start");
    				out.flush();
    			}
    			if(result!=null&&result.equals("end_gps")){
    				out.write("GPS_stop");
    				out.flush();
    			}
    		} catch (SQLException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    			
    				
    				
    				
    			
    		}
    		
    		try {
    			 //上传的服务器的数据
    		
    			
    			
    			if(longitude!=null&&latitude!=null&&height!=null){
    				info=new GpsInfo();
    				info.setLongitude(longitude);
    				info.setLatitude(latitude);
    				info.setHeight(height);
    				info.setName(name);
    				DbUtis.insertGpsInfos(info);
    				System.out.println("游客终端上传的数据:"+info.toString());
    				
    				
    			
    			
    			
    				out.write("GPS数据已经上传到服务器");
    				
    				
    				out.flush();
    			}
    			
    				
    			
    				
    			
    			
    	
    		} catch (SQLException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}finally{
    			/*if(out!=null){
    				out.close();
    			}*/
    			
    			
    		}
    		
    	}
    
    }
    

    (2)
    /**
     * 处理gps开关信息的servlet
     * @author yqq_coder
     *
     */
    public class GpsOnOffAction extends HttpServlet {
    	@Override
    	protected void doPost(HttpServletRequest req, HttpServletResponse resp)
    			throws ServletException, IOException {
    		//开启GPS收集
    		String gpsSend=req.getParameter("namegpsend");
    		//关闭GPS终端收集服务
    		String gpsstop=req.getParameter("namegpsstop");
    		PrintWriter out=resp.getWriter();
    		//开启GPS收集
    		if(gpsSend!=null&&gpsSend.equals("start_gps")){
    			System.out.println("GPS信息收集指令:"+gpsSend);
    			out.write("终端GPS信息收集开启");
    			try {
    				DbUtis.deleteGpsSatus();
    				DbUtis.insertGpsSatus("start_gps");
    			} catch (SQLException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    			// req.setAttribute("nameAction", "GPS_start");
    			// req.getRequestDispatcher("/MyTest").forward(req, resp);  
    		}else
    		//关闭GPS终端收集服务
    		if(gpsstop!=null&&gpsstop.equals("end_gps")){
    			System.out.println("GPS信息关闭指令:"+gpsstop);
    			out.write("终端GPS信息收集关闭");
    			try {
    				DbUtis.deleteGpsSatus();
    				DbUtis.insertGpsSatus("end_gps");
    			} catch (SQLException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    			
    			//req.setAttribute("nameAction", "GPS_stop");
    			 //req.getRequestDispatcher("/MyTest").forward(req, resp);  
    		}
    		out.flush();
    		
    	}
    	@Override
    	protected void doGet(HttpServletRequest req, HttpServletResponse resp)
    			throws ServletException, IOException {
    		
    	doPost(req, resp);
    	}
    	@Override
    	protected void service(HttpServletRequest req, HttpServletResponse resp)
    			throws ServletException, IOException {
    		// TODO Auto-generated method stub
    		super.service(req, resp);
    	}
    	
    
    }
    
    /**
     * 查询GPS信息
     * @author yqq_coder
     *
     */
    public class QurAction extends HttpServlet {
    	private JSONArray infos;
    	@Override
    	protected void doPost(HttpServletRequest req, HttpServletResponse resp)
    			throws ServletException, IOException {
    		//轨迹显示参数
    		String s = req.getParameter("namereq");
    		PrintWriter out=resp.getWriter();
    		//查询
    		//http://172.22.122.1:8080/MyServer/MyTest?namereq=Test
    		if(s!=null){
    			
    		 out=resp.getWriter();
    			System.out.println(s);
    			try {
    				infos=DbUtis.getData(s);
    				System.out.println("返回客户端的数据:"+infos.toString());
    				
    				out.write(infos.toString());
    				
    					
    				out.flush();
    			} catch (SQLException e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}finally{
    				
    				if(out!=null){
    					out.close();
    				}
    			}
    			
    			
    		}
    		
    	
    		
    	}
    	
    	@Override
    	protected void doGet(HttpServletRequest req, HttpServletResponse resp)
    			throws ServletException, IOException {
    		// TODO Auto-generated method stub
    		doPost(req, resp);
    	}
    	
    	
    
    }

    /**
     * 处理是否开启GPS信息收集的servlet
     * @author yqq_coder
     *
     */
    public class StartAction extends HttpServlet {
    	
    	@Override
    	protected void doGet(HttpServletRequest req, HttpServletResponse resp)
    			throws ServletException, IOException {
    		doPost(req, resp);
    	
    	}
    
    	@Override
    	protected void doPost(HttpServletRequest req, HttpServletResponse resp)
    			throws ServletException, IOException {
    		req.setCharacterEncoding("UTF-8");
    		resp.setContentType("text/html;charset=utf-8");
    		resp.setCharacterEncoding("utf-8");
    		PrintWriter  out=resp.getWriter();
    		String nameAction=(String)req.getAttribute("nameAction");
    		
    		
    		
    		
    		String mAction=req.getParameter("mAction");
    		//查询服务器端数据库并获得返回值
    		
    		
    	
    		if(mAction!=null&&mAction.equals("find_gps_switcher1")){
    			System.out.println("定时器服务查询:"+mAction);
    		try {
    			
    			String result=DbUtis.getGPSStaus();
    			if(result!=null&&result.equals("start_gps")){
    				out.write("GPS_start");
    				out.flush();
    			}
    			if(result!=null&&result.equals("end_gps")){
    				out.write("GPS_stop");
    				out.flush();
    			}
    		} catch (SQLException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}finally{
    			if(out!=null){
    				out.close();
    		}
    			
    				
    				
    				
    			
    		}
    		
    		
    		}
    			
    			
    		
    	}
    
    }
    

    数据库工具类:

    
    
    import java.sql.DriverManager;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import java.sql.Connection;
    import java.sql.PreparedStatement;
    import java.sql.Statement;
    import java.util.ArrayList;
    import java.util.List;
    
    
    
    import org.json.JSONArray;
    import org.json.JSONException;
    import org.json.JSONObject;
    
    
    
    
    
    public class DbUtis {
    	private static String ip="192.168.1.134";
    	private static Connection conn;
    
    	public static JSONArray getData(String name) throws SQLException {
    		List<GpsInfo> infos = new ArrayList<GpsInfo>();
    		JSONArray array = new JSONArray();
    		GpsInfo info = null;
    		JSONObject jsonObject = null;
    		PreparedStatement pstmt =null;
    		ResultSet rs = null;
    		// 连接数据库
    		try {
    			Class.forName("com.mysql.jdbc.Driver");
    			// 链接数据库
    			conn =   DriverManager.getConnection(
    					"jdbc:mysql://"+ip+":3306/test", "root", "admin");
    			// Statement stmt =(Statement) conn.prepareStatement("");
    			String sql="select name,longitude,latitude from gpsinfos where name=?";
    			pstmt=  conn.prepareStatement(sql);
    			pstmt.setString(1, name);
    			rs = pstmt.executeQuery();
    			
    			// 从结果集里取值
    			//System.out.println(rs.getRow());
    			while (rs.next()) {
    
    				// info=new GpsInfo();
    				// info.setLatitude(rs.getString(0));//纬度
    				// info.setLongitude(rs.getString(1));
    				// infos.add(info);
    				// info=null;
    				jsonObject = new JSONObject();
    				try {
    					jsonObject.put("name", rs.getString("name"));
    					jsonObject.put("longitude", rs.getString("longitude"));
    					jsonObject.put("latitude", rs.getString("latitude"));
    					array.put(jsonObject);
    					jsonObject=null;
    				} catch (JSONException e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();
    				} 
    
    			}
    			
    
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}finally {
    			
    			if (rs != null) {
    				rs.close();
    				rs = null;
    			}
    			if(pstmt!=null)
    			{
    				pstmt.close();
    				pstmt = null;
    			}
    			if (conn != null) {
    				conn.close();
    				conn = null;
    			}
    		}
    
    		return array;
    
    	}
    	
    	public static String getGPSStaus() throws SQLException {
    		String result=null;
    		PreparedStatement pstmt =null;
    		ResultSet rs = null;
    		// 连接数据库
    		try {
    			Class.forName("com.mysql.jdbc.Driver");
    			// 链接数据库
    			conn =   DriverManager.getConnection(
    					"jdbc:mysql://"+ip+":3306/test", "root", "admin");
    			// Statement stmt =(Statement) conn.prepareStatement("");
    			String sql="select gps_staus from gps_switcher ";
    			pstmt=  conn.prepareStatement(sql);
    			
    			rs = pstmt.executeQuery();
    			
    			// 从结果集里取值
    			//System.out.println(rs.getRow());
    			while (rs.next()) {
    				result=rs.getString("gps_staus");
    				
    			
    			}
    			
    			
    			return result;
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}finally {
    			
    			if (rs != null) {
    				rs.close();
    				rs = null;
    			}
    			if(pstmt!=null)
    			{
    				pstmt.close();
    				pstmt = null;
    			}
    			if (conn != null) {
    				conn.close();
    				conn = null;
    			}
    		}
    
    		return null;
    
    	}
    	
    	
    	public static void insertGpsInfos(GpsInfo info) throws SQLException{
    		PreparedStatement pstmt = null; // 数据库表达式
    	        ResultSet rs = null; // 结果集
    	        try {
    	            /*加载驱动*/
    	        	//192.168.173.1
    	            Class.forName("com.mysql.jdbc.Driver");
    	            /*连接到数据库*/
    	            conn =   DriverManager.getConnection(
    	                    "jdbc:mysql://"+ip+":3306/test", "root", "admin");
    	            String sql = "insert into gpsinfos (name,longitude,latitude) values (?,?,?)";
    	            /* 获取表达式*/
    	             pstmt =  conn.prepareStatement(sql);
    	             pstmt.setString(1,info.getName());
    	            pstmt.setString(2, info.getLongitude());
    	            pstmt.setString(3, info.getLatitude());
    	            /*  插入数据*/
    	           pstmt.execute();
    	            /* 执行SQL*/
    	            rs = pstmt.executeQuery("select * from gpsinfos");
    	            /* 查看里面的数据*/
    	            while (rs.next()) {
    	            	 System.out.println("插入的数据姓名=" + rs.getString("name"));
    	                System.out.println("插入的数据经度=" + rs.getString("longitude"));
    	                System.out.println("插入的数据纬度=" + rs.getString("latitude"));
    	            }        
    	        } catch (SQLException ex) {
    	            ex.printStackTrace();
    	        } catch (Exception e) {
    	            // TODO Auto-generated catch block
    	            e.printStackTrace();
    	        }finally{
    	        	
    	        	if(rs!=null){
    	        		rs.close();
    	        	}
    	        	if(pstmt!=null)
    				{
    					pstmt.close();
    					pstmt = null;
    				}
    	        	
    	        	if(conn!=null){
    	        		conn.close();
    	        	}
    	        	
    	        	
    	        }
    	    }
    		
    	
          
    	
    	
    	public static void insertGpsSatus(String staus) throws SQLException{
    		PreparedStatement pstmt = null; // 数据库表达式
    	        ResultSet rs = null; // 结果集
    	        try {
    	            /*加载驱动*/
    	        	//192.168.173.1
    	            Class.forName("com.mysql.jdbc.Driver");
    	            /*连接到数据库*/
    	            conn =   DriverManager.getConnection(
    	                    "jdbc:mysql://"+ip+":3306/test", "root", "admin");
    	            String sql = "insert into gps_switcher (gps_staus) values (?)";
    	            /* 获取表达式*/
    	             pstmt =  conn.prepareStatement(sql);
    	             pstmt.setString(1,staus);
    	           
    	            /*  插入数据*/
    	           pstmt.execute();
    	            /* 执行SQL*/
    	            rs = pstmt.executeQuery("select * from gps_switcher");
    	            /* 查看里面的数据*/
    	            while (rs.next()) {
    	            	 System.out.println("插入的数据GPS状态=" + rs.getString("gps_staus"));
    	              
    	            }        
    	        } catch (SQLException ex) {
    	            ex.printStackTrace();
    	        } catch (Exception e) {
    	            // TODO Auto-generated catch block
    	            e.printStackTrace();
    	        }finally{
    	        	
    	        	if(rs!=null){
    	        		rs.close();
    	        	}
    	        	if(pstmt!=null)
    				{
    					pstmt.close();
    					pstmt = null;
    				}
    	        	
    	        	if(conn!=null){
    	        		conn.close();
    	        	}
    	        	
    	        	
    	        }
    	    }
    		
    	
    	
    	public static void deleteGpsSatus() throws SQLException{
    		PreparedStatement pstmt = null; // 数据库表达式
    	        ResultSet rs = null; // 结果集
    	        try {
    	            /*加载驱动*/
    	        	//192.168.173.1
    	            Class.forName("com.mysql.jdbc.Driver");
    	            /*连接到数据库*/
    	            conn =   DriverManager.getConnection(
    	                    "jdbc:mysql://"+ip+":3306/test", "root", "admin");
    	            String sql="delete from gps_switcher";  
    	         
    	             pstmt =  conn.prepareStatement(sql);
    	           
    	         
    	          
    	           pstmt.execute();
    	          
    	        } catch (SQLException ex) {
    	            ex.printStackTrace();
    	        } catch (Exception e) {
    	            // TODO Auto-generated catch block
    	            e.printStackTrace();
    	        }finally{
    	        	
    	        	if(rs!=null){
    	        		rs.close();
    	        	}
    	        	if(pstmt!=null)
    				{
    					pstmt.close();
    					pstmt = null;
    				}
    	        	
    	        	if(conn!=null){
    	        		conn.close();
    	        	}
    	        	
    	        	
    	        }
    	    }
    		
    	
    	
    	
    	
    	public static void createTable() throws SQLException{
    		try {
    			//Class.forName("com.mysql.jdbc.Driver");
    			Connection conn =  DriverManager.getConnection("jdbc:mysql://"+ip+":3306/test","root","admin");
    
    			String sql = "CREATE TABLE gpsinfos (id int primary key auto_increment, name varchar(64) not null, longitude varchar(256) not null , latitude varchar(256) not null );";
    			//CREATE TABLE gpsinfos (id int primary key auto_increment, gps_staus varchar(16) not null)
    			//gps_switcher(id int primary key auto_increment, gps_staus varchar(16) not null unique)
    			PreparedStatement pstmt =  conn.prepareStatement(sql);
    			pstmt.executeUpdate();
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		
    	}
    	
    
    	public static void main(String[]args) throws SQLException{
    		/*
    		try {
    			createTable();
    		} catch (SQLException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		
    		try {
    			
    		} catch (SQLException e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}
    		*/
    		//insertGpsInfos(new GpsInfo("小强","5225.1111111","5333333.888222"));
    		System.out.println(DbUtis.getData("Lihua"));
    	}
    }
    


    控制端主要是发送几个GET方式的请求,这里就不再贴代码了。

    几个请求:

    "http://"+ConentValues.serverIp+":8080/MyServer/MyTest?mAction=find_gps_switcher";

    "http://"+ConentValues.serverIp+":8080/MyServer/StartAction?mAction=find_gps_switcher1";

    http://172.22.122.1:8080/MyServer/MyTest?longitude=111&latitude=222&height=1000&name=Test

    http://172.22.122.1:8080/MyServer/MyTest?namereq=Test

    demo下载地址:http://download.csdn.net/detail/u014600432/8209931


    展开全文
  •  参考spydroid源码,花了一上午的编码,用java在PC上完成了rtsp服务器实现了VLC与服务器的交互。 大致流程: 1、服务器端,开启一个线程监听客户端VLC请求。VLC请求地址 rtsp://192.168.1.38:8086/

    http://blog.csdn.net/xiaoliouc/article/details/8517051

            参考spydroid源码,花了一上午的编码,用java在PC上完成了rtsp服务器,实现了VLC与服务器的交互。

    大致流程:

    1、服务器端,开启一个线程监听客户端VLC请求。VLC请求地址  rtsp://192.168.1.38:8086/

    2、当VLC请求服务器的时候,服务器开启一个workerThread,完成一次rtsp的会话交互

    3、rtsp交互包括options,describe,setup,play,teardown,pause 6个部分。

    4、在setup的时候,开启streaming流,在这里开启一个线程,接收android客户端发送过来的rtp数据,并转发到VLC

    5、VLC正常播放

     

               现在大致完成了服务器功能,但效果很差,延迟很严重,通过接收数据并转发,开始VLC还能播放,后面还存在问题。总算完成了大体流程,特此庆祝一下。


    后记:这种做法没什么作用,只是让我深入的了解了rtsp交互流程。实际项目还是考虑实时流推送到流媒体服务器,播放端通过地址播放。

     

     


     


    展开全文
  • 本人小白,刚接触网络编程。想知道怎么实现服务器在接收到一个客户端的数据后再转发给另一个客户端,在此基础上再实现两个客户端通过服务器实现数据的交流。我用的腾讯的云服务器。不涉及到数据库的那种
  • 存储方面,由于容器内部并不适合做数据持久化,所以一般通过挂载卷的方式将数据保存在服务器磁盘上。 但是服务器也不能保证绝对安全,所以数据也需要备份到云上。 代理转发 默认情况下容器之间的网络是互相隔离的,...
  • 我们将应用以Docker容器的方式部署到服务器上...存储方面,由于容器内部并不适合做数据持久化,所以一般通过挂载卷的方式将数据保存在服务器磁盘上。 但是服务器也不能保证绝对安全,所以数据也需要备份到云上。 代...
  • HttpServletRequest代表客户端的请求,用户通过Http协议访问服务器,HTTP请求中的所有信息会被封装到HttpServletRequest,通过这个HttpServletRequest的方法,获得客户端的所有信息; 1.获取前端传递的参数:...
  • eBPF/sockmap实现socket转发offload

    千次阅读 2019-12-25 22:46:24
    我们已经对eBPF将网络转发...通过代理服务器在两个TCP接连之间转发数据是一个非常常见的需求,特别是在CDN的场景下,然而这个代理服务器也是整条路径中的瓶颈之所在,代理服务器的七层转发行为极大地消耗着单机性...
  • 一张网卡接收UDP协议数据,再通过另外一张网卡发送出去。防火墙的映射应该也可以实现这需求,这里不研究了。 服务器配置了两个地址,一个外网地址 192.168.1.200 ,内网地址是10.10.1.1 。 # -* - coding: UTF-8 -* ...
  • 如标题,接收到了tcp服务器数据后,想转发给客户端。但是socket.io文档似乎没有这种方法。直接上代码。 服务器部分: **var express=require('express'); var app=express(); var fs =require('fs'); var ...
  •  调度器把请求报文通过IP隧道(相当于ipip或ipsec)转发至真实服务器,而真实服务器将响应处理后直接返回给客户,这种调度器只处理请求的入站报文,一般网络服务应答数据比请求报文大很多,采用VS/TUN技术后,集群...
  • java通过netty实现代理服务器

    万次阅读 2018-01-10 16:42:54
    因为是用BIO的一个连接一个线程去处理,对于HTTP这种短连接协议来说CPU开销是非常大的,就算加入了线程池也不能完美解决BIO的缺陷,所以可以用NIO进行服务器的优化,NIO基于IO多路复用以实现单线程处理大量连接,但是...
  • 我想要实现两部安卓客户端的实时语音通讯,安卓客户端都在内网,因此需要一外网pc做数据的中转服务器,安卓语音发送端通过audiotrack录制PCM音频数据并实时发送到服务器服务器接收数据并不断读入一个缓冲区,开启...
  • 想法:将数据保存在request中后,转发给另一个服务器中的项目,实现跨域问题。 失败:转发服务器内部的一次请求,如果希望跳转页面到外部链接,可以使用重定向。 request.getRequestDispatcher("URL").forward ...
  • 专门有一台机器装了双网卡用于数据转发。集群的大致结构是这样的: 对外IP(外网网卡IP):220.240.80.253 对内IP(内网网卡IP):10.0.38.200 tomcat+nginx服务器IP:10.0.38.144 外网请求->对外IP->对内IP->...
  • 本文目的实现Openwrt自动ssh数据转发,内部局域网用户可随时通过此ssh实现代***理上网,安装步骤: 1.Openwrt自带dropbear转发SSH只能监听本地端口,首先安装openssh客户端。 1 2 3 4 rm
  • 如何实现服务器转发请求第三方接口的数据,也是node服务器解决跨域的问题通过localhost转发接口 https://m.maizuo.com/v4/api/film/now-playing?__t=1523003169298&page=1&count=5 的数据,代码实例如下:...
  • 接收到客户端的数据转发到连接的服务器上面。 通过该工具的编码,也正好练习了一下Qt的socket编程(服务器/客户端),是个 不错的例子,欢迎大家来Emil索取源码,共同学习! Emil:wuquan-1230@163.com
  • 树莓派4B将接收到的数据转发给阿里云服务器ECS;阿里云服务器ECS对接收到的数据进行处理,存入mysql数据库;最后通过Navicat远程连接数据库,使用SSM框架搭建上位机系统对采集到的数据状态进行实时显示
  • 服务器性能数据收集

    2012-07-23 16:26:17
    2、此文仅仅实现数据的收集,不能统计出图。 简单说明: 通过sar命令来实现信息收集的功能,配合计划任务完成任务。 步骤说明: 1、网络配置 确保服务器可联网,可解析域名。相关配置如下: 配置好外网地址、...
  • SpringMVC中的重定向和转发实现

    千次阅读 2019-01-13 15:35:52
    请求转发服务器内部的跳转 地址栏不发生变化 只有一个请求响应 可以通过request域传递数据 请求重定向是浏览器自动发起对跳转目标的请求 地址栏会发生变化 两次请求响应 无法通过request域传递对象 ...
  • 目前主流的网游服务器实现机制是采用TCP的前置连接服务器分担广播压力。好处是可以通过增加前置连接服务器的数量增加负载能力,但是其发送延迟却不是最优的。 首先,TCP的可靠性保证,流量控制机制在保证可靠传输...
  •  通过服务器跳转到页面上,有两种实现方式:一种是转发,一种是重定向。  我们知道转发可以携带数据,而重定向无法携带数据,所以,要想携带数据跳转页面,必须通过转发实现。 3.解决方案  通过request对象的...
  • 通过使用令人敬畏的ftp-srv节点库和实现内存文件系统来实现这一点,作为 FTP DropBox 工作,像真实发生一样确认每个命令。 包括CWD、CHDIR、.. 描述 ftp2telegram 是一个独立的 FTP 服务器,它接受上传的图像、...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 678
精华内容 271
关键字:

通过服务器实现数据转发