java网络之tcp

简单tcp传输

package pack;

/*
 演示tcp传输。

 1,tcp分客户端和服务端。
 2，客户端对应的对象是Socket。
 服务端对应的对象是ServerSocket。

 客户端，
 通过查阅socket对象，发现在该对象建立时，就可以去连接指定主机。
 因为tcp是面向连接的。所以在建立socket服务时，
 就要有服务端存在，并连接成功。形成通路后，在该通道进行数据的传输。

 需求：给服务端发送给一个文本数据。

 步骤：
 1，创建Socket服务。并指定要连接的主机和端口。

 */
import java.io.*;
import java.net.*;

class TcpClient {
    public static void main(String[] args) throws Exception {
        // 创建客户端的socket服务。指定目的主机和端口
        Socket s = new Socket("127.0.0.1", 10003);

        // 为了发送数据，应该获取socket流中的输出流。
        OutputStream out = s.getOutputStream();

        out.write("tcp ge men lai le ".getBytes());

        s.close();
    }
}

/*
 * 需求：定义端点接收数据并打印在控制台上。
 *
 * 服务端: 1，建立服务端的socket服务。ServerSocket(); 并监听一个端口。 2，获取连接过来的客户端对象。
 * 通过ServerSokcet的 accept方法。没有连接就会等，所以这个方法阻塞式的。
 * 3，客户端如果发过来数据，那么服务端要使用对应的客户端对象，并获取到该客户端对象的读取流来读取发过来的数据。 并打印在控制台。
 *
 * 4，关闭服务端。（可选）
 */
class TcpServer {
    public static void main(String[] args) throws Exception {
        // 建立服务端socket服务。并监听一个端口。
        ServerSocket ss = new ServerSocket(10003);

        // 通过accept方法获取连接过来的客户端对象。
        while (true) {
            Socket s = ss.accept();

            String ip = s.getInetAddress().getHostAddress();
            System.out.println(ip + ".....connected");

            // 获取客户端发送过来的数据，那么要使用客户端对象的读取流来读取数据。
            InputStream in = s.getInputStream();

            byte[] buf = new byte[1024];
            int len = in.read(buf);

            System.out.println(new String(buf, 0, len));

            s.close();// 关闭客户端.
        }
        // ss.close();
    }
}
package pack;

/*
 * tcp客户端发送接收
 * 字符串转换服务器,客户端发送一个字符串,服务器把字符串转换成大学发送回去.
 */
import java.io.*;
import java.net.*;

class TransClient {
    public static void main(String[] args) throws Exception {
        Socket s = new Socket("127.0.0.1", 10005);

        // 定义读取键盘数据的流对象。
        BufferedReader bufr = new BufferedReader(new InputStreamReader(
                System.in));

        // 定义目的，将数据写入到socket输出流。发给服务端。
        // BufferedWriter bufOut =
        // new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
        PrintWriter out = new PrintWriter(s.getOutputStream(), true);

        // 定义一个socket读取流，读取服务端返回的大写信息。
        BufferedReader bufIn = new BufferedReader(new InputStreamReader(
                s.getInputStream()));

        String line = null;

        while ((line = bufr.readLine()) != null) {
            if ("over".equals(line))
                break;

            out.println(line);
            // bufOut.write(line);
            // bufOut.newLine();
            // bufOut.flush();

            String str = bufIn.readLine();
            System.out.println("server:" + str);

        }

        bufr.close();
        s.close();

    }
}

/*
 *
 * 服务端： 源：socket读取流。 目的：socket输出流。 都是文本，装饰。
 */

class TransServer {
    public static void main(String[] args) throws Exception {
        ServerSocket ss = new ServerSocket(10005);

        Socket s = ss.accept();
        String ip = s.getInetAddress().getHostAddress();
        System.out.println(ip + "....connected");

        // 读取socket读取流中的数据。
        BufferedReader bufIn = new BufferedReader(new InputStreamReader(
                s.getInputStream()));

        // 目的。socket输出流。将大写数据写入到socket输出流，并发送给客户端。
        // BufferedWriter bufOut =
        // new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));

        PrintWriter out = new PrintWriter(s.getOutputStream(), true);

        String line = null;
        while ((line = bufIn.readLine()) != null) {

            System.out.println(line);

            out.println(line.toUpperCase());
            // bufOut.write(line.toUpperCase());
            // bufOut.newLine();
            // bufOut.flush();
        }

        s.close();
        ss.close();

    }
}
/*
 * 该例子出现的问题。 现象：客户端和服务端都在莫名的等待。 为什么呢？ 因为客户端和服务端都有阻塞式方法。这些方法么没有读到结束标记。那么就一直等
 * 而导致两端，都在等待。
 */
