socketjava

⑴ 运用socket编写一个java程序

/*服务器端程序：*/
mport java.net.*;
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import javax.swing.*;

class ChatServer extends JFrame{
private JTextField inputBox;
private JTextArea outFrame;
private ObjectOutputStream outputS;
private ObjectInputStream inputS;
private ServerSocket toserver;
private Socket server;
private String message = "";
private int counter = 1;

ChatServer(){
super("Server");

Container container = getContentPane();
inputBox = new JTextField();
inputBox.setEditable(false);
//输出
inputBox.addActionListener(
//监听
new ActionListener(){
public void actionPerformed(ActionEvent ev)
{
sendMsg(ev.getActionCommand());
inputBox.setText(" ");
}
});
container.add(inputBox,BorderLayout.NORTH);
//输出框
outFrame = new JTextArea();
container.add(new JScrollPane(outFrame),
BorderLayout.CENTER);
setSize(208,160);
setVisible(true);
}

public void connectServer(){

try{
//创建一个ServerSocket
toserver = new ServerSocket(4000);
while(true){
//等待连接
wait1Connection();
//获取输出流
getStreams();
//处理连接
processConnection();
//关闭连接
closeConnection();
++counter;

}
}
catch(EOFException eofException){
System.out.println("Client terminated connection");
}
catch(IOException ee){
ee.printStackTrace();

}
}
private void wait1Connection() throws IOException
{
outFrame.setText("等待连接....\n");
server = toserver.accept();
outFrame.append("连接 " + counter +
" 来自于:" + server.getInetAddress().getHostName());
}
private void getStreams() throws IOException
{
outputS = new ObjectOutputStream(server.getOutputStream());
outputS.flush();
inputS = new ObjectInputStream(server.getInputStream());
outFrame.append("\n成功建立连接。\n");
}
//处理客户端连接：
private void processConnection() throws IOException
{
//连接成功
message = "成功连接到-->>^_^小粉条";
outputS.writeObject(message);
outputS.flush();//刷新输出流
//输入框
inputBox.setEditable(true);
//处理来自客户端的消息
do{
//读取消息；
try{
message = (String) inputS.readObject();
outFrame.append("\n" + message);

outFrame.setCaretPosition(outFrame.getText().length());
}
catch(ClassNotFoundException ex){
outFrame.append("\n UnKown object type received");
}
}
while(!message.equals("一肩秋色>> TERMINATE"));

}
private void closeConnection() throws IOException
{
outFrame.append("\n User terminated connction");
inputBox.setEditable(true);
outputS.close();
inputS.close();
server.close();
}
//向客户端发送消息
private void sendMsg(String message)
{
try{
outputS.writeObject("^_^小粉条>> " + message);
outputS.flush();
outFrame.append("\n^_^小粉条>>" + message);
}catch(IOException em){
outFrame.append("\nError writing object");
}

}
}
public class chat {

public static void main(String[] args) {
// TODO code application logic here
ChatServer process = new ChatServer();
process.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
process.connectServer();
}
}

/*客户端程序：*/
import java.io.*;
import javax.swing.*;
import java.awt.*;
import java.awt.event.*;
import java.net.*;

