java网络编程 socket

最新推荐文章于 2022-09-20 17:07:03 发布
最新推荐文章于 2022-09-20 17:07:03 发布
阅读量207 收藏
点赞数
分类专栏： Java

package com.dasenlin.socket;

import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;

public class Server {
    
    public static void main(String[] args) {
        try {
            ServerSocket server = new ServerSocket(8888);
            System.out.println("服务器启动中");
            while(true){
                java.net.Socket socket =server.accept();
                DataOutputStream output = new DataOutputStream(socket.getOutputStream());
                output.writeUTF("Ip:"+socket.getInetAddress());
                output.writeUTF("Port:"+socket.getPort());
                //output.flush();
                output.close();
                socket.close();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

 

package com.dasenlin.socket;

import java.io.DataInputStream;
import java.io.IOException;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Scanner;

public class Client {
    public static void main(String[] args) throws UnknownHostException, IOException {
        Scanner scan = new Scanner(System.in);
        System.out.println("请输入服务器地址:");
        String ip = scan.nextLine();
        System.out.println("请输入服务器端口:");
        int port=scan.nextInt();
        Socket socket=null;
        DataInputStream inputs=null;
        try {
            socket = new Socket(ip,port);
            inputs = new DataInputStream(socket.getInputStream());
            while(true){//链接上了，一直被阻塞着
                System.out.println("client:"+inputs.readUTF());
            }
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            inputs.close();
            socket.close();
        }
    }
}

package com.dasenlin.socket;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.DataInputStream;
import java.io.File;
import java.io.FileReader;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;
import java.text.SimpleDateFormat;
import java.util.Date;

public class HardServer {
    public static void main(String[] args) {
        ServerSocket server =null;
        Socket socket =null;
        try {
            server = new ServerSocket(8888);
            System.out.println("服务器运行中....");
            while(true){
                socket = server.accept();
                Thread t = new Thread(new ServerRunner(socket));
                t.start();
            }
        } catch (IOException e) {
            e.printStackTrace();
        } 
    }
}
class ServerRunner implements Runnable{
    private Socket socket;
    
    public ServerRunner(Socket socket) {
        this.socket = socket;
    }

    @Override
    public void run() {
        try {
            DataInputStream input = new DataInputStream(socket.getInputStream());
            BufferedWriter writer = new BufferedWriter(new OutputStreamWriter(socket.getOutputStream()));
            while(true){
                String command =input.readUTF();
                String[] array = command.split(":");
                StringBuilder builder = new StringBuilder();
                if("GET".equals(array[0])){
                    File file =new File(array[1]);
                    BufferedReader reader = new BufferedReader(new FileReader(file));
                    String fileContent=null;
                    while((fileContent=reader.readLine())!=null){
                        builder.append(fileContent);
                        builder.append("\n");
                    }
                    
                }else if("TIME".equals(array[0])){
                    SimpleDateFormat sf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
                    builder.append(sf.format(new Date()));
                    builder.append("\n");
                }else{
                    builder.append("未知指令");
                    builder.append("\n");
                }
                builder.append("EOF\n");
                writer.write(builder.toString());
                writer.flush();
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        
    }
    
}
 

package com.dasenlin.socket;

import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.Socket;
import java.util.Scanner;

public class HardClient {
    public static void main(String[] args) {
        try {
            Socket socket = new Socket("127.0.0.1",8888);
            System.out.println("已经链接上服务器，请向服务器输入指令:");
            Thread t = new Thread(new ClientRunner(socket));
            t.start();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
class ClientRunner implements Runnable{
    
    private Socket socket;
    
    public ClientRunner(Socket socket){
        this.socket=socket;
    }
    
    @Override
    public void run() {
        Scanner scan = new Scanner(System.in);
        try {
            BufferedReader input = new BufferedReader(new InputStreamReader(socket.getInputStream()));
            DataOutputStream output = new DataOutputStream(socket.getOutputStream());
            while(true){
                System.out.println("请输入你的请求");
                String command = scan.nextLine();
                output.writeUTF(command);
                while(true){
                    String response = input.readLine();
                    if("EOF".equals(response)){
                        break;
                    }
                    System.out.println(response);
                }
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
    
}

package com.dasenlin.socket;

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

public class FileServer {
    
    public static void main(String[] args) {
        ServerSocket server =null;
    try {
        server = new ServerSocket(8888);
        System.out.println("server start...");
        Thread t = new Thread(new SerRunner(server));
        t.start();
    } catch (IOException e) {
        e.printStackTrace();
    }    
    
    }
    
}
class SerRunner implements Runnable{
    private ServerSocket server;
    
    public SerRunner(ServerSocket server) {
        this.server=server;
    }

    @Override
    public void run() {
        Socket socket=null;
        BufferedOutputStream output=null;
        try {
            socket = server.accept();
            File file =new File(socket.getPort()+".txt");
            output = new BufferedOutputStream(new FileOutputStream(file));
            byte[] bytes = new byte[1024];
            while(true){
                int i=socket.getInputStream().read(bytes);
                if(i==-1)break;
                output.write(bytes,0,i);
            }
            System.out.println("successed"+file.getAbsoluteFile().getAbsolutePath());
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                if(null!=output)output.close();
                if(null!=socket)socket.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    
}

package com.dasenlin.socket;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.net.Socket;
import java.util.Scanner;

public class FileClient {
    public static void main(String[] args) {
        Scanner csan = new Scanner(System.in);
        String ip = "127.0.0.1";
        Integer port = 8888;
        System.out.println("请输入文件名:");
        String filepath=csan.nextLine();
        Thread t = new Thread(new ClientFile(ip,port,filepath));
        t.start();
    }
}
class ClientFile implements Runnable{
    private String ip;
    private Integer port;
    private String filepath;
    public ClientFile(String ip,Integer port,String filepath) {
        this.ip=ip;
        this.port=port;
        this.filepath=filepath;
    }

    @Override
    public void run() {
        BufferedOutputStream out =null;
        BufferedInputStream input=null;
        try {
            Socket socket = new Socket(ip,port);
             out = new BufferedOutputStream(socket.getOutputStream());
             input = new BufferedInputStream(new FileInputStream(new File(filepath)));
            byte [] bytes = new byte[1024];
            int i=-1;
            while((i=input.read(bytes))!=-1){
                out.write(bytes,0,i);
            }
            out.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }finally{
            try {
                if(null!=out)out.close();
                if(null!=input)input.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
    
}

package com.dasenlin.socket;

import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.net.ServerSocket;
import java.net.Socket;

public class ChartServer {
    
    public static void main(String[] args) throws IOException {
        ServerSocket server = new ServerSocket(8888);
        while(true){
                final Socket socket = server.accept();
                Thread t1 = new Thread(){
                    @Override
                    public void run(){
                        try {
                            DataInputStream input = new DataInputStream(socket.getInputStream());
                            while(true){
                                String s = input.readUTF();
                                System.out.println("客户端说:"+s);
                            }
                        
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                        
                    }
                };
                t1.start();
                
                Thread t2 = new Thread(){
                    @Override
                    public void run(){
                        try {
                            BufferedReader br = new BufferedReader(new InputStreamReader(System.in, "UTF-8"));
                            try {
                                DataOutputStream out = new DataOutputStream(socket.getOutputStream());
                                while(true){
                                    String s = br.readLine();
                                    out.writeUTF(s);
                                }
                            } catch (IOException e) {
                                e.printStackTrace();
                            }
                        } catch (UnsupportedEncodingException e) {
                            e.printStackTrace();
                        }
                    }
                };
                t2.start();
            
        }
    }
}
 

package com.dasenlin.socket;

import java.io.BufferedReader;
import java.io.DataInputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UnsupportedEncodingException;
import java.net.Socket;
import java.net.UnknownHostException;

public class ChartClient {
    
    public static void main(String[] args) throws UnknownHostException, IOException {
            final Socket s = new Socket("127.0.0.1",8888);
            Thread t1 = new Thread(){
                @Override
                public void run(){
                    DataInputStream input;
                    try {
                        input=new DataInputStream(s.getInputStream());
                        while(true){
                            String s = input.readUTF();
                            System.out.println("服务端说:"+s);
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                    
                }
            };
            t1.start();
            
            Thread t2 = new Thread(){
                @Override
                public void run(){
                    try {
                        BufferedReader br = new BufferedReader(new InputStreamReader(System.in, "utf-8"));
                        try {
                            DataOutputStream out = new DataOutputStream(s.getOutputStream());
                            while(true){
                                String s=br.readLine();
                                out.writeUTF(s);
                            }
                        
                        } catch (IOException e) {
                            e.printStackTrace();
                        }
                    
                    } catch (UnsupportedEncodingException e) {
                        e.printStackTrace();
                    }
                
                }
            };
            t2.start();
            
        
    }
}
 

 

修炼到救赎
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
记一次Socket通信InputStream中数据读取不完整踩坑
weixin_43861609的博客
04-13 3305
记一次Socket通信InputStream中数据读取不完整踩坑 问题代码： String message="ceshibaowen"; Socket socket=new Socket(socketIP,socketPort); socket.setSoTimeout(120000); DataInputStream in=new DataInputStream(socket.getInputStream()); OutputStream out=socket.getOutputStream(); out
Java Socket网络编程
Bjk1304228686的博客
05-04 358
1 Socket概述 Java的网络编程主要涉及到的内容是Socket编程。Socket，套接字，就是两台主机之间逻辑连接的端点。TCP/IP协议是传输层协议，主要解决数据如何在网络中传输，而HTTP是应用层协议，主要解决如何包装数据。Socket是通信的基石，是支持TCP/IP协议的网络通信的基本操作单元。它是网络通信过程中端点的抽象表示，包含进行网络通信必须的五种信息：连接使用的协议、本地主机的IP地址、本地进程的协议端口、远程主机的IP地址、远程进程的协议端口。 应用层通过传输层进行数据通信时，T
Java游戏服务器-Netty自动重连与会话管理
mingtianhaiyouwo的博客
11-24 2845
 网游少不了网络通信，不像写C++时自己造轮子，Java服务器使用Netty。Netty做了很多工作，使编写网络程序变得轻松简单。灵活利用这些基础设施，以实现我们的需求。 其中一个需求是自动重连。自动重连有两种应用场景： 开始连接时，对端尚未开启 连接中途断开 在有多个服务器（比如LoginServer和GameServer等）时，这样就不用考虑服务器启动顺序。 有需求就需要有
python--HTTP通过127.0.0.1:8888访问百度网页
万物皆有灵
08-09 9731
一、HTTP测试 在本地网址输入：127.0.0.1:8888，网址会响应hello world #!/usr/bin/python3 # -*- coding: utf-8 -*- # @Date : 2021/8/5 # @Name : ZhouZongXin """ http测试 在本地网址输入：127.0.0.1:8888，网址会响应hello world """ from socket import * s = socket() s.bind(("0.0.0.0", 8888)) s.
Fiddler使用
yushuangyushuang的博客
07-20 1492
一、web Session面板 主要是Fiddler抓取到的每条http请求（每一条称为一个session）,主要包含了请求 的url,协议，状态码，body等信息，详细的字段含义如下图所示： ...
java socket编程_Java套接字Socket编程如何实现聊天小工具
weixin_39732506的博客
11-23 186
#头条公开课繁星计划# #Java# 聊天工具在如今这个信息爆炸时代，是不可或缺的必备社交工具之一。对于初学Java套接字Socket编程者，用Java套接字Socket编程实现简单的聊天小工具，就是一个很好的练习项目。既简单，有能基本理解Java套接字的运行原理、所涉及到的类及其属性和类之间的关系。该聊天小工具需要完成服务器端和客服端2部分功能。创建项目，其结构如下：Java套接字Socket编...
java网络编程——socket
qq_43501944的博客
11-14 158
一、服务端： 使用ServerSocket监听指定的端口，端口可以随意指定（由于1024以下的端口通常属于保留端口，在一些操作系统中不可以随意使用， 所以建议使用大于1024的端口），等待客户连接请求，客户连接后，会话产生；在完成会话后，关闭连接。 1、主类：调用第一个线程类 public class TestMain { JFrame jFrame; public static void ma...
java网络编程 socket的TCP应用编程
01-09
- Java Socket类和ServerSocket类是进行TCP网络编程的核心API。 - ServerSocket用于创建服务器端的套接字，监听特定端口的连接请求。 - Socket用于创建客户端的套接字，与服务器建立连接。 3. **服务端编程**： ...
java网络编程socket非阻塞通信
06-14
通过java网络编程深入理解socket阻塞通信和非阻塞通信的在网络中的应用 源码包每一行都有注释，在代码里面每一个类都有详细的注释来解释这个类的功能这个方法的功能，调用哪一个类的哪一个功能等等。 压缩包包含实验...
Java网络编程socket
11-04
Java网络编程中的Socket是连接应用程序与网络协议的重要接口，它提供了低级别的TCP/IP通信机制。在Java中，Socket编程主要用于实现客户端（Client）与服务器端（Server）之间的双向通信。本篇文章将深入探讨Java ...
Java 网络编程socket编程等详解
08-30
本文将深入探讨Java中的网络编程，特别是焦点在于Socket编程。 首先，我们要理解网络编程的基本概念。网络编程涉及编写能够在多台设备间通信的程序，这些设备通过网络连接。Java的`java.net`包包含了处理网络通信所...
java网络编程socket
01-04
这是java网路编程中的socket客户端
Socket 实现TCP长连接二，最简单代码，DataInputStream、DataOutputStream方式，控制台可测试
haoranhaoshi的博客
07-27 1537
package TCP.LongConnection1; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.IOException; import java.io.InputStream; import java.net.ServerSocket; import java.net.So...
java 实现 tcp_java实现TCP通信
weixin_31641077的博客
02-18 1759
1.概述通过ServerSocket与Socket实现的TCP的通信,这个例子配合了swing使用,其实作者之前发过一篇ServerSocker与Socket的通信,在这里,这边文章就是在这个例子上修改而成的.其实原理很简单的,就是一个服务端一个客户端,服务端这边创建好ServerSocket后,使用accept()堵塞一直等待客户端发送socket.好吧,不废话了.进正题.2.服务端swing的...
java服务端与客户端通信,Java Socket 服务端与客户端通信
weixin_42513296的博客
03-13 119
Java Socket 服务端与客户端通讯Server.javaimport java.io.BufferedReader;import java.io.DataInputStream;import java.io.DataOutputStream;import java.io.InputStreamReader;import java.net.ServerSocket;import java.n...
socket传输不同的数据类型
hongmofang10的博客
05-31 8417
主要记录一下用socket传输不同的数据用到的各种API。方便日后查询。 1，传输数字 发送端： Socket socket = new Socket("127.0.0.1", 9099); OutputStream os = socket.getOutputStream(); DataOutputStream dos = new DataOutputStream(os); dos.w...
Java 网络编程（大全）
热门推荐
快乐学习
09-20 1万+
浏览器就是我们日常使用的浏览器去访问各种网站，只要有浏览器就可以访问，不依赖特定的PC端，在任意设备上都可以访问网站服务器。不需要建立连接（因为把数据源IP、目的地IP、端口封装成数据包），每个数据包在64KB内，只管发，不管对方有没有接到确认什么的。IP地址可以理解为具体哪个计算机，端口理解计算机上的程序（一个程序一个端口），协议理解为电脑通过什么方式和外界交互。客户端是需要程序员去开发的，例如日常使用的各种的APP，服务端就是服务器。一、2请分析C/S和B/S架构相比的各自的优缺点？
03 爬虫 - HTTP代理神器Fiddler
阿甘兄
08-29 463
Fiddler是一款强大Web调试工具，它能记录所有客户端和服务器的HTTP请求。 Fiddler启动的时候，默认IE的代理设为了127.0.0.1:8888，而其他浏览器是需要手动设置。 工作原理 Fiddler 是以代理web服务器的形式工作的，它使用代理地址：127.0.0.1，端口：8888 Fiddler抓取HTTPS设置 1.启动Fiddler，打开菜单栏中的 Tools > ...
8051Proteus仿真c源码8X8点阵应用演示程序
最新发布
08-20
8051Proteus仿真c源码8X8点阵应用演示程序提取方式是百度网盘分享地址
Java网络编程Socket
05-12
Java网络编程中，Socket是常用的网络通信工具之一。Socket是一种抽象层，它提供了一种机制，使得应用程序可以通过网络进行通信。可以使用Socket在两台计算机之间建立一个连接，通过这个连接进行数据的传输。 在Java...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值