package pack;

import java.io.*;
import java.net.*;
/**
 *    tcp 上传文件到服务器
 */

class TextClient {
    public static void main(String[] args) throws Exception {
        Socket s = new Socket("127.0.0.1", 10006);

        BufferedReader bufr = new BufferedReader(new FileReader("IPDemo.java"));

        PrintWriter out = new PrintWriter(s.getOutputStream(), true);

        String line = null;
        while ((line = bufr.readLine()) != null) {
            out.println(line);
        }

        s.shutdownOutput();// 关闭客户端的输出流。相当于给流中加入一个结束标记-1.

        BufferedReader bufIn = new BufferedReader(new InputStreamReader(
                s.getInputStream()));

        String str = bufIn.readLine();
        System.out.println(str);

        bufr.close();

        s.close();
    }
}

class TextServer {
    public static void main(String[] args) throws Exception {
        ServerSocket ss = new ServerSocket(10006);

        Socket s = ss.accept();
        String ip = s.getInetAddress().getHostAddress();
        System.out.println(ip + "....connected");

        BufferedReader bufIn = new BufferedReader(new InputStreamReader(
                s.getInputStream()));

        PrintWriter out = new PrintWriter(new FileWriter("server.txt"), true);

        String line = null;

        while ((line = bufIn.readLine()) != null) {
            // if("over".equals(line))
            // break;
            out.println(line);
        }

        PrintWriter pw = new PrintWriter(s.getOutputStream(), true);
        pw.println("上传成功");

        out.close();
        s.close();
        ss.close();

    }
}
package pack;

/*
    tcp上传图片
*/

import java.io.*;
import java.net.*;

class PicClient {
    public static void main(String[] args) throws Exception {
        Socket s = new Socket("192.168.1.254", 10007);
        FileInputStream fis = new FileInputStream("c:\\1.bmp");
        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 num = in.read(bufIn);
        System.out.println(new String(bufIn, 0, num));
        fis.close();
        s.close();
    }
}

/*
 * 服务端
 */
class PicServer {
    public static void main(String[] args) throws Exception {

        ServerSocket ss = new ServerSocket(10007);
        Socket s = ss.accept();
        InputStream in = s.getInputStream();
        FileOutputStream fos = new FileOutputStream("server.bmp");
        byte[] buf = new byte[1024];
        int len = 0;

        while ((len = in.read(buf)) != -1) {
            fos.write(buf, 0, len);
        }

        OutputStream out = s.getOutputStream();
        out.write("上传成功".getBytes());
        fos.close();
        s.close();
        ss.close();
    }
}
/*
 *    上传图片;  服务端多线程接收
 */

import java.io.*;
import java.net.*;

class PicClient {
    public static void main(String[] args) throws Exception {
        if (args.length != 1) {
            System.out.println("请选择一个jpg格式的图片");
            return;
        }

        File file = new File(args[0]);
        if (!(file.exists() && file.isFile())) {
            System.out.println("该文件有问题，要么补存在，要么不是文件");
            return;
        }

        if (!file.getName().endsWith(".jpg")) {
            System.out.println("图片格式错误,请重新选择");
            return;
        }

        if (file.length() > 1024 * 1024 * 5) {
            System.out.println("文件过大，没安好心");
            return;
        }

        Socket s = new Socket("192.168.1.254", 10007);
        FileInputStream fis = new FileInputStream(file);
        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 num = in.read(bufIn);
        System.out.println(new String(bufIn, 0, num));

        fis.close();
        s.close();
    }
}