class CClient extends JFrame{
private JTextField inputBox;
private JTextArea outFrame;
private ObjectOutputStream outputS;
private ObjectInputStream inputS;
private String message = "";
private String ChatServer;
private Socket toclient;
CClient(String srhost)
{
super("Client");
ChatServer = srhost;
//设置客户端连接的服务器
Container container = getContentPane();
inputBox = new JTextField();
//建立输入框
inputBox.setEditable(false);
inputBox.addActionListener(
//监听
new ActionListener(){
public void actionPerformed(ActionEvent e)
{
sendMsg(e.getActionCommand());
inputBox.setText(" ");
}
}
);
container.add(inputBox,BorderLayout.NORTH);
//输出框
outFrame = new JTextArea();
container.add(new JScrollPane(outFrame),
BorderLayout.CENTER);
setSize(208,160);
setVisible(true);
}
public void connectClient()
{
try{

//用于连接的Socket
connect1Server();
//得到输入输出流
getStreams();
//处理连接
processConnection();
//关闭连接
closeConnection();
}
catch(EOFException eofException){
System.out.println("Client terminated connection");
}
catch(IOException ee){
ee.printStackTrace();

}
}
//捕获异常
private void getStreams() throws IOException
{
outputS = new ObjectOutputStream(toclient.getOutputStream());
outputS.flush();
inputS = new ObjectInputStream(toclient.getInputStream());
outFrame.append("\n成功建立连接。\n");
}
private void connect1Server() throws IOException
{
outFrame.setText("连接中....\n");
toclient = new Socket(InetAddress.getByName(ChatServer),4000);
outFrame.append("连接至：" + toclient.getInetAddress().getHostName());
}
private void processConnection() throws IOException
{

inputBox.setEditable(true);
//处理来自客户端的消息
do{
//读取消息；
try{
message = (String) inputS.readObject();
outFrame.append("\n" + message);

outFrame.setCaretPosition(outFrame.getText().length());
}
catch(ClassNotFoundException ex){
outFrame.append("\n UnKown object type received");
}
}
while(!message.equals("^_^小粉条>> TERMINATE"));

}
private void closeConnection() throws IOException
{
outFrame.append("\n 关闭连接");
inputBox.setEditable(false);
outputS.close();
inputS.close();
toclient.close();
}
//向服务器端发送消息
private void sendMsg(String message)
{
try{
outputS.writeObject("一肩秋色>> " + message);
outputS.flush();
outFrame.append("\n一肩秋色>>" + message);
}catch(IOException em){
outFrame.append("\nError writing object");
}
}

}
public class ChatClient {

/**
* @param args the command line arguments
*/
public static void main(String[] args) {
// TODO code application logic here
CClient beginning;
if(args.length == 0)
beginning = new CClient("192.168.1.100");//连接到IP
else
beginning = new CClient(args[0]);
beginning.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
beginning.connectClient();
}

}
//无聊写的简单Socket程序，你把里面的名字改下应该就可以用

⑵ java socket有什么作用

所谓socket通常也称作"套接字"，用于描述IP地址和端口，是一个通信链的句柄。应用程序通常通过"套接字"向网络发出请求或者应答网络请求。
以J2SDK-1.3为例，Socket和ServerSocket类库位于java.net包中。ServerSocket用于服务器端，Socket是建立网络连接时使用的。在连接成功时，应用程序两端都会产生一个Socket实例，操作这个实例，完成所需的会话。对于一个网络连接来说，套接字是平等的，并没有差别，不因为在服务器端或在客户端而产生不同级别。不管是Socket还是ServerSocket它们的工作都是通过SocketImpl类及其子类完成的。
重要的Socket API：
java.net.Socket继承于java.lang.Object，有八个构造器，其方法并不多，下面介绍使用最频繁的三个方法，其它方法大家可以见JDK-1.3文档。
. Accept方法用于产生"阻塞"，直到接受到一个连接，并且返回一个客户端的Socket对象实例。"阻塞"是一个术语，它使程序运行暂时"停留"在这个地方，直到一个会话产生，然后程序继续；通常"阻塞"是由循环产生的。
. getInputStream方法获得网络连接输入，同时返回一个InputStream对象实例，。
. getOutputStream方法连接的另一端将得到输入，同时返回一个OutputStream对象实例。
注意：其中getInputStream和getOutputStream方法均会产生一个IOException，它必须被捕获，因为它们返回的流对象，通常都会被另一个流对象使用。
编辑本段ServerSocket类例子
int PORT = 8888; // 侦听端口
// 创建ServerSocket
ServerSocket serverSocket = new ServerSocket(PORT);
// 开始循环
while (true) {
// 等待连接
Socket socket = serverSocket.accept();
// 处理链接的线程类
ServerThread st = new ServerThread(socket);
// 启动线程处理
new Thread(st).start();
}
编辑本段客户端的例子
int PORT = 8888; // 侦听端口
// 建立连接
socket = new Socket(“127.0.0.1”, 8888);
// 输入数据的读取
BufferedReader netIn = new BufferedReader(new InputStreamReader(socket.getInputStream()));
// 写入数据
PrintWriter netOut = new PrintWriter(socket.getOutputStream());

⑶ java做什么会用到socket

