Java入门笔记9_Socket

类别:Java 点击:0 评论:0 推荐:
1. Client/Server Networking

Java通过socket来完成它所有的网络底层的通讯,socket是一种通讯的通道,通过它可以将数据通过特定的端中发送及接收。Java中的socket可以分成二大类:

(1) Datagram Sockets:数据包socket;

(2) Stream Sockets:流socket;

1.2 Datagram Socket

Datagram socket使用UDP来实现数据通讯,因此它不能保证数据能够到达目的地,但是由于它不需要专用的网络链接,所以它所需的资源相对少的多。

Datagram以包的方式发送数据,但它不能保证这些数据包以特定的顺序到达目的,因此包中往往需要包含序列号的信息,接收方可以根据序列号的信息决定是否所有的包都已收到,并按正常顺序重组这些包。

Java通过两个类DatagramSocket和DatagramPacket来支持Datagram socket。DatagramSocket实现了Datagram socket的基本功能,而DatagramPacket则提供了对包的一些支持。

DatagramSocket的几个重要方法:

(1) DatagramSocket():随机绑定一个有效的端口;

(2) DatagramSocket(int port):绑定指定的端口;

(3) Void send(DatagramPacket p):发送数据报,由于目的地的地址信息已包含在数据报中,所以不需要在本函数中提供地址信息;

(4) synchronized void receive(DatagramPacket p):接收数据包,线程安全;

(5) synchronized void close():关闭socket;

在DatagramSocket中并不区分ServerSocket和ClientSocket,如果一定要区分,那么发送的是client,而接收的是server。

DatagramPacket有以几个重要的方法:

(1) DatagramPacket(byte ibuf[], int ilength):用于接收数据报;

(2) DatagramPacket(byte ibuf[], int ilength, InetAddressiaddr, int iport):用于发送的数据报;

(3) byte[] getData()

(4) int getLength()

以下是完整的Datagram Socket的例子:

接收端,Server端代码:

import java.io.*;

import java.net.*;

 

class FortuneServer1 extends Thread

{

  DatagramSocket ServerSocket;

  public FortuneServer1()

  {

    super("FortuneServer1");

    try

      {

        ServerSocket = new DatagramSocket(1114);

        System.out.println("FortuneServer up and running...");

      }

    catch (SocketException e)

      {

        System.err.println("Exception: couldn't create datagram socket");

        System.exit(1);

      }  } 

 

  public static void main(String[] args)

  {

     FortuneServer1 server = new FortuneServer1();

     server.start();

  }

 

 public void run()

 {

   if (ServerSocket == null)

     return;

 

   while (true)

   {

     try

       {

          InetAddress     address;

          int             port;

          DatagramPacket  packet;

          byte[]          data = new byte[256];

          int             num = 1;

         

          packet = new DatagramPacket(data, data.length);

          ServerSocket.receive(packet);   

          address = packet.getAddress();

          port = packet.getPort();

         

          File inFile = new File("Fortunes.txt");

          FileInputStream inStream = new FileInputStream(inFile);

         

          if (inStream.read(data) <= 0)

            {

               System.err.println("Error: couldn't read fortunes");            

            }

         

         packet = new DatagramPacket(data, data.length, address, port);

          ServerSocket.send(packet);

       }

     catch (Exception e)

       {

          System.err.println("Exception: " + e);

          e.printStackTrace();

       }   } } }

说明:

(1) 这个例子中接收端的socket使用了多线程,多线程的概念可以参考本文的多线程部分;

(2) 在构造函数中创建了DatagramSocket,并且使用了1114这个端口;

(3) 本例子的关键函数是run,它使用了死循环,在循环中使用了receive这方法来临听1114端口,如果1114端口没有请求数据到来,那么这个程序就一直停留在receive这个位置,不再往下执行;

(4) 当1114端有数据时,receive方法将接收到的DatagramPacket数据包放在packet这个对象中,然后解析其中的数据,获取发送方的地址信息;

(5) 然后再创建DatagramPacket包,并填充数据,发送到原接收端。