/*
 * 服务端
 *
 * 这个服务端有个局限性。当A客户端连接上以后。被服务端获取到。服务端执行具体流程。 这时B客户端连接，只有等待。
 * 因为服务端还没有处理完A客户端的请求，还有循环回来执行下次accept方法。所以 暂时获取不到B客户端对象。
 *
 * 那么为了可以让多个客户端同时并发访问服务端。 那么服务端最好就是将每个客户端封装到一个单独的线程中，这样，就可以同时处理多个客户端请求。
 * 如何定义线程呢？
 *
 * 只要明确了每一个客户端要在服务端执行的代码即可。将该代码存入run方法中。
 */

class PicThread implements Runnable {

    private Socket s;

    PicThread(Socket s) {
        this.s = s;
    }

    public void run() {

        int count = 1;
        String ip = s.getInetAddress().getHostAddress();
        try {
            System.out.println(ip + "....connected");

            InputStream in = s.getInputStream();
            File dir = new File("d:\\pic");
            File file = new File(dir, ip + "(" + (count) + ")" + ".jpg");

            while (file.exists())
                file = new File(dir, ip + "(" + (count++) + ")" + ".jpg");

            FileOutputStream fos = new FileOutputStream(file);

            byte[] buf = new byte[1024];

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

            OutputStream out = s.getOutputStream();
            out.write("上传成功".getBytes());
            fos.close();

            s.close();
        } catch (Exception e) {
            throw new RuntimeException(ip + "上传失败");
        }
    }
}

class PicServer {
    public static void main(String[] args) throws Exception {
        ServerSocket ss = new ServerSocket(10007);

        while (true) {
            Socket s = ss.accept();

            new Thread(new PicThread(s)).start();

        }

        // ss.close();
    }
}
/**
*    模拟ie浏览器  访问tomcat服务器
*/
class MyIE
{
    public static void main(String[] args)throws Exception
    {
        Socket s = new Socket("192.168.1.254",8080);

        PrintWriter out = new PrintWriter(s.getOutputStream(),true);

        out.println("GET /myweb/demo.html HTTP/1.1");
        out.println("Accept: */*");
        out.println("Accept-Language: zh-cn");
        out.println("Host: 192.168.1.254:11000");
        out.println("Connection: closed");    //这里设置成close,就会结束访问.

        out.println();    //这里注意要多输出2行 ,   这里是存消息体的.
        out.println();

        BufferedReader bufr = new BufferedReader(new InputStreamReader(s.getInputStream()));

        String line = null;

        while((line=bufr.readLine())!=null)
        {
            System.out.println(line);
        }

        s.close();

    }
}
/*
http://192.168.1.254:11000/myweb/demo.html

GET /myweb/demo.html HTTP/1.1
Accept: application/x-shockwave-flash, image/gif, image/x-xbitmap, image/jpeg, i
mage/pjpeg, application/vnd.ms-excel, application/vnd.ms-powerpoint, application
/msword, application/QVOD, application/QVOD,
Accept-Language: zh-cn
Accept-Encoding: gzip, deflate
User-Agent: Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 2.0
.50727)
Host: 192.168.1.254:11000
Connection: Keep-Alive

*/
/*
    简单用户登录,可以有3次机会.
*/
import java.io.*;
import java.net.*;

class  LoginClient
{
    public static void main(String[] args) throws Exception
    {
        Socket s = new Socket("192.168.1.254",10008);

        BufferedReader bufr =
            new BufferedReader(new InputStreamReader(System.in));

        PrintWriter out = new PrintWriter(s.getOutputStream(),true);

        BufferedReader bufIn =
            new BufferedReader(new InputStreamReader(s.getInputStream()));

        for(int x=0; x<3; x++)
        {
            String line = bufr.readLine();
            if(line==null)
                break;
            out.println(line);

            String info = bufIn.readLine();
            System.out.println("info:"+info);
            if(info.contains("欢迎"))
                break;

        }

        bufr.close();
        s.close();
    }
}