1、web项目的话一般用到的socket比较少，因为web项目的话一般运用了一些框架，它们帮你把这些东西都封装了，所以一般不会用到。
2、socket能然你较常接触主要是在网络编程中，很多东西没人帮你封装好，你要自己亲手去敲，去了解。比如你自己写一个聊天系统，你就会较广泛的去运用到socket

⑷ java中的socket是什么意思

所谓socket通常也称作"套接字"，用于描述IP地址和端口，是一个通信链的句柄。应用程序通常通过"套接字"向网络发出请求或者应答网络请求。
以J2SDK-1.3为例，Socket和ServerSocket类库位于java.net包中。ServerSocket用于服务器端，Socket是建立网络连接时使用的。在连接成功时，应用程序两端都会产生一个Socket实例，操作这个实例，完成所需的会话。对于一个网络连接来说，套接字是平等的，并没有差别，不因为在服务器端或在客户端而产生不同级别。不管是Socket还是ServerSocket它们的工作都是通过SocketImpl类及其子类完成的。
重要的Socket API：
java.net.Socket继承于java.lang.Object，有八个构造器，其方法并不多，下面介绍使用最频繁的三个方法，其它方法大家可以见JDK-1.3文档。
. Accept方法用于产生"阻塞"，直到接受到一个连接，并且返回一个客户端的Socket对象实例。"阻塞"是一个术语，它使程序运行暂时"停留"在这个地方，直到一个会话产生，然后程序继续；通常"阻塞"是由循环产生的。
. getInputStream方法获得网络连接输入，同时返回一个InputStream对象实例。
. getOutputStream方法连接的另一端将得到输入，同时返回一个OutputStream对象实例。
注意：其中getInputStream和getOutputStream方法均会产生一个IOException，它必须被捕获，因为它们返回的流对象，通常都会被另一个流对象使用。
2ServerSocket类例子编辑