以下是发送端的代码:

import java.io.*;

import java.net.*;

class FortuneClient

{

    public static void main(String args[])

    {

        FortuneClient client = new FortuneClient();

        System.out.println(client.getMessage());

    }

   

    public String getMessage()

    {

        String fortune;

   try {

     DatagramSocket  socket;

     DatagramPacket  packet;

     byte[]          data = new byte[256];

 

     socket = new DatagramSocket();

     packet = new DatagramPacket(data, data.length,InetAddress.getByName("127.0.0.1"), 1114);

     socket.send(packet);

 

     packet = new DatagramPacket(data, data.length);

     socket.receive(packet);

     fortune = new String(packet.getData(), 0);

     socket.close();

   }

   catch (UnknownHostException e) {

     System.err.println("Exception: host could not be found");

     return null;

   }

   catch (Exception e) {

     System.err.println("Exception: " + e);

     e.printStackTrace();

     return null;

   }

   return fortune;

  } }

客户端的代码与服务器端的代码基本相同,只是没有了循环,并且处理步骤与服务器端的基本相反。这也说明了Datagram Socket不真正区分Server和Client。

1.3 Stream Socket

Stream Socket与Datagram Socket不同,它有一个永久性的链接,可以确保数据可靠的发送到对方。但是Stream Socket所占的资源更多。

Java主要通过Socket及ServerSocket来实现Stream Socket,一个用于客户端,另一个用户服务器端。

Socket类的几个重要方法如下:

(1) Socket(String host, int port)

(2) Socket(InetAddress address, int port)

(3) synchronized void close()

(4) InputStream getInputStream()

(5) OutputStream getOutputStream()

可以看出Stream Socket中的Socket与Datagram Socket中的Socket的区别:

(1) 在构造函数中,这里需要指定服务器的地址与端口,用于它发送数据之前建立链接,而Datagram的Socket不需要建立链接,它仅需要在要发送的数据包中包含地址信息即可;

(2) Stream Socket的两个重要方法和其它流的方法类似,而且在操作上也相似,其实在操作Stream Socket时,只要建立了链接,那么以后的操作和流的操作一样了,你可以忘了你在操作Socket,只当做自己在操作普通的流。

ServerSocket有以下几个重要的方法:

(1) ServerSocket(int port):监听指定端口,监听时间为默认值50;

(2) ServerSocket(int port, int count):监听指定端口,并指定监听时间;

(3) ServerSocket(int port, int backlog, InetAddress bindAddr):只接收指定接口发过来的数据;

(4) Socket accept():accpet方法会返回一个Socket对象,使用该Socket对象的getInputStream及getOutputStream方法获取输入及输出流。由此可见无论是服务器端还是客户端,它们都是通过Socket对象来收发数据的。程序执行到accpet时会进入监听状态,不再向下执行一直到接收到数据。

(5) void close()

以下是关于Stream Socket的一个例子,在这个例子中使用单独的二个类Receiver和Sender负责对指定的输入及输出流进行操作,用另一个类SocketPerformer来创建Receiver和Sender这两个类的实例,并传入指定的输入及输出流,而在Client及Server这两个类中,负责创建SocketPerformer对象,并传入指定的Socket。因此这五个类在功能上分为三层,第一层负责对流进行操作,第二层负责创建指定的Socket流,并这些Socket流传到第一层,第三层负责创建Socket并将这些Socket传到第二层。

Receriver代码:

package socketChat;

import java.io.BufferedReader;

public class Receiver extends Thread {

    BufferedReader reader;

    public Receiver(BufferedReader theSocketReader) {

        reader = theSocketReader;

    }

 

    public void run() {

        while (true) {

            try {

                String words = reader.readLine();                System.out.println("\r\n<<< " + words);

            } catch (Exception e) {

                e.printStackTrace();

                return;

            }        }    }}

Sender代码:

package socketChat;

import java.io.BufferedReader;

import java.io.InputStreamReader;

import java.io.PrintWriter;

 

public class Sender extends Thread {   

    PrintWriter writer;

