java18 任务调度

任务调度;
Timer类，
/**
    了解
  Timer()
  schedule(TimerTask task, Date time)
  schedule(TimerTask task, Date firstTime, long period)
  自学 quartz
 */
public class TimeDemo01 {
    public static void main(String[] args) {
        Timer timer =new Timer();
        timer.schedule(
            new TimerTask(){//TimerTask是一个抽象类需要创建它的子类，重写run方法
                @Override
                public void run() {
                    System.out.println("so easy....");
                }
            },
            new Date(System.currentTimeMillis()+),
        );
    }

}

///public abstract class TimerTask implements Runnable,TimerTask是一个抽象类和线程类。
//void java.util.Timer.schedule(TimerTask task, Date firstTime, long period)。
//new Date(System.currentTimeMillis()+1000)表示一秒后。

多线程总结：
一、创建线程
.继承Thread
.实现Runnable
.实现Callable
二、线程的状态
.新生-start-就绪-运行-阻塞-终止
.终止线程的方法（重点）
.sleep方法
三、线程信息
.Thread.currentThread()
.

网络编程关注的是网络底层的交互。
一、网络：将不同区域的计算机连接到一起，分为：局域网、城域网、互联网。
二、地址:ip地址，确定网络上的一个绝对地址。
三、端口号（2个字节，-65525共65536个）：由于计算机上有很多程序，用于区分   计算机上的软件的。
   .在同一个协议下，端口号不能重复。不同协议下tcp和udp下端口号可以重复。
   .1024以下的不要使用，是操作系统预留的，例如80->http，->ftp。
四、资源定位：url：统一资源定位符，uri:统一资源。uri只有资源，url不仅仅有   资源还有定位（L表示location）。
五、数据传输：  .协议（一个约定，比如规定现在上课说话的语言，用的书籍，不然大家听不懂）：tcp和udp协议，
   1.1 TCP协议：类似于电话，需要先建立连接。面向连接，点到点通信，完全可靠，效率相当低下。
   1.2 UDP：类似于短信，非面向连接，效率高，传输不可靠数据可能丢失。
   .传输：  （jsp、servlet在网络分层中是应用层，传输层（TCP/UDP）,网络层（IP）,数据链路层是操作系统。应用层是建立在传输层和网络层之上的。）
   2.1 先封装：应用层数据进过一层一层的封装后传到物理链路层。
   2.2 后拆封：物理链路层的数据进过一层一层的拆封后传到应用层。

Java封装的类：(数据传输过程中里面还是流)
.InnetAddress InetSocketAddress
.URL
.TCP:ServerSocket Socket
.UDP:DatagramSocket DatagramPacket

每个类都有构造器，只是访问权限不一样。

InetAddress类：
确定ip地址和域名解析（DNS，dns作用是将www..com转换为61.135.253.），但是没有端口信息。
InetSocketAddress类：
包含端口，用于socket通信。

import java.net.InetAddress;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.UnknownHostException;
/**
 * 没有封装端口
 */
public class InetDemo01 {
    public static void main(String[] args) throws UnknownHostException{
        //使用getLocalHost方法创建InetAddress对象
        InetAddress addr = InetAddress.getLocalHost();
        System.out.println(addr.getHostAddress());  //返回：192.168.1.100
        System.out.println(addr.getHostName());  //输出计算机名
        //根据域名得到InetAddress对象
        addr = InetAddress.getByName("www.163.com");
        System.out.println(addr.getHostAddress());  //返回 163服务器的ip:61.135.253.15
        System.out.println(addr.getHostName());  //输出：www.163.com
        //根据ip得到InetAddress对象
        addr = InetAddress.getByName("61.135.253.15");
        System.out.println(addr.getHostAddress());  //返回 163服务器的ip:61.135.253.15
        System.out.println(addr.getHostName());  //输出ip而不是域名。如果这个IP地 址不存在或DNS服务器不允许进行IP地址和域名的映射，getHostName方法就直接返回这个IP地址。
    }
}

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

/**
 * 封装端口:在InetAddress基础上+端口
 */
