java socket入门学习笔记

最新推荐文章于 2023-02-14 18:35:43 发布
最新推荐文章于 2023-02-14 18:35:43 发布
阅读量96 收藏 1
点赞数
分类专栏： JAVA基础 文章标签： socket java 网络 多线程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wuraox/article/details/114545528
版权

java socket

计算机网络知识不做赘述

一、InetAddress类

public static void main(String[] args) {
        try {
            System.out.println("--------获取ip地址-------");
            InetAddress byName = InetAddress.getByName("192.168.43.8");
            System.out.println(byName);
            System.out.println("--------根据域名获取ip地址-------");
            InetAddress n2 = InetAddress.getByName("www.baidu.com");
            System.out.println(n2);
            System.out.println(n2.getHostName());  //获取ip对应的域名
            System.out.println(n2.getHostAddress());  //获取IP地址
            System.out.println("--------获取本地址-------");
            InetAddress localHost = InetAddress.getLocalHost();
            System.out.println(localHost);
        } catch (UnknownHostException e) {
            e.printStackTrace();
        }
    }

二、TCP编程

可靠，效率低

客户端：

  1. 创建Socket对象，指明服务器端的ip

  2. 获取一个输出流，用于输出数据

  3. 写出数据

  4. 关闭资源

    public class client {
    private static String ip="127.0.0.1";
    private static int port=8000;

    public static void main(String[] args) {
        /*
        *   1. 创建Socket对象，指明服务器端的ip
            2. 获取一个输出流，用于输出数据
            3. 写出数据
            4. 关闭资源
        * */

        InetAddress ipAddr = null;
        Socket socket = null;
        OutputStream os = null;
        try {
            ipAddr = InetAddress.getByName(ip);
            socket = new Socket(ipAddr, port);
            os = socket.getOutputStream();
            while(true){
                os.write("你好~~".getBytes());
                Thread.currentThread().sleep(3000);
            }
        } catch (IOException e) {
            e.printStackTrace();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } finally {
            if(os != null){
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(socket != null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

服务器端：

  1. 创建服务器端SeverSocket对象，指明端口

  2. 接收来自客户端的socket

  3. 获取输入流

  4. 读取数据

  5. 关闭资源

    public class server {
    private static int port = 8000;
    public static void main(String[] args) {

        /*
        1. 创建服务器端SeverSocket对象，指明端口
        2. 接收来自客户端的socket
        3. 获取输入流
        4. 读取数据
        5. 关闭资源
        * */
        ServerSocket serverSocket = null;
        Socket socket = null;
        InputStream inputStream = null;
        ByteOutputStream bos = null;
        try {
            serverSocket = new ServerSocket(port);
            socket = serverSocket.accept();
            inputStream = socket.getInputStream();
            bos = new ByteOutputStream();
            int len = 0;
            byte [] buf = new byte[10];
            while((len = inputStream.read(buf)) != -1){
                bos.write(buf,0,len);
                System.out.println(bos.toString());
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(bos != null){
                bos.close();
            }
            if(inputStream != null){
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(socket != null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(serverSocket != null){
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

三、UDP编程

不可靠，效率高

客户端：

  1. 创建DatagramSocket对象
  2. 创建datagramPacket数据包对象
  3. 发送数据
  4. 关闭连接
public class client {
    private static String ip = "127.0.0.1";
    private static int port = 8000;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        DatagramSocket datagramSocket = null;
        DatagramPacket datagramPacket = null;
        try{
            datagramSocket = new DatagramSocket();
            while(true){
                String s = sc.next();
                byte [] buf = s.getBytes();
                if(!"q".equals(s) && !"Q".equals(s)){
                    datagramPacket = new DatagramPacket(buf,0,buf.length,InetAddress.getByName(ip),port);
                    datagramSocket.send(datagramPacket);
                }else{
                    break;
                }
            }
        }catch(Exception e){
            e.printStackTrace();
        }finally{
            if(datagramSocket != null){
                datagramSocket.close();
            }
        }
    }
}

服务器端：

  1. 创建DatagramSocket对象
  2. 创建datagramPacket数据包对象
  3. 接收数据
  4. 关闭连接
public class sever {
    private static int port = 8000;
    public static void main(String[] args) {
        DatagramSocket datagramSocket = null;
        byte [] buf = new byte[100];
        DatagramPacket datagramPacket = null;
        try {
            datagramSocket = new DatagramSocket(port);
            datagramPacket = new DatagramPacket(buf, 0, buf.length);
            while (true){
                datagramSocket.receive(datagramPacket);
                System.out.println(datagramPacket.getAddress() + ":" + new String(datagramPacket.getData(),0,datagramPacket.getLength()));
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            datagramSocket.close();
        }
    }
}

四、URL编程

URL类

public static void main(String[] args) {
        try {
            URL url = new URL("http://127.0.0.1:8080/MyWeb/hwllo.html?uername=zjj");
            System.out.println(url.getProtocol());   //获取协议名称
            System.out.println(url.getHost());     //获取IP地址
            System.out.println(url.getPort());     //获取端口号
            System.out.println(url.getPath());    //路径资源
            System.out.println(url.getQuery());   //获取参数
        } catch (MalformedURLException e) {
            e.printStackTrace();
        }
    }

URL访问服务器下载图片

 public static void main(String[] args) {
        HttpURLConnection conn = null;
                InputStream inputStream = null;
        FileOutputStream fos = null;
        try {
            URL url = new URL("http://localhost:8080/jsp/zxy.png");
            conn = (HttpURLConnection) url.openConnection();
            conn.connect();
            inputStream = conn.getInputStream();
            fos = new FileOutputStream("zxy.png");
            byte[] buf = new byte[1024];
            int len =0;
            while((len = inputStream.read(buf)) != -1){
                fos.write(buf,0,len);
            }

        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            if(fos != null){
                try {
                    fos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(inputStream != null){
                try {
                    inputStream.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(conn != null){
                conn.disconnect();
            }
        }
    }

实例：

一、实现传输文件至本地（此处用图片）

实现：socket+io

客户端：

public static void main(String[] args) {
        BufferedInputStream bis = null;
        Socket socket = null;
        OutputStream os = null;
        InputStream is = null;
        try {
            bis = new BufferedInputStream(new FileInputStream("C:\\Users\\18255\\Desktop\\zxy.png"));
            socket = new Socket(InetAddress.getByName("127.0.0.1"), 8000);
            os = socket.getOutputStream();
            is = socket.getInputStream();
            int len = 0;
            byte [] buf = new byte[1024];
            while((len = bis.read(buf)) != -1){
                os.write(buf,0,len);
            }
            socket.shutdownOutput();     //给服务器传传输完成指令
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            byte [] buf2 = new byte[20];
            int len1 = 0;
            while((len1 = is.read(buf2)) != -1){
                bos.write(buf2,0,len1);
            }
            System.out.println(bos.toString());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(os != null){
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(socket != null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

服务端：

public static void main(String[] args) {
        ServerSocket serverSocket = null;
        Socket socket = null;
        InputStream is = null;
        BufferedOutputStream bos = null;
        OutputStream os = null;
        try {
            serverSocket = new ServerSocket(8000);
            socket = serverSocket.accept();
            is = socket.getInputStream();
            bos = new BufferedOutputStream(new FileOutputStream("C:\\Users\\18255\\Desktop\\socketFile.png"));
            int len = 0;
            byte [] buf = new byte[1024];
            while((len = is.read(buf)) != -1){         //由于read是阻塞式的，所以需要在客户端给出停止传输指令才能跳出循环
                bos.write(buf,0,len);
            }
            os = socket.getOutputStream();
            os.write("complete~".getBytes());
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(os != null){
                try {
                    os.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(bos != null){
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(is != null){
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(socket != null){
                try {
                    socket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
            if(serverSocket != null){
                try {
                    serverSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

二、使用UDP实现双向通信

实现方式：开启双线程一个用于接收，另一个用于发送

客户端：

public class client {
    public static void main(String[] args) {
        Send send = new Send();
        Recive recive = new Recive();
        Thread t1 = new Thread(send);
        t1.setName("发送线程");
        Thread t2 = new Thread(recive);
        t2.setName("接收线程");
        t1.start();
        t2.start();
    }
}
/*发送*/
class Send implements  Runnable{
    @Override
    public void run() {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入对方的ip地址:");
        String ip = sc.next();
        InetAddress ipaddr = InetAddress.getByName(ip);
        System.out.println("请输入对方的额端口号:");
        int port = sc.nextInt();
        DatagramSocket socket = null;
        DatagramPacket datagramPacket = null;
        try{
            socket = new DatagramSocket();
            byte []buf = null;
            while(true){
                //System.out.println("请输入信息：");
                String s = sc.next();
                buf = s.getBytes();
                datagramPacket = new DatagramPacket(buf,0, buf.length,ipaddr,port);
                socket.send(datagramPacket);
            }
        }catch(Exception e){
            e.printStackTrace();
        }finally {
            socket.close();
        }
    }
}
/*接收*/
class Recive implements Runnable{
    @Override
    public void run() {
        Scanner sc = new Scanner(System.in);
        DatagramSocket socket = null;
        DatagramPacket datagramPacket = null;
        try {
            socket = new DatagramSocket(8000);
            byte []buf = new byte[100];
            while(true){
                datagramPacket = new DatagramPacket(buf, 0, buf.length);
                socket.receive(datagramPacket);
                System.out.println(new String(datagramPacket.getData(),0,datagramPacket.getLength()));
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(socket != null){
                socket.close();
            }
        }
    }
}

服务端：

public class sever {
    public static void main(String[] args) {
        Send1 send = new Send1();
        Recive1 recive = new Recive1();
        Thread t1 = new Thread(send);
        t1.setName("发送线程");
        Thread t2 = new Thread(recive);
        t2.setName("接收线程");
        t1.start();
        t2.start();
    }
}
/*发送*/
class Send1 implements  Runnable{
    @Override
    public void run() {
        Scanner sc = new Scanner(System.in);
        System.out.println("请输入对方的ip地址:");
        String ip = sc.next();
        InetAddress ipaddr = InetAddress.getByName(ip);
        System.out.println("请输入对方的额端口号:");
        int port = sc.nextInt();
        DatagramSocket socket = null;
        DatagramPacket datagramPacket = null;
        try{
            socket = new DatagramSocket();
            byte []buf = null;
            while(true){
                //System.out.println("请输入信息：");
                String s = sc.next();
                buf = s.getBytes();
                datagramPacket = new DatagramPacket(buf,0, buf.length,ipaddr,port);
                socket.send(datagramPacket);
            }
        }catch(Exception e){
            e.printStackTrace();
        }finally {
            socket.close();
        }
    }
}
/*接收*/
class Recive1 implements Runnable{
    @Override
    public void run() {
        Scanner sc = new Scanner(System.in);
        DatagramSocket socket = null;
        DatagramPacket datagramPacket = null;
        try {
            socket = new DatagramSocket(8001);
            byte []buf = new byte[100];
            while(true){
                datagramPacket = new DatagramPacket(buf, 0, buf.length);
                socket.receive(datagramPacket);
                System.out.println(new String(datagramPacket.getData(),0,datagramPacket.getLength()));
            }
        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(socket != null){
                socket.close();
            }
        }
    }
}

以上服务器于客户端基本一致，所以可以不区分服务器与客户端，谁先开启谁就是服务端（UDP才可以，TCP只能服务端先开启）

wuraox
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
JAVA Socket编程简单笔记
qq_40692756的博客
09-09 210
TCP连接建立过程： 发送端： 1.确定目的ip与端口： InetAddress serverIP = InetAddress.getByName("127.0.0.1"); int port = 31233; 2．创建套接字： Socket socket=new Socker(serverIP,port); 3．获得输出流： outputStream = socket.getOutputStream(); 4．向流进行写入操作 例如写入一句话： outputStream.write(“一句话”.ge
java学习笔记markdown
03-12
通过学习这份Markdown版的Java学习笔记，不仅可以掌握Java编程的基础，还能了解到一些高级话题，为成为熟练的Java开发者打下坚实基础。同时，Markdown格式使得笔记易于编辑和分享，是个人学习和团队协作的理想选择。
Java socket编程入门[1]
myali88的专栏
11-09 1435
本教程由IBM DevelopWorks提供，版权归IBM所有原作：Roy Miller   翻译：Robinh00d[CSTC]翻译本文的目的仅仅是为了练习，本教程版权归IBM所有，本人不对其拥有版权第一章：学习提示我适合学习这份教程吗    Socket提供了两台计算机之间进行通讯的机制，在James Gosling注意Java语言之前就已经很闻名了。Java语言使你更简单有效的使用Socke
Java socket入门
qq_46198929的博客
12-03 108
import java.io.IOException; import java.io.InputStream; import java.net.ServerSocket; import java.net.Socket; public class ServerDemo { public static void main(String[] args) throws IOException { ServerSocket ss=new ServerSocket(10000);
Java的Socket简单入门
吹大的草的博客
05-21 172
聊天室的简单实现 服务端代码 /** * @author gjw * @createTime 2019/5/21 19:06 */ public class FirstSocket { public static void main(String[] args) throws IOException { int linkCount = 0; //建...
Java Socket编程入门
Oscar Chen
03-31 5939
摘要：对Java Socket（套接字）编程做入门的整理、学习的东西太散就老感觉既熟悉又陌生、记录一下、没事的时候可以翻翻看看。以后工作中用到的时候也不会两眼一抹黑、说听过、但是具体说个一二三却哑口无言。注：概念性的解释都是摘抄自网络！
Java基础尚硅谷宋红康学习笔记
05-29
【Java基础】 Java是一种广泛使用的面向对象的编程语言，由Sun Microsystems（现已被Oracle公司收购）于1995年发布。Java以其“一次编写，到处运行”的特性...通过深入学习和实践，你可以不断提升自己的Java编程能力。
java学习笔记
12-22
Java学习笔记涵盖了大量的Java基础知识，包括面向对象编程和高级特性。以下是对这些知识点的详细解释： **基础语法** 1. **数据类型**：Java有基本数据类型和引用数据类型。基本数据类型包括整型（byte, short, int...
java基础知识学习笔记
最新发布
12-26
这篇“java基础知识学习笔记”是为初学者设计的，涵盖了从入门到精通的关键概念，旨在帮助新手快速掌握Java编程。 首先，从入门阶段开始，Java的学习会从安装JDK（Java Development Kit）开始，这是编写、编译和...
java深入学习笔记.pdf
11-29
"java深入学习笔记.pdf" java是一种广泛应用的编程语言，具有平台独立性、对象oriented、分布式处理等特点。在java深入学习笔记.pdf中，我们可以学习到以下知识点： 一、java基础知识 * 变量声明：在java中，变量...
Java socket 入门 示例
gwoham的专栏
07-07 142
面向连接传输协议（TCP） 两台电脑在传输数据前，会先建立一个专属的连接，就如打电话一般，双方通话时，会占有一条专属的通讯连接，当有一方挂机后，此连接就会消失。面向连接的协议特点： 确认回应：设甲乙两台电脑，当甲传数据到乙时，会等乙送回确认后才会再去传下一笔数据。当一段时间没有收到乙的确认回复，甲会试着再传一次，如果传送多次都没有回应，就表示连接可能断了。 分组序号：面向连接协议在传送...
Java Socket 单线程的简单入门案例
天下没有难写的代码
12-01 388
1. 项目目录* 1.1 SocketClient.java源码*package socket.base; import java.io.BufferedReader; import java.io.BufferedWriter; import java.io.IOException; import java.io.InputStreamReader; import java.io.OutputSt
javaSocket笔记
weixin_34357267的博客
04-02 121
1、查看电脑当前开放链接的端口号 使用netstat命令 netstat -nao 可以查看PID进程号 netstat -nab 获取进程的详细信息 2、类创建的不同对象，引用是不同的。也就是说同一个类创建的不同对象，对象中存储的变量是两个不同的存储空间。 1、打开软件 CPNtools 2、新建NewNet，拉取库所(place)和变迁（transition...
Java Socket（慕课网笔记）
hulamua的博客
12-01 660
Java Socket（慕课网笔记）网络基础知识两台主机通过网络进行通信的必备条件： IP地址、协议、端口号 TCP/IP是目前世界上应用最为广泛的协议 是以TCP和IP为基础的不同层次上多个协议的集合 TCP：传输控制协议 IP：互联网协议 端口用于区分不同应用程序。端口号范围为0~65535，其中0-1023为系统所保留，自定义可以选其后的 IP地址和端口号组成了Sock
java-socket学习笔记
csu_vc的博客
03-18 758
最近在学习计算机网络时老师布置了一个socket编程的作业，基于老师给出的服务器以及端口，实现了以下三个功能 第一个listall（），实现获取服务器文件列表 import java.io.*; import java.net.Socket; import java.net.UnknownHostException; public class client
Java Socket 入门
Connect Things
11-08 6813
Java Socket 入门1. Socket 简介1.1 关键问题一：如何定位到目标应用1.2 关键问题二：与 TCP/IP 关系1.3 关键问题三：socket 工作过程2. TCP Echo Request 样例2.1 Server 端2.2 Client 端3. UDP Echo Request 实例3.1 Server 端3.2 Client 端4. UDP Socket 与 TCP S...
JavaSocket编程简单入门
AAS48的博客
09-21 956
【网络知识基础】： 书本官方上说Socket就是{ip:port}的组合。 之后我也看了很多解释Socket的博文，各有各的好，接下来谈谈我个人的看法。 我个人的理解是，在传输层中，socket就能唯一确定一个应用进程。因为，我们可以通过ip地址确定该用户的主机地址，然后可以通过port端口号确定是哪个进程在发出请求或相应。 Socket英文是插座、接口这种意思。其实Socket的工作过程和电话机...
Java基础——Socket：随想笔记
Zain_horse的博客
02-14 106
Java基础——Socekt的使用
java socket 简书_Java之Socket编程入门篇
weixin_39956612的博客
02-26 109
1、什么是SocketSocket是应用层与TCP/IP协议族通信的中间软件抽象层，它是一组接口。在设计模式中，Socket其实就是一个门面模式，他把复杂的TCP/IP协议族隐藏在Socket接口后面，对用户来说，一组简单的接口就是全部，让Socket去组织数据，以符合指定的协议。2、几个专用名词IP：每个计算机都有对应的唯一标识即IP地址，IP地址格式为：255.255.255.255。目前是第...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值