Java基础——网络编程

1、获取IP

package cn.itcast.net.p1.ip;

import java.net.InetAddress;
import java.net.UnknownHostException;

public class IPDemo {

    public static void main(String[] args) throws UnknownHostException {
        // TODO Auto-generated method stub
//      获取本地主机ip地址对象
        InetAddress ip=InetAddress.getLocalHost();
//      获取其他主机的ip地址对象
        ip=InetAddress.getByName("www.baidu.com");
        System.out.println(ip.getHostAddress());//获取本地主机IP地址
        System.out.println(ip.getHostName());//获取本地主机名称
    }

}

2、UDP传输方式编程

发送端

package cn.itcast.net.p1.udp;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;

public class UDPSendDemo {

    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        /*
         * 创建UDP传输的发送端
         * 思路：
         * 1、建立UDP的socket服务
         * 2、将要发送的数据封装到数据包中
         * 3、通过udp的socket服务将数据包发送出去
         * 4、关闭socket服务
         * 
         * */
        System.out.println("发送端启动");
//      1、建立udpsocket服务，使用DatagramSocket对象
        DatagramSocket ds=new DatagramSocket();
//      2、将要发送的数据封装到数据包中
        String str="udp传输演示";
//      使用DatagramPacket将数据封装到该对象包中
        byte[]buf=str.getBytes();
        DatagramPacket dp=new DatagramPacket(buf,buf.length,InetAddress.getByName("172.25.11.91"),10000);
//      3、通过udp的socket服务将数据包发送出去，使用send方法
        ds.send(dp);
//      4、关闭资源
        ds.close();
    }

}

接收端

package cn.itcast.net.p1.udp;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

public class UDPReceiveDemo {

    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        /*
         * 建立UDP接收端的思路：
         * 1、建立socket服务，因为是要接收数据，必须要明确一个端口号
         * 2、创建数据包，用于存储接收到的数据，方便用数据包对象的方法解析这些数据
         * 3、使用socket服务的receive方法将接收的数据存储到数据包中
         * 4、通过数据包的方法解析数据包中的数据
         * 5、关闭资源
         * 
         * */
        System.out.println("接收端启动");
//      1、建立udp socket服务
        DatagramSocket ds=new DatagramSocket(10000);
//      2、创建数据包
        byte[]buf=new byte[1024];
        DatagramPacket dp=new DatagramPacket(buf,buf.length);
//      3、使用接收方法将数据存储到数据包中
        ds.receive(dp);//阻塞式的
//      4、通过数据包对象的方法，解析其中的数据，比如，地址、端口、数据内容
        String ip=dp.getAddress().getHostAddress();
        int port=dp.getPort();
        String text=new String(dp.getData(),0,dp.getLength());

        System.out.println(ip+":"+port+":"+text);
//      5、关闭资源
        ds.close();
    }

}

加强版

发送端

package cn.itcast.net.p1.udp;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class UDPSendDemo2 {

    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        /*
         * 创建UDP传输的发送端
         * 思路：
         * 1、建立UDP的socket服务
         * 2、将要发送的数据封装到数据包中
         * 3、通过udp的socket服务将数据包发送出去
         * 4、关闭socket服务
         * 
         * */
        System.out.println("发送端启动");
//      1、建立udpsocket服务，使用DatagramSocket对象
        DatagramSocket ds=new DatagramSocket();
//      2、将要发送的数据封装到数据包中

        BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
        String line=null;
        while((line=bufr.readLine())!=null) {

            byte[] buf=line.getBytes();
            DatagramPacket dp=new DatagramPacket(buf,buf.length,InetAddress.getByName("172.25.11.91"),10000);
//          3、通过udp的socket服务将数据包发送出去，使用send方法
            ds.send(dp);
            if("over".equals(line))
                break;
        }


//      4、关闭资源
        ds.close();
    }

}

接收端

package cn.itcast.net.p1.udp;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;

