第84节：Java中的网络编程（中）

第84节：java中的网络编程（中）

实现客户端和服务端的通信：

客户端需要的操作，创建socket，明确地址和端口，进行键盘录入，获取需要的数据，然后将录入的数据发送给服务端，为socket输出流，然后进行读取服务端发送回来的大写数据，为socket读取流，最后进行客户端显示器的显示，进行读写操作，关闭资源。

网络编程tcp客户端

package com.dashucoding.tcp3;

import java.io.bufferedreader;
import java.io.bufferedwriter;
import java.io.ioexception;
import java.io.inputstream;
import java.io.inputstreamreader;
import java.io.outputstream;
import java.io.outputstreamwriter;
import java.io.printwriter;
import java.net.socket;
import java.net.unknownhostexception;

public class transclient {

    public static void main(string[] args) throws ioexception {
        // 客户端
        // 创建socket 明确地址和端口
        socket s = new socket("192.168.1.151",10005);
        
        // 键盘录入
        bufferedreader bufr = new bufferedreader(new inputstreamreader(system.in));
        
        // 网络， socket输出流
//      outputstream out = s.getoutputstream();
        
        // 传的是字符数据， 转换，提高效率
//      bufferedwriter bufout = new bufferedwriter(new outputstreamwriter(out));
        
        // 打印流，既能接收字符又能接收字节
        printwriter out = new printwriter(s.getoutputstream());
        
        // 读取流,读取服务端发来的数据
//      inputstream in = s.getinputstream();
        bufferedreader bufin = new bufferedreader(new inputstreamreader(s.getinputstream()));
        
        // 显示数据，使用输出语句
        
        // 频繁读写，读键盘
        string line = null;
        while((line=bufr.readline()) != null) {
            if("over".equals(line)) {
                break;
            }
            // 读取键盘的数据发送到服务端
            out.println(line);
            
            // 读取服务端返回的数据
            string uppertext = bufin.readline();
            system.out.println(uppertext);
            
        }
        
        // 关闭资源
        s.close();
        
    }

}

对于服务端，要创建一个服务端的socket，然后明确端口，要读取客户端发送过来的数据，要读取socket输入流，接着使用socket输出流，将数据发送给客户端，进行读写操作，关闭资源。

网络编程tcp服务端

package com.dashucoding.tcp3;

import java.io.bufferedreader;
import java.io.ioexception;
import java.io.inputstreamreader;
import java.io.printwriter;
import java.net.serversocket;
import java.net.socket;

public class transserver {

    public static void main(string[] args) throws ioexception {

        system.out.println("服务端运行。。。");
        // 服务端：
        // 创建服务端的socket,明确端口
        serversocket ss = new serversocket(10005);

        while (true) {
            // 获取客户端对象

            socket s = ss.accept();
            
            // 打印ip地址
            system.out.println(s.getinetaddress().gethostaddress()+"...connected");

            // socket输入流，读取客户端发过来的数据
            bufferedreader bufin = new bufferedreader(new inputstreamreader(s.getinputstream()));

            // socket输出流，将数据发送给客户端
//          printwriter out = new printwriter(s.getoutputstream());
            printwriter out = new printwriter(s.getoutputstream(), true);

            // 频繁的读写操作
            string line = null;
            while ((line = bufin.readline()) != null) {
                // 如果客户端发送过来的是over
                if ("over".equals(line)) {
                    break;
                }
                
                // 客户端的数据
                system.out.println(line);
                // 字母转大写
                out.println(line.touppercase());
                // 都在缓冲区中，刷新
//              out.flush();
            }
            // 关闭客户端
            s.close();
        }
    }

}

package com.dashucoding.tcp3;

import java.io.bufferedreader;
import java.io.bufferedwriter;
import java.io.ioexception;
import java.io.inputstream;
import java.io.inputstreamreader;
import java.io.outputstream;
import java.io.outputstreamwriter;
import java.io.printwriter;
import java.net.socket;
import java.net.unknownhostexception;

public class transclient {

