网络编程

网络编程

网络模型：
OSI参考模型
TCP/IP参考模型
网络通讯要素：
·
IP地址
 端口号
 传输协议,

 IP地址：
    对应对象InetAddress
    网络中设备的标识
    本地回环地址：127.0.0.1  主机名：localhost

 端口号：
    用于标识进程的逻辑地址，不同进程的标识
    有效端口：0~65535，其中0~1024系统使用或保留端口

传输协议：
    通讯的规则
    常见协议:TCP  UDP

Socket：（插座的意思，程序上的插座）
    Socket就是为网络服务提供的一种机制
    通信的两端都有Socket
    网络通信其实就是Socket间的通信。
    数据在两个Socket间通过IO传输。


TCP和UDP

UDP：
1.
将数据及源和目的封装成数据包，不需要建立连接
每个数据报的大小在限制64K内
因无连接，是不可靠协议
不需要建立连接，速度快。

2.UDP的Socket服务建立：
DatagramSocket与DatagramPacket
建立发送端，接收端。
建立数据包。
调用Socket的发送接收方法。
关闭Socket。
发送端与接收端是两个独立的运行程序。

TCP
建立连接，形成传输数据的通道
在连接中进行大数据量传输
通过三次握手完成连接，是可靠协议
必须建立连接，效率会稍低
    

/*IP*/
import java.net.*;
class IPDemo
{
    public static void main(String[] args)throws Exception
    {
        InetAddress i=InetAddress.getLocalHost();//通过静态方法，获得InetAddress对象

        sop(i.toString());
        sop("address:"+i.getHostAddress());
        sop("name:"+i.getHostName());


        InetAddress ia=InetAddress.getByName("www.baidu.com");//获得指定主机对象
        sop("address:"+ia.getHostAddress());
        sop("name:"+ia.getHostName());

    }
    public static void sop(Object obj)
    {
        System.out.println(obj);
    }

}

/*UDP*/

/*
需求：通过udp传输方式，将一段数据发送出去。
定义一个udp发送端
思路：
1.建立udpsocket服务。
2.提供数据，并将数据封装到数据包中。
3，通过socket服务的发送功能，将数据包发出去。
4.关闭资源。

*/
import java.net.*;
class UdpSend
{
    public static void main(String[] args)throws Exception
    {
        /*发送端：*/
        //1.创建udp服务，通过DatagramSocket对象。
        DatagramSocket ds=new DatagramSocket(8888);//此处也可指定发送端的端口，也可不指定
        //2，确定数据，并封装成数据包
        byte[] buf="udp ge men lai le ".getBytes();
        DatagramPacket dp
                =new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.247.15"),10000);//10000为端口
        //用DatagramPacket封装成包,指定数组，发送的长度，地址
        //3.通过socket服务，将已有的数据包发送出去，通过send方法。
        ds.send(dp);
        //4.关闭资源
        ds.close();

    }
}
/*定义udp接收端：
需要：定义一个应用程序，用于接收udp协议传输的数据并处理

思路：
1.定义udpsocket服务。通常会监听一个端口，其实就是给这个接收网络应用程序定义数字标识
方便于明确哪些数据过来该应用程序可以处理。
2.定义一个数据包，因为要存储接收到的字节数据。因为数据包对象中
有更多功能可以提取字节数据中的不同数据信息。
3.通过socket服务的receive方法。将收到的数据存入已定义好的数据包中
4.通过数据包对象的特有功能，将这些不同的数据取出。打印在控制台上。
5.关闭资源。
*/
class UdpRace
{
    public static void main(String[] args)
    {
        //1.创建udp socket，建立端点
        DatagramSocket ds=new DatagramSocket(10000);//指定端口！！！
        while(true)//为了一直能接受数据
        {
        //2.定义数据包，用于存储数据。
        byte[] buf=new byte[1024];
        DatagramPacket dp=new DatagramPacket(buf,buf.length);
        //3.通过服务的receive方法将收到数据存入数据包中。
        ds.receive(dp);//堵塞式方法，不接到数据时一直等待。

        //4.通过数据包的方法获取其中的数据。
        String ip=dp.getAddress().getHostAddress();//dp.getAddress返回对象

        String data=new String(dp.getData(),0,dp.getLength());//dp.getData()返回字节数组
        
        int port=dp.getPort();//获取端口

        System.out.println(ip+"::"+data+"::"+port);

        //5.关闭资源

        ds.close();
        }
    }
}

