* 思想：
1.直接将所有数据安装字节数组发送
2.对象序列化方式
*/
/**
* thread方式
*
* @author Administrator
*/
public class TestSocketActivity4 extends Activity {
private static final int FINISH = 0
private Button send = null
private TextView info = null
private Handler myHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
switch (msg.what) {
case FINISH:
String result = msg.obj.toString() // 取出数据
if ("true".equals(result)) {
TestSocketActivity4.this.info.setText(" *** 作成功！")
} else {
TestSocketActivity4.this.info.setText(" *** 作失败！")
}
break
}
}
}
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState)
super.setContentView(R.layout.activity_test_sokect_activity4)
// StrictMode.setThreadPolicy(new StrictMode.ThreadPolicy.Builder()
// .detectDiskReads().detectDiskWrites().detectNetwork()
// .penaltyLog().build())
// StrictMode.setVmPolicy(new StrictMode.VmPolicy.Builder()
// .detectLeakedSqlLiteObjects().detectLeakedClosableObjects()
// .penaltyLog().penaltyDeath().build())
this.send = (Button) super.findViewById(R.id.send)
this.info = (TextView) super.findViewById(R.id.info)
this.send.setOnClickListener(new SendOnClickListener())
}
private class SendOnClickListener implements OnClickListener {
@Override
public void onClick(View v) {
try {
new Thread(new Runnable() {
@Override
public void run() {
try {
//1:
Socket client = new Socket("192.168.1.165", 9898)
//2:
ObjectOutputStream oos = new ObjectOutputStream(
client.getOutputStream())
//3:
UploadFile myFile = SendOnClickListener.this
.getUploadFile()
//4:
oos.writeObject(myFile)// 写文件对象
// oos.writeObject(null)// 避免EOFException
oos.close()
BufferedReader buf = new BufferedReader(
new InputStreamReader(client
.getInputStream())) // 读取返回的数据
String str = buf.readLine() // 读取数据
Message msg = TestSocketActivity4.this.myHandler
.obtainMessage(FINISH, str)
TestSocketActivity4.this.myHandler.sendMessage(msg)
buf.close()
client.close()
} catch (Exception e) {
Log.i("UploadFile", e.getMessage())
}
}
}).start()
} catch (Exception e) {
e.printStackTrace()
}
}
private UploadFile getUploadFile() throws Exception { // 包装了传送数据
UploadFile myFile = new UploadFile()
myFile.setTitle("tangcco安卓之Socket的通信") // 设置标题
myFile.setMimeType("image/png") // 图片的类型
File file = new File(Environment.getExternalStorageDirectory()
.toString()
+ File.separator
+ "Pictures"
+ File.separator
+ "b.png")
InputStream input = null
try {
input = new FileInputStream(file) // 从文件中读取
ByteArrayOutputStream bos = new ByteArrayOutputStream()
byte data[] = new byte[1024]
int len = 0
while ((len = input.read(data)) != -1) {
bos.write(data, 0, len)
}
myFile.setContentData(bos.toByteArray())
myFile.setContentLength(file.length())
myFile.setExt("png")
} catch (Exception e) {
throw e
} finally {
input.close()
}
return myFile
}
}
}
public class UploadFile implements Serializable {
private String title
private byte[] contentData
private String mimeType
private long contentLength
private String ext
public String getTitle() {
return title
}
public void setTitle(String title) {
this.title = title
}
public byte[] getContentData() {
return contentData
}
public void setContentData(byte[] contentData) {
this.contentData = contentData
}
public String getMimeType() {
return mimeType
}
public void setMimeType(String mimeType) {
this.mimeType = mimeType
}
public long getContentLength() {
return contentLength
}
public void setContentLength(long contentLength) {
this.contentLength = contentLength
}
public String getExt() {
return ext
}
public void setExt(String ext) {
this.ext = ext
}
}
下边是服务端
public class Main4 {public static void main(String[] args) throws Exception {
ServerSocket server = new ServerSocket(9898) // 服务器端端口
System.out.println("服务启动........................")
boolean flag = true // 定义标记，可以一直死循环
while (flag) { // 通过标记判断循环
new Thread(new ServerThreadUtil(server.accept())).start() // 启动线程
}
server.close() // 关闭服务器
}
}
public class ServerThreadUtil implements Runnable {
private static final String DIRPATH = "D:" + File.separator + "myfile"
+ File.separator // 目录路径
private Socket client = null
private UploadFile upload = null
public ServerThreadUtil(Socket client) {
this.client = client
System.out.println("新的客户端连接...")
}
@Override
public void run() {
try {
ObjectInputStream ois = new ObjectInputStream(
client.getInputStream()) // 反序列化
this.upload = (UploadFile) ois.readObject() // 读取对象//UploadFile需要和客户端传递过来的包名类名相同，如果不同则会报异常
System.out.println("文件标题：" + this.upload.getTitle())
System.out.println("文件类型：" + this.upload.getMimeType())
System.out.println("文件大小：" + this.upload.getContentLength())
PrintStream out = new PrintStream(this.client.getOutputStream())// BufferedWriter
out.print(this.saveFile())//返回响应
// BufferedWriter writer = null
// writer.write("")
} catch (Exception e) {
e.printStackTrace()
} finally {
try {
this.client.close()
} catch (IOException e) {
e.printStackTrace()
}
}
}
private boolean saveFile() throws Exception { // 负责文件内容的保存
/**
* java.util.UUID.randomUUID():
* UUID.randomUUID().toString()是javaJDK提供的一个自动生成主键的方法。 UUID(Universally
* Unique Identifier)全局唯一标识符,是指在一台机器上生成的数字，它保证对在同一时空中的所有机器都是唯一的，
* 是由一个十六位的数字组成
* ,表现出来的形式。由以下几部分的组合：当前日期和时间(UUID的第一个部分与时间有关，如果你在生成一个UUID之后，
* 过几秒又生成一个UUID，
* 则第一个部分不同，其余相同)，时钟序列，全局唯一的IEEE机器识别号（如果有网卡，从网卡获得，没有网卡以其他方式获得
* ），UUID的唯一缺陷在于生成的结果串会比较长，字符串长度为36。
*
* UUID.randomUUID().toString()是java JDK提供的一个自动生成主键的方法。 UUID(Universally
* Unique Identifier)全局唯一标识符, 是指在一台机器上生成的数字，它保证对在同一时空中的所有机器都是唯一的，
* 是由一个十六位的数字组成,表现出来的形式
*/
File file = new File(DIRPATH + UUID.randomUUID() + "."
+ this.upload.getExt())
if (!file.getParentFile().exists()) {
file.getParentFile().mkdir()
}
OutputStream output = null
try {
output = new FileOutputStream(file)
output.write(this.upload.getContentData())
return true
} catch (Exception e) {
throw e
} finally {
output.close()
}
}
}
public class UploadFile implements Serializable {
private String title
private byte[] contentData
private String mimeType
private long contentLength
private String ext
public String getTitle() {
return title
}
public void setTitle(String title) {
this.title = title
}
public byte[] getContentData() {
return contentData
}
public void setContentData(byte[] contentData) {
this.contentData = contentData
}
public String getMimeType() {
return mimeType
}
public void setMimeType(String mimeType) {
this.mimeType = mimeType
}
public long getContentLength() {
return contentLength
}
public void setContentLength(long contentLength) {
this.contentLength = contentLength
}
public String getExt() {
return ext
}
public void setExt(String ext) {
this.ext = ext
}
}
由于二者不属于同一层面，所以本来是没有可比性的。但随着发展，默认的Http里封装了下面几层的使用，所以才会出现Socket &HTTP协议的对比：（主要是工作方式的不同）：
Socket可理解为一种特殊的文件，在服务器和客户端各自维护一个文件，并使用SocketAPI函数对其进行文件 *** 作。在建立连接打开后，可以向各自文件写入内容供对方读取或读取对方内容，通信结束时关闭文件。在UNIX哲学中“一切皆文件”，文件的 *** 作模式基本为“打开-读写-关闭”三大步骤，Socket其实就是这个模式的一个实现。
创建socket的时候，也可以指定不同的参数创建不同的socket描述符，socket函数的三个参数分别为：
当我们调用socket创建一个socket时，返回的socket描述字它存在于协议族（address family，AF_XXX）空间中，但没有一个具体的地址。如果想要给它赋值一个地址，就必须调用bind()函数，否则就当调用connect()、listen()时系统会自动随机分配一个端口。
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen)
函数的三个参数分别为：
如果作为一个服务器，在调用socket()、bind()之后就会调用listen()来监听这个socket，如果客户端这时调用connect()发出连接请求，服务器端就会接收到这个请求。
TCP服务器端依次调用socket()、bind()、listen()之后，就会监听指定的socket地址了。TCP客户端依次调用socket()、connect()之后就想TCP服务器发送了一个连接请求。TCP服务器监听到这个请求之后，就会调用accept()函数取接收请求，这样连接就建立好了。之后就可以开始网络I/O *** 作了，即类同于普通文件的读写I/O *** 作。
注意：accept的第一个参数为服务器的socket描述字，是服务器开始调用socket()函数生成的，称为监听socket描述字；而accept函数返回的是已连接的socket描述字。一个服务器通常通常仅仅只创建一个监听socket描述字，它在该服务器的生命周期内一直存在。内核为每个由服务器进程接受的客户连接创建了一个已连接socket描述字，当服务器完成了对某个客户的服务，相应的已连接socket描述字就被关闭。
万事具备只欠东风，至此服务器与客户已经建立好连接了。可以调用网络I/O进行读写 *** 作了，即实现了网咯中不同进程之间的通信！网络I/O *** 作有下面几组：
read()/write()
recv()/send()
readv()/writev()
recvmsg()/sendmsg()
recvfrom()/sendto()
我推荐使用recvmsg()/sendmsg()函数，这两个函数是最通用的I/O函数，实际上可以把上面的其它函数都替换成这两个函数。
从图中可以看出，当客户端调用connect时，触发了连接请求，向服务器发送了SYN J包，这时connect进入阻塞状态；服务器监听到连接请求，即收到SYN J包，调用accept函数接收请求向客户端发送SYN K ，ACK J+1，这时accept进入阻塞状态；客户端收到服务器的SYN K ，ACK J+1之后，这时connect返回，并对SYN K进行确认；服务器收到ACK K+1时，accept返回，至此三次握手完毕，连接建立。
总结：客户端的connect在三次握手的第二个次返回，而服务器端的accept在三次握手的第三次返回。
某个应用进程首先调用close主动关闭连接，这时TCP发送一个FIN M；
另一端接收到FIN M之后，执行被动关闭，对这个FIN进行确认。它的接收也作为文件结束符传递给应用进程，因为FIN的接收意味着应用进程在相应的连接上再也接收不到额外数据；
一段时间之后，接收到文件结束符的应用进程调用close关闭它的socket。这导致它的TCP也发送一个FIN N；
接收到这个FIN的源发送端TCP对它进行确认。
这样每个方向上都有一个FIN和ACK。
所谓短连接，即连接只保持在数据传输过程，请求发起，连接建立，数据返回，连接关闭。它适用于一些实时数据请求，配合轮询来进行新旧数据的更替。
https://github.com/nuisanceless/MySocketDemo
https://github.com/xuuhaoo/OkSocket
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）