    public Sender(PrintWriter theWriter) {

        writer = theWriter;

    }

    public void run() {

        try {

            while (true) {

                BufferedReader consoleReader = new BufferedReader(

                        new InputStreamReader(System.in));

                String userInput = consoleReader.readLine();

                writer.write(userInput + "\r\n");

                writer.flush(); // send the data in buffer immediately

            }

        } catch (Exception e) {

            e.printStackTrace();

            return;

        }    }}

SocketPerformer代码:

package socketChat;

import java.io.BufferedReader;

import java.io.InputStreamReader;

import java.io.PrintWriter;

import java.net.Socket;

public class SocketPerformer {

    Socket socket;

    public SocketPerformer(Socket theSoc){

        socket = theSoc;

    }

    public void execut() throws Exception{

        BufferedReader socketReader = new BufferedReader(new InputStreamReader(

                socket.getInputStream()));

        PrintWriter socketWriter = new PrintWriter(socket.getOutputStream());

        System.out.println("connection built !"); 

     

        Receiver rec = new Receiver(socketReader);

        rec.start();

       

        Sender sender = new Sender(socketWriter);

        sender.start();

    }}

Server代码:

package socketChat;

 

import java.net.ServerSocket;

import java.net.Socket;

public class Server {

    public static void main(String[] args) throws Exception {      

        ServerSocket server = new ServerSocket(30000, 5);

        Socket socket = null;

        System.out.println("waiting incoming connection...");

        socket = server.accept();

        System.out.println("a connection built!");

        System.out.println("the peer ip is: " + socket.getInetAddress().getHostAddress());

        new SocketPerformer(socket).execut();

        server.close();

    }}

Client端代码如下:

package socketChat;

import java.net.Socket;

public class Client {

 

    public static void main(String[] args) throws Exception {

        String ip = "127.0.0.1";                  

        int port = 30000;

        System.out.println("connecting to server: " + ip

                + " at port: " + port + " ...");       

 

        Socket soc = new Socket(ip, port);

        new SocketPerformer(soc).execut();

    }}

2. 其它

(1) 常量定义以final做修饰符,如final int I = 3;final还可以用在class及method上,如果用在class上,那么该class不能被继承,如果用在method上,那么该method不能被重载

(2) 类变量定义:static int sum

(3) 判断对象类型:objName instanceof className,如"helloWorld" instanceof String,判断的结果是true

(4) 提取对象的类名:objName.getClass().getName()

(5) java.lang:Java最基本的包,包含java语言最基本的定义

(6) java.util:包含如Date,及基本的集合类,如Vector、Hashtable等

(7) java.io:包含输入输出的定义

(8) java.net:包含如Socket等

(9) java.awt:用于Window界面开发

(10) java.applet:用于applet开发

(11) null关键字引用null对象,注意大小写

(12) 每个基本的数据类型如int,都有相应的类与之对应中Int

(13) 构造函数名与类名相同,并且不需要返回类型,即在构造函数前不需要加类型修饰符

(14) 调用自身的构造函数:this(参数列表);

(15) 调用父类的构造函数:super(参数列表);

(16) 调用父类已被重载的函数:super.方法名(参数列表);

(17) 在同一文件中可以有多个类的定义,但只能有一个类是public并且类名与文件一样,该文件编译成功后会生成多个.class文件,与类的定义一一对应;

(18) 接口比抽象类功能强有:抽象类属于特定的类结构树中,它不能被其它树中的类共享;

(19) 接口的定义与类的定义类似,只需将class改成interface即可,但接口定义必须是public或者缺省的(package);

(20) 在接口中可以定义方法和变量,接口中的定义的方法应是public并且是abstract的(缺省);变量的定义必须是public static final(缺省);

(21) String.copyValueOf(buffer, 0, offset):用于从字符数组中取出字符,并形成字符串;

(22) new String(buf, 0, count)

(23) System.in(标准输入)是一个InputStream;

(24) System.err是一个PrintStream;

(25) System.out是一个PrintStream;

本文地址:http://com.8s8s.com/it/it11286.htm