20 线程：生产者消费者

等待和唤醒的方法
为了体现生产和消费过程中的等待和唤醒，Java就提供了几个方法供我们使用，这几个方法在Object类中
Object类的等待和唤醒方法：

方法名	说明
void wait()	导致当前线程等待，直到另一个线程调用该对象的 notify()方法或 notifyAll()方法
void notify()	唤醒正在等待对象监视器的单个线程
void notifyAll()	唤醒正在等待对象监视器的所有线程

代码实现–基础版

厨子Cooker（生产者）

public class Cooker extends Thread {
//    生产者步骤：
//            1，判断桌子上是否有汉堡包
//    如果有就等待，如果没有才生产。
//            2，把汉堡包放在桌子上。
//            3，叫醒等待的消费者开吃。
    @Override
    public void run() {
        while(true){
            synchronized (Desk.lock){
                if(Desk.count == 0){
                    break;
                }else{
                    if(!Desk.flag){
                        //生产
                        System.out.println("厨师正在生产汉堡包");
                        Desk.flag = true;
                        Desk.lock.notifyAll();
                    }else{
                        try {
                            Desk.lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
}

顾客Foodie（消费者）

public class Foodie extends Thread {
    @Override
    public void run() {
//        1，判断桌子上是否有汉堡包。
//        2，如果没有就等待。
//        3，如果有就开吃
//        4，吃完之后，桌子上的汉堡包就没有了
//                叫醒等待的生产者继续生产
//        汉堡包的总数量减一

        //套路:
            //1. while(true)死循环
            //2. synchronized 锁,锁对象要唯一
            //3. 判断,共享数据是否结束. 结束
            //4. 判断,共享数据是否结束. 没有结束
        while(true){
            synchronized (Desk.lock){
                if(Desk.count == 0){
                    break;
                }else{
                    if(Desk.flag){
                        //有
                        System.out.println("吃货在吃汉堡包");
                        Desk.flag = false;
                        Desk.lock.notifyAll();
                        Desk.count--;
                    }else{
                        //没有就等待
                        //使用什么对象当做锁,那么就必须用这个对象去调用等待和唤醒的方法.
                        try {
                            Desk.lock.wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }

    }
}

桌子Desk

public class Desk {

    //定义一个标记
    //true 就表示桌子上有汉堡包的,此时允许吃货执行
    //false 就表示桌子上没有汉堡包的,此时允许厨师执行
    public static boolean flag = false;

    //汉堡包的总数量
    public static int count = 10;

    //锁对象
    public static final Object lock = new Object();
}

主程序Demo

public class Demo {
    public static void main(String[] args) {
        /*消费者步骤：
        1，判断桌子上是否有汉堡包。
        2，如果没有就等待。
        3，如果有就开吃
        4，吃完之后，桌子上的汉堡包就没有了
                叫醒等待的生产者继续生产
        汉堡包的总数量减一*/



        /*生产者步骤：
        1，判断桌子上是否有汉堡包
        如果有就等待，如果没有才生产。
        2，把汉堡包放在桌子上。
        3，叫醒等待的消费者开吃。*/

        Foodie f = new Foodie();
        Cooker c = new Cooker();

        f.start();
        c.start();

    }
}

代码实现–优化版(Desk类以JavaBean实现)

厨子Cooker（生产者）

public class Cooker extends Thread {

    private Desk desk;

    public Cooker(Desk desk) {
        this.desk = desk;
    }
//    生产者步骤：
//            1，判断桌子上是否有汉堡包
//    如果有就等待，如果没有才生产。
//            2，把汉堡包放在桌子上。
//            3，叫醒等待的消费者开吃。

    @Override
    public void run() {
        while(true){
            synchronized (desk.getLock()){
                if(desk.getCount() == 0){
                    break;
                }else{
                    //System.out.println("验证一下是否执行了");
                    if(!desk.isFlag()){
                        //生产
                        System.out.println("厨师正在生产汉堡包");
                        desk.setFlag(true);
                        desk.getLock().notifyAll();
                    }else{
                        try {
                            desk.getLock().wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }
    }
}

顾客Foodie（消费者）

public class Foodie extends Thread {
    private Desk desk;

    public Foodie(Desk desk) {
        this.desk = desk;
    }

    @Override
    public void run() {
//        1，判断桌子上是否有汉堡包。
//        2，如果没有就等待。
//        3，如果有就开吃
//        4，吃完之后，桌子上的汉堡包就没有了
//                叫醒等待的生产者继续生产
//        汉堡包的总数量减一

        //套路:
            //1. while(true)死循环
            //2. synchronized 锁,锁对象要唯一
            //3. 判断,共享数据是否结束. 结束
            //4. 判断,共享数据是否结束. 没有结束
        while(true){
            synchronized (desk.getLock()){
                if(desk.getCount() == 0){
                    break;
                }else{
                    //System.out.println("验证一下是否执行了");
                    if(desk.isFlag()){
                        //有
                        System.out.println("吃货在吃汉堡包");
                        desk.setFlag(false);
                        desk.getLock().notifyAll();
                        desk.setCount(desk.getCount() - 1);
                    }else{
                        //没有就等待
                        //使用什么对象当做锁,那么就必须用这个对象去调用等待和唤醒的方法.
                        try {
                            desk.getLock().wait();
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }
                    }
                }
            }
        }

    }
}

桌子Desk

public class Desk {

    //定义一个标记
    //true 就表示桌子上有汉堡包的,此时允许吃货执行
    //false 就表示桌子上没有汉堡包的,此时允许厨师执行
    //public static boolean flag = false;
    private boolean flag;

    //汉堡包的总数量
    //public static int count = 10;
    //以后我们在使用这种必须有默认值的变量
   // private int count = 10;
    private int count;

    //锁对象
    //public static final Object lock = new Object();
    private final Object lock = new Object();

    public Desk() {
        this(false,10);
    }

    public Desk(boolean flag, int count) {
        this.flag = flag;
        this.count = count;
    }

    public boolean isFlag() {
        return flag;
    }

    public void setFlag(boolean flag) {
        this.flag = flag;
    }

    public int getCount() {
        return count;
    }

    public void setCount(int count) {
        this.count = count;
    }

    public Object getLock() {
        return lock;
    }

    @Override
    public String toString() {
        return "Desk{" +
                "flag=" + flag +
                ", count=" + count +
                ", lock=" + lock +
                '}';
    }
}

主程序Demo

public class Demo {
    public static void main(String[] args) {
        /*消费者步骤：
        1，判断桌子上是否有汉堡包。
        2，如果没有就等待。
        3，如果有就开吃
        4，吃完之后，桌子上的汉堡包就没有了
                叫醒等待的生产者继续生产
        汉堡包的总数量减一*/



        /*生产者步骤：
        1，判断桌子上是否有汉堡包
        如果有就等待，如果没有才生产。
        2，把汉堡包放在桌子上。
        3，叫醒等待的消费者开吃。*/

        Desk desk = new Desk();

        Foodie f = new Foodie(desk);
        Cooker c = new Cooker(desk);

        f.start();
        c.start();

    }
}

代码实现–优化版(阻塞)

阻塞队列继承结构

阻塞队列实现等待唤醒机制

BlockingQueue的核心方法：

put(anObject):将参数放入队列，如果放不进去会阻塞。
take():取出第一个数据，取不到会阻塞。

常见BlockingQueue：

ArrayBlockingQueue：底层是数组，有界。
LinkedBlockingQueue：底层是链表，无界。但不是真正的无界，最大为int的最大值。

厨子Cooker（生产者）

public class Cooker extends Thread {

    private ArrayBlockingQueue<String> bd;

    public Cooker(ArrayBlockingQueue<String> bd) {
        this.bd = bd;
    }
//    生产者步骤：
//            1，判断桌子上是否有汉堡包
//    如果有就等待，如果没有才生产。
//            2，把汉堡包放在桌子上。
//            3，叫醒等待的消费者开吃。

    @Override
    public void run() {
        while (true) {
            try {
                bd.put("汉堡包");
                System.out.println("厨师放入一个汉堡包");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

顾客Foodie（消费者）

public class Foodie extends Thread {
    private ArrayBlockingQueue<String> bd;

    public Foodie(ArrayBlockingQueue<String> bd) {
        this.bd = bd;
    }

    @Override
    public void run() {
//        1，判断桌子上是否有汉堡包。
//        2，如果没有就等待。
//        3，如果有就开吃
//        4，吃完之后，桌子上的汉堡包就没有了
//                叫醒等待的生产者继续生产
//        汉堡包的总数量减一

        //套路:
        //1. while(true)死循环
        //2. synchronized 锁,锁对象要唯一
        //3. 判断,共享数据是否结束. 结束
        //4. 判断,共享数据是否结束. 没有结束
        while (true) {
            try {
                String take = bd.take();
                System.out.println("吃货将" + take + "拿出来吃了");
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

    }
}

主程序Demo

public class Demo {
    public static void main(String[] args) {
//        创建阻塞队列，容量为1
        ArrayBlockingQueue<String> bd = new ArrayBlockingQueue<>(1);

//        创建线程，并开启
        Foodie f = new Foodie(bd);
        Cooker c = new Cooker(bd);

        f.start();
        c.start();
    }
}

21 网络编程

1. 常用命令

ipconfig：查看本机IP地址
ping IP地址：检查网络是否连通
127.0.0.1：代表本机IP地址

2. InetAddress类

获取IP和主机名

//static InetAddress getByName(String host)
//                          确定主机名称的IP地址。主机名称可以是机器名称，也可以是IP地址
//String getHostName()     获取此IP地址的主机名
//String getHostAddress()  返回文本显示中的IP地址字符串
public class InetadressDemo1 {
    public static void main(String[] args) throws UnknownHostException {
        InetAddress address = InetAddress.getByName("沉迷代码");

        String hostName = address.getHostName();
        System.out.println("主机名为" + hostName);

        String ip = address.getHostAddress();
        System.out.println("IP为" + ip);
    }
}

3. UDP

基本使用

客户端Client

public class ClientDemo {
    public static void main(String[] args) throws IOException {
        //1.找码头
        DatagramSocket ds = new DatagramSocket();
        //2.打包礼物
        //DatagramPacket(byte[] buf, int length, InetAddress address, int port)
        String s = "送给村长老丈人的礼物";
        byte[] bytes = s.getBytes();
        InetAddress address = InetAddress.getByName("127.0.0.1");
        int port = 10000;
        DatagramPacket dp = new DatagramPacket(bytes,bytes.length,address,port);


        //3.由码头发送包裹
        ds.send(dp);

        //4.付钱走羊
        ds.close();
    }
}

服务端Server

public class ServerDemo {
    //注意点:
        //1.要先运行接收端,再运行发送端
        //2.如果接收端再启动之后,没有接收到数据,那么会死等(阻塞).
        //3.在接收数据的时候,需要调用一个getLength方法,表示接收到了多少字节
    public static void main(String[] args) throws IOException {
        //1.找码头     ---- 表示接收端从10000端口接收数据的.
        DatagramSocket ds = new DatagramSocket(10000);
        //2,创建一个新的箱子
        byte [] bytes = new byte[1024];
        DatagramPacket dp = new DatagramPacket(bytes,bytes.length);
        //3.接收礼物,把礼物放到新的箱子中
        System.out.println("-----------接收前----------");
        ds.receive(dp);
        System.out.println("------------接收后---------");
        //4.从新的箱子里面获取礼物
       // byte[] data = dp.getData();
        int length = dp.getLength();
        System.out.println(new String(bytes,0,length));
        //5.拿完走羊
        ds.close();
    }
}

简易的聊天室

介绍

Client：可以运行多个Client，发送的数据会依次在Server展示，形成聊天室的效果。
Server：只运行一个Server，不进行close关闭。

客户端Client

public class ClientDemo {
    public static void main(String[] args) throws IOException {
        Scanner sc = new Scanner(System.in);
        DatagramSocket ds = new DatagramSocket();
        while (true) {
            String s = sc.nextLine();
            if("886".equals(s)){ // 输入886结束通讯
                break;
            }
            byte[] bytes = s.getBytes();
            InetAddress address = InetAddress.getByName("127.0.0.1");
            int port = 10000;
            DatagramPacket dp = new DatagramPacket(bytes,bytes.length,address,port);

            ds.send(dp);
        }

        ds.close();
    }
}

服务端Server

public class ServerDemo {
    public static void main(String[] args) throws IOException {
        DatagramSocket ds = new DatagramSocket(10000);

        while (true) {
            byte [] bytes = new byte[1024];
            DatagramPacket dp = new DatagramPacket(bytes,bytes.length);

            ds.receive(dp);

            byte[] data = dp.getData();
            int length = dp.getLength();

            System.out.println(new String(data,0,length));
        }

       // ds.close();
    }
}

4. TCP

基本使用

客户端Client

public class ClientDemo {
    public static void main(String[] args) throws IOException {
        //1,创建一个Socket对象
        Socket socket = new Socket("127.0.0.1",10000);

        //2.获取一个IO流开始写数据
        OutputStream os = socket.getOutputStream();
        os.write("hello".getBytes());

        /*while(true){

        }*/
        //3.释放资源
        os.close(); // close 默认带结束标记
        socket.close();
    }
}

服务端Server

public class ServerDemo {
    public static void main(String[] args) throws IOException {
        //1. 创建Socket对象
        ServerSocket ss = new ServerSocket(10000);
        //2. 等待客户端连接
        System.out.println(111);
        Socket accept = ss.accept(); // accept方法是阻塞的
        System.out.println(222);
        //3.获得输入流对象
        InputStream is = accept.getInputStream();
        int b;
        while((b = is.read()) != -1){ // read方法也是阻塞的，接收客户端close默认发送的结束标记，继续执行后面代码
            System.out.print((char) b);
        }

        System.out.println("看看我执行了吗?");

        //4.释放资源
        is.close();
        ss.close();
    }
}

客户端和服务端相互通信

⚫ 客户端：发送数据，接收服务器反馈
⚫ 服务器：接收数据，给出反馈

客户端Client

public class ClientDemo {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("127.0.0.1",10000);

        OutputStream os = socket.getOutputStream();
        os.write("hello".getBytes());
       // os.close();如果在这里关流,会导致整个socket都无法使用
        socket.shutdownOutput();//仅仅关闭输出流.并写一个结束标记,对socket没有任何影响


        /*InputStream is = socket.getInputStream(); // 服务器发送数据带中文会出现乱码，所以要用转换流
        int b;
        while((b = is.read()) !=-1){
            System.out.println((char) b);
        }*/

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

服务端Server

public class ServerDemo {
    public static void main(String[] args) throws IOException {
        ServerSocket ss = new ServerSocket(10000);

        Socket accept = ss.accept();

        InputStream is = accept.getInputStream();
        int b;
        while((b = is.read())!=-1){
            System.out.println((char) b);
        }

        System.out.println("看看我执行了吗?");
       /* OutputStream os = accept.getOutputStream(); // 客户端按照字节接收，带中文会出现乱码，所以要用转换流
        os.write("你谁啊?".getBytes());*/
        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(accept.getOutputStream()));
        bw.write("你谁啊?");
        bw.newLine();
        bw.flush();

        bw.close();
        is.close();
        accept.close();
        ss.close();
    }
}

本地文件上传服务器保存

⚫ 客户端：将本地文件上传到服务器。接收服务器的反馈。
⚫ 服务器：接收客户端上传的文件，上传完毕之后给出反馈。

客户端Client

public class ClientDemo {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("127.0.0.1",10000);

        //是本地的流,用来读取本地文件的.
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("socketmodule\\ClientDir\\1.jpg"));

        //写到服务器 --- 网络中的流
        OutputStream os = socket.getOutputStream();
        BufferedOutputStream bos = new BufferedOutputStream(os);

        int b;
        while((b = bis.read())!=-1){
            bos.write(b);//通过网络写到服务器中
        }
        bos.flush();
        //给服务器一个结束标记,告诉服务器文件已经传输完毕
        socket.shutdownOutput();


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


    }
}

服务端Server

public class ServerDemo {
    public static void main(String[] args) throws IOException {
        ServerSocket ss = new ServerSocket(10000);

        Socket accept = ss.accept();

        //网络中的流,从客户端读取数据的
        BufferedInputStream bis = new BufferedInputStream(accept.getInputStream());
        //本地的IO流,把数据写到本地中,实现永久化存储
        BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("socketmodule\\ServerDir\\copy.jpg"));

        int b;
        while((b = bis.read()) !=-1){
            bos.write(b);
        }

        BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(accept.getOutputStream()));
        bw.write("上传成功");
        bw.newLine();
        bw.flush();

        bos.close();
        accept.close();
        ss.close();


    }
}

本地文件上传服务器保存（优化）

⚫ 服务器只能执行一次。（用循环解决）
⚫ 第二次上传文件会把第一次文件覆盖。（用UUID解决）

客户端Client

public class ClientDemo {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("127.0.0.1",10000);

        //是本地的流,用来读取本地文件的.
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("optimizeserver\\ClientDir\\1.jpg"));

        //写到服务器 --- 网络中的流
        OutputStream os = socket.getOutputStream();
        BufferedOutputStream bos = new BufferedOutputStream(os);

        int b;
        while((b = bis.read())!=-1){
            bos.write(b);//通过网络写到服务器中
        }
        bos.flush();
        //给服务器一个结束标记,告诉服务器文件已经传输完毕
        socket.shutdownOutput();



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


        bis.close();
        socket.close();
    }
}

服务端Server

public class ServerDemo {
    public static void main(String[] args) throws IOException {
        ServerSocket ss = new ServerSocket(10000);

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

            //网络中的流,从客户端读取数据的
            BufferedInputStream bis = new BufferedInputStream(accept.getInputStream());
            //本地的IO流,把数据写到本地中,实现永久化存储
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("optimizeserver\\ServerDir\\" + UUID.randomUUID().toString() + ".jpg"));

            int b;
            while((b = bis.read()) !=-1){
                bos.write(b);
            }

            BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(accept.getOutputStream()));
            bw.write("上传成功");
            bw.newLine();
            bw.flush();

            bos.close();
            accept.close();
        }
        //ss.close();


    }
}

本地文件上传服务器保存（二次优化-线程池）

⚫ 只能与一个客户端保持通信（开多线程）

客户端Client

public class ClientDemo {
    public static void main(String[] args) throws IOException {
        Socket socket = new Socket("127.0.0.1",10000);

        //是本地的流,用来读取本地文件的.
        BufferedInputStream bis = new BufferedInputStream(new FileInputStream("optimizeserver\\ClientDir\\1.jpg"));

        //写到服务器 --- 网络中的流
        OutputStream os = socket.getOutputStream();
        BufferedOutputStream bos = new BufferedOutputStream(os);

        int b;
        while((b = bis.read())!=-1){
            bos.write(b);//通过网络写到服务器中
        }
        bos.flush();
        //给服务器一个结束标记,告诉服务器文件已经传输完毕
        socket.shutdownOutput();



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


        bis.close();
        socket.close();


    }
}

服务端Server

public class ServerDemo {
    public static void main(String[] args) throws IOException {
        ServerSocket ss = new ServerSocket(10000);
        ThreadPoolExecutor pool = new ThreadPoolExecutor(
                3,//核心线程数量
                10,   //线程池的总数量
                60,   //临时线程空闲时间
                TimeUnit.SECONDS, //临时线程空闲时间的单位
                new ArrayBlockingQueue<>(5),//阻塞队列
                Executors.defaultThreadFactory(),//创建线程的方式
                new ThreadPoolExecutor.AbortPolicy()//任务拒绝策略
        );

        while (true) {
            Socket accept = ss.accept();
            ThreadSocket ts = new ThreadSocket(accept);
            //new Thread(ts).start();
            pool.submit(ts);

        }
        //ss.close();


    }
}

多线程ThreadSocket

public class ThreadSocket implements Runnable {
    private Socket acceptSocket;

    public ThreadSocket(Socket accept) {
        this.acceptSocket = accept;
    }

    @Override
    public void run() {
        BufferedOutputStream bos = null;
        try {
            //网络中的流,从客户端读取数据的
            BufferedInputStream bis = new BufferedInputStream(acceptSocket.getInputStream());
            //本地的IO流,把数据写到本地中,实现永久化存储
            bos = new BufferedOutputStream(new FileOutputStream("optimizeserver\\ServerDir\\" + UUID.randomUUID().toString() + ".jpg"));

            int b;
            while((b = bis.read()) !=-1){
                bos.write(b);
            }

            BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(acceptSocket.getOutputStream()));
            bw.write("上传成功");
            bw.newLine();
            bw.flush();


        } catch (IOException e) {
            e.printStackTrace();
        } finally {
            if(bos != null){
                try {
                    bos.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

            if (acceptSocket != null){
                try {
                    acceptSocket.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }

        }
    }
}

22 XML

XML类似于HTML，只是标签是自定义的。

用途
一般是作为软件的配置文件，在软件内部编写好的。

1. 基础语法

<!--文档声明，version是必需的 -->
<?xml version="1.0" encoding="UTF-8" ?>
<!--注释的内容-->
<!--本xml文件用来描述多个学生信息-->
<students>

    <!--第一个学生信息-->
    <student id="1">
        <name>张三</name>
        <age>23</age>
<!--        特殊字符的处理-->
<!--        &lt; < 小于-->
<!--        &gt; > 大于-->
<!--        &amp; & 和号-->
<!--        &apos; ' 单引号-->
<!--        &quot; " 引号-->
        <!--<info>学生&lt; &gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;的信息</info>-->
        
<!--        特殊字符的处理：第二种方式CDATA方式 -->
        <!--<message> <![CDATA[内容 <<<<<< >>>>>> ]]]></message>-->
    </student>


    <!--第二个学生信息-->
    <student id="2">
        <name>李四</name>
        <age>24</age>
    </student>

    <aaa></aaa>

</students>

2. 解析使用（DOM4J）

DOM4J: 全称：Dom For Java。读dom for j。不要读4。4只是因为跟for英文同音而已。

dom4j下载地址：https://download.csdn.net/download/Litt_White/87393709

导入DOM4J的jar包

方式1

复制jar包
项目中新增libs文件夹（右键-new-directory）
选中libs
粘贴jar包（Ctrl+V）
选中粘贴的jar包
将jar包导入当前项目（右键-Add as Library-确定）
导入成功，会有三角打开标识，可以看到jar内容。

方式2

File-Project Structure- Libraries
右侧是已经成功导入的jar包
新增jar包，可以点击+进行导入操作。

java解析xml文件，获取xml数据

xmlParse.java

public class XmlParse {
    public static void main(String[] args) throws DocumentException {
        //1.获取一个解析器对象
        SAXReader saxReader = new SAXReader();
        //2.利用解析器把xml文件加载到内存中,并返回一个文档对象
        Document document = saxReader.read(new File("myxml\\xml\\student.xml"));
        //3.获取到根标签
        Element rootElement = document.getRootElement();
        //4.通过根标签来获取student标签
        //elements():可以获取调用者所有的子标签.会把这些子标签放到一个集合中返回.
        //elements("标签名"):可以获取调用者所有的指定的子标签,会把这些子标签放到一个集合中并返回
        //List list = rootElement.elements();
        List<Element> studentElements = rootElement.elements("student");
        //System.out.println(list.size());

        //用来装学生对象
        ArrayList<Student> list = new ArrayList<>();


        //5.遍历集合,得到每一个student标签
        for (Element element : studentElements) {
            //element依次表示每一个student标签

            //获取id这个属性
            Attribute attribute = element.attribute("id");
            //获取id的属性值
            String id = attribute.getValue();


            //获取name标签
            //element("标签名"):获取调用者指定的子标签
            Element nameElement = element.element("name");
            //获取这个标签的标签体内容
            String name = nameElement.getText();


            //获取age标签
            Element ageElement = element.element("age");
            //获取age标签的标签体内容
            String age = ageElement.getText();

//            System.out.println(id);
//            System.out.println(name);
//            System.out.println(age);

            Student s = new Student(id,name,Integer.parseInt(age));
            list.add(s);
        }
        //遍历操作
        for (Student student : list) {
            System.out.println(student);
        }
    }
}

student.xml

<?xml version="1.0" encoding="UTF-8" ?>
<students>

    <student id="1">
        <name>张三</name>
        <age>23</age>
    </student>

    <student id="2">
        <name>李四</name>
        <age>24</age>
    </student>

    <aaa></aaa>
    
</students>

Student.java

public class Student {
    private String id;
    private String name;
    private int age;

    public Student() {
    }

    public Student(String id, String name, int age) {
        this.id = id;
        this.name = name;
        this.age = age;
    }

    public String getId() {
        return id;
    }

    public void setId(String id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" +
                "id='" + id + '\'' +
                ", name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

3. XML约束

概述

什么是约束

用来限定xml文件中可使用的标签以及属性

分类

DTD
schema

DTD约束

引入1（引入本地dtd）

<?xml version="1.0" encoding="UTF-8" ?>
<!--引入本地dtd-->
<!DOCTYPE persons SYSTEM 'persondtd.dtd'>

<persons>
    <person>
        <name>张三</name>
        <age>23</age>
    </person>

</persons>

单独的persondtd.dtd文件

// persondtd.dtd文件
<!ELEMENT persons (person)>
<!ELEMENT person (name,age)>
<!ELEMENT name (#PCDATA)>
<!ELEMENT age (#PCDATA)>

引入2（在xml文件内部引入）

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE persons [
        <!ELEMENT persons (person)>
        <!ELEMENT person (name,age)>
        <!ELEMENT name (#PCDATA)>
        <!ELEMENT age (#PCDATA)>
        ]>

<persons>
    <person>
        <name>张三</name>
        <age>23</age>
    </person>

</persons>

引入3（引入网络dtd）

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE persons PUBLIC "dtd文件的名称" "dtd文档的URL">

<persons>
    <person>
        <name>张三</name>
        <age>23</age>
    </person>

</persons>

DTD约束语法

定义元素

定义一个元素的格式为：<!ELEMENT 元素名 (元素类型)>

元素类型:

简单元素：没有子元素
- EMPTY: 表示标签体为空
- ANY: 表示标签体可以为空也可以不为空
- PCDATA: 表示该元素的内容部分为字符串.
复杂元素：有子元素
- 直接写子元素名称. 多个子元素可以使用","或者"|"隔开；
- ","表示定义子元素的顺序 ; "|": 表示子元素只能出现任意一个
- "?"零次或一次, "+"一次或多次, "*"零次或多次;如果不写则表示出现一次.

<!ELEMENT persons (person+)>
<!ELEMENT person (name,age)>
<!ELEMENT name (#PCDATA)>
<!ELEMENT age (#PCDATA)>

定义属性

格式
<!ATTLIST 元素名称属性名称属性的类型属性的约束>

属性的类型：
CDATA类型：普通的字符串

属性的约束:
#REQUIRED：必须的
#IMPLIED：属性不是必需的
#FIXED value：属性值是固定的

// 约束person元素的 属性id 必须为字符串，且属性值是固定的p1
<!ATTLIST person id CDATA #FIXED "p1">

schema约束

schema和dtd的区别

schema约束文件也是一个xml文件，符合xml的语法，这个文件的后缀名.xsd
一个xml中可以引用多个schema约束文件，多个schema使用名称空间区分（名称空间类似于java包名）
dtd里面元素类型的取值比较单一常见的是PCDATA类型，但是在schema里面可以支持很多个数据类型
schema 语法更加的复杂

编写schema约束

步骤

创建一个文件，这个文件的后缀名为.xsd。
定义文档声明
schema文件的根标签为：
在中定义属性：xmlns=http://www.w3.org/2001/XMLSchema
在中定义属性：targetNamespace =唯一的url地址，指定当前这个schema文件的名称空间。
在中定义属性：elementFormDefault=”qualified“，表示当前schema文件是一个质量良好的文件。
通过element定义元素
判断当前元素是简单元素还是复杂元素
添加属性约束，在和之间。

<?xml version="1.0" encoding="UTF-8" ?>
<schema
    xmlns="http://www.w3.org/2001/XMLSchema"
    targetNamespace="http://www.itheima.cn/javase"
    elementFormDefault="qualified"
>

    <!--定义persons复杂元素-->
    <element name="persons">
        <complexType>
            <sequence>
                <!--定义person复杂元素-->
                <element name = "person">
                    <complexType>
                        <sequence>
                            <!--定义name和age简单元素-->
                            <element name = "name" type = "string"></element>
                            <element name = "age" type = "string"></element>
                        </sequence>
                        
                        <!--定义属性，required( 必须的)/optional( 可选的)-->
                        <attribute name="id" type="string" use="required"></attribute>
                    </complexType>
                </element>
            </sequence>
        </complexType>

    </element>

</schema>

引入schema约束

步骤

在根标签上定义属性xmlns=“http://www.w3.org/2001/XMLSchema-instance”
通过xmlns引入约束文件的名称空间
给某一个xmlns属性添加一个标识，用于区分不同的名称空间。
格式为: xmlns:标识=“名称空间地址” ,标识可以是任意的，但是一般取值都是xsi
通过xsi:schemaLocation指定名称空间所对应的约束文件路径
格式为：xsi:schemaLocation = “名称空间url 文件路径“

<?xml version="1.0" encoding="UTF-8" ?>

<persons
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns="http://www.itheima.cn/javase"
    xsi:schemaLocation="http://www.itheima.cn/javase person.xsd"
>
    <person id="001">
        <name>张三</name>
        <age>23</age>
    </person>

</persons>

23 枚举

1. 概述【理解】

为了间接的表示一些固定的值，Java就给我们提供了枚举
是指将变量的值一一列出来,变量的值只限于列举出来的值的范围内

2. 定义格式【应用】

格式

public enum s {   
	枚举项1,枚举项2,枚举项3;
}
注意: 定义枚举类要用关键字enum

示例代码（右键-new-java class – Enum）

// 定义一个枚举类，用来表示春，夏，秋，冬这四个固定值
public enum Season {
    SPRING,SUMMER,AUTUMN,WINTER;
}

枚举的特点【理解】

特点
- 所有枚举类都是Enum的子类
- 我们可以通过”枚举类名.枚举项名称”去访问指定的枚举项
- 每一个枚举项其实就是该枚举的一个对象
- 枚举也是一个类，也可以去定义成员变量
- 枚举类的第一行上必须是枚举项，最后一个枚举项后的分号是可以省略的，但是如果枚举类有其他的东西，这个分号就不能省略。建议不要省略
- 枚举类可以有构造器，但必须是private的，它默认的也是private的。
  
  枚举项的用法比较特殊：枚举(“”);
- 枚举类也可以有抽象方法，但是枚举项必须重写该方法

枚举的方法【应用】

方法介绍

方法名	说明
String name()	获取枚举项的名称
int ordinal()	返回枚举项在枚举类中的索引值
int compareTo(E o)	比较两个枚举项，返回的是索引值的差值
String toString()	返回枚举常量的名称
static T valueOf(Class type,String name)	获取指定枚举类中的指定名称的枚举值
values()	获得所有的枚举项

示例代码

public enum Season {
    SPRING,SUMMER,AUTUMN,WINTER;
}

public class EnumDemo {
    public static void main(String[] args) {
//        String name() 获取枚举项的名称
        String name = Season.SPRING.name();
        System.out.println(name);
        System.out.println("-----------------------------");

//        int ordinal() 返回枚举项在枚举类中的索引值
        int index1 = Season.SPRING.ordinal();
        int index2 = Season.SUMMER.ordinal();
        int index3 = Season.AUTUMN.ordinal();
        int index4 = Season.WINTER.ordinal();
        System.out.println(index1);
        System.out.println(index2);
        System.out.println(index3);
        System.out.println(index4);
        System.out.println("-----------------------------");

//        int compareTo(E o) 比较两个枚举项，返回的是索引值的差值
        int result = Season.SPRING.compareTo(Season.WINTER);
        System.out.println(result);//-3
        System.out.println("-----------------------------");

//        String toString()   返回枚举常量的名称
        String s = Season.SPRING.toString();
        System.out.println(s);
        System.out.println("-----------------------------");

//        static <T> T valueOf(Class<T> type,String name)
//        获取指定枚举类中的指定名称的枚举值
        Season spring = Enum.valueOf(Season.class, "SPRING");
        System.out.println(spring);
        System.out.println(Season.SPRING == spring);
        System.out.println("-----------------------------");

//        values()       获得所有的枚举项
        Season[] values = Season.values();
        for (Season value : values) {
            System.out.println(value);
        }
    }
}

24 注解

概述【理解】

概述

对我们的程序进行标注和解释
注解和注释的区别
- 注释: 给程序员看的
- 注解: 给编译器看的
使用注解进行配置配置的优势

代码更加简洁,方便

25 单元测试

1. 概述【理解】

JUnit是一个 Java 编程语言的单元测试工具。JUnit 是一个非常重要的测试工具.

JUnit 下载地址：https://download.csdn.net/download/Litt_White/87393707

2. 使用步骤【应用】

使用步骤
1. 将junit的jar包导入到工程中 junit-4.9.jar
2. 编写测试方法该测试方法必须是公共的无参数``无返回值的非静态方法
3. 在测试方法上使用@Test注解标注该方法是一个测试方法
4. 选中@Test测试方法右键通过junit运行该方法
代码示例

public class JunitDemo1 {
    @Test
    public void add() {
        System.out.println(2 / 0);
        int a = 10;
        int b = 20;
        int sum = a + b;
        System.out.println(sum);
    }
}

26 日志(Log4J的使用)

Log4J下载地址：https://download.csdn.net/download/Litt_White/87393707

1. 入门案例【应用】

使用步骤
1. 导入log4j的相关jar包
2. 编写log4j配置文件
3. 在代码中获取日志的对象
4. 按照级别设置记录日志信息
代码示例

// log4j的配置文件,名字为log4j.properties, 放在src根目录下
log4j.rootLogger=debug,my,fileAppender

### direct log messages to my ###
log4j.appender.my=org.apache.log4j.ConsoleAppender
log4j.appender.my.ImmediateFlush = true
log4j.appender.my.Target=System.out
log4j.appender.my.layout=org.apache.log4j.PatternLayout
log4j.appender.my.layout.ConversionPattern=%d %t %5p %c{1}:%L - %m%n

# fileAppender��ʾ
log4j.appender.fileAppender=org.apache.log4j.FileAppender
log4j.appender.fileAppender.ImmediateFlush = true
log4j.appender.fileAppender.Append=true
log4j.appender.fileAppender.File=D:/log4j-log.log
log4j.appender.fileAppender.layout=org.apache.log4j.PatternLayout
log4j.appender.fileAppender.layout.ConversionPattern=%d %5p %c{1}:%L - %m%n

// 测试类
public class Log4JTest01 {

    //使用log4j的api来获取日志的对象
    //弊端：如果以后我们更换日志的实现类，那么下面的代码就需要跟着改
    //不推荐使用
    //private static final Logger LOGGER = Logger.getLogger(Log4JTest01.class);

    //使用slf4j里面的api来获取日志的对象
    //好处：如果以后我们更换日志的实现类，那么下面的代码不需要跟着修改
    //推荐使用
    private static  final Logger LOGGER = LoggerFactory.getLogger(Log4JTest01.class);

    public static void main(String[] args) {
        //1.导入jar包
        //2.编写配置文件
        //3.在代码中获取日志的对象
        //4.按照日志级别设置日志信息
        LOGGER.debug("debug级别的日志");
        LOGGER.info("info级别的日志");
        LOGGER.warn("warn级别的日志");
        LOGGER.error("error级别的日志");
    }
}

2. 配置文件详解【理解】

三个核心

Loggers(记录器) 日志的级别

Loggers组件在此系统中常见的五个级别：DEBUG、INFO、WARN、ERROR 和 FATAL。

DEBUG < INFO < WARN < ERROR < FATAL。

Log4j有一个规则：只输出级别不低于设定级别的日志信息。

Appenders(输出源) 日志要输出的地方

把日志输出到不同的地方，如控制台（Console）、文件（Files）等。

org.apache.log4j.ConsoleAppender（控制台）
org.apache.log4j.FileAppender（文件）

Layouts(布局) 日志输出的格式

可以根据自己的喜好规定日志输出的格式，常用的布局管理器：

org.apache.log4j.PatternLayout（可以灵活地指定布局模式）（一般用这个）
org.apache.log4j.SimpleLayout（包含日志信息的级别和信息字符串）
org.apache.log4j.TTCCLayout（包含日志产生的时间、线程、类别等信息）

配置根Logger

格式

log4j.rootLogger=日志级别，appenderName1，appenderName2，…

日志级别

OFF、FATAL、ERROR、WARN、INFO、DEBUG、ALL或者自定义的级别。

appenderName1

就是指定日志信息要输出到哪里。可以同时指定多个输出目的地，用逗号隔开。
例如：log4j.rootLogger＝INFO，ca，fa

ConsoleAppender常用的选项

ImmediateFlush=true

表示所有消息都会被立即输出，设为false则不输出，默认值是true。

Target=System.err

默认值是System.out。

FileAppender常用的选项

ImmediateFlush=true

表示所有消息都会被立即输出。设为false则不输出，默认值是true

Append=false

true表示将消息添加到指定文件中，原来的消息不覆盖。

false则将消息覆盖指定的文件内容，默认值是true。

File=D:/logs/logging.log4j

指定消息输出到logging.log4j文件中

PatternLayout常用的选项

ConversionPattern=%m%n

设定以怎样的格式显示消息

3. 在项目中的应用【应用】

步骤

导入相关的依赖
将资料中的properties配置文件复制到src目录下
在代码中获取日志的对象
按照级别设置记录日志信息

代码实现

@WebServlet(urlPatterns = "/servlet/loginservlet")
public class LoginServlet implements HttpServlet{

    //获取日志的对象
    private static final Logger LOGGER = LoggerFactory.getLogger(LoginServlet.class);

    @Override
    public void service(HttpRequest httpRequest, HttpResponse httpResponse) {
       //处理
        System.out.println("LoginServlet处理了登录请求");

        LOGGER.info("现在已经处理了登录请求，准备给浏览器响应");

       //响应
        httpResponse.setContentTpye("text/html;charset=UTF-8");
        httpResponse.write("登录成功");
    }
}

文章由极客之音整理，本文链接：https://www.bmabk.com/index.php/post/84934.html

Java：多线程、网络编程(UDP&TCP)、XML、枚举、注解、单元测试、日志

20 线程：生产者消费者

代码实现–基础版

厨子Cooker（生产者）

顾客Foodie（消费者）

桌子Desk

主程序Demo

代码实现–优化版(Desk类以JavaBean实现)

厨子Cooker（生产者）

顾客Foodie（消费者）

桌子Desk

主程序Demo

代码实现–优化版(阻塞)

阻塞队列继承结构

阻塞队列实现等待唤醒机制

厨子Cooker（生产者）

顾客Foodie（消费者）

主程序Demo

21 网络编程

1. 常用命令

2. InetAddress类

获取IP和主机名

3. UDP

基本使用

客户端Client

服务端Server

简易的聊天室

介绍

客户端Client

服务端Server

4. TCP

基本使用

客户端Client

服务端Server

客户端和服务端相互通信

客户端Client

服务端Server

本地文件上传服务器保存

客户端Client

服务端Server

本地文件上传服务器保存（优化）

客户端Client

服务端Server

本地文件上传服务器保存（二次优化-线程池）

客户端Client

服务端Server

多线程ThreadSocket

22 XML

1. 基础语法

2. 解析使用（DOM4J）

导入DOM4J的jar包

方式1

方式2

java解析xml文件，获取xml数据

xmlParse.java

student.xml

Student.java

3. XML约束

概述

DTD约束

引入1（引入本地dtd）

引入2（在xml文件内部引入）

引入3（引入网络dtd）

DTD约束语法

定义元素

定义属性

schema约束

schema和dtd的区别

编写schema约束

引入schema约束

23 枚举

1. 概述【理解】

2. 定义格式【应用】

枚举的特点【理解】

枚举的方法【应用】

24 注解

概述【理解】

25 单元测试

1. 概述【理解】

2. 使用步骤【应用】