网络编程

网络编程

网络编程三要素:
	协议   Ip地址  端口号
        
        
   	
协议:
	网络协议:
		UDP和TCP
     区别:
        1.是否需要建立连接通道
           UDP:不需要建立通道
           TCP:需要建立连接通道
       2.是否可靠连接(是否安全)
            UDP:是一种不可靠连接,不安全,执行效率高
            TCP:是一种可靠连接,服务算一致阻塞状态(同步的,-安全性)执行效率低
     共同点:都需要有Socket编程

     Socket编程:
          特点:
            1.两端都需要有Socket对象
            2.发送端/客户端:有对应ip地址和端口号
            3.接收端/服务端;绑定对应的端口号                               
  应用协议:
	http协议
	https协议(比上http协议)
	
		
第一要素:
	ip地址
	192.168.138.1:	使用点分十进制法
	
	A类IP地址:第一段号码为网络号码，剩下的三段号码为本地计算机的号码  (政府部门)
	B类IP地址:前二段号码为网络号码，剩下的二段号码为本地计算机的号码 (大学校园)
	C类IP地址:前三段号码为网络号码，剩下的一段号码为本地计算机的号码(私人地址)
	
	127.0.0.1:回环地址:表示本机	---- 域名:localhost

	xxx.xxx.xxx.255 广播地址

        
第二个要素:端口号

    使用360软件---查看当前计算机中每个软件 的端口号
    有效端口号:0-65535
        0-1024:保留端口号

    http://www.baidu.com
    http://192.168.25.1:80(可以不写)/xx
        一般:80端口号:是不写的(省略)
    常见端口号
        tomcat: 8080
        redis:6575.. (数据库---非关系型数据库  key-value )
        mysql软件:3306
        

InetAddress类:互联网ip地址统称

java.net.InetAddress类:互联网ip地址统称
 		注: 这个类没有构造方法,不能直接创建对象!,提供一些成员方法使用:静态的
  
  
  Runtime类: 单例模式
  		提供静态方法,返回该类本身
  
  	public static InetAddress getByName(String host):
  		参数为:主机名称:
  
  
成员方法
      public String getHostAddress()返回 IP 地址字符串（以文本表现形式）。 
      public String getHostName():获取主机名

UDP协议接收端的实现步骤

UDP协议接收端的实现步骤
 
      1)创建接收端的Socket对象,绑定端口号
      2)创建一个数据报包---DatagramPacket:当前接收容器
      public DatagramPacket(byte[] buf,int length)
      3)接收数据
      4)从接收容器中解析实际数据
      5)展示数据
          
  例:
		//创建接收端的Socket对象,绑定端口号
		DatagramSocket ds= new DatagramSocket(10086);
		//不断接收数据
		while(true) {
		//创建接收容器
		byte[]bytes=new byte[1024];
		int length=bytes.length;
		DatagramPacket dp=new DatagramPacket(bytes,length);
		//接收数据
		ds.receive(dp);
		//解析当前接收容器中的实际数据
		//获取缓冲区数据实际字节数组
		byte[]buf=dp.getData();
		//获取缓冲区实际长度
		int leng=dp.getLength();
		//获取接收端发送的数据:ip地址
		InetAddress address=dp.getAddress();
		String ip=address.getHostAddress();
		//展示数据
		String s=new String(buf,0,leng);
		System.out.println("Data is:"+s+", from"+ip);
		//关闭资源
		ds.close();
          

UDP协议发送端的步骤

UDP协议发送端的步骤
 
      1)创建发送端的Socket对象
      2)数据数据报包对象:DatagramPacket
      3)发送数据
      4)关闭资源
          
          
 例:
	  //创建发送端Socket对象
	 //DatagramSocket,此类表示用来发送和接收数据报包的套接字
	 DatagramSocket ds=new DatagramSocket();
     //创建数据报包对象
	 String s="helloWorld";
	 byte[]bytes = s.getBytes();
	 int length = bytes.length;
	 DatagramPacket dp= new DatagramPacket(bytes,length,
			 InetAddress.getByName("10.12.156.197"),10086); 
	 //发送数据
	 ds.send(dp);
	 //释放资源
	 ds.close();
          
          
          