public class UDPReceiveDemo {

    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        /*
         * 建立UDP接收端的思路：
         * 1、建立socket服务，因为是要接收数据，必须要明确一个端口号
         * 2、创建数据包，用于存储接收到的数据，方便用数据包对象的方法解析这些数据
         * 3、使用socket服务的receive方法将接收的数据存储到数据包中
         * 4、通过数据包的方法解析数据包中的数据
         * 5、关闭资源
         * 
         * */
        System.out.println("接收端启动");
//      1、建立udp socket服务
        DatagramSocket ds=new DatagramSocket(10000);
//      2、创建数据包
        byte[]buf=new byte[1024];
        DatagramPacket dp=new DatagramPacket(buf,buf.length);
//      3、使用接收方法将数据存储到数据包中
        ds.receive(dp);//阻塞式的
//      4、通过数据包对象的方法，解析其中的数据，比如，地址、端口、数据内容
        String ip=dp.getAddress().getHostAddress();
        int port=dp.getPort();
        String text=new String(dp.getData(),0,dp.getLength());

        System.out.println(ip+":"+port+":"+text);
//      5、关闭资源
        ds.close();
    }

}

多线程聊天

主程序

package cn.itcast.net.p2.chat;

import java.net.DatagramSocket;
import java.net.SocketException;

public class ChatDemo {

    public static void main(String[] args) throws SocketException {
        // TODO Auto-generated method stub
        DatagramSocket send=new DatagramSocket();
        DatagramSocket receive=new DatagramSocket(10000);

//      Send s=new Send(send);
//      Receive r=new Receive(receive);
        new Thread(new Send(send)).start();
        new Thread(new Receive(receive)).start();
    }

}

发送端

package cn.itcast.net.p2.chat;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;

public class Send implements Runnable {

    private DatagramSocket ds;

    public Send(DatagramSocket ds) {
        this.ds=ds;
        // TODO Auto-generated constructor stub
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        try {

            BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
            String line=null;
            while((line=bufr.readLine())!=null) {

                byte[] buf=line.getBytes();
                DatagramPacket dp=new DatagramPacket(buf,buf.length,InetAddress.getByName("172.25.11.91"),10000);
//              3、通过udp的socket服务将数据包发送出去，使用send方法
                ds.send(dp);
                if("over".equals(line))
                    break;
            }
            ds.close();

        }catch(Exception e){

        }

    }

}

接收端

package cn.itcast.net.p2.chat;

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

public class Receive implements Runnable {

    private DatagramSocket ds;

    public Receive(DatagramSocket ds) {
        this.ds=ds;
        // TODO Auto-generated constructor stub
    }

    @Override
    public void run() {
        // TODO Auto-generated method stub
        try {
        while(true) {
//      2、创建数据包
        byte[]buf=new byte[1024];
        DatagramPacket dp=new DatagramPacket(buf,buf.length);
//      3、使用接收方法将数据存储到数据包中
        ds.receive(dp);//阻塞式的
//      4、通过数据包对象的方法，解析其中的数据，比如，地址、端口、数据内容
        String ip=dp.getAddress().getHostAddress();
        int port=dp.getPort();
        String text=new String(dp.getData(),0,dp.getLength());

        System.out.println(ip+":"+port+":"+text);
        if(text.equals("886"))
        {
            System.out.println(ip+"....退出聊天室");
        }
        }
        }catch(Exception e) {

        }
    }

}

3、TCP/IP传输方式编程
3.1 普通版
客户端

package cn.itcast.net.p4.tcp;

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

public class TCPClientDemo {

    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
//      客户端发送数据到服务端
        /*
         * tcp传输，客户端建立的过程
         * 1、创建tcp客户端socket服务，使用的是Socket对象
         *      建议该对象一创建就明确目的地即要连接的主机
         * 2、如果连接建立成功，说明传输通道已建立
         *      该通道就是socket流，是底层建立好的，既然是流，说明这里既有输入又有输出
         *      想要输入或者输出流对象，可以找socket来获取
         *      可以通过getInputStream()和getOutputStream()来获取两个字节流
         * 3、使用输出流，将数据写出
         * 4、关闭资源
         * */
//      1、创建客户端Socket服务
        Socket socket=new Socket("172.25.11.91",10003);
//      2、获取socket流中的输出流
        OutputStream out=socket.getOutputStream();
//      3、使用输出流将指定的数据写出来
        out.write("tcp演示。。。。".getBytes());
//      4、关闭资源
        socket.close();
    }


}

服务端

package cn.itcast.net.p4.tcp;

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

public class ServerDemo {