/*UDP-键盘录入方式数据*/
import java.net.*;
import java.io.*;
class UdpSend2
{
    public static void main(String[] args)throws Exception
    {
    DatagramSocket ds=new DatagramSocket();
    BufferedReader bfr=new BufferedReader(new InputStreamReader(System.in));
    String line=null;
    while((line=bfr.readLine())!=null)
    {
        if("886".equals(line))
            break;
        byte[] buf=line.getBytes();

        DatagramPacket dp=new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.247.255"),1001);//注意：247.255表示247段内广播，247.*都能收到
        ds.send(dp);
    }
        ds.close();
    }
}
class UdpRace2
{
    public static void main(String[] args)throws Exception
    {
        DatagramSocket ds=new DatagramSocket(1001);
        while(true)
        {
            //定义接受包的缓冲区数组
            byte[]buf=new byte[1024];//担心定义多小，可定义为64K，包最大为64k
            DatagramPacket dp2=new DatagramPacket(buf,buf.length);

            ds.receive(dp2);//接受到的包放到dp2里
            String ip=dp2.getAddress().getHostAddress();
            String data=new String(dp2.getData(),0,dp2.getLength());

            System.out.println(ip+"::"+data);
        }

    }
}
/*编写一个聊天程序。
有收数据和发数据的部分。
这两部分必须同时执行。
需要多线程技术。
一个线程控制手，一个线程控制发。

因为手和发动作是不一致的，所以要两天run方法，
而且这两个方法要封装到不同类中*/
import java.io.*;
import java.net.*;
class Send implements Runnable
{
    private DatagramSocket ds;
    public Send(DatagramSocket ds)
    {
        this.ds=ds;
    }
    public void run()
    {
        try
        {
            BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
            String line=null;
            while((line=bufr.readLine())!=null)
            {
                if("886".equals(line))
                    break;
                byte[]buf=line.getBytes();
                DatagramPacket dp=
                    new DatagramPacket(buf,buf.length,InetAddress.getByName("192.168.247.255"),1000);
                ds.send(dp);
            }
        }
        catch (Exception e)
        {
            throw new RuntimeException("发送端失败");
        }
    }
}
class Race implements Runnable
{
    private DatagramSocket ds;
    public Race(DatagramSocket ds)
    {
        this.ds=ds;
    }
    public void run()
    {
        try
        {
            while(true)
            {
                byte[] buf=new byte[1024];
                DatagramPacket dp=new DatagramPacket(buf,buf.length);
                ds.receive(dp);

                String ip=dp.getAddress().getHostAddress();
                String data=new String(dp.getData(),0,dp.getLength());
                System.out.println(data);
            }
        }
        catch (Exception e)
        {
            throw new RuntimeException("接受失败");
        }
    }
}
class ChatDemo
{
    public static void main(String[] args)throws Exception
    {
        DatagramSocket sendSocket=new DatagramSocket();
        DatagramSocket raceSocket=new DatagramSocket(1000);
        new Thread(new Send(sendSocket)).start();
        new Thread(new Race(raceSocket)).start();


    }
}

/*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("192.168.247.15",10002);
        //为了发送数据，应该获取socket流中的输出流
        OutputStream out=s.getOutputStream();
        out.write("tcp  ge men lai le ".getBytes());

        s.close();
    }
}

/*
    需求：定义端点接收数据并打印在控制台上。

    服务端：
    1.建立服务端的socket服务，ServerSocket（）；
    并监听一个端口
    2.获取连接过来的客户端对象。
        通过ServerSocket的accept方法。所以这个方法是阻塞式的。
    3.客户端如果发过来数据，那么服务端要使用对应的客户端对象，
        并获取该客户端对象的读取流来读取 发过来的数据。并打印在控制台上。
    4.关闭服务端.(一般会一直开着)


*/
class TcpServer
 