package com.lanber.socket;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
public class ServerDemo {
/**
* 注意：Socket的发送与接收是需要同步进行的，即客户端发送一条信息，服务器必需先接收这条信息，
* 而后才可以向客户端发送信息，否则将会有运行时出错。
* @param args
*/
public static void main(String[] args) {
ServerSocket ss = null;
try {
ss = new ServerSocket(8888);
//服务器接收到客户端的数据后，创建与此客户端对话的Socket
Socket socket = ss.accept();
//用于向客户端发送数据的输出流
DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
//用于接收客户端发来的数据的输入流
DataInputStream dis = new DataInputStream(socket.getInputStream());
System.out.println("服务器接收到客户端的连接请求：" + dis.readUTF());
//服务器向客户端发送连接成功确认信息
dos.writeUTF("接受连接请求，连接成功!");
//不需要继续使用此连接时，关闭连接
socket.close();
ss.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}

3客户端的例子编辑
package com.lanber.socket;
importjava.io.DataInputStream;
import java.io.DataOutputStream;
importjava.io.IOException;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
public class ClientDemo {
/**
* @param args
*/
public static void main(String[] args) {
Socket socket = null;
try {
socket = new Socket("localhost",8888);
//获取输出流，用于客户端向服务器端发送数据
DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
//获取输入流，用于接收服务器端发送来的数据
DataInputStream dis = new DataInputStream(socket.getInputStream());
//客户端向服务器端发送数据
dos.writeUTF("我是客户端，请求连接!");
//打印出从服务器端接收到的数据
System.out.println(dis.readUTF());
//不需要继续使用此连接时，记得关闭哦
socket.close();
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
}
}
}

⑸ java socket编程 用在哪里 为什么要用

进程通信用，建议网络

简单的Client/Server程序

1.客户端程序

importjava.io.*;
importjava.net.*;

publicclassTalkClient{

publicstaticvoidmain(Stringargs[]){

try{
Socketsocket=newSocket("127.0.0.1",4700);
//向本机的4700端口发出客户请求
BufferedReadersin=newBufferedReader(newInputStreamReader(System.in));
//由系统标准输入设备构造BufferedReader对象
PrintWriteros=newPrintWriter(socket.getOutputStream());
//由Socket对象得到输出流，并构造PrintWriter对象
BufferedReaderis=newBufferedReader(newInputStreamReader(socket.getInputStream()));
//由Socket对象得到输入流，并构造相应的BufferedReader对象
Stringreadline;
readline=sin.readLine();//从系统标准输入读入一字符串
while(!readline.equals("bye")){
//若从标准输入读入的字符串为"bye"则停止循环
os.println(readline);
//将从系统标准输入读入的字符串输出到Server
os.flush();
//刷新输出流，使Server马上收到该字符串
System.out.println("Client:"+readline);
//在系统标准输出上打印读入的字符串
System.out.println("Server:"+is.readLine());
//从Server读入一字符串，并打印到标准输出上
readline=sin.readLine();//从系统标准输入读入一字符串
}//继续循环
os.close();//关闭Socket输出流
is.close();//关闭Socket输入流
socket.close();//关闭Socket
}catch(Exceptione){
System.out.println("Error"+e);//出错，则打印出错信息
}
}
}

2.服务器端程序

importjava.io.*;

importjava.net.*;

importjava.applet.Applet;

publicclassTalkServer{

publicstaticvoidmain(Stringargs[]){

try{

ServerSocketserver=null;

try{

server=newServerSocket(4700);

//创建一个ServerSocket在端口4700监听客户请求

}catch(Exceptione){

System.out.println("cannotlistento:"+e);

//出错，打印出错信息

}

Socketsocket=null;

try{

socket=server.accept();

//使用accept()阻塞等待客户请求，有客户

//请求到来则产生一个Socket对象，并继续执行

}catch(Exceptione){

System.out.println("Error."+e);

//出错，打印出错信息

}

Stringline;

BufferedReaderis=newBufferedReader(newInputStreamReader(socket.getInputStream()));

//由Socket对象得到输入流，并构造相应的BufferedReader对象

PrintWriteros=newPrintWriter(socket.getOutputStream());

//由Socket对象得到输出流，并构造PrintWriter对象

BufferedReadersin=newBufferedReader(newInputStreamReader(System.in));

//由系统标准输入设备构造BufferedReader对象

System.out.println("Client:"+is.readLine());

//在标准输出上打印从客户端读入的字符串

line=sin.readLine();

//从标准输入读入一字符串

while(!line.equals("bye")){

//如果该字符串为"bye"，则停止循环

os.println(line);

//向客户端输出该字符串

os.flush();

//刷新输出流，使Client马上收到该字符串

System.out.println("Server:"+line);

//在系统标准输出上打印读入的字符串

System.out.println("Client:"+is.readLine());

//从Client读入一字符串，并打印到标准输出上

line=sin.readLine();

//从系统标准输入读入一字符串

}//继续循环

os.close();//关闭Socket输出流

is.close();//关闭Socket输入流

socket.close();//关闭Socket

server.close();//关闭ServerSocket

}catch(Exceptione){

System.out.println("Error:"+e);

//出错，打印出错信息

}

}

}

⑹ java Socket通信原理

具体如下：

首先socket 通信是基于TCP/IP 网络层上的一种传送方式，我们通常把TCP和UDP称为传输层。其中UDP是一种面向无连接的传输层协议。UDP不关心对端是否真正收到了传送过去的数据。

如果需要检查对端是否收到分组数据包，或者对端是否连接到网络，则需要在应用程序中实现。UDP常用在分组数据较少或多播、广播通信以及视频通信等多媒体领域。

在这里我们不进行详细讨论，这里主要讲解的是基于TCP/IP协议下的socket通信。

socket是基于应用服务与TCP/IP通信之间的一个抽象，他将TCP/IP协议里面复杂的通信逻辑进行分装。

服务端初始化ServerSocket，然后对指定的端口进行绑定，接着对端口及进行监听，通过调用accept方法阻塞。

此时，如果客户端有一个socket连接到服务端，那么服务端通过监听和accept方法可以与客户端进行连接。

Java是一门面向对象编程语言，不仅吸收了C++语言的各种优点，还摒弃了C++里难以理解的多继承、指针等概念，因此Java语言具有功能强大和简单易用两个特征。

Java语言作为静态面向对象编程语言的代表，极好地实现了面向对象理论，允许程序员以优雅的思维方式进行复杂的编程。

Java具有简单性、面向对象、分布式、健壮性、安全性、平台独立与可移植性、多线程、动态性等特点。Java可以编写桌面应用程序、Web应用程序、分布式系统和嵌入式系统应用程序等。

⑺ java中如何创建socket连接的过程

这是我写过的一个简单聊天软件客户端 你参考下

importjava.util.*;
importjava.io.*;
importjava.net.*;
importjava.awt.*;
importjavax.swing.*;
importjava.awt.event.*;

{
	privateJTextAreajta=newJTextArea();
	privateJTextFieldjtf=newJTextField();
	privateJComboBox<String>jcb=newJComboBox<String>();
	privateJButtonjbsend=newJButton("send");
	privateJButtonjbrefresh=newJButton("refresh");
	privateInputStreaminput;
	privateOutputStreamoutput;
	private	Socketsocket;
	publicstaticStringSERVER_IP="192.168.1.101";
	publicstaticintSERVER_PORT=8888;
	//Message1->refreshmessage
	//Message2->sendmessage
	publictestChatClient()
	{
		initComponents();
		try
		{
			socket=newSocket(SERVER_IP,SERVER_PORT);
			input=socket.getInputStream();
			output=socket.getOutputStream();	
		}
		catch(IOExceptione)
		{
			System.err.println(e);
		}
		jbrefresh.addActionListener(newActionListener()
		{
			publicvoidactionPerformed(ActionEvente)
			{
				jta.setText("");
				try
				{
					if(socket==null)
						socket=newSocket(SERVER_IP,SERVER_PORT);
					output.write(0x31);
				}
				catch(IOExceptionex)
				{
					JOptionPane.showConfirmDialog(null,ex);
				}
			}	
		});
		jbsend.addActionListener(newActionListener()
		{
			publicvoidactionPerformed(ActionEvente)
			{
				if(jtf.getText()==null||jtf.getText().equals(""))
					return;
				if(jtf.getText().length()>=400)
				{
					JOptionPane.showConfirmDialog(null,"最大字数不能超过400");
					return;
				}
				try
				{
					Stringdestination=jcb.getSelectedItem().toString();
					Stringmessage=jtf.getText();
					if(socket==null)
						socket=newSocket(SERVER_IP,SERVER_PORT);
					byte[]temp=newbyte[3+destination.getBytes().length+message.getBytes().length];
					temp[0]=0x32;
					temp[1]=(byte)destination.getBytes().length;
					inti=2;
					for(intj=0;j<destination.getBytes().length;i++,j++)
						temp[i]=destination.getBytes()[j];
					temp[i++]=(byte)message.getBytes().length;
					for(intj=0;j<message.getBytes().length;i++,j++)
					{
						temp[i]=message.getBytes()[j];
						System.out.println();
					}
					output.write(temp);
					jta.append("me:
");
					jta.append(jtf.getText());
					jta.append("
");
					jtf.setText("");
				}
				catch(IOExceptionex)
				{
					System.err.println(ex);
				}
			}
		});
		try
		{
			jbrefresh.doClick();
			while(true)
			{
				byte[]tempBytes=newbyte[1000];
				input.read(tempBytes);
				intcommand=tempBytes[0]-0x30;
				//intreadLength=input.read();
				switch(command)
				{
					case1:
					{
						intreadLength=tempBytes[1];
						String[]temp=newString(tempBytes,2,readLength,"UTF-8").split(";");
						jcb.removeAllItems();
						if(temp.length==0&&temp[0].equals(""))
							return;
						for(inti=0;i<temp.length;i++)
						{
							jcb.addItem(temp[i]);
						}
						jcb.setSelectedIndex(0);
						break;
					}
					case2:
					{
						intreadLength1=tempBytes[1];
						jta.append(newString(tempBytes,2,readLength1,"UTF-8")+"
");
						intreadLength2=tempBytes[2+readLength1];
						jta.append(newString(tempBytes,3+readLength1,readLength2,"UTF-8")+"
");
						break;
					}
				}
			}
		}
		catch(IOExceptione)
		{
			System.err.println(e);
		}
	}
	publicstaticvoidmain(String[]args){
		testChatClientframe=newtestChatClient();
	}
	publicvoidinitComponents()
	{
		setLayout(newBorderLayout());
		JPaneljpNorth=newJPanel();
		jpNorth.setLayout(newBorderLayout());
		jpNorth.add(jcb,BorderLayout.CENTER);
		jpNorth.add(jbrefresh,BorderLayout.EAST);
		JPaneljpSouth=newJPanel();
		jpSouth.setLayout(newBorderLayout());
		jpSouth.add(jtf,BorderLayout.CENTER);
		jpSouth.add(jbsend,BorderLayout.EAST);
		add(jpNorth,BorderLayout.NORTH);
		add(jpSouth,BorderLayout.SOUTH);
		add(newJScrollPane(jta),BorderLayout.CENTER);
		this.getRootPane().setDefaultButton(jbsend);
		setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
		setSize(300,600);
		setVisible(true);
	}
}

⑻ 用Java 的socket实现客户端的功能

//服务端程序：
importjava.io.*;
importjava.net.*;

publicclassTCPServer{
publicstaticvoidmain(String[]args)throwsIOException{
newTCPServer().init();
}
@SuppressWarnings("static-access")
privatevoidinit()throwsIOException{
@SuppressWarnings("resource")
ServerSocketserver=newServerSocket(1000);
Socketclient=null;
while(true){
try{
client=server.accept();
BufferedInputStreambis=newBufferedInputStream(client.getInputStream());
byte[]b=newbyte[1024];
intlen=0;
Stringmessage="";
while((len=bis.read(b))!=-1){
message=newString(b,0,len);
System.out.print("客户端："+client.getInetAddress().getLocalHost().getHostAddress()+"发来消息："+message);
if("byte".equals(message.trim()))
client.close();
PrintWriterpw=newPrintWriter(client.getOutputStream(),true);
pw.println(message);
}
}catch(Exceptione){
System.err.println("客户端："+client.getInetAddress().getLocalHost().getHostAddress()+"已断开连接！");
}
}
}
}

//客户端程序：
importjava.io.*;
importjava.net.Socket;

{
publicstaticvoidmain(String[]args)throwsIOException{
newTCPClient().init();
}
privatevoidinit()throwsIOException{
@SuppressWarnings("resource")
finalSocketclient=newSocket("127.0.0.1",1000);
BufferedReaderin=newBufferedReader(newInputStreamReader(System.in));
Stringsend="";
while(true){
send=in.readLine();
PrintWriterout=newPrintWriter(client.getOutputStream(),true);
if(!"byte".equals(send.trim()))
out.println(send);
else{
out.println(send);
System.exit(0);
}
newThread(newTCPClient(){
@SuppressWarnings("static-access")
publicvoidrun(){
try{
BufferedInputStreambis=newBufferedInputStream(client.getInputStream());
byte[]b=newbyte[1024];
intlen=0;
while((len=bis.read(b))!=-1){
System.out.println("服务器："+client.getInetAddress().getLocalHost().getHostAddress()+"发来消息："+newString(b,0,len).trim());
}
}catch(IOExceptione){
System.err.println("连接服务器失败!");
}
}
}).start();
}
}
publicvoidrun(){}
}

//服务器测试结果：

客户端：192.168.0.200发来消息：001 byte

客户端：192.168.0.200发来消息：byte

客户端：192.168.0.200 已断开连接！

客户端：192.168.0.200发来消息：adasd

客户端：192.168.0.200 已断开连接！

//客户端测试结果：

---001号客户端--

001byte

服务器：192.168.0.200发来消息：001byte

byte //001礼貌说跟服务器说byte

---002号客户端--

adasd //002客户端直接关闭程序

服务器：192.168.0.200发来消息：adasd

⑼ 用JAVA写一个SOCKET 接收TCP发来的消息

服务端监听：ServerSocket server=new ServerSocket(port);//port：绑定的端口号
Socket client=server.accept()();//监听端口，一旦取得连接则获得客户端的socket连接对象client

客户端： Socket s=new Socket(ip,port);//要连接的服务器的ip以及端口号

如果正常连接上之后，socket的对象可以获得InputStream和OutputStreame，然后就可以进行通信了

完成通信之后，执行socket对象的close（）方法关闭连接，完成一次完整的socket连接