    public static void main(String[] args) throws UnknownHostException, IOException {
        // TODO Auto-generated method stub
//      服务端接收客户端发送过来的数据，并打印在控制台上
        /*
         * 建立tcp服务端的思路：
         * 1、创建服务端Socket服务。通过ServerSocket对象
         * 2、服务端必须对外提供一个端口，否则客户端无法连接
         * 3、获取连接过来的客户端对象
         * 4、通过客户端对象获取socket流读取客户端发来的数据
         *      并打印在控制台上
         * 5、关闭资源，关客户端、关服务端
         *  
         * */
        //1、创建服务端对象
        ServerSocket ss=new ServerSocket(10003);
        //2、获取连接过来的客户端对象
        Socket s=ss.accept();

        String ip=s.getInetAddress().getHostAddress();//获取IP地址的字符串形式
        //3、通过Socket对象获取输入流，要读取客户端发来的数据
        InputStream in=s.getInputStream();

        byte[]buf=new byte[1024];

        int len=in.read(buf);
        String text=new String(buf,0,len);
        System.out.println("ip:"+text);

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


    }

}

3.2 加强版

客户端

package cn.itcast.net.p4.tcp;

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

public class TCPClientDemo2 {

    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
//      客户端发送数据到服务端
        /*
         * tcp传输，客户端建立的过程
         * 1、创建tcp客户端socket服务，使用的是Socket对象
         *      建议该对象一创建就明确目的地即要连接的主机
         * 2、如果连接建立成功，说明传输通道已建立
         *      该通道就是socket流，是底层建立好的，既然是流，说明这里既有输入又有输出
         *      想要输入或者输出流对象，可以找socket来获取
         *      可以通过getInputStream()和getOutputStream()来获取两个字节流
         * 3、使用输出流，将数据写出
         * 4、关闭资源
         * */

        Socket socket=new Socket("172.25.11.91",10003);

        OutputStream out=socket.getOutputStream();


        out.write("tcp演示。。。。".getBytes());
//      读取服务端返回的数据，使用socket读取流
        InputStream in=socket.getInputStream();
        byte[]buf=new byte[1024];
        int len=in.read(buf);
        String text=new String(buf,0,len);
        System.out.println(text);


//      4、关闭资源
        socket.close();
    }


}

服务端

package cn.itcast.net.p4.tcp;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;
import java.net.UnknownHostException;

public class ServerDemo2 {

    public static void main(String[] args) throws UnknownHostException, IOException {
        // TODO Auto-generated method stub
//      服务端接收客户端发送过来的数据，并打印在控制台上
        /*
         * 建立tcp服务端的思路：
         * 1、创建服务端Socket服务。通过ServerSocket对象
         * 2、服务端必须对外提供一个端口，否则客户端无法连接
         * 3、获取连接过来的客户端对象
         * 4、通过客户端对象获取socket流读取客户端发来的数据
         *      并打印在控制台上
         * 5、关闭资源，关客户端、关服务端
         *  
         * */
        //1、创建服务端对象
        ServerSocket ss=new ServerSocket(10003);
        //2、获取连接过来的客户端对象
        Socket s=ss.accept();//阻塞式

        String ip=s.getInetAddress().getHostAddress();//获取IP地址的字符串形式
        //3、通过Socket对象获取输入流，要读取客户端发来的数据
        InputStream in=s.getInputStream();

        byte[]buf=new byte[1024];

        int len=in.read(buf);
        String text=new String(buf,0,len);
        System.out.println("ip:"+text);
//      使用客户端socket对象的输出流给客户端返回数据
        OutputStream out=s.getOutputStream();
        out.write("收到".getBytes());


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


    }

}

3.3 文本上传下载

客户端