{
    public static void main(String[] args)throws Exception
    {
        //建立服务端socket服务，并监听一个端口
        ServerSocket ss=new ServerSocket(10002);

        //通过accept方法获取连接过来的客户端对象。
        Socket s=ss.accept();
        String ip=s.getInetAddress().getHostAddress();
        System.out.println(ip+"....connecter");
        //获取客户端发送过来的数据，那么要使用客户端对象的读取流来获取数据。

        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();

    }
}


/*演示：tcp的传输的客户端和服务端的互访。

需求：客户端给服务端发送数据，服务端收到后，给客户端反馈信息。
*/
/*
客户端：
1.建立socket服务，指定要连接主机和端口
2.获取socket流中的输出流，将数据写到该该流中，通过网络发给服务端。
3.获取socket流中输入流，将服务端反馈的数据获取到，并打印。
4.关闭客户端资源。


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

class TcpClient2
{
    public static void main(String[] args)throws Exception
    {
        Socket s=new Socket("192.168.247.15",110);
        OutputStream out=s.getOutputStream();
        out.write("服务端，你好".getBytes());
        

        InputStream in=s.getInputStream();//接收来自服务端的流
        byte[] buf=new byte[1024];//read是阻塞式方法
        int len=in.read(buf);

        System.out.println(new String(buf,0,len));
        s.close();
    }
}
class TcpServer2
{
    public static void main(String[] args)throws Exception
    {
        ServerSocket ss=new ServerSocket(110);
        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));

        OutputStream out=s.getOutputStream();//客户端的输出流
        out.write("哥们收到,你也好".getBytes());
        s.close();


    }
}

/*TCP练习：

需求：建立一个文本转化服务器。
客户端给服务端发送文件，服务端会将文本转成大写再返回给客户端。
而且客户端可以不断的进行转换，当客户端输入over时，转换结束。


分析：
客户端：
    既然是操作数据，那么就可以使用ＩＯ技术，并按照ＩＯ的操作规律来思考。
源：键盘录入。
目的：网路设备，网络输出流。
而且操作的是文本数据。可以选择字符流。


步骤：
１.建立服务。
２.获取键盘录入。
３.将数据发给服务端。
４.获取服务端返回的大写数据
５.结束，关资源。

都是文本数据，可以使用字符流进行操作。同时提供效率，加入缓冲。



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

class TransClient
{
    public static void main(String[] args)throws Exception
    {
        Socket s=new Socket("192.168.247.15",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);
        那么while（）函数中，可只写一句：
        out.println(line);
        */


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

        String line=null;
        while((line=bufr.readLine())!=null)
        {
            if("over".equals(line))
                break;
            bufOut.write(line);
            bufOut.newLine();//一定要换行！！否则在执行服务端的ReadLine()时，
                                //读不到回车，就不会结束一行，一直在等待读回车标记
            //不要忘记刷新！！
            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);
        那么while（）函数中，可只写一句：
        out.println(line.toUpperCase());
        */
        
        String line=null;
        while((line=bufIn.readLine())!=null)
        {
            System.out.println(line);
            bufOut.write(line.toUpperCase());
            bufOut.newLine();//一定要换行，同上
            bufOut.flush();//一定要刷新！写到socket输出流
        }
        s.close();
        ss.close();

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


/*TCP复制文件*/