class UserThread implements Runnable
{
    private Socket s;
    UserThread(Socket s)
    {
        this.s = s;
    }
    public void run()
    {
        String ip = s.getInetAddress().getHostAddress();
        System.out.println(ip+"....connected");
        try
        {
            for(int x=0; x<3; x++)
            {
                BufferedReader bufIn = new BufferedReader(new InputStreamReader(s.getInputStream()));

                String name = bufIn.readLine();
                if(name==null)    //这里判断空,是因为如果对方尝试登录1次时候 强行结束,跳出for循环,都close(),就会发送-1过来,readLine()就会读null
                    break;

                BufferedReader bufr = new BufferedReader(new FileReader("user.txt"));

                PrintWriter out = new PrintWriter(s.getOutputStream(),true);

                String line = null;

                boolean flag = false;
                while((line=bufr.readLine())!=null)
                {
                    if(line.equals(name))
                    {
                        flag = true;
                        break;
                    }
                }

                if(flag)
                {
                    System.out.println(name+",已登录");
                    out.println(name+",欢迎光临");
                    break;
                }
                else
                {
                    System.out.println(name+",尝试登录");
                    out.println(name+",用户名不存在");
                }

            }
            s.close();
        }
        catch (Exception e)
        {
            throw new RuntimeException(ip+"校验失败");
        }
    }
}
class  LoginServer
{
    public static void main(String[] args) throws Exception
    {
        ServerSocket ss = new ServerSocket(10008);

        while(true)
        {
            Socket s = ss.accept();

            new Thread(new UserThread(s)).start();
        }
    }
}
import java.io.*;
import java.net.ServerSocket;
import java.net.Socket;

/**
*    简单架设java服务端,用ie访问,输入网址 http://127.0.0.1:10086
*/
public class ServerDemo
{
    public static void main(String[] args) throws Exception {
        ServerSocket ss = new ServerSocket(10086);
        Socket s = ss.accept();
        System.out.println(s.getInetAddress().getHostAddress()+"...connect");

        InputStream is = s.getInputStream();

        byte[] buf = new byte[1024];

        int len = is.read(buf);

        System.out.println(new String(buf,0,len));    //这里会把http协议打印出来

        PrintWriter out = new PrintWriter(s.getOutputStream(),true);
        out.println("登录成功");

        s.close();
        ss.close();
    }
}

