android客户端在多个界面切换时保持socket的链接
socket连接处理
Socket 连接处理长链接:当数据发送完成后socket链接不断开。
一直保留到异常或者是程序退出为止,这种方式的好处是不用每次去发起连接断开,在速度上可以比短连接要快一些,但是相对来说对服务器的资源压力也要大些。
长链接用的范围很广,比如游戏系统,qq等等,长(常)链接一般还需要定时向服务器ping数据,以保证socket链接畅通。
当ping不通服务器时,需要重新开启链接。
短链接:当一次数据发送完毕后,主动断开链接,每次发送数据都要一次链接、断开操作,这种方式的好处是:对服务器的资源占用相对来说比较小,但是由于每次都要重新链接,速度开销上也比较大,这种方式对于那种不需要经常与服务器交互的情况下比较适用。
上面两种方法在用户量非常大的情况下都存在着很大的不足,因此,我们考虑可以用一种折衷的办法,那就是使用socket的连接池。
程序一开始初始化创建若干数量的长链接。
给他们设置一个标识位,这个标识位表示该链接是否空闲的状态。
当需要发送数据的时候,系统给它分配一个当前空闲的链接。
同时,将得到的链接设置为“忙”,当数据发送完毕后,把链接标识位设置为“闲”,让系统可以分配给下个用户,这样使得两种方式的优点都充分的发挥出来了。
杭州携购网络科技有限公司旗下的携购独立购物网()系统采用的就是这种方式。
用户数量足够多的时候,只需要动态增加链接池的数量即可。
下面我们用具体的程序来讲解下:首先我们声明一个socket类:public class XieGouSocket{public Socket m_socket; //Socket对象public bool m_isFree; //判断是否空闲public int m_index; //在链接缓存池中的索引值}下面的函数是创建socket链接池,这里为了使代码更加清晰,我特地把异常处理部分全部取掉了。
public XieGouSocket[] m_socket; //先定义个缓冲池public void CreateSocketPool(){string ip= “127.0.0.1”;string port= 2003;IPAddress serverIp=IPAddress.Parse(ip);int serverPort=Convert.ToInt32(port);IPEndPoint iep=new IPEndPoint(serverIp,serverPort);m_socket = new XieGouSocket[200];for(int i =0; i < 200 ; i ++){m_socket[i] = new XieGouSocket();m_socket[i].m_index = i ;m_socket[i].m_isFree = true;m_socket[i].m_socket =new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);m_socket[i].m_socket.SetSocketOption(SocketOptionLevel.Socket,SocketOptionName.SendTime out,1000);m_socket[i].m_socket.Connect(iep);}}下面的函数是获取当前空闲的socket链接:因为是多线程,所以我们需要加一个原子操作,定义一个原子变量,以防止多个线程之间抢占资源问题的发生。
【android】Socket简单用法
【android】Socket简单⽤法Socket通常也称做”套接字“,⽤于描述IP地址和端⼝,废话不多说,它就是⽹络通信过程中端点的抽象表⽰。
值得⼀提的是,Java在包中提供了两个类Socket和ServerSocket,分别⽤来表⽰双向连接的客户端和服务端。
这是两个封装得⾮常好的类,使⽤起来很⽅便!下⾯将⾸先创建⼀个SocketServer的类作为服务端如下,该服务端实现了多线程机制,可以在特定端⼝处监听多个客户请求,⼀旦有客户请求,Server总是会创建⼀个服务纯种来服务新来的客户,⽽⾃⼰继续监听。
程序中accept()是⼀个阻塞函数,所谓阻塞性⽅法就是说该⽅法被调⽤后将等待客户的请求,直到有⼀个客户启动并请求连接到相同的端⼝,然后accept()返回⼀个对应于客户的Socket。
这时,客户⽅和服务⽅都建⽴了⽤于通信的Socket,接下来就是由各个Socket分别打开各⾃的输⼊、输出流。
SocketServer类,服务器实现:1 package HA.Socket;23 import java.io.*;4 import .*;56public class SocketServer {78 ServerSocket sever;910public SocketServer(int port){11try{12 sever = new ServerSocket(port);13 }catch(IOException e){14 e.printStackTrace();15 }16 }1718public void beginListen(){19while(true){20try{21 final Socket socket = sever.accept();2223new Thread(new Runnable(){24public void run(){25 BufferedReader in;26try{27in = new BufferedReader(new InputStreamReader(socket.getInputStream(),"UTF-8"));28 PrintWriter out = new PrintWriter(socket.getOutputStream());29while (!socket.isClosed()){30 String str;31 str = in.readLine();32out.println("Hello!world!! " + str);33out.flush();34if (str == null || str.equals("end"))35break;36 System.out.println(str);37 }38 socket.close();39 }catch(IOException e){40 e.printStackTrace();41 }42 }43 }).start();44 }catch(IOException e){45 e.printStackTrace();46 }47 }48 }49 }SocketClient类,客户端实现:1 package HA.Socket;23 import java.io.*;4 import .*;56public class SocketClient {7static Socket client;89public SocketClient(String site, int port){10try{11 client = new Socket(site,port);12 System.out.println("Client is created! site:"+site+" port:"+port);13 }catch (UnknownHostException e){14 e.printStackTrace();15 }catch (IOException e){16 e.printStackTrace();17 }18 }1920public String sendMsg(String msg){21try{22 BufferedReader in = new BufferedReader(new InputStreamReader(client.getInputStream()));23 PrintWriter out = new PrintWriter(client.getOutputStream());24out.println(msg);25out.flush();26return in.readLine();27 }catch(IOException e){28 e.printStackTrace();29 }30return"";31 }32public void closeSocket(){33try{34 client.close();35 }catch(IOException e){36 e.printStackTrace();37 }38 }39public static void main(String[] args) throws Exception{4041 }4243 }接下来就是来测试Socket通信了!先运⾏TestSocketServer类,打开服务端,在12345端⼝处监听!1 package HA.Socket;23public class TestSocketServer {45public static void main(String[] argvs){6 SocketServer server = new SocketServer(12345);7 server.beginListen();8 }9 }再运⾏TestSocketClient类:1 package HA.Socket;23public class TestSocketClient {45public static void main(String[] args){67 SocketClient client = new SocketClient("127.0.0.1",12345);8 System.out.println(client.sendMsg("nimei1"));9 client.closeSocket();1011 SocketClient client1 = new SocketClient("127.0.0.1",12345);12 System.out.println(client1.sendMsg("nimei1111"));13 client1.closeSocket();1415 SocketClient client11 = new SocketClient("127.0.0.1",12345);16 System.out.println(client11.sendMsg("nimei11111111"));17 client11.closeSocket();1819 SocketClient client111 = new SocketClient("127.0.0.1",12345);20 System.out.println(client111.sendMsg("nimei11111111111111111"));21 client111.closeSocket();2223 }24 }输出结果如下:服务端:Client is created! site:127.0.0.1 port:12345Hello!world!! nimei1Client is created! site:127.0.0.1 port:12345Hello!world!! nimei1111Client is created! site:127.0.0.1 port:12345Hello!world!! nimei11111111Client is created! site:127.0.0.1 port:12345Hello!world!! nimei11111111111111111客户端:nimei1nimei1111nimei11111111nimei11111111111111111。
Android客户端与PC服务器实现Socket通信(wifi)
Android客户端与PC服务器实现Socket通信(wifi)本文介绍Android终端持续扫描AP信息并发送给服务器端的实现。
首先基于TCP协议在Android终端和PC两端之间形成网络虚拟链路。
使用ServerSocket创建TCP服务器端,然后在Android客户端使用Socket的构造器来连接服务器。
其中Android终端通过WIFI连接和PC处于同一局域网。
1. PC服务器启用ServerSocket两个通信实体在建立虚拟链路之前,需要有一方先准备好,主动接受来自其他通信实体的连接请求。
使用ServerSocket对象监听来自客户端的Socket连接//创建ServerSocket对象ServerSocket ss = new ServerSocket(30000);//监听来自客户端的请求while(true){Socket s = ss.accept();…}如果没有连接,则将一直处于等待状态。
当接收到连接请求后,获取消息到输入流,并保存到文件。
//接收客户端消息BufferedReader in = new BufferedReader(new InputStreamReader(client.getInputStream())); String str;BufferedWriter bw = new BufferedWriter(new FileWriter("D:/ApInfo"+ (i++) +".txt"));while ((str = in.readLine()) != null) {System.out.println(str);bw.write(str);bw.newLine();}2. Android终端使用Socket通信客户端使用Socket的构造器连接服务器,指定服务器IP和端口号就可以了。
Socket s = new Socket(“192.168.1.100”, 30000);这样服务器端的accept()方法就得到响应,从而向下执行,服务器端和客户端就形成了一对互相连接的Socket。
android sock5代理 原理
android sock5代理原理Android Socks5代理的原理Socks5是一种网络代理协议,它允许应用程序通过代理服务器进行网络通信。
在Android中实现Socks5代理的原理可以分为以下几个步骤:1. 配置代理服务器:首先,需要配置一个Socks5代理服务器的地址和端口。
这个代理服务器将作为中间人,负责转发Android设备与互联网之间的通信。
2. 建立连接:Android设备上的应用程序将会尝试与目标服务器建立连接。
在建立连接之前,应用程序必须先与Socks5代理服务器建立连接。
3. 握手协议:建立连接后,Android设备会发送一个握手请求给Socks5代理服务器。
握手请求中包含了支持的认证方法列表,如无需认证、用户名密码认证等。
4. 选择认证方法:Socks5代理服务器会从客户端发送的认证方法列表中选择一个合适的认证方法,并将其作为响应发送回给客户端。
5. 发送认证信息:如果选择的认证方法需要认证信息,Android设备将会发送相应的认证信息给Socks5代理服务器,以便进行身份验证。
6. 建立代理隧道:认证成功后,Socks5代理服务器与目标服务器之间将会建立一个代理隧道。
此时,所有来自Android设备的网络请求将会通过代理服务器转发到目标服务器。
7. 数据传输:一旦代理隧道建立,Android设备上的应用程序可以将网络请求发送到代理服务器。
代理服务器会将请求转发到目标服务器,并将响应返回给Android设备。
通过上述步骤,Android设备上的应用程序可以通过Socks5代理实现与目标服务器的网络通信。
这种方式可以用于绕过某些网络限制或保护用户隐私等需求。
需要注意的是,使用Socks5代理可能会导致网络连接速度的下降,因为所有的网络请求都需要经过代理服务器转发。
使用socket实现长连接
使⽤socket实现长连接我们常⽤的Ajax请求,是HTTP请求,请求过程是建⽴连接、客户端发送请求给服务器、服务端返回结果给客户端、关闭连接,这称为短连接。
若想要实现长连接,即⼀直保持连接,⽽且服务器甚⾄可以直接发消息通知客户端,则需要使⽤socket技术。
代码实现如下:mounted() {this.initWebSocket()}socket相关函数如下:initWebSocket() { // 初始化weosocketconst wsuri = WS_URL + '/createConnect'this.websock = new WebSocket(wsuri + '?token=' + getToken() + '&connectId=' + uuid.v1())this.websock.onmessage = this.websocketonmessagethis.websock.onopen = this.websocketonopenthis.websock.onerror = this.websocketonerrorthis.websock.onclose = this.websocketclose},websocketonopen() { // 连接建⽴之后执⾏send⽅法发送数据const data = Object.assign({}, { 'pageSize': 10, 'pageNum': 1 })const actions = { 'data': data, 'module': 'getColdAlarmLog' }this.websocketsend(JSON.stringify(actions))},websocketonerror() { // 连接建⽴失败重连activeToken().then(rspData => {if (rspData.data.code === 200) {setTimeout(this.initWebSocket(), 15000)}})},websocketonmessage(e) { // 数据接收let socketReturnVal = JSON.parse(e.data)console.log('socketReturnVal', socketReturnVal)if (socketReturnVal == 'alarmFlag') {('监听到新的告警信息')this.handleQuery()}},websocketsend(data) { // 数据发送this.websock.send(data)},websocketclose(e) { // 关闭console.log('断开连接', e)activeToken().then(rspData => {console.log("正在进⾏重连1-1")if (rspData.data.code === 200) {console.log("正在进⾏重连1-2")setTimeout(this.initWebSocket(), 15000)}})}其中,WS_URL的值为ws://localhost:8901上⾯的代码需要导⼊uuid库"vue-uuid": "^1.1.1"import { uuid } from 'vue-uuid'socket技术常⽤于监控中,即后台产⽣告警消息,前端接受到消息(onmessage)做出响应。
使用Socket实现多客户端同时连接的聊天系统
使用Socket实现多客户端同时连接的聊天系统Socket 是网络通信中传送数据的一种协议,通过 Socket,我们可以在不同计算机之间建立连接,从而实现网络通信。
在现代化的互联网应用中,我们经常需要使用 Socket 来实现多客户端同时连接的聊天系统。
聊天系统通常包括客户端和服务器端两个部分,客户端通过连接服务器端实现客户端之间的实时通信。
在实现多客户端同时连接的聊天系统时,我们需要考虑以下几个方面的问题。
一、服务器端的实现服务器端是实现多客户端连接必不可少的组成部分。
通过Socket,我们可以在服务器端建立一个监听线程,来等待客户端的连接请求。
监听线程一旦接收到了客户端的连接请求,就会开启一个新的线程来处理这个客户端的请求。
这个新线程创建一个Socket,将接收到的请求数据传输到服务端,同时也可以将服务端返回的数据传输到客户端。
在多客户端聊天系统中,服务器端也需要维护多个客户端的连接,并处理客户端之间的消息传输。
可以考虑使用一个消息队列,或以集合的方式维护多个客户端的连接。
当消息到达时,服务器端将消息发送给所有连接的客户端。
二、客户端的实现客户端通过 Socket 连接到服务器端,实现客户端之间的实时通信。
客户端需要向服务器端发送请求,同时接收从服务器端发送过来的消息。
客户端也需要实现多客户端连接的处理,并将用户输入的消息发送给服务器端。
在客户端实现中,可以考虑使用多线程或线程池的方式来处理多个客户端连接。
当客户端输入一条消息时,该消息会被传输到服务器端,并在服务器端通过消息队列或集合的方式分发给其他客户端。
同时,客户端也需要接收其他客户端发送过来的消息,并在界面上显示。
三、网络传输的数据格式在多客户端聊天系统中,传输的数据极其复杂,并需要保证数据传输的可靠性和实时性。
因此,我们需要考虑一种合适的数据格式来进行网络传输。
可以考虑使用 JSON 或 XML 数据格式来进行网络传输。
JSON 和 XML 都是轻量级的数据交换格式,便于处理和解析。
socket长连接原理 -回复
socket长连接原理-回复Socket长连接原理Socket长连接是一种在网络通信中经常使用的模式,它在一次连接的过程中可以持续进行大量的数据传输,而不需要频繁地建立和断开连接。
这种模式适用于许多应用场景,包括实时通信、远程监控、聊天应用等。
本文将从深入解析Socket长连接的原理和实现,从建立连接到保持连接的全过程进行逐步讲解。
首先,我们先来了解Socket的概念。
Socket是一种通信协议的抽象概念,在网络编程中,它被用来在不同的设备之间进行通信。
Socket的核心就是建立一个可靠的双向连接,通过这个连接可以在设备之间进行数据传输。
在Internet协议族中,Socket通常使用TCP协议来实现,因为TCP协议提供了可靠的数据传输和错误检测机制。
接下来,我们来讲解Socket长连接的实现过程。
Socket长连接的实现依赖于TCP协议的特性。
在TCP协议中,需要通过三次握手来建立连接。
首先,客户端向服务器发送连接请求;然后,服务器向客户端发送确认请求;最后,客户端再次向服务器发送确认请求。
通过这个过程,连接就建立起来了。
一旦连接建立成功,数据的传输就可以进行了。
在Socket长连接中,客户端和服务器之间可以持续进行大量的数据传输,而不需要频繁地重新建立连接。
在传输过程中,服务器会保持连接打开,以便能够实时地接收和处理客户端发送的数据。
客户端也可以持续地向服务器发送数据,而不需要等待服务器的响应。
这种方式在实时通信和远程监控等场景中非常有效,可以大大提高通信的效率。
然而,由于长连接需要维持一段时间的连接状态,所以在实际应用中需要考虑连接的稳定性和可靠性。
为了确保连接的稳定性,可以使用心跳机制。
心跳机制是指在一定的时间间隔内,客户端向服务器发送一个特定的心跳数据包,以表示自己仍然处于活动状态。
服务器接收到心跳数据包后,可以根据需要进行响应或忽略。
通过心跳机制,可以及时发现连接是否异常断开,并采取相应的措施进行处理。
基于android的Socket通信
基于android的Socket通信⼀、Socket通信简介Android与服务器的通信⽅式主要有两种,⼀是Http通信,⼀是Socket通信。
两者的最⼤差异在于,http连接使⽤的是“请求—响应⽅式”,即在请求时建⽴连接通道,当客户端向服务器发送请求后,服务器端才能向客户端返回数据。
⽽Socket通信则是在双⽅建⽴起连接后就可以直接进⾏数据的传输,在连接时可实现信息的主动推送,⽽不需要每次由客户端想服务器发送请求。
那么,什么是socket?Socket⼜称套接字,在程序内部提供了与外界通信的端⼝,即端⼝通信。
通过建⽴socket连接,可为通信双⽅的数据传输传提供通道。
socket的主要特点有数据丢失率低,使⽤简单且易于移植。
1.1什么是Socket Socket是⼀种抽象层,应⽤程序通过它来发送和接收数据,使⽤Socket可以将应⽤程序添加到⽹络中,与处于同⼀⽹络中的其他应⽤程序进⾏通信。
简单来说,Socket提供了程序内部与外界通信的端⼝并为通信双⽅的提供了数据传输通道。
1.2Socket的分类根据不同的的底层协议,Socket的实现是多样化的。
本指南中只介绍TCP/IP协议族的内容,在这个协议族当中主要的Socket类型为流套接字(streamsocket)和数据报套接字(datagramsocket)。
流套接字将TCP作为其端对端协议,提供了⼀个可信赖的字节流服务。
数据报套接字使⽤UDP协议,提供数据打包发送服务。
下⾯,我们来认识⼀下这两种Socket类型的基本实现模型。
⼆、Socket 基本通信模型三、Socket基本实现原理3.1基于TCP协议的Socket服务器端⾸先声明⼀个ServerSocket对象并且指定端⼝号,然后调⽤Serversocket的accept()⽅法接收客户端的数据。
accept()⽅法在没有数据进⾏接收的处于堵塞状态。
(Socketsocket=serversocket.accept()),⼀旦接收到数据,通过inputstream读取接收的数据。
Android客户端Socket连接PC服务器端
Android客户端Socket连接PC服务器端(转载加评论)文章分类:JavaEye先上代码:1. SocketConnect.java文件Java代码1.package ;2.3.import java.io.BufferedReader;4.import java.io.BufferedWriter;5.import java.io.InputStreamReader;6.import java.io.OutputStreamWriter;7.import java.io.PrintWriter;8.import .Socket;9.10.import android.app.Activity;11.import android.os.Bundle;12.import android.util.Log;13.import android.view.View;14.import android.view.View.OnClickListener;15.import android.widget.Button;16.import android.widget.EditText;17.import android.widget.TextView;18.19.public class SocketConnect extends Activity {20.21. private TextView mTextView = null;22. private EditText mEditText = null;23. private Button mButton = null;24.25. /** Called when the activity is first created. */26. @Override27. public void onCreate(Bundle savedInstanceState) {28. super.onCreate(savedInstanceState);29. setContentView(yout.main);30.31. mButton = (Button) findViewById(R.id.Button01);32. mTextView = (TextView) findViewById(R.id.TextView01);33. mEditText = (EditText) findViewById(R.id.EditText01);34.35. // 登陆36. mButton.setOnClickListener(new OnClickListener() {38. Socket socket = null;39. String message = mEditText.getText().toString() + "\r\n";40. try {41. // 创建Socket42. socket = new Socket("192.168.1.100", 5554); // 查看本机IP,每次开机都不同43. // 向服务器发送消息44. PrintWriter out = new PrintWriter(new BufferedWriter(45. new OutputStreamWriter(socket.getOutputStream())),46. true);47. out.println(message);48.49. // 接收来自服务器的消息50. BufferedReader br = new BufferedReader(51. new InputStreamReader(socket.getInputStream()));52. String msg = br.readLine();53.54. if (msg != null) {55. mTextView.setText(msg);56. } else {57. mTextView.setText("数据错误!");58. }59. // 关闭流60. out.close();61. br.close();62. // 关闭Socket63. socket.close();64. } catch (Exception e) {65. // TODO: handle exception66. Log.e("", e.toString());67. }68. }69. });70. }71.}Java代码1.<?xml version="1.0" encoding="utf-8"?>2.<LinearLayout xmlns:android="/apk/res/android"3.android:orientation="vertical" android:layout_width="fill_parent"4.android:layout_height="fill_parent">5.<Button android:text="Button01" android:id="@+id/Button01"6.android:layout_width="wrap_content" android:layout_height="wrap_content"></Button>7.<TextView android:text="TextView01" android:id="@+id/TextView01"8.android:layout_width="wrap_content" android:layout_height="wrap_content"></TextView>9.<EditText android:text="EditText01" android:id="@+id/EditText01"10. android:layout_width="wrap_content" android:layout_height="wrap_content"></EditText>11.</LinearLayout>3.注意添加AndroidMenifest.xml的权限Java代码1.<uses-permission android:name="android.permission.INTERNET" />4.服务器端,就是建立一个简单的java文件,运行起来就可以了Java代码1.package ;2.3.import java.io.BufferedReader;4.import java.io.BufferedWriter;5.import java.io.InputStreamReader;6.import java.io.OutputStreamWriter;7.import java.io.PrintWriter;8.import .ServerSocket;9.import .Socket;10.11.public class Server implements Runnable {12. public void run() {13. try {14. // 创建ServerSocket15. ServerSocket serverSocket = new ServerSocket(16. while (true) {17. // 接受客户端请求18. Socket client = serverSocket.accept();19. System.out.println("accept");20. try {21. // 接收客户端消息22. BufferedReader in = new BufferedReader(23. new InputStreamReader(client.getInputStream()));24. String str = in.readLine();25. System.out.println("read:" + str);26. // 向服务器发送消息27. PrintWriter out = new PrintWriter(new BufferedWriter(28. new OutputStreamWriter(client.getOutputStream())),29. true);30. out.println("server message");31. // 关闭流32. out.close();33. in.close();34. } catch (Exception e) {35. System.out.println(e.getMessage());36. e.printStackTrace();37. } finally {38. // 关闭39. client.close();40. System.out.println("close");41. }42. }43. } catch (Exception e) {44. System.out.println(e.getMessage());45. }46. }47.48. // main函数,开启服务器49. public static void main(String a[]) {50. Thread desktopServerThread = new Thread(new Server());51. desktopServerThread.start();53.}以上即为所以代码,希望大家有所收获...感谢志毅的blog啊,之前写过差不多的代码没有调试成功还....呵呵[其他难题] Android客户端连接PC服务器端(Socket连接) [复制链接]客户端代码:package ;import java.io.DataInputStream;import java.io.DataOutputStream;import java.io.IOException;import .Socket;import android.app.Activity;import android.os.Bundle;import android.widget.Button;import android.widget.TextView;import android.view.View;import android.view.View.OnClickListener;public class SocketClient extends Activity implements OnClickListener{DataInputStream dis;DataOutputStream dos;private TextView mTextView1;private Button Button01;/** Called when the activity is first created. */@Overridepublic void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(yout.main);mTextView1 = (TextView) findViewById(R.id.rec);Button01 = (Button) findViewById(R.id.Button01); Button01.setOnClickListener(this);Client("127.0.0.1");//WriteInt(25);//WriteString("client");//ReadInt();}public void Client(String IP) {try {// specified by the parameters dstName and dstPort.// 创建一个socket流连接到目标主机,socket = new Socket(IP, 10000);// 输入流读出数据输出流写数据dis = new DataInputStream(socket.getInputStream()); dos = new DataOutputStream(socket.getOutputStream()); } catch (IOException ioe) {ioe.printStackTrace();}}// 写数据到socketpublic void WriteInt(int i) {try {dos.writeInt(i);dos.flush();} catch (IOException ioe) {ioe.printStackTrace();}}StringBuffer message = new StringBuffer(); message.append(str);byte[] b = new byte[6];try {dos.write(12);} catch (IOException e) {// TODO Auto-generated catch blocke.printStackTrace();}}// 显示从socket返回的数据public void ReadInt() {try {mTextView1.setText(dis.readInt()); System.out.println(dis.readInt());} catch (IOException ioe) {ioe.printStackTrace();}}@Overridepublic void onClick(View v) {// TODO Auto-generated method stub WriteInt(25);}}复制代码服务器端代码:package ;import java.io.DataInputStream;import java.io.DataOutputStream;import java.io.IOException;import .ServerSocket;import .Socket;public class Server {ServerSocket serversocket;Socket socket;DataInputStream dis; DataOutputStream dos;public Server() {try {serversocket = new ServerSocket(10000);System.out.println("等待Client 連接");socket = serversocket.accept();System.out.println("Client 已連接");dis = new DataInputStream(socket.getInputStream()); dos = new DataOutputStream(socket.getOutputStream()); } catch (IOException ioe) {ioe.printStackTrace();}}public void WriteInt(int i) {try {dos.writeInt(i);dos.flush();} catch (IOException ioe) {ioe.printStackTrace();}}public void ReadInt() {try {System.out.println(dis.readInt());} catch (IOException ioe) {}}public static void main(String args[]) { Server theServer = new Server(); theServer.WriteInt(10); theServer.ReadInt();}}成功解决问题服务器端代码package wsq.study;import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.IOException;import .ServerSocket;import .Socket;public class Server {ServerSocket serversocket;Socket socket;DataInputStream dis; DataOutputStream dos;public Server() {try {serversocket = new ServerSocket(1900);System.out.println("等待Client 连接");// 侦听套接字上的连接socket = serversocket.accept();System.out.println("Client 已连接");dis = new DataInputStream(socket.getInputStream()); dos = new DataOutputStream(socket.getOutputStream()); } catch (IOException ioe) {ioe.printStackTrace();}}public void WriteInt(int i) {try {// 向socket的输出流写入Int(32位integer)数据// 如果是4个字节,则从高到底写入dos.writeInt(i);dos.flush();} catch (IOException ioe) {ioe.printStackTrace();}}// 从socket的输入流读出int(32位integer)数据public void ReadInt() {try {System.out.println(dis.readInt());} catch (IOException ioe) {ioe.printStackTrace();}}public void readString(){try{System.out.println(dis.readUTF());}catch(IOException e){e.printStackTrace();}}public static void main(String args[]) {Server theServer = new Server();// 接收服务器端已经成功,获取客户端发送来的25 theServer.ReadInt();theServer.readString();theServer.WriteInt(10);}}。
androidstudio中socket的用法
androidstudio中socket的用法在Android Studio中使用Socket是一种常见的方法来实现网络通信。
Socket 是一种能够在网络上进行通信的编程接口,它使得不同设备之间可以进行数据传输和接收。
Android Studio提供了Socket类和相关的网络API,使得我们能够轻松地实现Socket通信。
在Android Studio中使用Socket分为客户端和服务器端两个角色。
服务器端负责监听和接收来自客户端的连接请求,而客户端负责建立与服务器的连接并发送请求。
首先,我们需要创建一个服务器端的Socket。
可以通过创建一个Thread来监听来自客户端的连接请求。
以下是一个简单的服务器端代码示例:import java.io.IOException;import .ServerSocket;import .Socket;public class Server {private static final int PORT = 8080;public static void main(String[] args) {try {ServerSocket serverSocket = new ServerSocket(PORT);System.out.println("Server started...");while (true) {Socket clientSocket = serverSocket.accept();System.out.println("Client connected: " + clientSocket.getInetAddress());处理客户端请求的逻辑...}} catch (IOException e) {e.printStackTrace();}}}上述代码中,我们通过`ServerSocket`类创建一个服务器端的Socket,并指定监听的端口号为8080。
Android学习之Socket通信
Socket俗称套接字,用于描述IP地址和端口,是一个通信链的句柄。
应用程序通常通过套接字向网络发出请求或者应答网络请求。
他是通信的基石,是支持TCP/IP协议的网络通信的基本操作单元。
它是网络通信过程中端点的抽象表示,包含进行网络通信必需的5中信息:连接使用的协议、本地主机的IP地址,本地进程的协议端口、远程主机的IP地址和远地进程的协议端口。
Socket有两种主要的操作方式:面向连接的和无连接的。
面向连接:必须建立一个连接和一个呼叫,所有事情的到达顺序和出发顺序一致。
使用TCP协议,此时Socket必须在发送数据之前与目的地的Socket取得连接。
效率不高,但是安全。
无连接:事情到达顺序和出发顺序不保证一致。
使用数据报协议,一个数据报是一个独立的单元,它包含了这次投递的所有信息。
快速,高效,但安全性不高。
若数据的可靠性更重要的话推荐使用面向连接的操作。
Socket构造中提供了两个类Socket和ServerSocket,分别用来表示双向连接的客户端和服务端。
部分构造方法如下:Socket(InetAddress address,int port ,InetAddress localAddr ,int localPort)Socket(InetAddress address, int port ,boolean stream)Socket(SocketImpl impl)ServerSocket(int port , int backlog, InetAddress bindAddr)address、host、port分别表示双向连接中另一方的IP地址、主机名、端口号stream指明Socket是流Socket还是数据报SocketlocalAddr,bindAddr是本地机器的地址(ServerSocket的主机地址)impl是Socket的父类,既可以创建ServerSocket,也可创建Socket在选择端口时必须小心。
Socket编程总结—Android手机服务器与多个Android手机客户端之间的通信(非阻塞)
Socket编程总结—Android手机服务器与多个Android手机客户端之间的通信(非阻塞)根据前两周写的关于Socket编程的网络通信的代码,现在对有关知识和注意事项进行总结如下:1.首先说下Android NIO中有关Socket编程的类:1)ServerSocketChannel类:服务器套接字通道相当于传统IO下的ServerSocket,通过ServerSocketChannel的socket()可以获得传统的ServerSocket,反过来使用ServerSocket的getChannel()可以获得ServerSocketChannel对象;实例化ServerSocketChannel可以直接通过ServerSocketChannel的静态方法open()就可以了。
2)SocketChannel类:套接字通道相当于传统IO下的Socket,通过SocketChannel的socket()可以获得传统的Socket,反过来使用Socket的getChannel()可以获得SocketChannel对象;3)Selector选择器:在NIO中注册各种事件的方法主要使用Selector来实现的,我们可以使用Selector类的静态方法open()来实例化。
4)SelectionKey类:是个选择键,在NIO中选择器和选择键是很重要的,SelectionKey描述了NIO中比较重要的事件,如OP_ACCEPT、OP_READ、OP_WRITE。
2.然后说下非阻塞和阻塞模式的区别以及非阻塞模式的实现:1)非阻塞:所谓非阻塞就是说,服务器监听客户端连接的时候,如果没有客户连接,程序还接续执行,不会停在这里等待客户连接;或者客户连接上了,下一步就是等待客户发数据,如果不发,程序不会停留在这里,而是继续执行。
反过来停留在这里,不继续执行就是阻塞。
2)非阻塞模式的实现:对于客户端来说,得到SocketChannel对象后,通过调用方法configureBlocking(false)来设置这个Socket为非阻塞状态。
Android开发时的Socket通信介绍
Android开发时的Socket通信介绍————————————————————————————————作者:————————————————————————————————日期:Socket通信当服务器端断开时,用户端可以进行如下设置解决方法:/// global variablespublic Socket socket = null;private InetSocketAddress isa = null;private static final String HOST = "10.13.81.26";private static final String PORT = 5000;private static final String TIMEOUT = 100;///connect to servertry{socket = new Socket();isa = new InetSocketAddress(HOST,PORT);socket.connect(isa,TIMEOUT);}catch(IOException e){e.printStackTrace();}finnally{this.disconnectToServer();}///disconnect to servertry{if(socket != null){socket.close();}catch(IOException e){e.printStackTrace();}}public MyConnector(String address,int port){try{socket = new Socket();isa = new InetSocketAddress(address,port);socket.connect(isa,TIMEOUT);din = new DataInputStream(socket.getInputStream()); //dout = new DataOutputStream(socket.getOutputStream()); //获得输出流}catch(Exception e){e.printStackTrace();socket = null;}finally{}Log.i("MyConnector", "socket is or not "+socket);Log.i("MyConnector", "din is or not "+din);Log.i("MyConnector", "dout is or not "+dout);1)}之前链接socket直接用:Socket socket = new Socket("10.13.81.26",5000);socket.setTimeout(100);这样,如果出现服务器端未开启时,即使设置了100ms超时时间,也会过很长时间才会捕捉到IOException现在先定义isa,通过isa跟socket链接可以解决上面的问题2)解决方法:class MyThread extends Thread{public void run(){try{socket = new Socket(address1,port1);din = new DataInputStream(socket.getInputStream()); //获得输入流dout = new DataOutputStream(socket.getOutputStream()); //获得输出流}catch(Exception e){e.printStackTrace();}}}// public MyConnector(String address,int port){// address1 = address;// port1 = port;// MyThread mt = new MyThread();// mt.start();// try{// /*Thread.sleep(outtime);*/// for(int i = 0;i < 50; i++)// {// Thread.sleep(outtime);// if(socket == null) continue;// else break;// }// }catch(Exception e){// e.printStackTrace();// }// if (socket == null){// mt.interrupt();// socket = null; //声明Socket对象// din = null; //声明数据输入流对象// dout = null; //声明数据输出流对象// }// Log.i("MyConnector", "socket is or not "+socket);// Log.i("MyConnector", "din is or not "+din);// Log.i("MyConnector", "dout is or not "+dout);//// }Toast的使用:Android中的Toast是一种简易的消息提示框,toast提示框不能被用户点击,toast会根据用户设置的显示时间后自动消失。
android socket原理
Android Socket原理一、什么是SocketSocket(套接字)是计算机网络中用于实现不同主机间通信的一种技术。
它提供了一种统一的接口,使得不同操作系统、不同编程语言之间可以相互通信。
在Android开发中,Socket常用于实现网络通信,使得Android设备可以与远程主机进行数据交换。
二、Socket通信原理Socket通信基于客户端(Client)和服务器(Server)之间的交互。
客户端向服务器发送请求,服务器接收请求并返回响应。
具体的通信流程如下:1.客户端创建一个Socket对象,指定要连接的服务器的IP地址和端口号。
2.客户端通过Socket对象与服务器建立连接。
3.客户端通过输出流向服务器发送请求数据。
4.服务器接收到请求数据后进行处理,然后通过输出流向客户端发送响应数据。
5.客户端接收到服务器的响应数据。
三、Socket相关类介绍在Android开发中,主要使用以下几个类实现Socket通信:.Socket:客户端Socket对象,用于与服务器建立连接和发送接收数据。
.ServerSocket:服务器Socket对象,用于监听客户端的连接请求。
.SocketException:Socket异常类,用于处理Socket通信过程中的异常。
4.java.io.InputStreamReader和java.io.OutputStreamWriter:用于将字节流转换为字符流。
四、Socket编程步骤1. 客户端编程步骤以下是Android客户端Socket编程的步骤:1.创建一个Socket对象,指定服务器的IP地址和端口号。
2.获取Socket对象的输出流,用于向服务器发送数据。
3.获取Socket对象的输入流,用于接收服务器返回的数据。
4.向服务器发送请求数据。
5.接收服务器返回的响应数据。
2. 服务器端编程步骤以下是Android服务器端Socket编程的步骤:1.创建一个服务器Socket对象,指定监听的端口号。
Android界面切换与网络通信
一、Android 的界面切换方法有两个:方法1、通过setContentView切换layout,这个我比较常用。
有以下步骤:①新建一个界面的layout的xml文件②触发某一控件(如Button),该控件已经加载监听器,监听器通过setContentView函数切换layout这样的实现整个过程都是在一个Activity上面实现,所有变量都在同一状态,因此所有变量都可以在这个Activity状态中获得。
代码如下:③在原来的Activity上面通过创建Intent类来进行Activity的切换,代码如下二、Android与服务器通信的方法有:方法一:http通信,以xml或者json为载体,相互通信数据。
Android对于http的网络通信,提供了标准的java接口——httpURLConnection接口,以及apache的接口——httpclient接口。
其中我自己用的比较多的而是httpclient这个接口,因为它的功能更为丰富很有效。
同时http通信也分为post方式和get的方式,两个相比较的话,post传送的数据量比较大,安全性也比较高。
因此在做数据查询时,我会用get方式;而在做数据添加、修改或删除时,我就用Post方式以下是基于httpclient接口,用get和post的方式通信的代码。
(get方式)etStatusCode()=={ etStatusCode()=={ etHostAdd ress());的如下:view plaincopy to clipboardprint?package ;importimportimportimportimportimportimportimportimportimport/*** @author hellogv*/public class testMyListView extends Activity {/** Called when the activity is first created. */ListView lv;@Overridepublic void onCreate(Bundle savedInstanceState) {(savedInstanceState);setContentView("ListView自适应实现表格---hellogv");lv = (ListView)ArrayList<TableRow> table = new ArrayList<TableRow>();TableCell[] titles = new TableCell[5];etDefaultDisplay().getWidth()/;+ (i),titles[i].width,,;}cells[ - 1] = new TableCelltitles[ - 1].width,,;}}}package ;importimportimportimportimportimportimportimportimportimport/*** @author hellogv*/public class testMyListView extends Activity {/** Called when the activity is first created. */ListView lv;@Overridepublic void onCreate(Bundle savedInstanceState) { (savedInstanceState);("ListView自适应实现表格---hellogv");lv = (ListView)ArrayList<TableRow> table = new ArrayList<TableRow>();TableCell[] titles = new TableCell[5];etDefaultDisplay().getWidth()/;+ (i),titles[i].width,,;}cells[ - 1] = new TableCelltitles[ - 1].width,,;how();}}}ListView自适应实现Table的类代码如下:PS:TableCell是格单元的类,TableRow是表格行的类,TableRowView是实现表格行的组件。
Android (界面切换)跳转
Android (界面切换)跳转在Android中可以利用两种方式切换界面:1、利用setContentView;2、调用另外一个独立的Activity实现界面转换。
1、利用setContentView方法:新建一个layout在两个layout 中用分别初始化两个button用来触发切换这两个layout的事件,在各自的SetOnclickListenter函数中处理,实现跳转源码如下:m_button.setOnClickListener(new Button.OnClickListener(){//按键时间处理public void onClick(View v) {jumpToLayout2();//由界面一跳转到界面二}});public void jumpToLayout1(){setContentView(yout.main);//通过这个函数设定显示layoutButton button1 = (Button)findViewById(R.id.Button1);button1.setOnClickListener(new Button.OnClickListener(){//通过按键事件来触发切换public void onClick(View v) {jumpToLayout2();}});}public void jumpToLayout2(){setContentView(yout.mylayout);//通过这个函数设定显示layoutButton button2 = (Button)findViewById(R.id.Button2);button2.setOnClickListener(new Button.OnClickListener(){public void onClick(View v) {jumpToLayout1();}});}这样实现的切换是在一个Activity当中实现切换并无参数,所有的变量都在同一个状态中,这里的所有变量都可以在这个Activity的状态中直接取得。
android socket 原理
android socket 原理Socket是一种网络通信机制,它允许不同设备之间的数据传输。
在Android中,Socket可以用于建立客户端和服务器之间的通信连接。
Socket通常基于TCP/IP协议,它使用IP地址和端口号来唯一标识网络中的不同设备和应用程序。
Android中提供了Java的Socket类,用于在应用程序中创建和管理Socket连接。
Socket通信的原理如下:1. 客户端发起连接:客户端使用Socket类的构造函数创建一个Socket对象,并指定服务器的IP地址和端口号。
当客户端调用Socket的connect()方法时,它会尝试与服务器建立连接。
2. 服务器接受连接请求:服务器端使用ServerSocket类创建一个ServerSocket对象,并绑定到一个指定的端口号上。
服务器调用ServerSocket的accept()方法来监听客户端的连接请求。
当服务器接收到一个客户端的连接请求后,它会创建一个新的Socket对象来与该客户端进行通信。
3. 通信数据传输:一旦客户端和服务器成功建立连接,它们就可以通过Socket对象进行数据的传输。
客户端使用OutputStream向服务器发送数据,而服务器使用InputStream来接收客户端发送的数据。
同样地,服务器可以使用OutputStream向客户端发送数据,而客户端使用InputStream来接收服务器发送的数据。
4. 连接关闭:当通信结束时,客户端和服务器可以通过Socket 的close()方法来关闭连接。
在关闭连接之前,双方可以通过读写Socket对象来传输最后的数据。
总结来说,Socket通信的原理是通过客户端和服务器之间的Socket对象来建立连接并进行数据的传输。
客户端发起连接请求,服务器接受请求并创建新的Socket对象用于通信。
通过Socket对象的输入输出流进行数据传输,并在通信结束时关闭连接。
android客户端在多个界面切换时保持socket的链接
android客户端在多个界面切换时保持socket的链接研究一个socket在多个界面切换时保持链接的问题,现在我提供客户端的源码给有需要的人参考。
1、ApplicationUtil类:import java.io.DataInputStream;import java.io.DataOutputStream;import java.io.IOException;import .Socket;import .UnknownHostException;import android.app.Application;public class ApplicationUtil extends Application{private Socket socket;private DataOutputStream out = null;private DataInputStream in = null;public void init() throws IOException, Exception{this.socket = new Socket("192.168.1.104",10202);this.out = new DataOutputStream(socket.getOutputStream());this.in = new DataInputStream(socket.getInputStream());}public Socket getSocket() {return socket;}public void setSocket(Socket socket) {this.socket = socket;}public DataOutputStream getOut() {return out;}public void setOut(DataOutputStream out) {this.out = out;}public DataInputStream getIn() {return in;}public void setIn(DataInputStream in) {this.in = in;}}2、AndroidMainifest.xml中application的配置:<manifest xmlns:android="/apk/res/android"package="com.login"android:versionCode="1"android:versionName="1.0" ><uses-sdkandroid:minSdkVersion="10"android:targetSdkVersion="15" /><applicationandroid:name="com.util.ApplicationUtil"android:icon="@drawable/ic_launcher"android:label="@string/app_name"android:theme="@style/AppTheme" ><activityandroid:name=".LoginActivity"android:label="@string/title_activity_main" ><intent-filter><action android:name="android.intent.action.MAIN" /><category android:name="UNCHER" /> </intent-filter></activity><activity android:name=".MainActivity"/></application><!-- 振动需要的权限--><uses-permission android:name="android.permission.VIBRA TE"/><!-- 声明网络权限--><uses-permission android:name="android.permission.INTERNET"/></manifest>3、LoginActivity类:import java.io.BufferedWriter;import java.io.DataInputStream;import java.io.DataOutputStream;import java.io.IOException;import java.io.InputStreamReader;import java.io.OutputStream;import java.io.OutputStreamWriter;import java.io.PrintWriter;import .Socket;import .UnknownHostException;import com.login.R;import com.util.ApplicationUtil;import android.app.Activity;import android.content.Intent;import android.os.Bundle;import android.view.View;import android.view.View.OnClickListener;import android.widget.Button;import android.widget.EditText;import android.widget.Toast;public class LoginActivity extends Activity{private EditText usernameT;private EditText passwordT;private Button loginButton;private Socket socket;private DataOutputStream out;private DataInputStream in;@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(yout.login);usernameT = (EditText) findViewById(ername);passwordT = (EditText) findViewById(R.id.password);loginButton = (Button) findViewById(R.id.login);loginButton.setOnClickListener(new OnClickListener(){public void onClick(View v) {ApplicationUtil appUtil = (ApplicationUtil) LoginActivity.this.getApplication();try {appUtil.init();Socket socket = appUtil.getSocket();out = appUtil.getOut();in = appUtil.getIn();} catch (IOException e1) {e1.printStackTrace();} catch (Exception e1) {e1.printStackTrace();}String username = usernameT.getText().toString();String password = passwordT.getText().toString();MD5 md5 = new MD5();String ss = md5.MD5(username+"|"+password);try {//发送数据String str = "[login]|"+ss;out.writeBytes(str);out.flush();System.out.println("str ===> "+str);//创建一个缓冲字节数int r = in.available();while(r==0){r = in.available();}byte[] b = new byte[r];in.read(b);String result = new String(b,"utf-8");System.out.println("result = "+result);if(result.equals("登陆成功0")){Intent intent = new Intent();intent.setClass(LoginActivity.this, MainActivity.class);startActivity(intent);}else{Intent intent = new Intent();intent.setClass(LoginActivity.this, MainActivity.class);startActivity(intent);}} catch (UnknownHostException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();}}});}}4、MainActivity类:import java.io.BufferedReader;import java.io.DataInputStream;import java.io.IOException;import java.io.InputStreamReader;import .Socket;import com.image.TestActivity;import com.login.R;import com.util.ApplicationUtil;import android.media.RingtoneManager;import .Uri;import android.os.Bundle;import android.os.Handler;import android.os.Looper;import android.os.Message;import android.provider.MediaStore.Audio;import android.app.Activity;import android.app.Notification;import android.app.NotificationManager;import android.app.PendingIntent;import android.content.Context;import android.content.Intent;import android.util.Log;import android.view.View;import android.view.View.OnClickListener;import android.widget.Button;import android.widget.EditText;import android.widget.Toast;public class MainActivity extends Activity {private EditText mess;private Socket socket;private Handler handler;private DataInputStream in;private NotificationManager nm;private Notification n;private int messageNotificationID = 0;@Overridepublic void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(yout.success);mess = (EditText) findViewById(R.id.message);ApplicationUtil appUtil = (ApplicationUtil) MainActivity.this.getApplication();socket = appUtil.getSocket();in = appUtil.getIn();handler = new Handler(){@Overridepublic void handleMessage(Message msg) {//如果来自子线程if(msg.what == 0x123){mess.append(msg.obj.toString()+"\n");//消息通知mynoti();}}};//调用线程myThread();}//JA V A可以设置读写缓冲区的大小-setReceiveBufferSize(int size), setSendBufferSize(int size)。
Android中长连接的解决方案
Android中长连接的解决⽅案Http请求的过程1. 通过运营商的DNS服务器解析⽬标域名的ip地址,保存到localhost⽂件中缓存2. 通过TCP三次握⼿与服务端建⽴链接3. 写⼊Http的请求头、请求体以及数据后接收数据4. 接收完⼀个请求的数据后,通过TCP四次挥⼿释放链接如果还需要担⼼DNS劫持的话,则还需要加⼀层HttpDNS的过程。
也就是通过Http协议将域名解析成对应的可信任的IP 列表,通过ip直接访问。
长连接的优势长连接通过Socket与服务端建⽴持久的链接,即使单个请求发送与接收后也不会释放链接。
这样的好处有:1. 通过指定IP建⽴连接,减少DNS的查询时间2. 只⽤经历最初的⼀次TCP的三次握⼿,在真正请求时,则免去了建⽴连接的过程3. 在⼤量请求并发的时候,不会出现⼤量的Http链接断开重连的过程4. 服务端可以通过长连接进⾏推送,达到更加实时的效果5. TCP接收数据的滑动窗⼝也会⼀直保持长连接的问题虽然长连接的好处很多,但是在保持长连接稳定的过程中也会存在很多的问题:1. ⽹络切换的过程会导致长连接断开2. 进程被杀掉时候,也会导致长连接断开3. NAT超时,会导致长连接断开4. DHCP租期到了,会导致ip地址变化,导致长连接断开所以,在应⽤中,就需要保护长连接的稳定,否则会导致很多信息收不到。
NAT:因为 IP v4 的 IP 量有限,运营商分配给⼿机终端的 IP 是运营商内⽹的 IP,⼿机要连接 Internet,就需要通过运营商的⽹关做⼀个⽹络地址转换(Network Address Translation,NAT)。
简单的说运营商的⽹关需要维护⼀个外⽹IP、端⼝到内⽹ IP、端⼝的对应关系,以确保内⽹的⼿机可以跟 Internet 的服务器通讯。
GGSN(Gateway GPRS Support Node ⽹关GPRS⽀持结点)模块就实现了NAT功能。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
android客户端在多个界面切换时保持socket的链接研究一个socket在多个界面切换时保持链接的问题,现在我提供客户端的源码给有需要的人参考。
1、ApplicationUtil类:import java.io.DataInputStream;import java.io.DataOutputStream;import java.io.IOException;import .Socket;import .UnknownHostException;import android.app.Application;public class ApplicationUtil extends Application{private Socket socket;private DataOutputStream out = null;private DataInputStream in = null;public void init() throws IOException, Exception{this.socket = new Socket("192.168.1.104",10202);this.out = new DataOutputStream(socket.getOutputStream());this.in = new DataInputStream(socket.getInputStream());}public Socket getSocket() {return socket;}public void setSocket(Socket socket) {this.socket = socket;}public DataOutputStream getOut() {return out;}public void setOut(DataOutputStream out) {this.out = out;}public DataInputStream getIn() {return in;}public void setIn(DataInputStream in) {this.in = in;}}2、AndroidMainifest.xml中application的配置:<manifest xmlns:android="/apk/res/android"package="com.login"android:versionCode="1"android:versionName="1.0" ><uses-sdkandroid:minSdkVersion="10"android:targetSdkVersion="15" /><applicationandroid:name="com.util.ApplicationUtil"android:icon="@drawable/ic_launcher"android:label="@string/app_name"android:theme="@style/AppTheme" ><activityandroid:name=".LoginActivity"android:label="@string/title_activity_main" ><intent-filter><action android:name="android.intent.action.MAIN" /><category android:name="UNCHER" /> </intent-filter></activity><activity android:name=".MainActivity"/></application><!-- 振动需要的权限--><uses-permission android:name="android.permission.VIBRA TE"/><!-- 声明网络权限--><uses-permission android:name="android.permission.INTERNET"/></manifest>3、LoginActivity类:import java.io.BufferedWriter;import java.io.DataInputStream;import java.io.DataOutputStream;import java.io.IOException;import java.io.InputStreamReader;import java.io.OutputStream;import java.io.OutputStreamWriter;import java.io.PrintWriter;import .Socket;import .UnknownHostException;import com.login.R;import com.util.ApplicationUtil;import android.app.Activity;import android.content.Intent;import android.os.Bundle;import android.view.View;import android.view.View.OnClickListener;import android.widget.Button;import android.widget.EditText;import android.widget.Toast;public class LoginActivity extends Activity{private EditText usernameT;private EditText passwordT;private Button loginButton;private Socket socket;private DataOutputStream out;private DataInputStream in;@Overrideprotected void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(yout.login);usernameT = (EditText) findViewById(ername);passwordT = (EditText) findViewById(R.id.password);loginButton = (Button) findViewById(R.id.login);loginButton.setOnClickListener(new OnClickListener(){public void onClick(View v) {ApplicationUtil appUtil = (ApplicationUtil) LoginActivity.this.getApplication();try {appUtil.init();Socket socket = appUtil.getSocket();out = appUtil.getOut();in = appUtil.getIn();} catch (IOException e1) {e1.printStackTrace();} catch (Exception e1) {e1.printStackTrace();}String username = usernameT.getText().toString();String password = passwordT.getText().toString();MD5 md5 = new MD5();String ss = md5.MD5(username+"|"+password);try {//发送数据String str = "[login]|"+ss;out.writeBytes(str);out.flush();System.out.println("str ===> "+str);//创建一个缓冲字节数int r = in.available();while(r==0){r = in.available();}byte[] b = new byte[r];in.read(b);String result = new String(b,"utf-8");System.out.println("result = "+result);if(result.equals("登陆成功0")){Intent intent = new Intent();intent.setClass(LoginActivity.this, MainActivity.class);startActivity(intent);}else{Intent intent = new Intent();intent.setClass(LoginActivity.this, MainActivity.class);startActivity(intent);}} catch (UnknownHostException e) {e.printStackTrace();} catch (IOException e) {e.printStackTrace();}}});}}4、MainActivity类:import java.io.BufferedReader;import java.io.DataInputStream;import java.io.IOException;import java.io.InputStreamReader;import .Socket;import com.image.TestActivity;import com.login.R;import com.util.ApplicationUtil;import android.media.RingtoneManager;import .Uri;import android.os.Bundle;import android.os.Handler;import android.os.Looper;import android.os.Message;import android.provider.MediaStore.Audio;import android.app.Activity;import android.app.Notification;import android.app.NotificationManager;import android.app.PendingIntent;import android.content.Context;import android.content.Intent;import android.util.Log;import android.view.View;import android.view.View.OnClickListener;import android.widget.Button;import android.widget.EditText;import android.widget.Toast;public class MainActivity extends Activity {private EditText mess;private Socket socket;private Handler handler;private DataInputStream in;private NotificationManager nm;private Notification n;private int messageNotificationID = 0;@Overridepublic void onCreate(Bundle savedInstanceState) {super.onCreate(savedInstanceState);setContentView(yout.success);mess = (EditText) findViewById(R.id.message);ApplicationUtil appUtil = (ApplicationUtil) MainActivity.this.getApplication();socket = appUtil.getSocket();in = appUtil.getIn();handler = new Handler(){@Overridepublic void handleMessage(Message msg) {//如果来自子线程if(msg.what == 0x123){mess.append(msg.obj.toString()+"\n");//消息通知mynoti();}}};//调用线程myThread();}//JA V A可以设置读写缓冲区的大小-setReceiveBufferSize(int size), setSendBufferSize(int size)。