UDP协议的应用

需求
  UDP:发送端键盘录入数据,接收端不断接收数据(不关闭)
      
 发送端:
		public class SendDemo {
	
            public static void main(String[] args) throws IOException {

                //1)创建发送端的Socket对象
                DatagramSocket ds = new DatagramSocket() ;
                //2)键盘录入数据
                //创建bufferedReader类对象
                BufferedReader br = new BufferedReader(
                        new InputStreamReader(System.in)) ;
                //一次读取一行内容
                String line = null ;
                while((line=br.readLine())!=null) {
                    //自定义结束条件
                    if(line.equals("886")) {
                        break ;
                    }
                    //line:发送的数据
                    byte[] bytes = line.getBytes() ;
                    int length = bytes.length ;
                    //创建数据报包对象
                    DatagramPacket dp = new DatagramPacket(
                            bytes, length, InetAddress.getByName("10.12.156.36"),10000) ;
                    //发送数据
                    ds.send(dp);
                }
                //释放资源
                ds.close();
            }
        }

接收端:
		public class ReceiveDemo {

	public static void main(String[] args) throws IOException {
		//创建一个接收端的Socket
		DatagramSocket ds = new DatagramSocket(10000) ;
		//不断接收数据
		while(true) {
			//创建接收容器
			byte[] bytes = new byte[1024] ;
			int length = bytes.length ;
			DatagramPacket dp = new DatagramPacket(bytes , length) ;
			//接收
			ds.receive(dp);
			//解析真实数据
			String str = new String(dp.getData(), 0, dp.getLength()) ;
			//获取ip地址
			String ip = dp.getAddress().getHostAddress() ;
			//展示数据
			System.out.println("data is :"+str+"from "+ip);
		}
		//接收端不关闭
	}
}
  

TCP 协议客户端的实现步骤

客户端的实现步骤
		1)创建客户端的Socket对象
		2)获取客户端通道内的输出流,写入内容
		3)关闭资源
    
    例:
		//创建客户端的Socket对象
		Socket s=new Socket("10.12.156.197",8888);
		//获取客户端通道内输出流,写入内容
		OutputStream out=s.getOutputStream();
		out.write("helloWorld".getBytes());
		//释放资源
		s.close();
    

TCP协议服务端的实现步骤

服务端的实现步骤
		1)创建服务端的Socket对象,绑定端口号
		2)进入阻塞状态,监听客户端连接
		3)获取动态内输入流,读数据
		4)展示数据
		5)释放资源
		
	例:
		//创建服务端的Socket对象,绑定端口号
		ServerSocket ss=new ServerSocket();
		//进入阻塞状态,监听客户端连接
		Socket s=ss.accept();
		//获取动态内输入流,读数据
		InputStream in=s.getInputStream();
		//读数据
		//一次读取一个字节数组
		byte[]bytes=new byte[1024];
		int len=in.read(bytes);
		//展示数据
		String clienStr=new String(bytes,0,len);
		String ip=s.getInetAddress().getHostAddress();
		//输出
		System.out.println("data is:"+clienStr+", from:"+ip);
		//释放资源
		ss.close();
		
		

TCP协议的应用

需求
  	键盘录入:BufferedReader
  1)客户端不断键盘录入数据,服务器端不断将数据展示在控制台上
  2)客户端不断键盘录入数据,服务器端将数据输出在某个文件中
客户端:
	public class ClientTest{
        
        public static void main(String[]args)throws IOException{
            
            //创建客户端Socket
            Socket socket = new Socket("10.12.156.197",6666);
            //客户端不断键盘录入数据
            BufferedReader br=new BufferedReader(new InputStreamReader(System.in));
            //将字节输出流封装成BufferedWirter
            BufferedWriter bw=new BufferedWirter(new OutputStreamWriter(Socket.getOutputStream()));
            //读取数据:键盘录入数据
            String line=null;
            while((line=br.readLine())!=null){
                //结束条件
                if(line.equals("over")){
                    break;
                }
                //写数据
                bw.write();
                bw.newLine();
                bw.flush();
            }
            //释放资源
            socket.close();
        }
    }


