androidsocket

㈠ android上的socket通信的开源框架有哪些

Netty是由JBOSS提供的一个java开源框架。Netty提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可靠性的网络服务器和客户端程序。也就是说，Netty 是一个基于NIO的客户，服务器端编程框架，它在socket的基础上根据各种常用的应用协议又进一步封装，提供更便利的接口。如果需要快速搭建一个C/S服务框架，那Netty过来用是没错。 反过来你的情况是需要学习这个课程，你应该掌握基本的socket编程及其通信原理，所以学习时直接用socket编程比较好。也许哪一天，你灵感来了，编出一个比Netty更好的框架，一个更牛的软件。

㈡ android socket怎么获得ip地址

TCP Socket的代码
[java] view plain
class TCPThread extends Thread {
@Override
public void run() {
Log.i("juetion", "TCPThread runing");
int i = 0;
while (!this.isInterrupted()) { //判断是否中断线程
ServerSocket serverSocket = null;//声明一个ServerSocket对象
Log.i("juetion", "TCPThread run times:" + (i));
i++;
try {
serverSocket = new ServerSocket(12345);//创建一个ServerSocket对象，并在12345端口监听
Socket socket = serverSocket.accept();//接受客户端发送的请求
InputStream inputStream = socket.getInputStream();//获取数据流
byte buffer[] = new byte[1024 * 4];
int temp = 0;
while ((temp = inputStream.read(buffer)) != -1) {
Log.i("juetion", new String(buffer, 0, temp)); //数据输出
}
} catch (IOException e) {
e.printStackTrace();
}
try {
Log.i("juetion", "serverSocket close");
serverSocket.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
UDP Socket 的代码：
[java] view plain
class UDPThread extends Thread {
@Override
public void run() {
Log.i("juetion", "UDPThread runing");
int i = 0;
while (!this.isInterrupted()) {//判断是否中断线程
DatagramSocket datagramSocket = null;//声明DatagramSocket对象
Log.i("juetion", "UDPThread run times:" + (i));
i++;
try {
datagramSocket = new DatagramSocket(12345);//创建对象，并监听12345端口
byte data[] = new byte[1024];
DatagramPacket datagramPacket = new DatagramPacket(data, data.length); //获取数据包
datagramSocket.receive(datagramPacket);//接受数据
Log.i("juetion", "" + new String(datagramPacket.getData(), datagramPacket.getOffset(), datagramPacket.getLength()));//数据输出
} catch (Exception e) {
e.printStackTrace();
}
Log.i("juetion", "datagramSocket close");
datagramSocket.close();
}
}
}

㈢ android做客户端socket如何让点击按钮向服务器发送信息

使用基于TCP协议的Socket
一个客户端要发起一次通信，首先必须知道运行服务器端的主机IP地址。然后由网络基础设施利用目标地址，将客户端发送的信息传递到正确的主机上，在Java中，地址可以由一个字符串来定义，这个字符串可以使数字型的地址（比如192.168.1.1），也可以是主机名（example.com）。
而在android 4.0 之后系统以后就禁止在主线程中进行网络访问了，原因是：

主线程是负责UI的响应，如果在主线程进行网络访问，超过5秒的话就会引发强制关闭，所以这种耗时的操作不能放在主线程里。放在子线程里，而子线程里是不能对主线程的UI进行改变的，因此就引出了Handler,主线程里定义Handler,子线程里使用。
以下是一个android socket客户端的例子：
---------------------------------Java代码---------------------------------------
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

import java.io.PrintStream;
import java.io.UnsupportedEncodingException;
import java.net.InetSocketAddress;
import java.net.Socket;
import java.net.UnknownHostException;

import android.app.Activity;
import android.content.Context;
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.Toast;

public class TCPSocketActivity extends Activity {

public static final String TAG = TCPSocketActivity.class.getSimpleName();

/* 服务器地址 */
private String host_ip = null;
/* 服务器端口 */
private int host_port = 0;

private Button btnConnect;
private Button btnSend;
private EditText editSend;
private EditText hostIP;
private EditText hostPort;
private Socket socket;
private PrintStream output;
private String buffer = "";
private Context context;

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_socket_test);
context = this;
initView();

btnConnect.setOnClickListener(new Button.OnClickListener() {
@Override
public void onClick(View v) {
host_ip = hostIP.getText().toString();
host_port = Integer.parseInt(hostPort.getText().toString());
new Thread(new ConnectThread()).start();
}
});

btnSend.setOnClickListener(new Button.OnClickListener() {
@Override
public void onClick(View v) {
new Thread(new SendThread(editSend.getText().toString())).start();
}
});
}

private void toastText(String message) {
Toast.makeText(context, message, Toast.LENGTH_LONG).show();
}

public void handleException(Exception e, String prefix) {
e.printStackTrace();
toastText(prefix + e.toString());
}

public void initView() {
btnConnect = (Button) findViewById(R.id.btnConnect);
btnSend = (Button) findViewById(R.id.btnSend);
editSend = (EditText) findViewById(R.id.sendMsg);
hostIP = (EditText) findViewById(R.id.hostIP);
hostPort = (EditText) findViewById(R.id.hostPort);
}

private void closeSocket() {
try {
output.close();
socket.close();
} catch (IOException e) {
handleException(e, "close exception: ");
}
}

Handler handler = new Handler() {
@Override
public void handleMessage(Message msg) {
super.handleMessage(msg);
if (0x123 == msg.what) {
toastText("连接成功！");
}
}
};

/* 连接socket线程 */
public class ConnectThread implements Runnable {
@Override
public void run() {
// TODO Auto-generated method stub
Message msg = Message.obtain();
try {
if (null == socket || socket.isClosed()) {
socket = new Socket();
socket.connect(new InetSocketAddress(host_ip,host_port),5000);
output = new PrintStream(socket.getOutputStream(), true,
"utf-8");
}
msg.what = 0x123;
handler.sendMessage(msg);
} catch (UnsupportedEncodingException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}

/*发送信息线程*/
public class SendThread implements Runnable {

String msg;

public SendThread(String msg) {
super();
this.msg = msg;
}

@Override
public void run() {
// TODO Auto-generated method stub
try {
output.print(msg);
} catch (Exception e) {
e.printStackTrace();
}
closeSocket();
}

}

public class SocketThread implements Runnable {
public String txt1;

public SocketThread(String txt1) {
super();
this.txt1 = txt1;
}

@Override
public void run() {
// TODO Auto-generated method stub
Message msg = Message.obtain();
try {
/* 连接服务器 并设置连接超时为5秒 */
if (socket.isClosed() || null == socket) {
socket = new Socket();
socket.connect(new InetSocketAddress(host_ip,host_port),5000);
}
// 获取输入输出流
PrintStream ou = new PrintStream(socket.getOutputStream(),
true, "UTF-8");
BufferedReader bff = new BufferedReader(new InputStreamReader(
socket.getInputStream()));
// 读取发来服务器信息
String line = null;
buffer = "";
while ((line = bff.readLine()) != null) {
buffer = line + buffer;
}

// 向服务器发送信息
ou.print(txt1);
ou.flush();
// 关闭各种输入输出流
bff.close();
ou.close();
socket.close();
msg.what = 0x123;
handler.sendMessage(msg);
} catch (UnknownHostException e) {
} catch (IOException e) {
}
}
}
}
-----------------------------布局文件activity_socket_test.xml--------------------------------------
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:background="@color/white"
android:orientation="vertical" >

<EditText
android:id="@+id/hostIP"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_margin="5dip"
android:hint="服务器ip"
android:singleLine="true"
android:inputType="text" />

<EditText
android:id="@+id/hostPort"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_margin="5dip"
android:hint="端口"
android:singleLine="true"
android:inputType="number" />

<Button
android:id="@+id/btnConnect"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:layout_gravity="center_vertical|center_horizontal"
android:background="@drawable/style_btn_shape"
android:layout_margin="5dip"
android:text="@string/connect"
android:textColor="@color/white" />

<EditText
android:id="@+id/sendMsg"
android:layout_width="match_parent"
android:layout_height="wrap_content"
android:layout_margin="5dip"
android:hint="需要发送的内容"
android:inputType="text" />

<Button
android:id="@+id/btnSend"
android:layout_width="fill_parent"
android:layout_height="wrap_content"
android:layout_margin="5dip"
android:background="@drawable/style_btn_shape"
android:layout_gravity="center_vertical|center_horizontal"
android:text="@string/send"
android:textColor="@color/white" />

</LinearLayout>
-------------------------样式文件style_btn_shape.xml----------------------------------
<?xml version="1.0" encoding="UTF-8"?>
<shape
xmlns:android="http://schemas.android.com/apk/res/android"
android:shape="rectangle">
<!-- 填充的颜色 -->
<solid android:color="#0465b2" />
<!-- 设置按钮的四个角为弧形 -->
<!-- android:radius 弧形的半径 -->
<corners android:radius="15dip" />

<!-- padding：Button里面的文字与Button边界的间隔 -->
<padding
android:left="10dp"
android:top="10dp"
android:right="10dp"
android:bottom="10dp"
/>
</shape>
------------------------------END---------------------------------------

㈣ Android socket通信协议的封装和解析

android socket通信协议的封装和解析，其实是和java一样的，都是通过http中的相关知识来封装和解析，主要是通过多次握手，如下代码：

importjava.io.BufferedReader;
importjava.io.BufferedWriter;
importjava.io.IOException;
importjava.io.InputStreamReader;
importjava.io.OutputStreamWriter;
importjava.io.PrintWriter;
importjava.net.ServerSocket;
importjava.net.Socket;
importjava.util.ArrayList;
importjava.util.List;
importjava.util.concurrent.ExecutorService;
importjava.util.concurrent.Executors;


publicclassMain{
privatestaticfinalintPORT=9999;
privateList<Socket>mList=newArrayList<Socket>();
privateServerSocketserver=null;
=null;//threadpool

publicstaticvoidmain(String[]args){
newMain();
}
publicMain(){
try{
server=newServerSocket(PORT);
mExecutorService=Executors.newCachedThreadPool();//createathreadpool
System.out.println("服务器已启动...");
Socketclient=null;
while(true){
client=server.accept();
//把客户端放入客户端集合中
mList.add(client);
mExecutorService.execute(newService(client));//
}
}catch(Exceptione){
e.printStackTrace();
}
}
{
privateSocketsocket;
privateBufferedReaderin=null;
privateStringmsg="";

publicService(Socketsocket){
this.socket=socket;
try{
in=newBufferedReader(newInputStreamReader(socket.getInputStream()));
//客户端只要一连到服务器，便向客户端发送下面的信息。
msg="服务器地址："+this.socket.getInetAddress()+"cometoal:"
+mList.size()+"（服务器发送）";
this.sendmsg();
}catch(IOExceptione){
e.printStackTrace();
}

}

@Override
publicvoidrun(){
try{
while(true){
if((msg=in.readLine())!=null){
//当客户端发送的信息为：exit时，关闭连接
if(msg.equals("exit")){
System.out.println("ssssssss");
mList.remove(socket);
in.close();
msg="user:"+socket.getInetAddress()
+"exittotal:"+mList.size();
socket.close();
this.sendmsg();
break;
//接收客户端发过来的信息msg，然后发送给客户端。
}else{
msg=socket.getInetAddress()+":"+msg+"（服务器发送）";
this.sendmsg();
}
}
}
}catch(Exceptione){
e.printStackTrace();
}
}
/**
*循环遍历客户端集合，给每个客户端都发送信息。
*/
publicvoidsendmsg(){
System.out.println(msg);
intnum=mList.size();
for(intindex=0;index<num;index++){
SocketmSocket=mList.get(index);
PrintWriterpout=null;
try{
pout=newPrintWriter(newBufferedWriter(
newOutputStreamWriter(mSocket.getOutputStream())),true);
pout.println(msg);
}catch(IOExceptione){
e.printStackTrace();
}
}
}
}
}

㈤ 用android写socket client 端的程序，socket.isClosed()为假，socket.isConnected()为真

找问题，要一点一点debug，你贴出来的东西太少了，我只能说，你要跟踪这个流程，看看走到哪里出现的问题，一段时间，如果黑屏很久会使网络中断，如果不是网络问题，看看服务端是不是在那个时间点不传输数据了，等等，需要你跟中调试才有能结果。

㈥ android 什么时候用到socket

通讯时要用到，当然通讯有三种，get;post;socket.

㈦ android socket 异常退出问题

你没有用线程！！！
--------------------
客户Socket
产生Socket对象，客户端连接服务端的端口，这也需要放到线程中，由newSocket()子程序负责； 读Socket得到的字符串通过消息传给主程序协助显示，这由clientRead(Socket sk)子程序负责，这两个耗时性子程序都要放到子线程才能工作， clientRead(final String ip,final int port)产生即时子线程供调用。

Socket newSocket(String ip,int port)
{ Socket sk=null;
try
{ sk=new Socket(ip,port); // 连接服务端，返回Socket
}
catch(Exception e)
{
}
return(sk);
}
void clientRead(Socket sk)
{ // 客户端读Socket
DataInputStream inf;
try
{ inf=new DataInputStream(sk.getInputStream());
while(sk.isConnected() && !sk.isClosed())
{ String s=inf.readUTF();
if (s.length()>0)
{ Message msg=cHandler.obtainMessage(2,s);
cHandler.sendMessage(msg);
}
}
}
catch(Exception e)
{
}
}
void clientRead(final String ip,final int port)
{ // 子线程中客户端读Socket
new Thread(new Runnable()
{ @Override
public void run()
{ Socket sk=newSocket(ip,port);
clientSocket=sk;
if (sk!=null)
clientRead(sk);
}
}).start();
}
一次成功的连接，在服务端与客户端各自都会产生一个Socket对象，并包含了许多方法与属性，对象中可以知道对方的IP地址与端口，还有判断连接状态的函数，如Socket.isConected()和Socket.isClosed(),但这只能判断自已的Socket是否已连接与断开，但无法判断对方的是否断开状态，解决的办法是服务端向对方发“心跳包”或自行在对话协议中向对方发应答命令，以是否响应超时作为判断对方是否断开的依据。

㈧ Android socket通信能发数据但不能接收到数据

我C#项目中做过同样的Android移动Socket通信。

Android客户端：

SocketClient对象receive函数就调用读取函数，当然之前是打开了Socket连接。

publicStringreceive()throwsIOException{

BufferedReaderreader=newBufferedReader(
newInputStreamReader(client.getInputStream()));
Stringtxt=reader.readLine();

returntxt;
}

Activity页面使用任务不间断监听接收。

<Void,Void,Void>{
@Override
protectedVoiddoInBackground(Void...arg0){

SocketClientclient=SocketClient.getInstance();

while(true)
{
try{
Thread.sleep(5000);

Stringre=client.receive();

if(re==null||(re!=null&&re.equals(""))){
continue;
}

if(isCancelled())
returnnull;

//TODO:处理接收到消息

}catch(SocketExceptione){
//服务端断开，启动重连任务
if(e.getMessage().contains("ECONNRESET")){
reconnectTask=newReconnectServerTask();
reconnectTask.execute((Void)null);
}
returnnull;
}catch(IOExceptione){
e.printStackTrace();
}catch(InterruptedExceptione){
e.printStackTrace();
}catch(Exceptione){
e.printStackTrace();
}
}
}
}

㈨ android的socket怎样判断断线

非阻塞模式，如果暂时没有数据，返回的值也会是<=0的，如果用阻塞模式的话，返回<=0的值是可以认为socket已经无效了。

当使用 select()函数测试一个socket是否可读时，如果select()函数返回值为1，
且使用recv()函数读取的数据长度为0 时，就说明该socket已经断开。

经过代码试验，如果进程受到一些信号时，例如：EINTR，recv()返回值小于等于0时，这是就需要判断 errno是否等于 EINTR , 如果errno == EINTR 则说明recv函数是由于程序接收到信号后返回的，socket连接还是正常的，不应close掉socket连接。

如果write，我觉得还有一些情况需要考虑，那就是写的太快的时候，有可能buffer写满了，这是，errno是EAGAIN，可以根据实际需要，如果errno是EAGAIN的话，再写几次。

当然，read的时候也有类似write的情况，需要check一下errno，如果是EAGAIN或者EINTR，最好不要立刻终止操作，再尝试一下！

这是我写的一个代码！int SocketConnected(int sock)
{
int res,recvlen;
char buf[20] = {'\0'};
struct timeval timeout={3,0};
fd_set rdfs;
FD_ZERO(&rdfs);
FD_SET(sock,&rdfs);

res = select(sock+1,&rdfs,NULL,NULL,&timeout);

if(res > 0){

recvlen = recv(sock,buf,sizeof(buf),0);
if(recvlen > 0){
printf("socket connected\n");
return 1;
} else if (recvlen < 0 ){
if(errno == EINTR){
printf("socket connected\n");
return 1;
}else {
printf("socket disconnected! connect again!\n");
return 0;
}
} else if (recvlen == 0){
printf("socket disconnected!connect again\n");
return 0;
}
} else if(res == 0 ){
//time out
printf("socket connected\n");
return 1;
} else if(res < 0){
if (errno == EINTR){
printf("socket connected\n");
return 1;
}else{
printf("socket disconnected ! connect again!\n");
return 0;
}
}
return 0;
}

㈩ 求教Android studio socket通信

有现成的, android socket通讯代码, 不过是eclipse项目, 可以转成android studio项目
是基于socket的文件收发代码