    public static void main(string[] args) throws ioexception {
        
        system.out.println("客户端运行。。。");
        // 客户端
        // 创建socket 明确地址和端口
        socket s = new socket("192.168.2.151",10005);
        
        // 键盘录入
        bufferedreader bufr = new bufferedreader(new inputstreamreader(system.in));
        
        // 网络， socket输出流
//      outputstream out = s.getoutputstream();
        
        // 传的是字符数据， 转换，提高效率
//      bufferedwriter bufout = new bufferedwriter(new outputstreamwriter(out));
        
        // 打印流，既能接收字符又能接收字节
//      printwriter out = new printwriter(s.getoutputstream());
        printwriter out = new printwriter(s.getoutputstream(), true);
        
        // 读取流,读取服务端发来的数据
//      inputstream in = s.getinputstream();
        bufferedreader bufin = new bufferedreader(new inputstreamreader(s.getinputstream()));
        
        // 显示数据，使用输出语句
        
        // 频繁读写，读键盘
        string line = null;
        // 都一行，有行终止符才返回
        while((line=bufr.readline()) != null) {
            // 读取键盘的数据发送到服务端
//          out.print(line+"\r\n");
            out.println(line);
            // 刷数据，都在缓冲区中
//          out.flush();
            if("over".equals(line)) {
                break;
            }
            
            // 读取服务端返回的数据
            string uppertext = bufin.readline();
            system.out.println(uppertext);
            
        }
        
        // 关闭资源
        s.close();
        
    }

}

上传文件

void shutdowninput() 此套接字的输入流置于“流的末尾”
void shutdownoutput() 禁用此套接字的输出流
string tostring() 将此套接字转换为string.

客户端：

package com.dashucoding.net.uploadtext;

import java.io.bufferedreader;
import java.io.filereader;
import java.io.ioexception;
import java.io.inputstreamreader;
import java.io.printwriter;
import java.net.socket;
import java.net.unknownhostexception;

public class uploadtextclient {

    public static void main(string[] args) throws unknownhostexception, ioexception {
        system.out.println("上传文件客户端运行。。。");
        // 客户端
        // 创建socket 明确地址和端口
        socket s = new socket("192.168.43.126", 10006);

        // 读取文本文件
        bufferedreader bufr = new bufferedreader(new filereader("tempfile\\client.txt"));
        // 将数据发送给服务端
        printwriter out = new printwriter(s.getoutputstream(), true);
        
        
        // 显示数据，使用输出语句

        // 频繁读写，读键盘
        string line = null;
        // 都一行，有行终止符才返回true
        while ((line = bufr.readline()) != null) {
            
            out.println(line);

        }
        
        // 给服务端发送一个结束标记，条约标记
//      out.println("over");
        s.shutdownoutput();
        // 向服务端发送了结束标记
        
        // 读取流,读取服务端发来的数据
        bufferedreader bufin = new bufferedreader(new inputstreamreader(s.getinputstream()));
        string info = bufin.readline();
        system.out.println(info);
        // 关闭资源
        bufr.close();
        s.close();
    }

}

服务端：

package com.dashucoding.net.uploadtext;

import java.io.bufferedreader;
import java.io.filewriter;
import java.io.ioexception;
import java.io.inputstreamreader;
import java.io.printwriter;
import java.net.serversocket;
import java.net.socket;

public class uploadtextserver {

    public static void main(string[] args) throws ioexception {
        system.out.println("上传文本服务端运行。。。");
        // 服务端：
        // 创建服务端的socket,明确端口
        serversocket ss = new serversocket(10006);

        while (true) {
            // 获取客户端对象

            socket s = ss.accept();
            system.out.println(s.getinetaddress().gethostaddress() + "...connected");

            // socket输入流，读取客户端发过来的数据
            bufferedreader bufin = new bufferedreader(new inputstreamreader(
                    s.getinputstream()));

            // socket输出流，目的是文件
            printwriter pw = new printwriter(new filewriter("tempfile\\server.txt"), true);

            // 频繁的读写操作
            string line = null;
            while ((line = bufin.readline()) != null) {
                if("over".equals(line)) {
                    break;
                }
                
                pw.println(line);
            }
            
            // 发回给客户端，上传成功
            printwriter out = new printwriter(s.getoutputstream(),true);
            out.println("上传成功");
            
            // 关闭客户端
            s.close();
        }
    }

}

上传图片

客户端：

package com.dashucoding.net.uploadpic;

import java.io.file;
import java.io.fileinputstream;
import java.io.ioexception;
import java.io.inputstream;
import java.io.outputstream;
import java.net.socket;
import java.net.unknownhostexception;

public class uploadpicclient {

    public static void main(string[] args) throws ioexception {
        
        system.out.println("上传图片客户端运行。。。");
        // 上传图片
        // 创建socket
        socket s = new socket("192.168.43.126",10007);
        
        // 读取图片，图片路径
        file picfile = new file("tempfile\\001.jpg");
        fileinputstream fis = new fileinputstream(picfile);
        
        // socket 输出流
        outputstream out = s.getoutputstream();
        
        byte[] buf = new byte[1024];
        int len = 0;
        while((len=fis.read(buf)) != -1) {
            out.write(buf,0,len);
        }
        
        // 告诉服务器端图片数据发送完毕，不要等着读了。
        s.shutdownoutput();
        
        // 读取上传成功
        inputstream in = s.getinputstream();
        byte[] bufin = new byte[1024];
        int lenin = in.read(bufin);
        system.out.println(new string(bufin, 0, lenin));
        
        // 关闭
        fis.close();
        s.close();
        
    }

}

