精华内容
下载资源
问答
  • socket5代理转换为http代理

    千次阅读 2017-09-27 13:12:00
    归根结底还是万恶的ZFW,MD弄得现在Google,gmail,...使用使用socket代理,安卓还好点,root之后装个***就ok了,可是我的5s暂时还没想越狱呢,于是就只有想办法将socket代理转换为http代理了,这样我的5s也就可以翻越GFW...

    归根结底还是万恶的ZFW,MD弄得现在Google,gmail,dropbox都用不了了,看来这是要万民欢迎大中华局域网的到来了.
    最近在使用一同学的***来突破GFW的限制,可是电脑ok了,手机呢,手机还是不行唉.使用使用socket代理,安卓还好点,root之后装个***就ok了,可是我的5s暂时还没想越狱呢,于是就只有想办法将socket代理转换为http代理了,这样我的5s也就可以翻越GFW了.
    好了,废话不多说,下面是软件的下载地址,先去下载下来
    http://sourceforge.net/projects/ijbswa/?source=typ_redirect
    1.修改软件的配置文件,找到找到listen-address这一行修改为
    listen-address 192.168.1.106:8118
    192.168.1.106就是你电脑的ip地址,8118就是http代理的端口.
    2.找到“forward-socks5”这一行,去掉前面的注释标记#,将这一行修改为
    forward-socks5t / 127.0.0.1:1080 .
    1080就是你本地的socket代理端口,一般情况下socket代理都是这个端口吧.
    接下来重启下软件,将你手机的http代理地址设置为你电脑的ip地址,端口设置为上面所设置的端口就好啦.

    转载于:https://www.cnblogs.com/topcoder/p/7601225.html

    展开全文
  • android socket网络通信

    2016-11-29 17:16:24
    Socket通常称为“套接字”,是支持TCP/IP协议的网络通信的基本操作单元。它是网络通信过程中端点的抽象表示,包含进行网络通信必须的五种信息:连接使用的协议,本地主机的IP地址,本地进程的协议端口,远地主机的IP...

             本文为本人由网上搜集的一些资料的修改整合。

    Socket通常称为“套接字”,是支持TCP/IP协议的网络通信的基本操作单元。它是网络通信过程中端点的抽象表示,包含进行网络通信必须的五种信息:连接使用的协议,本地主机的IP地址,本地进程的协议端口,远地主机的IP地址,远地进程的协议端口。Socket字面上的中文意思为“插座”。一台服务器可能会提供很多服务,每种服务对应一个Socket(也可以这么说,每个Socket就是一个插座,客户若是需要哪种服务,就将插头插到相应的插座上面),而客户的“插头”也是一个Socket。Socket是应用层与TCP/IP协议族通信的中间软件抽象层,它是一组接口。Socket把复杂的TCP/IP协议族隐藏在Socket接口后面,对用户来说,一组简单的接口就是全部,让Socket去组织数据,以符合指定的协议。Socket用于描述IP地址和端口,是一个通信链的句柄。应用程序通常通过套接字向网络发出请求或者应答网络请求。

    应用层通过传输层进行数据通信时,TCP会遇到同时为多个应用程序进程提供并发服务的问题。多个TCP连接或多个应用程序进程可能需要通过同一个TCP协议端口传输数据。为了区别不同的应用程序进程和连接,许多计算机操作系统为应用程序与TCP/IP协议交互提供了套接字(Socket)接口。应用层可以和传输层通过Socket接口,区分来自不同应用程序进程或网络连接的通信,实现数据传输的并发服务。

    总之一句话,socket是对TCP/IP协议的封装。

    Socket的基本操作包括:

    连接远程机器

    发送数据

    接收数据

    关闭连接

    绑定端口

    监听到达数据

    在绑定的端口上接受来自远程机器的连接

    服务器要和客户端通信,两者都要实例化一个Socket。服务器和客户端的Socket是不一样的,客户端可以实现连接远程机器、发送数据、接收数据、关闭连接等,服务器还需要实现绑定端口,监听到达的数据,接受来自远程机器的连接。Android在包java.net里面提供了两个类:ServerSocket和Socket,前者用于实例化服务器的Socket,后者用于实例化客户端的Socket。在连接成功时,应用程序两端都会产生一个Socket实例,操作这个实例,完成客户端到服务器所需的会话。

    接下来分析一些重要的Socket编程接口。首先是如何构造一个Socket,常用的构造客户端Socket的方法有以下几种:

    Socket():创建一个新的未连接的Socket。

    Socket(Proxy proxy):使用指定的代理类型创建一个新的未连接的Socket。

    Socket(String dstName,int dstPort):使用指定的目标服务器的IP地址和目标服务器的端口号,创建一个新的Socket。

    Socket(String dstName,int dstPort,InetAddress localAddress,int localPort):使用指定的目标主机、目标端口、本地地址和本地端口,创建一个新的Socket。

    Socket(InetAddress dstAddress,int dstPort):使用指定的本地地址和本地端口,创建一个新的Socket。

    Socket(InetAddress dstAddress,int dstPort,InetAddress localAddress,int localPort):使用指定的目标主机、目标端口、本地地址和本地端口,创建一个新的Socket。

    其中,proxy为代理服务器地址,dstAddress为目标服务器IP地址,dstPort为目标服务器的端口号(因为服务器的每种服务都会绑定在一个端口上面),dstName为目标服务器的主机名。Socket构造函数代码举例如下所示:

    Socket client=new Socket("192.168.1.23", 2012); 
        // 第一个参数是目标服务器的IP地址,2012是目标服务器的端口号
        Socket sock = new Socket(new Proxy(Proxy.Type.SOCKS,
        new InetSocketAddress("test.domain.org", 2130)));
        // 实例化一个Proxy,以该Proxy为参数,创建一个新的Socket

    注意 0~1023端口为系统保留,用户设定的端口号应该大于1023。

    方 法 原 型 功 能 描 述
        Public InputStream getInputStream() 读出该Socket中的数据
        public OutputStream getOutputStream() 向该Socket中写入数据
        public synchronized void close() 关闭该Socket

    上面是构造Socket客户端的几种常用的方法,构造服务器端的ServerSocket的方法有以下几种。

    ServerSocket():构造一个新的未绑定的ServerSocket。

    ServerSocket(int port):构造一个新的ServerSocket实例并绑定到指定端口。如果port参数为0,端口将由操作系统自动分配,此时进入队列的数目将被设置为50。

    ServerSocket(int port,int backlog):构造一个新的ServerSocket实例并绑定到指定端口,并且指定进入队列的数目。如果port参数为0,端口将由操作系统自动分配。

    ServerSocket(int port,int backlog,InetAddress localAddress):构造一个新的ServerSocket实例并绑定到指定端口和指定的地址。如果localAddress参数为null,则可以使用任意地址,如果port参数为0,端口将由操作系统自动分配。

    下面举例说明ServerSocket的构建方法,代码如下所示:

    ServerSocket socketserver=new ServerSocket(2012); 
        // 2012表示服务器要监听的端口号 

    构造完ServerSocket之后,需要调用ServerSocket.accept()方法来等待客户端的请求(因为Socket都是绑定在端口上面的,所以知道是哪个客户端请求的)。accept()方法就会返回请求这个服务的客户端的Socket实例,然后通过返回的这个Socket实例的方法,操作传输过来的信息。当Socket对象操作完毕之后,使用close()方法将其关闭。

    方 法 原 型 功 能 描 述
        public Socket accept () 等待Socket请求,直到连接被打开,该方法返回一个刚刚打开的连接Socket对象
        public void close() 关闭该服务器Socket

    Socket一般有两种类型:TCP套接字和UDP套接字。

    TCP和UDP在传输过程中的具体实现方法不同。两者都接收传输协议数据包并将其内容向前传送到应用层。TCP把消息分解成数据包(数据报,datagrams)并在接收端以正确的顺序把它们重新装配起来,TCP还处理对遗失数据包的重传请求,位于上层的应用层要处理的事情就少多了。UDP不提供装配和重传请求这些功能,它只是向前传送信息包。位于上层的应用层必须确保消息是完整的,并且是以正确的顺序装配的。

    接下来我们分别详细讨论使用TCP和UDP通信的一些细节。

    使用TCP通信

    TCP建立连接之后,通信双方都同时可以进行数据的传输;在保证可靠性上,采用超时重传和捎带确认机制;在流量控制上,采用滑动窗口协议,协议中规定,对于窗口内未经确认的分组需要重传;在拥塞控制上,采用慢启动算法。

    TCP服务器端工作的主要步骤如下。
        步骤1 调用ServerSocket(int port)创建一个ServerSocket,并绑定到指定端口上。
        步骤2 调用accept(),监听连接请求,如果客户端请求连接,则接受连接,返回通信套接字(socket实例)。
        步骤3 调用Socket类的getOutputStream()和getInputStream()获取输出和输入流,开始网络数据的发送和接收。
        步骤4 关闭通信套接字。
        示例代码如下所示:

    ServerSocket serverSocket = null;//创建一个ServerSocket对象
        try {
          // TCP_SERVER_PORT为指定的绑定端口,为int类型
          serverSocket = new ServerSocket(TCP_SERVER_PORT);
          // 监听连接请求
          Socket socket = serverSocket.accept();
          // 放到读Buffer中
          BufferedReader in = new BufferedReader(new
          // 获取输入流
          InputStreamReader(socket.getInputStream()));
          // 放到写Buffer中
          BufferedWriter out = new BufferedWriter(new
          // 获取输出流
          OutputStreamWriter(socket.getOutputStream()));
          // 读取接收信息,转换为字符串
          String incomingMsg = in.readLine() + System.getProperty("line.separator");
          // 生成发送字符串
          String outgoingMsg = "goodbye from port " + TCP_SERVER_PORT +
          System.getProperty("line.separator");
          // 将发送字符串写入上面定义的BufferedWriter中
          out.write(outgoingMsg);
          // 刷新,发送
          out.flush();
          // 关闭
          socket.close();
        } catch (InterruptedIOException e) {
          // 超时错误
          e.printStackTrace();
          // IO异常
        } catch (IOException e) {
          // 打印错误
          e.printStackTrace();
        } finally {
          // 判定是否初始化ServerSocket对象,如果初始化则关闭serverSocket
          if (serverSocket != null) {
                    try {
                        serverSocket.close();
                } catch (IOException e) {
                        e.printStackTrace();
                }
          }
        }
        TCP客户端工作的主要步骤如下。
        步骤1 调用Socket()创建一个流套接字,并连接到服务器端。
        步骤2 调用Socket类的getOutputStream()和getInputStream()方法获取输出和输入流,开始网络数据的发送和接收。
        步骤3 关闭通信套接字。
        编写TCP客户端代码如下所示:
    try {
          // 初始化Socket,TCP_SERVER_PORT为指定的端口,int类型
          Socket socket = new Socket("localhost", TCP_SERVER_PORT);
          // 获取输入流
          BufferedReader in = new BufferedReader(new
          InputStreamReader(socket.getInputStream()));
          // 生成输出流
          BufferedWriter out = new BufferedWriter(new
          OutputStreamWriter(socket.getOutputStream()));
          // 生成输出内容
          String outMsg = "TCP connecting to " + TCP_SERVER_PORT +
          System.getProperty("line.separator");
          // 写入
          out.write(outMsg);
          // 刷新,发送
          out.flush();
          // 获取输入流
          String inMsg = in.readLine() + System.getProperty("line.separator");
          Log.i("TcpClient", "received: " + inMsg);
          // 关闭连接
          socket.close();
          } catch (UnknownHostException e) {
                    e.printStackTrace();
          } catch (IOException e) {
                    e.printStackTrace();
        }
        注意 无论是客户端还是服务器端,都要添加UnknownHostException(处理网络异常)和IOException(处理I/O异常)异常处理。
        在Android配置文件中需要添加下面的权限:
        <uses-permission android:name="android.permission.INTERNET"/>

      使用UDP通信

        UDP有不提供数据报分组、组装和不能对数据包排序的缺点,也就是说,当报文发送之后,是无法得知其是否安全完整到达的。UDP用来支持那些需要在计算机之间传输数据的网络应用,包括网络视频会议系统在内的众多的客户端/服务器模式的网络应用都需要使用UDP协议。UDP协议的主要作用是将网络数据流量压缩成数据报的形式。一个典型的数据报就是一个二进制数据的传输单位。UDP传输原理示意图如图2-6所示。

        

        UDP服务器端工作的主要步骤如下。
        步骤1 调用DatagramSocket(int port)创建一个数据报套接字,并绑定到指定端口上。
        步骤2 调用DatagramPacket(byte[]buf,int length),建立一个字节数组以接收UDP包。
        步骤3 调用DatagramSocket类的receive(),接受UDP包。
        步骤4 关闭数据报套接字。
        示例代码如下所示:

    byte[] lMsg = new byte[MAX_UDP_DATAGRAM_LEN];//接收的字节大小,客户端发送的数据不能超过MAX_UDP_DATAGRAM_LEN
        // 实例化一个DatagramPacket类
        DatagramPacket dp = new DatagramPacket(lMsg, lMsg.length);
        // 新建一个DatagramSocket类
        DatagramSocket ds = null;
        try {
          // UDP服务器监听的端口 
          ds = new DatagramSocket(UDP_SERVER_PORT);
          // 准备接收数据 
          ds.receive(dp);
        } catch (SocketException e) {
          e.printStackTrace();
        } catch (IOException e) {
          e.printStackTrace();
        } finally {
          // 如果ds对象不为空,则关闭ds对象
          if (ds != null) {
                    ds.close();
          }
        }
        UDP客户端工作的主要步骤如下。
        步骤1 调用DatagramSocket()创建一个数据包套接字。
        步骤2 调用DatagramPacket(byte[]buf,int offset,int length,InetAddress address,int port),建立要发送的UDP包。
        步骤3 调用DatagramSocket类的send()发送UDP包。
        步骤4 关闭数据报套接字。
        示例代码如下所示:
    // 定义需要发送的信息
        String udpMsg = "hello world from UDP client " + UDP_SERVER_PORT;
        // 新建一个DatagramSocket对象
        DatagramSocket ds = null;
        try {
          // 初始化DatagramSocket对象
          ds = new DatagramSocket();
          // 初始化InetAddress对象
          InetAddress serverAddr = InetAddress.getByName("127.0.0.1");
          DatagramPacket dp;
          // 初始化DatagramPacket对象
          dp = new DatagramPacket(udpMsg.getBytes(), udpMsg.length(), serverAddr, UDP_SERVER_PORT);
          // 发送
          ds.send(dp);
        }
        // 异常处理
        // Socket连接异常
        catch (SocketException e) {
          e.printStackTrace();
        // 不能连接到主机
        }catch (UnknownHostException e) {
          e.printStackTrace();
        // 数据流异常
        } catch (IOException e) {
          e.printStackTrace();
        // 其他异常
        } catch (Exception e) {
          e.printStackTrace();
        } finally {
          // 如果DatagramSocket已经实例化,则需要将其关闭
          if (ds != null) {
                    ds.close();
          }
        }


    参考文章:http://book.2cto.com/201308/30046.html

     http://www.jb51.net/article/53196.htm

    展开全文
  • 我是新的socket编程,基本上想通过socket编程将多个数据从服务器(带python的PC)发送到我的android应用程序。问题是:1)服务器确认abt 10+连接并停止接收客户端请求。在2)客户端服务器挂起,不打印单个数据。在试图...

    我是新的socket编程,基本上想通过socket编程将多个数据从服务器(带python的PC)发送到我的android应用程序。问题是:

    1)服务器确认abt 10+连接并停止接收客户端请求。在

    2)客户端服务器挂起,不打印单个数据。在

    试图同步异步任务,但似乎表面上不起作用,它应该如何。在

    如果有任何建议能让它发挥作用,我们将不胜感激。在

    ANDROID客户端package com.example.clientserver;

    import java.io.ByteArrayOutputStream;

    import java.io.IOException;

    import java.io.InputStream;

    import java.net.Socket;

    import java.net.UnknownHostException;

    import java.util.concurrent.Semaphore;

    import android.os.AsyncTask;

    import android.os.Bundle;

    import android.app.Activity;

    import android.view.View;

    import android.view.View.OnClickListener;

    import android.widget.Button;

    import android.widget.EditText;

    import android.widget.TextView;

    public class MainActivity extends Activity {

    TextView textResponse;

    EditText editTextAddress, editTextPort;

    Button buttonConnect, buttonClear;

    @Override

    protected void onCreate(Bundle savedInstanceState) {

    super.onCreate(savedInstanceState);

    setContentView(R.layout.activity_main);

    editTextAddress = (EditText) findViewById(R.id.address);

    editTextPort = (EditText) findViewById(R.id.port);

    buttonConnect = (Button) findViewById(R.id.connect);

    buttonClear = (Button) findViewById(R.id.clear);

    textResponse = (TextView) findViewById(R.id.response);

    buttonConnect.setOnClickListener(buttonConnectOnClickListener);

    buttonClear.setOnClickListener(new OnClickListener() {

    @Override

    public void onClick(View v) {

    textResponse.setText("");

    }

    });

    }

    OnClickListener buttonConnectOnClickListener = new OnClickListener() {

    @Override

    public void onClick(View arg0) {

    /*

    * MyClientTask myClientTask = new MyClientTask(

    * editTextAddress.getText().toString(),

    * Integer.parseInt(editTextPort.getText().toString()));

    * myClientTask.execute();

    */

    RealTimeTask realTimeTask = new RealTimeTask(editTextAddress

    .getText().toString(), Integer.parseInt(editTextPort

    .getText().toString()));

    realTimeTask.start();

    }

    };

    public class RealTimeTask {

    String dstAddress;

    int dstPort;

    String response = "";

    RealTimeTask(String addr, int port) {

    dstAddress = addr;

    dstPort = port;

    }

    public void start() {

    int loop = 0;

    Semaphore semaphore = new Semaphore(1);

    while (true) {

    try {

    Thread.sleep((long) 0.1);

    } catch (InterruptedException e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    }

    try {

    semaphore.acquire();

    } catch (InterruptedException e) {

    System.out.println("got interrupted!");

    }

    MyClientTask myClientTask = new MyClientTask(dstAddress,

    dstPort);

    myClientTask.execute();

    semaphore.release();

    loop++;

    }

    }

    }

    public class MyClientTask extends AsyncTask {

    String dstAddress;

    int dstPort;

    String response = "";

    MyClientTask(String addr, int port) {

    dstAddress = addr;

    dstPort = port;

    }

    @Override

    protected Void doInBackground(Void... arg0) {

    Socket socket = null;

    try {

    socket = new Socket(dstAddress, dstPort);

    ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream(

    1024);

    byte[] buffer = new byte[1024];

    int bytesRead;

    InputStream inputStream = socket.getInputStream();

    /*

    * notice: inputStream.read() will block if no data return

    */

    while ((bytesRead = inputStream.read(buffer)) != -1) {

    byteArrayOutputStream.write(buffer, 0, bytesRead);

    response += byteArrayOutputStream.toString("UTF-8");

    }

    } catch (UnknownHostException e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    response = "UnknownHostException: " + e.toString();

    } catch (IOException e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    response = "IOException: " + e.toString();

    } finally {

    if (socket != null) {

    try {

    socket.close();

    } catch (IOException e) {

    // TODO Auto-generated catch block

    e.printStackTrace();

    }

    }

    }

    return null;

    }

    @Override

    protected void onPostExecute(Void result) {

    textResponse.setText(response);

    super.onPostExecute(result);

    }

    }

    }

    PYTHON服务器

    ^{pr2}$

    展开全文
  • Android Socket接口实现即时通讯  最近学习Android 通信的知识,做一个小实例,巩固下学习内容,以下内容是网上找的资料,觉得很不错,知识比较全面,大家看下。  首先了解一下即时通信的概念。通过消息通道 传输...
  • Android Socket编程 一、什么是Socket 什么是socket呢?socket起源于Unix,而Unix/Linux基本哲学之一就是“一切皆文件”,都可以用“打开open –> 读写write/read –> 关闭close”模式来操作。我的理解就是Socket...

    Android Socket编程

    一、什么是Socket

    什么是socket呢?socket起源于Unix,而Unix/Linux基本哲学之一就是“一切皆文件”,都可以用“打开open –> 读写write/read –> 关闭close”模式来操作。我的理解就是Socket就是该模式的一个实现,socket即是一种特殊的文件,一些socket函数就是对其进行的操作(读/写IO、打开、关闭)。

    二、Socket的连接过程

    根据连接启动的方式以及本地Socket要连接的目标,Socket之间的连接过程可以分为三个步骤:服务器监听,客户端请求,连接确认。
    1、服务器监听:是服务器端Socket并不定位具体的客户端Socket,而是处于等待连接的状态,实时监控网络状态。
    2、客户端请求:是指由客户端的Socket提出连接请求,要连接的目标是服务器端的Socket。为此,客户端的Socket必须首先描述它要连接的服务器的Socket,指出服务器端Socket的地址和端口号,然后就向服务器端Socket提出连接请求。
    3、连接确认:是指当服务器端Socket监听到或者说接收到客户端Socket的连接请求,它就响应客户端Socket的请求,建立一个新的线程,把服务器端套接字的描述发给客户端,一旦客户端确认了此描述,连接就建立好了。而服务器端Socket继续处于监听状态,继续接收其他客户端Socket的连接请求。

    三、Android socket的基础知识 

    1.1         Accept Timeout

    Accept timeout 仅对ServerSocket有用。ServerSocket 使用accept()方法来监听客户端Socket的连接。默认,ServerSocket.accept() 方法会一直阻塞直到有客户端来连接。通常,我们不需要设置accept timeout.

     

    但有时候特殊情况,还是要考虑设置accept timeout.

    比如: 程序A给程序B发了一个JMS消息,然后程序A启动一个Socket Server,想通过socket等待接收程序B的返回消息。如果不设置accept timeout, 并且程序B因为某些原因一直不能连接Socket Server,最终会导致程序A挂起。

     

    Accept Timeout可以这样设置:

    ServerSocket serverSocket = new ServerSocket(5555);

    serverSocket.setSoTimeout(5000); // in milliseconds

    while (true) {

        Socket socket = serverSocket.accept();

            …

    }

     

    1.2         Connect Timeout

    当Client端连接Server端的时候,可以指定Connect Timeout

    如果没有指定,会使用操作系统的默认值:

    OS

    Default TCP timeout

    BSD

    75 seconds

    Linux

    189 seconds

    Solaris

    225 seconds

    Windows XP

    21 seconds

     

    Connect Timeout可以这样设置:

    SocketAddress socketAddress = new InetSocketAddress(host, port);

    socket = new Socket();

    socket.connect(socketAddress, connectTimeout);

     

    1.3         Receive Timeout

    当socket从另一方接收数据时,可以设置Receive Timeout

    默认没有timeout,socket会一直阻塞直到有数据可读取。

    Receive Timeout可以这样设置:

    Socket socket = new Socket(host, port);

    socket.setSoTimeout(timeout);

     

    1.4         Send Timeout

    Send Timeout是socket给另一方发送数据时使用的。

    不过Java里没有办法设置Send Timeout.

    当然,socket发送数据的时候,会首先发送到本机OS的一个buffer内。一般只要一次发送的数据不是很大,即使对方挂起或暂时不能接收数据,也不会导致发送方挂起。

     

    2.1       Socket ack (acknowledgement)

    Socket ack是指当socket接收到数据之后,发送一个ack字符串(比如$ACK)给socket发送方。这样,socket发送方可以根据是否收到了ack判断对方是否收到了数据。

    Socket ack是显示的在应用程序中加入的一种通讯协议。如果不使用ack,在socket通讯中,可能会丢失数据。

     

    比如,socket client要连续的给socket server发送100条消息。如果我们在server收到第50条消息的时候,强行kill了server。那么查询client端发送的log,可能client端成功发送了51条。只有当client端发送第52条消息的时候才遇到异常。这样第51条消息就丢失了。

    所以为了确保数据传输的准确性,我们可以引入ack协议。有时我们不仅要确保server不但收到了数据,而且还要保证server成功处理了数据。这时,可以等server成功处理完数据之后,再给client发ack。

     

    2.2       Socket Keep Alive

    Socket连接像数据库连接一样,属于重量型资源。如果我们频繁的创建socket、发送/接收数据、关闭socket,那么会有很大一部分时间浪费在socket的创建和关闭上。

    所以,如果我们经常需要与同一个socket地址发送/接收数据时,应该考虑只创建一次socket,然后一直使用这个socket对象发送/接收数据。

     

    2.3       Heartbeat

    通常,我们会设置socket的receive timeout。这样,如果我们一直打开着socket (keep alive), 而很长时间又没有数据通讯,socket接收方就会timeout,最终导致打开的连接坏掉。

    如果很长时间没有数据通讯,防火墙或代理服务器也可能会关闭打开的socket连接。

    所以为了保证打开的socket连接一直可用,如果一段时间没有数据进行通讯(或指定一个时间间隔),我们可以显示的发送一个heartbeat消息(比如: $HRT)给对方,从而保证连接不会被异常关闭。

     

    2.4       Socket Close

    每一个socket对象会持有一个socket descriptor (其实就是file descriptor),操作系统对于socket descriptor有一个最大限制。因此当socket不再使用时,一定要记得关闭,即使socket连接失败或出现异常,只要socket对象不为null,一定要记得关闭。

    四、socket服务端的编写

    服务器端编程步骤: 
    1: 创建服务器端套接字并绑定到一个端口上(0-1023是系统预留的,最好大约1024以上) 
    2: 套接字设置监听模式等待连接请求 
    3: 接受连接请求后进行通信 
    4: 返回,等待下一个连接请求 

    import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.OutputStreamWriter;
    import java.io.PrintWriter;
    import java.net.ServerSocket;
    import java.net.Socket;
    import java.util.ArrayList;
    import java.util.List;
    import java.util.concurrent.ExecutorService;
    import java.util.concurrent.Executors;
    
    public class SckServer {
    	private static final int PORT = 9999;// 端口
    	private List<Socket> mList = new ArrayList<Socket>();
    	private ServerSocket server = null;
    	private ExecutorService mExecutorService = null; // thread pool
    
    	public static void main(String[] args) {
    		new SckServer();
    	}
    
    	public SckServer() {
    		try {
    			// 创建服务器端socket并绑定到一个端口上
    			server = new ServerSocket(PORT);
    			// 使用连接池
    			mExecutorService = Executors.newCachedThreadPool();
    			System.out.print("server start ...");
    			Socket client = null;
    			// 接字设置监听模式等待连接请求
    			while (true) {
    				client = server.accept();
    				mList.add(client);
    				// 接受连接请求后进行通信
    				mExecutorService.execute(new Service(client));
    			}
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    	}
    
    	class Service implements Runnable {
    		private Socket socket;
    		private BufferedReader in = null;
    		private String msg = "";
    
    		public Service(Socket socket) {
    			this.socket = socket;
    			try {
    				in = new BufferedReader(new InputStreamReader(
    						socket.getInputStream()));
    				msg = "user" + this.socket.getInetAddress() + "come toal:"
    						+ mList.size();
    				this.sendmsg();
    			} catch (IOException e) {
    				e.printStackTrace();
    			}
    
    		}
    
    		@Override
    		public void run() {
    			// TODO Auto-generated method stub
    			try {
    				while (true) {
    					if ((msg = in.readLine()) != null) {
    						if (msg.equals("exit")) {
    							System.out.println("ssssssss");
    							mList.remove(socket);
    							in.close();
    							msg = "user:" + socket.getInetAddress()
    									+ "exit total:" + mList.size();
    							socket.close();
    							this.sendmsg();
    							break;
    						} else {
    							msg = socket.getInetAddress() + ":" + msg;
    							this.sendmsg();
    						}
    					}
    				}
    			} catch (Exception e) {
    				e.printStackTrace();
    			}
    		}
    
    		public void sendmsg() {
    			System.out.println(msg);
    			int num = mList.size();
    			for (int index = 0; index < num; index++) {
    				Socket mSocket = mList.get(index);
    				PrintWriter pout = null;
    				try {
    					pout = new PrintWriter(new BufferedWriter(
    							new OutputStreamWriter(mSocket.getOutputStream())),
    							true);
    					pout.println(msg);
    				} catch (IOException e) {
    					e.printStackTrace();
    				}
    			}
    		}
    	}
    }


    五、Android客户端的编写

     客户端编程步骤: 
    1: 创建客户端套接字(指定服务器端IP地址与端口号) 
    2: 连接(Android 创建Sockett时会自动连接) 
    3: 与服务器端进行通信 
    4: 关闭套接字 

    package com.lyh.sck;
    
    import java.io.BufferedReader;
    import java.io.BufferedWriter;
    import java.io.IOException;
    import java.io.InputStreamReader;
    import java.io.OutputStreamWriter;
    import java.io.PrintWriter;
    import java.net.Socket;
    
    import android.app.Activity;
    import android.app.AlertDialog;
    import android.content.DialogInterface;
    import android.os.Bundle;
    import android.os.Handler;
    import android.os.Message;
    import android.view.View;
    import android.widget.Button;
    import android.widget.EditText;
    import android.widget.TextView;
    
    public class MainActivity extends Activity {
    	private TextView tv_msg = null;
    	private EditText ed_msg = null;
    	private Button btn_send = null;
    	private static final String HOST = "192.168.3.121";
    	private static final int PORT = 9999;
    	private Socket socket = null;
    	private BufferedReader in = null;
    	private PrintWriter out = null;
    	private String content = "";
    	public Handler scHandler;
    
    	/** Called when the activity is first created. */
    	@Override
    	public void onCreate(Bundle savedInstanceState) {
    		super.onCreate(savedInstanceState);
    		setContentView(R.layout.activity_main);
    		initData();
    		findViews();
    		initSocket();
    	}
    	
    	/**
    	 * 初始化控件
    	 * */
    	private void findViews() {
    		tv_msg = (TextView) findViewById(R.id.TextView);
    		ed_msg = (EditText) findViewById(R.id.EditText01);
    		btn_send = (Button) findViewById(R.id.Button02);
    	}
    	
    	/**
    	 * 初始化数据
    	 * */
    	private void initData() {
    		scHandler = new Handler() {
    			@Override
    			public void handleMessage(Message msg) {
    				// TODO Auto-generated method stub
    				super.handleMessage(msg);
    				if (msg.what == 0) {
    					btn_send.setOnClickListener(new Button.OnClickListener() {
    						@Override
    						public void onClick(View v) {
    							// TODO Auto-generated method stub
    							String msg = ed_msg.getText().toString();
    							if (socket.isConnected()) {
    								if (!socket.isOutputShutdown()) {
    									out.println(msg);
    								}
    							}
    						}
    					});
    					new Thread(runnable).start();
    				} else if (msg.what == 1) {
    					tv_msg.setText(tv_msg.getText().toString() + content);
    				} else if (msg.what == 2) {
    
    				}
    			}
    
    		};
    	}
    
    	/**
    	 * 初始化Socket
    	 * */
    	public void initSocket() {
    		new Thread() {
    			@Override
    			public void run() {
    				// TODO Auto-generated method stub
    				try {
    					socket = new Socket(HOST, PORT);//初始化socket对象
    					in = new BufferedReader(new InputStreamReader(
    							socket.getInputStream()));
    					out = new PrintWriter(new BufferedWriter(
    							new OutputStreamWriter(socket.getOutputStream())),
    							true);
    					//初始化玩socket,将结果告知scHandler
    					Message msg=scHandler.obtainMessage();
    					msg.what=0;
    					scHandler.sendMessage(msg);
    				} catch (IOException ex) {
    					ex.printStackTrace();
    					ShowDialog("login exception" + ex.getMessage());
    				}
    			}
    		}.start();
    
    	}
    	/***
    	 * 获取数据线程
    	 * */
    	public Runnable runnable = new Runnable() {
    		@Override
    		public void run() {
    			// TODO Auto-generated method stub
    			try {
    				while (true) {
    					if (socket.isConnected()) {
    						if (!socket.isInputShutdown()) {
    							if ((content = in.readLine()) != null) {
    								content += "\n";
    								Message msg=scHandler.obtainMessage();
    								msg.what=1;
    								scHandler.sendMessage(msg);
    							} else {
    
    							}
    						}
    					}
    				}
    			} catch (Exception e) {
    				e.printStackTrace();
    			}
    		}
    	};
    
    	  
    
    	public void ShowDialog(String msg) {
    		new AlertDialog.Builder(this).setTitle("notification").setMessage(msg)
    				.setPositiveButton("ok", new DialogInterface.OnClickListener() {
    					@Override
    					public void onClick(DialogInterface dialog, int which) {
    						// TODO Auto-generated method stub
    
    					}
    				}).show();
    	}
    
    }


    备注:Android网络编程的时候,切记不能将耗时的上传下载线程放在UI线程中。

     

    源码下载地址:http://download.csdn.net/detail/stop_pig/7052629

     

    展开全文
  • android socket问题

    2012-05-04 10:39:46
    在网上说有这样的原因“终于找到很明晰的原因了,原因是往一个socket写一个序列化对象写了2次,因为网络不稳定,所以有短开重新连接的机制,但是由于两太机器通过服务代理的方式传输,所以server无法发现客护短...
  • 浅谈Android Socket

    2013-10-16 14:41:40
    Socket通常称为“套接字”。Socket字面上的中文意思为“插座”。一台服务器可能会提供很多服务,每种服务对应一个Socket(也可以这么说,每个Socket就是一个插座,客户若是需要哪种服务,就将插头插到相应的插座上面...
  • Android通过socket套接字实现网络连接,通过ip地址和ip端口实现访问服务器,从而实现客户端和服务器的连接,然后实现两者数据的互连
  • Android Socket通信(一) – 初识与相遇 Android Socket通信(二) --UDP,单播,广播和多播(组播) [Android Socket通信(三) – TCP 配置和传递基础数据](https:) 本系列代码链接:...
  • 需求在跨网络的操作中,我们想要连接一些内网服务,例如:对 机房内的安卓设备 进行 adb 连接。一般的做法呢,通常不想自己开发功能,可以有以下两种做法:可以采用 ssh 隧道的方式直接转...
  • 了解一下即时通信的概念。...消息通道可由TCP/IP UDP实现。通俗讲就是把一个人要发送给另外一个...即时通讯应该包括四种形式,在线直传、在线代理、离线代理、离线扩展。在线直传指不经过服务器,直接实现点对点传输。在线
  • 最近在编写Socket客户端代码,在Socket发送消息时报broken pipe的错误。具体情况如下: Socket连接正常,连接后能够...1.使用代理,在转发过程中代理出现中断; 2. 数据包过大,无法正常发送; 3. USB切换或息屏时导
  • Socket使用Linux SSH代理发送数据

    千次阅读 2012-05-10 11:24:57
    Socket使用Linux SSH代理发送数据 写这篇文章是为了解决项目开发中,在处理第三方接口时,在本地开发调试的问题。 场景: 某应用需要调用发送短信接口发送短信(或调用其他第三方接口),但是这些接口...
  • 使用Socket和ServerSocket在局网使用二台电脑 创建服务器和客户端连接,发送数据 第一步创 建服务器 在台试电脑 AbdroidStudro,MainActivity类创建 ServerSocket服务器,发送数据给笔记本电脑客户端 在电脑打开...
  • 在这之前一直碰到这样的问题...Java程序一开始报错信息也是在socket 无法创建上,然后通过Google 得到了一个解决方案,通过是代理问题,在网络,高级,代理里将socket代理关闭,就可以运行Java程序没,然后通过创建s...
  • Native Socket.IO and Android

    千次阅读 2016-05-16 16:53:39
    利用Socket.io实现即时通讯
  • Android客户端与本地服务器Socket通信 Socket服务器运行结果图:smile: 一.客户端和服务器端的选择: 客户端是我们手机端,关于服务器端,只要安装了JDK,自然就拥有通讯的功能,我们只需要在Eclipse或者...
  • android中非阻塞socket通信

    千次阅读 2014-05-16 11:29:29
    如果解析失败,则该地址将被视为未解析 地址,但是其在某些情形下仍然可以使用,比如通过代理连接。 需注意接口: public InetSocketAddress(InetAddress addr,int port) 根据 IP 地址和端口号创建套接...
  • 多年以前Android的网络请求只有Apache开源的HttpClient和JDK的HttpUrlConnection,近几年随着OkHttp的流行Android在高版本的SDK中加入了OkHttp。但在Android官方文档中推荐使用HttpUrlConnection并且其会一直被维护...
  • 在一台电脑上,进行两个安卓模拟器的Socket通信时,因为host都是127.0.0.1,所以连接一直失败。 解决方法: 1、运行服务端模拟器,端口配置为8880 2、客户端模拟器,host配置为10.0.2.2,端口配置为8881 在终端...
  • android程序建立socket失败

    千次阅读 2014-04-30 20:54:43
    socket = new Socket("192.168.1.100", 9999); 用上面代码建立and
  • * 正如梁大所说 Rpc框架核心就是 Socket编程+动态代理 */ public class SocketClient { /** * 服务调用 * @param interfaceClass 接口 * @param Host ServerIP地址 * @param port 服务端口 * @...
  • Android 一套完整的 Socket 解决方案

    千次阅读 2018-01-04 00:00:00
    | MeloDev地址 | http://www.jianshu.com/p/61de9478c9aa声明 | 本文是 MeloDev 原创,已获授权发布,未经原作者允许请勿转载写在前面项目地址,喜欢点一个 star:https://github.com/itsMelo/AndroidSocket在上...
  • 我们说过Android中客户端与服务端通信有两种方式,HTTP通信和Socket通信,前面我们介绍过HTTP通信了,现在,我们来学习一下Socket通信。学习Socket之前,我们需要先学习一下TCP/IP协议和UDP协议。
  • 01-28 02:57:11.545: D/TyLogin(297): calling connect01-28 02:57:36.253: I/ActivityManager(59): Process android.process.acore (pid 169) has died.01-28 03:00:03.994: E/CheckinTask(190): Checkin failed:.....
  • Android网络编程(一)之Socket基础

    千次阅读 2014-06-03 14:10:23
    Socket通常称为“”套接字。Socket字面上的中文意思为“插座”。一台服务器可能会提供很多服务,每种服务对应一个Socket,而客户的“插头”也是一个SocketSocket是应用层与TCP/IP协议族通信的中间软件抽象层,它是...
  • Hash冲突,并发集合,线程安全集合及实现原理HashMap 和 HashTable 区别HashCode 作用,如何重载hashCode方法ArrayList与LinkList区别与联系GC机制Java反射机制,Java代理模式Java泛型Synchronized原理Volatile实现...
  • OkHttp3的最底层是Socket,而不是URLConnection,它通过Platform的Class.forName()反射获得当前Runtime使用的socket库,调用栈如下 okhttp//实现HTTP协议 ==>framwork//JRE,实现JDK中Socket封装  ==>jvm//JDK的...
  • Android 网络交互(五) Socket 小论

    千次阅读 2014-11-27 16:19:55
    Android与服务器的通信方式主要有两种,一是Http通信,一是Socket通信。两者的最大差异在于,http连接使用的是“请求—响应方式”,即在请求时建立连接通道,当客户端向服务器发送请求后,服务器端才能向客户端返回...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 13,688
精华内容 5,475
关键字:

安卓socket代理