public class InetSockeDemo01 {
    //    InetAddress是ip地址对象，
    //  InetSocketAddress包含ip地址和端口的对象
    public static void main(String[] args) throws UnknownHostException {
        InetSocketAddress  address = new InetSocketAddress("127.0.0.1",);//在本机开一个端口
        address = new InetSocketAddress(InetAddress.getByName("127.0.0.1"),);//这行和上面那行是一样的。
        System.out.println(address.getHostName());//WIN7U-20130526M
        System.out.println(address.getPort());//
        InetAddress addr =address.getAddress();
        System.out.println(addr.getHostAddress());  //返回：地址，127.0.0.1
        System.out.println(addr.getHostName());  //输出计算机名，WIN7U-20130526M
    }
}

URI(Uniform resource identifier)统一资源标示符，用来唯一的标识一个资源。
URL(Uniform resource Locator)统一资源定位器，不仅仅表示一种资源还表示这个资源的位置。

URL由4部分组成：协议、存放资源的主机域名、资源文件名和端口号。（我们自己敲的url时会自动省略http协议和80端口，因为是默认的。）

URL类：１.创建(绝对路径和相对路径构建)

import java.net.MalformedURLException;
import java.net.URL;
public class URLDemo01 {
    public static void main(String[] args) throws MalformedURLException {
        //绝对路径构建
        URL url = new URL("http://www.baidu.com:80/index.html?uname=bjsxt");
        System.out.println("协议:"+url.getProtocol());//协议:http
        System.out.println("域名:"+url.getHost());//域名:www.baidu.com
        System.out.println("端口:"+url.getPort());//端口:80
        System.out.println("资源:"+url.getFile());//资源:/index.html?uname=bjsxt
        System.out.println("相对路径:"+url.getPath());//相对路径:/index.html
        System.out.println("锚点:"+url.getRef()); //锚点:null
        System.out.println("参数:"+url.getQuery());//?参数 :存在锚点  返回null ,不存在，返回正确，参数:uname=bjsxt

         //相对路径构建
        url = new URL("http://www.baidu.com:80/a/");
        url = new URL(url,"b.txt");
        System.out.println(url.toString());//http://www.baidu.com:80/a/b.txt

    }
}

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.net.URL;

/**
 * 获取资源：源代码
 */
public class URLDemo02 {
    public static void main(String[] args) throws IOException {
        URL url = new URL("http://www.baidu.com"); //主页 默认资源

        //获取资源 网络流
        /*
        InputStream is =url.openStream();
        byte[] flush = new byte[1024];
        int len =0;
        while(-1!=(len=is.read(flush))){//每次读取1024字节到flush数组,len表示真实读取进flush的字节长度。
            System.out.println(new String(flush,0,len));
        }
        is.close();
        乱码的愿意1.编码，2.字节数不够。*/

        BufferedReader  br =
                new BufferedReader(new InputStreamReader(url.openStream(),"utf-8"));//网页utf-8编码，所以这里读进br也要utf-8
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("baidu2.html"),"utf-8"));//写入到文件baidu2.html也要utf-8,baidu2.html在工程目录下。

        String msg =null;
        while((msg=br.readLine())!=null){//读取进br
            //System.out.println(msg);
            bw.append(msg);//写入到文件baidu2.html
            bw.newLine();
        }
        bw.flush();

        bw.close();//close一定会flush()
        br.close();
    }
}

UDP通信：以数据为中心，不安全，非面向连接，数据可能丢失，效率高。
一、类：DatagramSocket DatagramPacket.
.客户端
1.1 创建客户端 Datagramsocket类 + 指定端口，
1.2 准备数据
1.3 打包 DatagramPacket + 服务器地址及端口
1.4 发送
1.5 释放资源
.服务器端
2.1 创建服务端 Datagramsocket类 + 指定端口，
2.2 准备接收的容器 （字节数组） 封装DatagramPacket
2.3 接收数据
2.4 分析
2.5 释放资源

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
/**
 * 服务端
 * 1、创建服务端 +端口
 * 2、准备接受容器
 * 3、封装成 包
 * 4、接受数据
 * 5、分析数据
 * 6、释放
 */