服务器端:
	public class ServerTest{
        public static void main(String[]args)throws IOException{
            
            //创建服务器端的Socket对象
            ServerSocket ss=new ServerSocket(6666);
            //监听客户端连接
            Socket socket=ss.accept();
            //获取通道内输入流
            BufferedReader br=new BufferedReader(new InputStreamReader(socket.getInputStream()));
            //1)
           	/* //输出数据
            String line=null;
            while((line=br.readLine())!=null){
                system.out.println(lines);
            }*/
            //2)
            //将服务器端读取的数据写入到文件中
            BufferedWriter bw=new BufferedWriter(new FileWriter("a.txt"));
            //读取数据
            String line = null;
            while((line=br.readLine())!=null){
                bw.write(line);
                bw.newline();
                bw.flush();
            }
            //关闭资源
            bw.close();
            socket.close();
        }
    }

TCP协议的应用2

需求:
	客户端将当前项目下ReceiveDemo.java文件 写入到通道内的流中
  	服务器端将客户端的文本进行复制:到当前项目Copy.java文件中(当复制完毕后加入反馈 )
     注:图片的复制:BufferedInputStream/BufferedOutputStream  
       	图片文件:没有复制完整,图片文件缺失(少字节数) 图片文件本身在内存中:缓存数据!
        字节缓冲输出流中:public void flush():强制将缓冲的字节数输出到流中!
       
    客户端:
       public class UploadClient {
            public static void main(String[] args) throws IOException {

                //创建Scoket对象
                Socket s = new Socket("10.12.156.36", 5555) ;
                //创建字符输入流BufferedReader
                BufferedReader br = new BufferedReader
                        (new FileReader("ReceiveDemo.java")) ;
                //封装通道内的字节输出流
                BufferedWriter bw =
                            new BufferedWriter(
                                    new OutputStreamWriter(s.getOutputStream())) ;
                //将文件的内容写到bw流对象中
                String line = null ;
                while((line=br.readLine())!=null) { //readLine():阻塞式方法
                    //写入
                    bw.write(line);
                    bw.newLine();
                    bw.flush();
                }
                /**
                 * 方案1
                 * //自定义一个结束标记
                bw.write("over");
                bw.newLine();
                bw.flush();
                 */
                //方案2
        		//public void shutdownOutput():
                //禁用此套接字的输出流:告诉服务器端,没有内容写入到通道流中
                s.shutdownOutput();
                
                //获取通道内的字节输入流,读取服务器端的反馈
                //将字节输入流---封装BufferedReader
                BufferedReader br2 = new BufferedReader
                        (new InputStreamReader(s.getInputStream())) ;
                //readLine()
                String serverMsg = br2.readLine() ;
                System.out.println(serverMsg);
                //关闭
                br.close();
                s.close();
            }
        }
  	

	服务器端:
		public class UploadServer {
	
            public static void main(String[] args)  throws IOException{

                //创建ServerSocket对象
                ServerSocket ss = new ServerSocket(5555) ;
                //监听链接
                Socket socket = ss.accept() ;
                //封装通道内的字节输入流
                BufferedReader br = new BufferedReader
                        (new InputStreamReader(socket.getInputStream())) ;
                //创建BufferedWriter将流中数据进行复制
                BufferedWriter bw = new BufferedWriter(new FileWriter("Copy.java")) ;
                String line = null ;
                while((line=br.readLine())!=null) {//阻塞式方法
                    /*
                    //读取客户端的自定义标记
                    if("over".equals(line)) {
                        break ;
                    }
                    */
                    bw.write(line);
                    bw.newLine();
                    bw.flush();
                }
                //客户端的文本文件,服务器端输出到另一个文件中,如果复制完毕
                //加入服务器端的反馈?
                //获取通道内的字节输出流---封装成BufferedWriter
                BufferedWriter bw2 = new BufferedWriter(
                        new OutputStreamWriter(socket.getOutputStream())) ;
                bw2.write("文件复制完毕");
                bw2.newLine();
                bw2.flush();
                //关闭
                bw.close();
                socket.close();
            }
        }