服务端：

package com.dashucoding.net.uploadpic;

import java.io.file;
import java.io.fileoutputstream;
import java.io.ioexception;
import java.io.inputstream;
import java.net.serversocket;
import java.net.socket;

import org.omg.corba_2_3.portable.outputstream;

public class uploadpicserver {

    public static void main(string[] args) throws ioexception {
        
        
        system.out.println("上传图片服务端运行。。。");
        // 创建serversocket
        serversocket ss = new serversocket(10007);

        while (true) { // 实现上传多回
            // 获取客户端
            socket s = ss.accept();
            string ip = s.getinetaddress().gethostaddress();
            system.out.println(ip+"...connected");

            // 读取图片数据
            inputstream in = s.getinputstream();

            // 写图片数据到文件
            file picfile = new file("tempfile\\server.jpg"); // 存储图片
            fileoutputstream fos = new fileoutputstream(picfile);

            byte[] buf = new byte[1024];
            int len = 0;
            while ((len = in.read(buf)) != -1) {
                fos.write(buf, 0, len);
            }

            // 给客户端返回一个回馈信息
            java.io.outputstream out = s.getoutputstream();
            out.write("上传成功".getbytes());

            // 关闭资源
            fos.close();
            s.close();
        }
    }

}

如何解决图片重名的问题：

package com.dashucoding.net.uploadpic;

import java.io.file;
import java.io.fileinputstream;
import java.io.ioexception;
import java.io.inputstream;
import java.io.outputstream;
import java.net.socket;
import java.net.unknownhostexception;

public class uploadpicclient {

    public static void main(string[] args) throws ioexception {
        
        system.out.println("上传图片客户端运行。。。");
        // 上传图片
        // 创建socket
        socket s = new socket("192.168",10007);
        
        // 读取图片，图片路径
        file picfile = new file("tempfile\\001.jpg");
        fileinputstream fis = new fileinputstream(picfile);
        
        // socket 输出流
        outputstream out = s.getoutputstream();
        
        byte[] buf = new byte[1024];
        int len = 0;
        while((len=fis.read(buf)) != -1) {
            out.write(buf,0,len);
        }
        
        // 告诉服务器端图片数据发送完毕，不要等着读了。
        s.shutdownoutput();
        
        // 读取上传成功
        inputstream in = s.getinputstream();
        byte[] bufin = new byte[1024];
        int lenin = in.read(bufin);
        system.out.println(new string(bufin, 0, lenin));
        
        // 关闭
        fis.close();
        s.close();
        
    }

}

package com.dashucoding.net.uploadpic;

import java.io.file;
import java.io.fileoutputstream;
import java.io.ioexception;
import java.io.inputstream;
import java.net.serversocket;
import java.net.socket;

import org.omg.corba_2_3.portable.outputstream;

public class uploadpicserver {

    public static void main(string[] args) throws ioexception {
        
        
        system.out.println("上传图片服务端运行。。。");
        // 创建serversocket
        serversocket ss = new serversocket(10007);

        while (true) { // 实现上传多回
            // 获取客户端
            socket s = ss.accept();
            string ip = s.getinetaddress().gethostaddress();
            system.out.println(ip+"...connected");

            // 读取图片数据
            inputstream in = s.getinputstream();

            // 写图片数据到文件
            // 创建目录
            file dir = new file("e:\\uploadpic");
            // 如果不存在就创建目录
            if(!dir.exists()) {
                dir.mkdir();
            }
            // 给文件编号
            // 加计数器
            int count = 1;
            // 防止第二次为0
            file picfile = new file(dir, ip + "("+count+").jpg");
//          if(picfile.exists()) {
            while(picfile.exists()) {
                count++;
                picfile = new file(dir, ip + "("+count+").jpg");
            }
            fileoutputstream fos = new fileoutputstream(picfile);
            
//          file picfile = new file("tempfile\\" + ip + ".jpg");
//          file picfile = new file("tempfile\\server.jpg"); 
            // 存储图片
            

            byte[] buf = new byte[1024];
            int len = 0;
            while ((len = in.read(buf)) != -1) {
                fos.write(buf, 0, len);
            }

            // 给客户端返回一个回馈信息
            java.io.outputstream out = s.getoutputstream();
            out.write("上传成功".getbytes());

            // 关闭资源
            fos.close();
            s.close();
        }
    }

}