import java.io.*;
import java.net.*;
class TextClient
{
    public static void main(String[] args)throws Exception
    {
        Socket s=new Socket("192.168.247.15",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();
    }
}

/*第二十四天

需求：上传图片

TCP-客户端并发上传图片
*/

/*
客户端：
1.服务端点：
2.读取客户端已有图片数据。
3.通过socket输出流将数据发给服务端
4.读取服务端反馈信息。
5.关闭。

*/
import java.io.*;
import java.net.*;
class PicClient
{
    public static void main(String[] args)throws Exception
    {
        if(args.length!=1)//args是一个数组，只能往里面传一个参数，运行时，直接指定文件路径即可
        {
            System.out.println("请选择一个png格式的图片");
            return;
        }
        
        File file=new File(args[0]);//把指定路径的文件封装成对象
        if(!(file.exists() && file.isFile()))
        {
            System.out.println("该文件有问题，要么不存在，要么不是文件");
            return;
        
        }

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

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



        Socket s=new Socket("192.168.247.15",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()
    {    
        String ip=s.getInetAddress().getHostAddress();//获取客户端ip
        try
        {    
            int count=1;
            
            System.out.println(ip+"...conncted");

            //拿到Socket流传过来的数据
            InputStream in=s.getInputStream();

            //为了不让传过来的图片，因为名字相同而覆盖掉同名的图片，
                //将传过来的图片以ip+count计数器命名
            File file=new File(ip+"("+(count)+")"+".png");//192.168.247.15（1）.png
            while(file.exists())
                file=new File(ip+"("+(count++)+")"+".png");
                

            
            //把数据写到文件里
            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();//accept为阻塞式，获取值才往下执行
            new Thread(new PicThread(s)).start();
    
        }
            //ss.close();
    }
}
/*

需求:
客户端通过键盘录入用户名。
服务端对这个用户进行校验。

如果该用户存在，在服务端显示XXX，已登录。
并在客户端显示XXX ,欢迎光临。

如果该用户不存在，在服务端显示ＸＸＸ，尝试登录。
并在客户端显示ＸＸＸ，该用户不存在。

最多就登录三次。

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

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


//读取键盘录入
        BufferedReader bufr=new BufferedReader(new InputStreamReader(System.in));
//表示要将读到的信息写到socket输出流
        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);//将读到的键盘流写到socket输出流里

            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)//客户端执行时，按ctrl+c出现姓名为空
                    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();
        }
    }
}

/*浏览器客户端-自定义服务端

1.客户端：浏览器
服务端：自定义

2.客户端：浏览器
服务端：Tomcat服务器

3.客户端：自定义
服务器：Tomcat服务器
*/
import java.io.*;
import java.net.*;

class  ServerDemo
{
    public static void main(String[] args) throws Exception
    {
        ServerSocket ss=new ServerSocket(11000);
        Socket s=ss.accept();
        System.out.println(s.getInetAddress().getHostAddress());

        InputStream in=s.getInputStream();//获取浏览器发过来的信息
        byte[] buf=new byte[1024];
        int len=in.read(buf);
        System.out.println(new String(buf,0,len));

        PrintWriter out=new PrintWriter(s.getOutputStream(),true);
        out.println("<font color='red' size='7'>客户端你好！</font>");
        s.close();
        ss.close();


    }
}
/*
http://192.168.1.254.11000/myweb/demo.html

浏览器向服务器发出的请求：http的请求消息头
GET / mywet/demo.html HTTP/1.1
Accept: text/html, application/xhtml+xml,
Accept-Language: zh-CN
User-Agent: Mozilla/5.0 (compatible; MSIE 9.0; Windows NT 6.1; Trident/5.0)
Accept-Encoding: gzip, deflate//告诉服务器的数据压缩方式
Host: 192.168.247.15:11000//告诉服务器要访问的主机
Connection: Keep-Alive

*/
/*自定义浏览器发送请求*/
class MyIE
{
    public static void main(String args)throws Exception
    {
        Socket s=new Socket("192.168.247.15",8080);

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

        out.println("GET /myweb/demo.html HTTP/1.1");
        out.println("Accept-Language: zh-CN");
        out.println("Accept:*/*");
        out.println("Host:192.168.247.15:11000");
        out.println("Connection: Keep-Alive");
        out.println();
        out.println();

        BufferedReader bufr=new BufferedReader(new InputStreamReader(s.getInputStream()));
        String line=null;
        while((line=bufr.readLine()!=null))
        {
            System.out.println(line);
        }
        s.close();
    }
}


/*URL*/
import java.net.*;
class URLDemo
{
    public static void main(String[] args)throws MalformedURLException
    {
        URL url=new URL("http://192.168.247.15/myweb/demo.html?name=haha&age=30");

        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());
        /*
        
        int port=getPort();//设置默认端口号
        if(port==-1)
            port=80;
            getPort()==-1
        
        */
        
    }
}
/* String getFile()
          获取此 URL 的文件名。
 String getHost()
          获取此 URL 的主机名（如果适用）。
 String getPath()
          获取此 URL 的路径部分。
 int getPort()
          获取此 URL 的端口号。
 String getProtocol()
          获取此 URL 的协议名称。
String getQuery()
          获取此 URL 的查询部分。
*/




/*URL-URLConnection
 URLConnection openConnection()
     返回一个 URLConnection 对象，它表示到 URL 所引用的远程对象的连接。
           
*/
import java.net.*;
import java.io.*;

class URLConnectionDemo
{
    public static void main(String[] args)throws MalformedURLException
    {
        URL url=new URL("http://192.168.247.15/myweb/demo.html?name=haha&age=30");

        URLConnection conn=url.openConnection();//与目的地址连接，就不用Socket了！！！

        System.out.println(conn);


        InputStream in=conn.getInputStream();
        byte[] buf=new byte[1024];
        int len=in.read(buf);
        System.out.println(new String(buf,0,len));
    }
}

/*带图形界面的自制浏览器:作为客户端向tomcat服务端发送请求
重点：URL-URLConnection部分

*/
import java.awt.*;
import java.awt.event.*;
import java.io.*;
import java.net.*;
class  MyIEByGUI2
{
    private Frame f;
    private TextField tf;
    private Button but;
    private TextArea ta;
    
