8.9.网络编程_Socket远程调用机制

public static void main(String[] args) throws UnknownHostException {
 　　InetAddress localHost = InetAddress.getLocalHost();
 　　System.out.println(localHost.getHostAddress());
 　　System.out.println(localHost.getHostName());
}

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
/**
 * Created by Administrator on 2018/6/7.
 */
public class SocketUDP {
    public static void main(String[] args) throws Exception {
        // 创建发送端 Socket 服务对象
        DatagramSocket dSocket = null;
        try {
            dSocket = new DatagramSocket();
            // 创建数据，打包数据
            String message = "hello ,are u UDP ?";
            byte[] bys = message.getBytes();
            int length = bys.length;
            InetAddress address = InetAddress.getByName("localhost");
            int port = 12621;
            DatagramPacket dPacket = new DatagramPacket(bys, length, address, port);
            // 发送数据
            dSocket.send(dPacket);
            // 资源释放
            dSocket.close();
        } catch (SocketException e) {
            e.printStackTrace();
        }
    }
}

import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

/**
 * Created by Administrator on 2018/6/7.
 */
public class SocketUDPServer {
    public static void main(String[] args) throws Exception {
        //创建接收端 Socket 服务对象
        DatagramSocket dSocket = new DatagramSocket(12621);
        //创建数据包（接收容器）
        byte[] bys = new byte[1024];
        DatagramPacket dPacket = new DatagramPacket(bys, bys.length);
        //调用接收方法
        dSocket.receive(dPacket);
        //数据包解析
        InetAddress address = dPacket.getAddress();
        String hostAddress = address.getHostAddress();
        byte[] data = dPacket.getData();
        String message = new String(data);
        System.out.println(hostAddress+"*********:"+message);
        //资源释放
        dSocket.close();
    }
}

import java.io.OutputStream;
import java.net.Socket;

/**
 * Created by Administrator on 2018/6/7.
 */
public class SocketTCPClient {
    public static void main(String[] args) throws  Exception{
        //创建客户端的 socket 服务，指定目的主机和端口
        Socket s = new Socket("127.0.0.1", 13131);
        //通过 socket 获取输出流，写数据
        OutputStream outputStream = s.getOutputStream();
        outputStream.write("hello ,this is tcp?".getBytes());
        //释放资源
        s.close();
    }
}

import java.io.InputStream;
import java.net.ServerSocket;
import java.net.Socket;

/**
 * Created by Administrator on 2018/6/7.
 */
public class SocketTCPServer {
    public static void main(String[] args) throws Exception {
        //建立服务端 socket 服务，并且监听一个端口
        ServerSocket ss = new ServerSocket(13131);
        //监听连接
        Socket s = ss.accept();
        //获取输入流，读取数据
        InputStream inputStream = s.getInputStream();
        byte[] bys = new byte[1024];
        int len = inputStream.read(bys);
        System.out.println(new String(bys, 0, len));
        //关闭客户端
        s.close();
        //关闭服务端，一般服务端不关闭
        ss.close();
    }
}

import java.net.InetSocketAddress;
import java.net.ServerSocket;
import java.net.Socket;

public class ServiceServer {

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

        // 创建一个serversocket，绑定到本机的8899端口上
        ServerSocket server = new ServerSocket();
        server.bind(new InetSocketAddress("localhost", 8899));

        // 接受客户端的连接请求;accept是一个阻塞方法，会一直等待，直到有客户端请求连接才返回
        while (true) {
            Socket socket = server.accept();
　　　　　　　//业务实现
            new Thread(new ServiceServerTask(socket)).start();
        }
    }
}

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;

public class ServiceServerTask implements Runnable{
    Socket socket ;
    InputStream in=null;
    OutputStream out = null;
    
    public ServiceServerTask(Socket socket) {
        this.socket = socket;
    }

    //业务逻辑：跟客户端进行数据交互
    @Override
    public void run() {
         try {
            //从socket连接中获取到与client之间的网络通信输入输出流 
            in = socket.getInputStream();
            out = socket.getOutputStream();            
            
            BufferedReader br = new BufferedReader(new InputStreamReader(in));
            //从网络通信输入流中读取客户端发送过来的数据
            //注意：socketinputstream的读数据的方法都是阻塞的 
            String param = br.readLine();
            
            /**
             * 可以根据客户端发过来的调用类名、调用方法名、调用该参数来灵活调用
             * 《反射》
             */
            
            GetDataServiceImpl getDataServiceImpl = new GetDataServiceImpl();
            String result = getDataServiceImpl.getData(param);
            
            
            //将调用结果写到sokect的输出流中，以发送给客户端
            PrintWriter pw = new PrintWriter(out);
            pw.println(result);
            pw.flush();
            
        } catch (IOException e) {
             
            e.printStackTrace();
        }finally{
            try {
                in.close();
                out.close();
                socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }    
        }        
    }
}

public class GetDataServiceImpl {
    
    public String getData(String param){    
        return "ok-"+param;
    }
}

import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.io.PrintWriter;
import java.net.Socket;

public class ServiceClient {

    public static void main(String[] args) throws Exception {
        
        /*ServiceIterface service = ProxyUtils.getProxy(ServiceIterface.class,"methodA",hostname,port);
        Result = service.methodA(parameters);*/
        
        // 向服务器发出请求建立连接
        Socket socket = new Socket("localhost", 8899);
        // 从socket中获取输入输出流
        InputStream inputStream = socket.getInputStream();
        OutputStream outputStream = socket.getOutputStream();

        PrintWriter pw = new PrintWriter(outputStream);
        pw.println("hello");
        pw.flush();

        BufferedReader br = new BufferedReader(new InputStreamReader(inputStream));
        String result = br.readLine();
        System.out.println(result);
        
        inputStream.close();
        outputStream.close();
        socket.close();    
    }
}