解决上传并发的问题

package com.dashucoding.net.uploadpic;

import java.io.file;
import java.io.fileinputstream;
import java.io.ioexception;
import java.io.inputstream;
import java.io.outputstream;
import java.net.socket;
import java.net.unknownhostexception;

public class uploadpicclient {

    public static void main(string[] args) throws ioexception {
        
        system.out.println("上传图片客户端运行。。。");
        // 上传图片
        // 创建socket
        socket s = new socket("",10007);
        
        // 读取图片，图片路径
        file picfile = new file("tempfile\\001.jpg");
        fileinputstream fis = new fileinputstream(picfile);
        
        // socket 输出流
        outputstream out = s.getoutputstream();
        
        byte[] buf = new byte[1024];
        int len = 0;
        while((len=fis.read(buf)) != -1) {
            out.write(buf,0,len);
        }
        
        // 告诉服务器端图片数据发送完毕，不要等着读了。
        s.shutdownoutput();
        
        // 读取上传成功
        inputstream in = s.getinputstream();
        byte[] bufin = new byte[1024];
        int lenin = in.read(bufin);
        system.out.println(new string(bufin, 0, lenin));
        
        // 关闭
        fis.close();
        s.close();
        
    }

}

package com.dashucoding.net.uploadpic;

import java.io.file;
import java.io.fileoutputstream;
import java.io.ioexception;
import java.io.inputstream;
import java.net.serversocket;
import java.net.socket;

import org.omg.corba_2_3.portable.outputstream;

public class uploadpicserver {

    public static void main(string[] args) throws ioexception {

        system.out.println("上传图片服务端运行。。。");
        // 创建serversocket
        serversocket ss = new serversocket(10007);

        while (true) { // 实现上传多回
            // 获取客户端
            socket s = ss.accept();

            new thread(new uploadpic(s)).start();
        }
    }

}

package com.dashucoding.net.uploadpic;

import java.io.file;
import java.io.fileoutputstream;
import java.io.ioexception;
import java.io.inputstream;
import java.net.socket;

// 创建任务
// 线程完成任务后，会自动结束
public class uploadpic implements runnable {

    private socket s;

    // 创建构造函数
    public uploadpic(socket s) {
        this.s = s;
    }

    @override
    public void run() {
        try {
            // 主线程负债接收客户端，其它线程负责接收数据

            string ip = s.getinetaddress().gethostaddress();
            system.out.println(ip + "...connected");

            // 读取图片数据
            inputstream in = s.getinputstream();

            // 写图片数据到文件
            // 创建目录
            file dir = new file("e:\\uploadpic");
            // 如果不存在就创建目录
            if (!dir.exists()) {
                dir.mkdir();
            }
            // 给文件编号
            // 加计数器
            int count = 1;
            // 防止第二次为0
            file picfile = new file(dir, ip + "(" + count + ").jpg");
//                      if(picfile.exists()) {
            while (picfile.exists()) {
                count++;
                picfile = new file(dir, ip + "(" + count + ").jpg");
            }
            fileoutputstream fos = new fileoutputstream(picfile);

            // 开始循环进行读写操作
            // 一个线程，不能处理并发的数据
            byte[] buf = new byte[1024];
            int len = 0;
            while ((len = in.read(buf)) != -1) {
                fos.write(buf, 0, len);
            }

            // 给客户端返回一个回馈信息
            java.io.outputstream out = s.getoutputstream();
            out.write("上传成功".getbytes());

            // 关闭资源
            fos.close();
            s.close();
        } catch (ioexception e) {
            e.printstacktrace();
        }
    }

}

客户端：浏览器，服务端：tomcat

端口号，\con\server.xml：

浏览器发送http请求

get / http / 1.1
accept: 
accept-language:
accept-encoding:
user-agent:
host:
connection:

请求行，协议，应用层协议，超文本传输协议，请求方式，访问资源的路径，http的协议版本，

package com.dashucoding.net.myserver;

import java.io.ioexception;
import java.io.inputstream;
import java.io.printwriter;
import java.net.socket;
import java.net.unknownhostexception;

public class mybrowser {

    public static void main(string[] args) throws unknownhostexception, ioexception {
        // 浏览器发送http消息
        socket s = new socket("",8080);
        
        // 把信息发送给服务端
        printwriter out=new printwriter(s.getoutputstream(),true);
        out.println("");
        out.println();//空行
        
        // 读取服务端的数据
        inputstream in = s.getinputstream();
        byte[] buf = new byte[1024];
        string text = new string(buf,0,len);
        system.out.print(text);

        s.close();
    }

}