    private Dialog d;
    private Label lab;
    private Button okBut;


    MyIEByGUI2()
    {
        init();
    }
    public void init()
    {
        f = new Frame("my window");
        f.setBounds(300,100,600,500);
        f.setLayout(new FlowLayout());

        tf = new TextField(60);

        but = new Button("转到");

        ta = new TextArea(25,70);


        d = new Dialog(f,"提示信息-self",true);
        d.setBounds(400,200,240,150);
        d.setLayout(new FlowLayout());
        lab = new Label();
        okBut = new Button("确定");

        d.add(lab);
        d.add(okBut);



        f.add(tf);
        f.add(but);
        f.add(ta);


        myEvent();
        f.setVisible(true);
    }
    private void  myEvent()
    {

        okBut.addActionListener(new ActionListener()
        {
            public void actionPerformed(ActionEvent e)
            {
                d.setVisible(false);
            }
        });
        d.addWindowListener(new WindowAdapter()
        {
            public void windowClosing(WindowEvent e)
            {
                d.setVisible(false);
            }
        });

        tf.addKeyListener(new KeyAdapter()
        {
            public void keyPressed(KeyEvent e)
            {
                try
                {
                        if(e.getKeyCode()==KeyEvent.VK_ENTER)
                    showDir();
                }
                catch (Exception ex)
                {
                }
            
            }
        });


        but.addActionListener(new ActionListener()
        {
            public void actionPerformed(ActionEvent e)
            {
                try
                {
                    showDir();
                }
                catch (Exception ex)
                {
                }
                
                
            }
        });

        f.addWindowListener(new WindowAdapter()
        {
            public void windowClosing(WindowEvent e)
            {
                System.exit(0);    
            }
        });
    }

    private void showDir()throws Exception
    {

        ta.setText("");
        String urlPath = tf.getText();//http://192.168.1.254:8080/myweb/demo.html
        
        URL url = new URL(urlPath);

        URLConnection conn = url.openConnection(); //与输入网址（tomcat）连接，返回一个 URLConnection 对象，它表示到 URL 所引用的远程对象的连接
        
        InputStream in = conn.getInputStream();

        byte[] buf = new byte[1024];

        int len = in.read(buf);

        ta.setText(new String(buf,0,len));

    }

    public static void main(String[] args)
    {
        new MyIEByGUI2();
    }
}




/*域名解析
在用域名上网时，浏览器先查看本机C:\Windows\System32\drivers\etc\hosts文件。
若文件中不存该域名与IP的对应关系，才去域名解析服务器就行域名解析。

例如：文件中        127.0.0.1：8080     localhost：8080是对应的
            

因此，我们可以修改本文件，把一些恶意网址，加入到该文件，让他对应另一个Ip，
当我们域名访问该网址时，就连接不到该网站了！！


*/