package cn.itcast.net.p5.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 UploadClient {

    public static void main(String[] args) throws UnknownHostException, IOException {
        // TODO Auto-generated method stub
        Socket s=new Socket("172.25.11.91",10005);
        BufferedReader bufr=new BufferedReader(new FileReader("client.txt"));
        PrintWriter out=new PrintWriter(s.getOutputStream(),true);

        String line=null;
        while((line=bufr.readLine())!=null) {
            out.println(line);
        }
//      告诉服务器，客户端写完了
        s.shutdownOutput();
//      out.println("over");
        BufferedReader bufIn=new BufferedReader(new InputStreamReader(s.getInputStream()));

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

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

}

服务端

package cn.itcast.net.p5.uploadtext;

import java.io.BufferedReader;
import java.io.BufferedWriter;
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 uploadServer {

    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        ServerSocket ss=new ServerSocket(10005);
        Socket s=ss.accept();
        String ip=s.getInetAddress().getHostAddress();
        System.out.println(ip+"......connected");
        BufferedReader bufIn=new BufferedReader(new InputStreamReader(s.getInputStream()));
        BufferedWriter bufw=new BufferedWriter(new FileWriter("server.txt"));

        String line=null;
        while((line=bufIn.readLine())!=null) {
//          if("over".equals(line))
//              break;
            bufw.write(line);
            bufw.newLine();
            bufw.flush();
        }
        PrintWriter out=new PrintWriter(s.getOutputStream(),true);
        out.println("上传成功");
        bufw.close();
        s.close();
        ss.close();

    }

}

3.4 字节文件上传下载
客户端

package cn.itcast.net.p5.uploadpic;

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 UnknownHostException, IOException {
        // TODO Auto-generated method stub
//      1、创建客户端的socket
        Socket s=new Socket("172.25.11.91",10007);
//      2、读取客户端要上传的图片文件
        FileInputStream fis=new FileInputStream("1.bmp");
//      3、获取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 lneIn=in.read(bufIn);
        String text=new String(bufIn,0,lneIn);
        System.out.println(text);

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

    }

}

服务端

package cn.itcast.net.p5.uploadpic;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.ServerSocket;
import java.net.Socket;



public class UploadPicServer {

    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
//      1、创建tcp的socket服务端
        ServerSocket ss=new ServerSocket(10007);

        while(true) {
            Socket s=ss.accept();
            new Thread(new UploadTask(s)).start();
        }
//      ss.close();
    }

}

多线程

package cn.itcast.net.p5.uploadpic;

import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;

public class UploadTask implements Runnable {

    private Socket s;
    public UploadTask(Socket s) {
        this.s=s;
    }
    @Override
    public void run() {
        // TODO Auto-generated method stub
        int count=0;
        String ip=s.getInetAddress().getHostAddress();
        System.out.println(ip+"......connected");
        try {
//      读取客户端发来的数据
        InputStream in=s.getInputStream();
//      将读取到的数据存储到一个文件中
        File dir=new File("pic");
        if(!dir.exists()) {
            dir.mkdirs();
        }

        File file=new File(dir,ip+".bmp");
        if(file.exists()) {
            file=new File(dir,ip+"("+(++count)+").bmp");
        }


        FileOutputStream fos=new FileOutputStream(file);
        byte[]buf=new byte[1024];
        int len=0;
        while((len=in.read(buf))!=-1) {
            fos.write(buf, 0, len);
        }
//      获取socket输出流，将上传成功字样发给客户端
        OutputStream out=s.getOutputStream();
        out.write("上传成功".getBytes());

        fos.close();
        s.close();}catch(IOException e) {

        }
    }

}

3.5 文本转换
客户端

package cn.itcast.net.p5.texttrans;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.net.UnknownHostException;

public class TransClient {

    public static void main(String[] args) throws UnknownHostException, IOException {
        // TODO Auto-generated method stub
        /*思路：
         * 转换客户端：
         * 1、需要先有socket端点
         * 2、客户端的数据源：键盘
         * 3、客户端的目的：socket
         * 4、接收服务端的数据，源：socket
         * 5、将数据显示打印出来，目的：控制台
         * 6、在这些流中操作的数据，都是文本数据
         * 
         * 创建socket客户端对象
         * 1、创建socket客户端对象
         * 2、获取键盘录入
         * 3、将录入的信息发送给socket输出流
         * */
//      1、创建socket客户端对象
        Socket s=new Socket("172.25.11.91",10004);
//      2、获取键盘录入
        BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
//      3、socket输出流
//      new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
        PrintWriter out=new PrintWriter(s.getOutputStream(),true);
//      4、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);
//          读取服务端发回的一行大写数据
            String upperStr=bufIn.readLine();
            System.out.println(upperStr);

        }
        s.close();

    }

}

服务端