public class MyServer {
    public static void main(String[] args) throws IOException {
        //1、创建服务端 +端口
        DatagramSocket server = new DatagramSocket();
        //2、准备接受容器
        byte[] container = new byte[];
        //3、把这个容器封装成 包 DatagramPacket(byte[] buf, int length)
        DatagramPacket packet =new DatagramPacket(container, container.length) ;
        //4、接受数据到packet
        server.receive(packet);
        //5、分析数据
        byte[] data =packet.getData();
        int len =packet.getLength();
        System.out.println(new String(data,,len));
        //6、释放
        server.close();
    }
}

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;
/**
 * 客户端
 * 1、创建客户端 +端口
 * 2、准备数据
 * 3、打包（发送的地点 及端口）
 * 4、发送
 * 5、释放
 * 思考: 89.12  数据+类型
 *
 * 即使服务器关闭了，运行客户端也不会报错，因为这是UDP。
 */
public class MyClient {
    public static void main(String[] args) throws IOException {
        //1、创建客户端 +端口
        DatagramSocket client = new DatagramSocket();
        //2、准备数据
        String msg ="udp编程";
        byte[] data =msg.getBytes();
        //3、数据打包（发送的地点 及端口） DatagramPacket(byte[] buf, int length, InetAddress address, int port)
        DatagramPacket packet = new DatagramPacket(data,data.length,new InetSocketAddress("localhost",));
        //4、发送
        client.send(packet);
        //5、释放
        client.close();
    }
}

看网页也是一种流的传输，下载也是一种流。

import java.io.ByteArrayInputStream;
import java.io.DataInputStream;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
/**
 * 服务端
 * 1、创建服务端 +端口
 * 2、准备接受容器
 * 3、封装成 包
 * 4、接受数据
 * 5、分析数据 字节数组-->double
 * 6、释放
 */
public class Server {
    public static void main(String[] args) throws IOException {
        //1、创建服务端 +端口
        DatagramSocket server = new DatagramSocket();
        //2、准备接受容器
        byte[] container = new byte[];
        //3、封装成 包 DatagramPacket(byte[] buf, int length)
        DatagramPacket packet =new DatagramPacket(container, container.length) ;
        //4、接受数据
        server.receive(packet);
        //5、分析数据
        double data =convert(packet.getData());
        System.out.println(data);
        //6、释放
        server.close();
    }
    /**
     * 字节数组 +Data 输入流
            字节数组转成double
     */
    public static double convert(byte[] data) throws IOException{
        DataInputStream dis =new DataInputStream(new ByteArrayInputStream(data));
        double num =dis.readDouble();
        dis.close();
        return num;
    }
}

import java.io.ByteArrayOutputStream;
import java.io.DataOutputStream;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetSocketAddress;

/**
 * 客户端
 * 1、创建客户端 +端口
 * 2、准备数据   double -->字节数组   字节数组输出流
 * 3、打包（发送的地点 及端口）
 * 4、发送
 * 5、释放
 */
public class Client {
    public static void main(String[] args) throws IOException {
        //1、创建客户端 +端口
        DatagramSocket client = new DatagramSocket();
        //2、准备数据
        double num =89.12;
        byte[] data =convert(num);
        //3、打包（发送的地点 及端口） DatagramPacket(byte[] buf, int length, InetAddress address, int port)
        DatagramPacket packet = new DatagramPacket(data,data.length,new InetSocketAddress("localhost",));
        //4、发送
        client.send(packet);
        //5、释放
        client.close();
    }

    /**
    double转成字节数组，DataOutputStream和DataInputStream是处理数据类型的。
     */
    public static byte[] convert(double num) throws IOException{
        byte[] data =null;
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        DataOutputStream dos =new DataOutputStream(bos);
        dos.writeDouble(num);//把内存中的num(89.12)转成字节数组输出到容器bos,
        dos.flush();

        //获取数据
        data = bos.toByteArray();
        dos.close();
        return data;
    }
}
UDP是数据里面去找服务器。