GET / HTTP/1.1
Accept: application/x-ms-application, image/jpeg, application/xaml+xml, image/gif, image/pjpeg, application/x-ms-xbap, */*
Accept-Language: zh-CN
User-Agent: Mozilla/4.0 (compatible; MSIE 8.0; Windows NT 6.1; WOW64; Trident/4.0; SLCC2; .NET CLR 2.0.50727; .NET CLR 3.5.30729; .NET CLR 3.0.30729; Media Center PC 6.0; .NET4.0C; .NET4.0E)
Accept-Encoding: gzip, deflate
Host: 127.0.0.1:10086
Connection: Keep-Alive

------------------------------------
小知识
public class Demo
{
    public static void main(String[] args) throws Exception{
        //socket连接服务器写法一
        Socket s1 = new Socket("127.0.0.1",30);

        //socket连接服务器写法二,两种功能一样,就写法有差别
        Socket s2 = new Socket();
        InetSocketAddress insa = new InetSocketAddress("127.0.0.1",80);
        s2.connect(insa);

        //public ServerSocket(int port,int backlog)    backlog队列的最大长度。 就是同时在线人数
        ServerSocket ss = new ServerSocket(10086, 10);
    }
}

--------------------------------------
为什么要有域名?因为ip难记住,所以有了域名.
但是访问服务器要通过ip,所以域名要转成ip就要通过DNS服务器.

访问www.sina.com.cn ->电信DNS服务器->返回一个ip:188.188.188.188->然后再通过ip访问新浪服务器
端口扫描工具
import java.net.*;
class ScanDemo
{
    public static void main(String[] args)
    {
        for(int x=130; x<145; x++)
        {
            try
            {
                Socket s = new Socket("192.168.1.254",x);

                System.out.println(x+"...open");

            }
            catch (Exception e)
            {
                System.out.println(x+"...closed");
            }
        }
    }
}
时间： 2024-10-10 13:47:30

java网络之tcp的相关文章

JAVA网络编程-----tcp

java采用TCP传输时利用Socket和ServerSocket Socket和ServerSocket 建立客户端和服务端 建立连接后,通过Socket中的IO流进行数据的传输. 关闭Socket 同样,客户端与服务端是两个独立的应用程序. 演示tcp传输 1.   tcp分客户端和服务端 2.   客户端对应的对象是Socket,服务端对应的对象是ServerSocket. 客户端: 通过查阅socket对象,发现在该对象建立时,就可以连接指定主机, 因为tcp是面向连接的,所以在建立so

JAVA网络编程TCP通信

Socket简介: Socket称为"套接字",描述IP地址和端口.在Internet上的主机一般运行多个服务软件,同时提供几种服务,每种服务都打开一个Socket,并绑定在一个端口上,不同的端口对应于不同的服务.Socket和ServerSocket类位于java.net包中.ServerSocket用于服务端,Socket是建立网络连接时使用的.连接成功时,应用程序两端都会产生一个Socket实例,通过操作这个实例完成所需会话. Socket常用方法: -int getLocalP

Java网络编程TCP程序，服务器和客户机交互流程以及基本操作步骤。

1.什么是网络编程 网络编程其实就是实现两个计算机的数据交换(交互). 可以通过直接或间接的通过网络协议与其他的计算机进行通讯.(HTTP协议,TCP/IP协议等) 2.Tcp网络编程的实现流程 主要分为服务器端(Server)和客户端(Client). 通过这个图我们其实就可以了解了实现服务器和客户机交互过程是怎么样的了. 实现这些原理最重要的是Socket类也叫做套接字.应用程序通常通过"套接字"向网络发出请求或者应答网络请求. 服务器端 1.首先创建ServerSocket对象并

java网络编程TCP

图片来自网络 [服务端] import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.net.ServerSocket; import java.net.Socket; //服务端 public class MyServer { public static void main(String[] args) { ServerSocket serverSocket =

Java网络编程のTCP/IP

TCP/IP参考模型和TCP/IP协议 与OSI参考模型相似,TCP/IP参考模型汲取了网络分层的思想,而且对网络的层次做了简化,并在网络各层都提供了完善的协议,这些协议构成了TCP/IP协议集,简称TCP/IP协议. TCP/IP参考模型分为4个层次:应用层.传输层.网络互连层和主机-网络层.在每一层都有相应的协议.确切地说,TCP/IP协议应该称为TCP/IP协议集,它是TCP/IP参考模型的除了主机-网络层(由第三方提供)以外的其他三层的协议的集合,而IP协议和TCP协议则是协议集中最核心

JAVA网络编程TCP案例

服务端 import java.net.*; import java.io.*; public class TCPServerSocket { public static void main(String[] args) throws Exception{ String data = ""; //while (true) { try{ ServerSocket ss = new ServerSocket(8888); Socket s = ss.accept(); InputStrea

java 网络编程 TCP协议 java 服务器和客户端 java socket编程

一个 HelloWord 级别的 Java Socket 通信的例子.通讯过程:        先启动 Server 端,进入一个死循环以便一直监听某端口是否有连接请求.然后运行 Client 端,客户端发出连接请求,服务端监听到这次请求后向客户端发回接受消息,连接建立,启动一个线程去处理这次请求,然后继续死循环监听其他请求.客户端输入字符串后按回车键,向服务器发送数据.服务器读取数据后回复客户端数据.这次请求处理完毕,启动的线程消亡.如果客户端接收到 "OK" 之外的返回数据,会再次

Java网络编程(TCP协议-服务端和客户端交互)

客户端: 1 package WebProgramingDemo; 2 3 import java.io.IOException; 4 import java.io.InputStream; 5 import java.io.OutputStream; 6 import java.net.Socket; 7 import java.net.UnknownHostException; 8 9 public class SocketDemo { 10 11 /** 12 * @param args

Java网络编程(TCP客户端)

1 package WebProgramingDemo; 2 3 import java.io.IOException; 4 import java.io.OutputStream; 5 import java.net.Socket; 6 import java.net.UnknownHostException; 7 8 public class SocketDemo { 9 10 /** 11 * @param args 12 * @throws IOException 13 * @throw