package cn.itcast.net.p5.texttrans;

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 {
        // TODO Auto-generated method stub
        /*
         * 转换服务端
         * 思路：
         * 1、serversocket服务
         * 2、获取socket对象
         * 3、源：socket,读取客户端发过来的需要转换的数据
         * 4、目的：显示在控制台上
         * 5、将数据转成大写发给客户端
         * */
//      1、serversocket服务
        ServerSocket ss=new ServerSocket(10004);
//      2、获取socket对象
        Socket s=ss.accept();
        System.out.println(s.getInetAddress().getHostAddress()+"......connected");
//      3、获取socket读取流，并装饰
        BufferedReader bufIn=new BufferedReader(new InputStreamReader(s.getInputStream()));
//      4、获取socket的输出流，并装饰
        PrintWriter out=new PrintWriter(s.getOutputStream(),true);
        String line=null;
        while((line=bufIn.readLine())!=null) {
            System.out.println(line);
            out.println(line.toUpperCase());//写到socket写入流
        }
        s.close();
        ss.close();
    }

}

主程序

package cn.itcast.net.p5.texttrans;

public class TextTransTest {

    public static void main(String[] args) {
        // TODO Auto-generated method stub
        /*
         * 客户端输入字母数据，发送给服务端
         * 服务端收到后显示在控制台，并将该数据转成大写返回给客户端
         * 知道客户端输入over，转换结束      
         * 
         * 创建一个英文大写转换服务器
         * 
         * 分析：
         * 有客户端和服务端，使用tcp传输
         * 
         * 
         * 
         * */
    }

}

3.6 浏览器实现原理
最常见的客户端：
浏览器：IE
最常见的服务端：
服务器：Tomcat
为了了解其原理：
1、自定义服务端
使用已有的客户端

网络架构：
1、C/S client/server
特点：
改结构的软件，客户端和服务端都需要编写。
开发成本较高，维护较为麻烦。
好处：
客户端在本地可以分担一部分运算。

2、B/S browser/server
特点：
该结构的软件，只开发服务器端，不开发客户端，因为客户端直接由浏览器取代
开发成本相对低，维护更为简单
缺点：所有运算都在服务端完成

客户端（浏览器）

package cn.itcast.net.p2.ie_server;

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 {
        // TODO Auto-generated method stub
        Socket s=new Socket("172.25.11.91",8080);
//      模拟浏览器，给tomcat服务端发送符合http协议的请求
        PrintWriter out=new PrintWriter(s.getOutputStream(),true);
        out.println("GET /myweb/1.html HTTP/1.1");//以GET请求方式获取/myweb/1.html文件，并以HTTP/1.1协议进行传输
        out.println("Accept: */*");//能接受什么格式的文件
        out.println("Host:192.168.1.100:8080");//地址是
        out.println("Connection:close");

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

        String str=new String(buf,0,len);
        System.out.println(str);
        s.close();
    }

}

服务器（tomcat）

package cn.itcast.net.p2.ie_server;

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

public class MyTomcat {

    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        ServerSocket ss=new ServerSocket(9090);
        Socket s=ss.accept();
        System.out.println(s.getInetAddress().getHostAddress()+"......connected");

        InputStream in=s.getInputStream();
        byte[]buf=new byte[1024];

        int len=in.read(buf);
        String text=new String(buf,0,len);
        System.out.println(text);

//      给客户端一个反馈信息
        PrintWriter out=new PrintWriter(s.getOutputStream(),true);
        out.println("欢迎光临");

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

    }

}

协议解析

package cn.itcast.net.p2.ie_server;

import java.io.IOException;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.net.URL;

public class URLDemo {
//  协议解析

    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        String str_url="http://192.168.1.100:8080/myweb/1.html?name=lisi";
        URL url=new URL(str_url);
//      System.out.println("getProtocol:"+url.getProtocol());//http
//      System.out.println("getHost:"+url.getHost());//192.168.1.100
//      System.out.println("getPort:"+url.getPort());//8080
//      System.out.println("getFile:"+url.getFile());///myweb/1.html?name=lisi
//      System.out.println("getPath:"+url.getPath());///myweb/1.html
//      System.out.println("getQuery:"+url.getQuery());//name=lisi

        InputStream in=url.openStream();

        byte[]buf=new byte[1024];
        int len=in.read(buf);
        String text=new String(buf,0,len);
        System.out.println(text);
        in.close();

    }

}