发送和http协议相同的信息，收到了tomcat服务器返回的数据。

package com.dashucoding.net.myserver;

import java.awt.borderlayout;
import java.awt.eventqueue;

import javax.swing.jframe;
import javax.swing.jpanel;
import javax.swing.border.emptyborder;

public class mybrowsergui extends jframe {

    private jpanel contentpane;

    /**
     * launch the application.
     */
    public static void main(string[] args) {
        eventqueue.invokelater(new runnable() {
            public void run() {
                try {
                    mybrowsergui frame = new mybrowsergui();
                    frame.setvisible(true);
                } catch (exception e) {
                    e.printstacktrace();
                }
            }
        });
    }

    /**
     * create the frame.
     */
    public mybrowsergui() {
        setdefaultcloseoperation(jframe.exit_on_close);
        setbounds(100, 100, 450, 300);
        contentpane = new jpanel();
        contentpane.setborder(new emptyborder(5, 5, 5, 5));
        contentpane.setlayout(new borderlayout(0, 0));
        setcontentpane(contentpane);
    }

}

url的描述

java.net
类 url
java.lang.object
java.net.url
所有已实现的接口:
serializable

public final class url extends object implements serializable

url 表示一个统一的资源定位符，用于指向互联网"资源"的指针。

// 构造方法
url (string spec)：
根据string表示形式创建url对象

url (string protocol, string host, int port, string file)
根据指定protocol,host,port号和file创建url对象

package com.dashucoding.net.url;

import java.io.ioexception;
import java.io.inputstream;
import java.net.malformedurlexception;
import java.net.url;
import java.net.urlconnection;

public class urldemo {

    public static void main(string[] args) throws ioexception {
        
string str_url = "http://";
        
        //将url地址封装成对象。
        url url = new url(str_url);
        
//      system.out.println("getprotocol:"+url.getprotocol());
//      system.out.println("gethost:"+url.gethost());
//      system.out.println("getport:"+url.getport());
//      system.out.println("getpath:"+url.getpath());
//      system.out.println("getfile:"+url.getfile());
//      system.out.println("getquery:"+url.getquery());
        
        //获取指定资源的连接对象,封装了socket。
        urlconnection conn = url.openconnection();
        
//      system.out.println(conn);
        
        inputstream in = conn.getinputstream();
        byte[] buf = new byte[1024];
        int len = in.read(buf);
        string text = new string(buf,0,len);
        system.out.println(text);
        
        
    }

}

openconnection
public urlconnection openconnection() throws ioexception
返回一个urlconnection对象，它表示到url所引用的远程对象的连接

urlconnection

package com.dashucoding.net.url;

import java.io.ioexception;
import java.io.inputstream;
import java.net.malformedurlexception;
import java.net.url;
import java.net.urlconnection;

public class urldemo {

    public static void main(string[] args) throws ioexception {

        string str_url = "http://";

        // 将url地址封装成对象。
        url url = new url(str_url);

//      system.out.println("getprotocol:"+url.getprotocol());
//      system.out.println("gethost:"+url.gethost());
//      system.out.println("getport:"+url.getport());
//      system.out.println("getpath:"+url.getpath());
//      system.out.println("getfile:"+url.getfile());
//      system.out.println("getquery:"+url.getquery());

        // 获取指定资源的连接对象,封装了socket。
        urlconnection conn = url.openconnection();

//      system.out.println(conn);

        inputstream in = conn.getinputstream();
        byte[] buf = new byte[1024];
        int len = in.read(buf);
        string text = new string(buf, 0, len);
        system.out.println(text);

    }

}

网络编程中http版本的区别

http1.0请求一次连接就断开了，一次连接只能有一次请求，http1.1一次连接多次请求。

url用于解析url地址，urlconnection用于获取url的连接。

常见的网络架构：cs和bs

client / server
客户端和服务端，维护麻烦

browser / server
只需要服务端，只要系统内置浏览器
所有的运算在服务端，简单易用

结言

好了，欢迎在留言区留言，与大家分享你的经验和心得。

感谢你学习今天的内容，如果你觉得这篇文章对你有帮助的话，也欢迎把它分享给更多的朋友，感谢。

达叔小生：往后余生，唯独有你
you and me, we are family !
90后帅气小伙，良好的开发习惯；独立思考的能力；主动并且善于沟通
简书博客： 达叔小生

结语

• 下面我将继续对 其他知识 深入讲解 ，有兴趣可以继续关注
• 小礼物走一走 or 点赞

如对本文有疑问， 点击进行留言回复！！