Socket通信：基于tcp协议，建立稳定连接的点对点通信，实时、快速、安全、占用系统资源多、效率相对低。
请求-相应模式：
    客户端：在网络通讯中，第一次主动发起通讯的程序称为客户端程序。
    服务器：第一次通讯中等待连接的程序称为服务器端程序。
Socket：发送TCP消息
ServerSocket：创建服务器

一、面向连接：请求-相应 Request-Response
二、服务器：ServerSocket，客户端Socket    客户端和服务端相当于有一个管道，这个管道就是socket，服务端的一个端口有可能有多个客户端来连接，每一个连接都有一个Socket。客户端和服务端都有一个端口，服务端的端口要指定，客户端的端口是自动分配的不需要指定。
（http协议底层的传输也是tcp协议，浏览器是一个基于tcp的客户端，只不过交互用的是http应用协议，tcp是http底层的协议。）

import java.io.BufferedWriter;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.OutputStreamWriter;
import java.net.ServerSocket;
import java.net.Socket;

/**
 必须先启动服务器 后连接
1、创建服务器  指定端口   ServerSocket(int port)
2、接收客户端连接
3、发送数据+接收数据
*/
public class Server {
    public static void main(String[] args) throws IOException {
        //1、创建服务器  指定端口   ServerSocket(int port)
        ServerSocket server = new ServerSocket();
        //2、接收客户端连接   阻塞式，Socket代表这条管道，这个管道也可以代表这个客户端。
        Socket socket =server.accept();//这行代码是服务端接收了客户端的连接，这就是服务端和客户端连接的那个管道，2者得到的是同一个管道。
        System.out.println("一个客户端建立连接");
        //3、发送数据到客户端
        String msg ="欢迎使用";
        //输出流
        /*
        BufferedWriter bw = new BufferedWriter(
                new OutputStreamWriter(     //OutputStreamWriter是一个转换流
                socket.getOutputStream()));

        bw.write(msg);
        bw.newLine();//在bw中加一个换行符，客户端读的时候br.readLine()是一行一行的读。
        bw.flush();*/

        //socket.getOutputStream()套接字的输出流，内部还是流。
        DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
        dos.writeUTF(msg);
        dos.flush();
    }
}

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

/**
 1、创建客户端   必须指定服务器+端口    此时就在连接
     Socket(String host, int port)
 2、接收数据 +发送数据
 */
public class Client {
    public static void main(String[] args) throws UnknownHostException, IOException {
        //1、创建客户端   必须指定服务器+端口    此时就在连接，这个客户端发送数据也是需要端口的只不过端口是系统自己分配（UDP的端口是要写的）。
        Socket client = new Socket("localhost",);//这里就和服务器建立了连接，这个Socket就是服务端和客户端连接的那个管道。
        //2、接收服务器来的数据
        /*
        BufferedReader br = new BufferedReader(new InputStreamReader(client.getInputStream()));
        String echo =br.readLine(); //阻塞式方法逐行的读取，br中要有行的结束符。
        System.out.println(echo);*/

        try {
            DataInputStream dis = new DataInputStream(client.getInputStream());
            String echo = dis.readUTF();
            System.out.println(echo);
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
}

接收多个客户端：

import java.io.DataOutputStream;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
/**
 必须先启动服务器 后连接
1、创建服务器  指定端口   ServerSocket(int port)
2、接收客户端连接
3、发送数据+接收数据
接收多个客户端
*/
public class MultiServer {
    public static void main(String[] args) throws IOException {
        //1、创建服务器  指定端口   ServerSocket(int port)
        ServerSocket server = new ServerSocket();
        //2、接收客户端连接   阻塞式
        while(true){ //死循环  一个accept()一个客户端
            Socket socket =server.accept();
            System.out.println("一个客户端建立连接");
            //3、发送数据
            String msg ="欢迎使用";
            //输出流

            DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
            dos.writeUTF(msg);
            dos.flush();
            while(true){
                System.out.println("qqqqqqq\n");
            }
        }
    }
}