看到下面的问答，有同学问，在讲使用线程池执行大量的Runnable命令时，案例中局部变量n的final为什么要加：

package productorandcustomer;

public class Producter implements Runnable {
	private Goods goods;

	public Producter(Goods goods) {
		super();
		this.goods = goods;
	}

	@Override
	public void run() {
		for (int i = 0; i < 100; i++) {
			if ((i % 2) == 0) {
				goods.set("小馒头", "旺仔");
			} else {
				goods.set("矿泉水", "哇哈哈");
			}
		}
	}

}

这块有点不明白

public Producter(Goods goods) {
		super();
		this.goods = goods;
	}

this意思不是当前对象吗  构造方法里可以用这个来给当前对象的属性赋值，goods不就是这个Goods类中的对象吗

那用this.对象是啥意思呢

老师我的web.xml没有错啊

<?xml version="1.0" encoding="UTF-8"?>
<web-app>
    <servlet>
        <servlet-name>login</servlet-name>
        <servlet-class>com.ha.servlet.LoginServlet</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>login</servlet-name>
        <url-pattern>/login</url-pattern>
        <url-pattern>/log</url-pattern>

    </servlet-mapping>
</web-app>

老师我这里出现了不能强制类型转换

package com.hao;


import cn.hao.Server;
import com.ha.servlet.Servlet;

import java.util.List;
import java.util.Map;

/**
 * @Author：@Author
 */
public class WebApp {   //App的意思就是应用程序
    private static ServletContext contxt;
    static {
        contxt=new ServletContext();
        //分别获取对应关系的Map集合
        Map<String,String> servlet=contxt.getServlet();
        Map<String,String> mapping=contxt.getMapping();
        //创建解析XML文件的对象
        WebDom4j we=new WebDom4j();
        we.parse(we.getDocument());//解析XML文件
        //获取解析后的XML文件之后的List集合
        List<Entity> entityList=we.getEntityList();
        List<Mapping> mappingList=we.getMappingList();
        //将List集合中的数据存储到Map集合当中
        for(Entity entity:entityList){
            servlet.put(entity.getName(),entity.getClazz());
        }
        //System.out.println(servlet);
        for(Mapping map:mappingList){
            //遍历url-pattern的集合
            List<String> urlPattern=map.getUrlPattern();
            for(String s:urlPattern){
                mapping.put(s,map.getName());
            }
        }
       // System.out.println(mapping);
    }
    public static Servlet getServlet(String url)  {
        if(url==null||url.trim().equals("")){
            return null;

        }

        try {
            //如果url正确
            //根据url的key获取servlet-name的值 /log=login
            String servletName=contxt.getMapping().get(url);
            //根据servletName得到对应的servlet-class
            String servletClass=contxt.getServlet().get(servletName);
            //使用反射创建Servlet对象


            Class clazz=Class.forName(servletClass);
            //调用无参构造方法创建Servlet对象
            Servlet servlet = (Servlet) clazz.newInstance();
            return  servlet;
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }

        return  null;
    }

    public static void main(String[] args) {
        System.out.println(getServlet("/log"));

    }
}

看到有同学问的这样一个问题，也引发了我的思考

于是查了查网上的帖子，发现，不是所有泛型都有所谓的泛型擦除效果的。

package com.bjsxt.server;

import java.util.List;
import java.util.Map;

import com.bjsxt.servlet.Servlet;

/**
 * Web应用程序
 * @version 1.0
 *
 */
public class WebApp {
	private static ServletContext contxt;
	static{
		contxt=new ServletContext();
		//分别获取对应关系的Map集合
		Map<String,String> servlet=contxt.getServlet();
		Map<String,String> mapping=contxt.getMapping();
		//创建解析XML文件对象
		WebDom4j web=new WebDom4j();
		web.parse(web.getDocument());//解析xml
		//获取解析XML之后的List集合
		List<Entity> entityList=web.getEntityList();
		List<Mapping> mappingList=web.getMappingList();
		
		//将List集合中的数据存储到Map集合
		for (Entity entity : entityList) {
			servlet.put(entity.getName(), entity.getClazz());
		}
		//	System.out.println(servlet);
		for( Mapping map:mappingList){
			//遍历url-pattern的集合
			List<String> urlPattern=map.getUrlPattern();
			for(String s:urlPattern){
				mapping.put(s, map.getName());
			}
		}
		System.out.println(mapping);
	}
	/**
	 * 通过反射创建Servlet对象
	 * @param url
	 * @return Servlet
	 */
	public static Servlet getServlet(String url){
		if (url==null||url.trim().equals("")) {
			return null;
		}
		//调用无参构造方法创建Servlet对象
		
		try {
			//如果url正确
			//根据url的key获取servlet-name的值 /log=login, /reg=register
			String servletName=contxt.getMapping().get(url);
			//根据servletName得到对应的servlet-class
			String servletClass=contxt.getServlet().get(servletName);  //得到的是一个完整个的包名+类的字符串
			System.out.println(servletClass);
			//使用反射创建 Servlet对象
			Class<?> clazz=Class.forName(servletClass);
			Servlet servlet = (Servlet) clazz.newInstance();
			return servlet;
		} catch (ClassNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (InstantiationException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		} catch (IllegalAccessException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return null;
	}
	public static void main(String[] args) {
		System.out.println(getServlet("/log"));
		System.out.println(getServlet("/login"));		
	}
}

老师，为什么这里得到的是一个包名+类的字符串，过程具体是怎么实现的？

老师getLocalHost()方法，来返回本地主机的地址？这个本地主机地址具体指什么？

在下面的问答看到有同学问jaxen的jar导它干什么，我在idea中，只导入了dom4j的jar，美元导入jaxen的jar。

在执行到第17行的xpath表达式的时候，报了异常，找不到类异常org.jaxen.JaxenException

导入jaxen的包后再次运行，成功

所以jaxen的jar应该主要是用来帮助解析dom4j提供的selectNodes()或selectSingleNode()等等方法中使用的xpath表达式的。少了它会报异常。

视频到最后 判断如果Sax解析的文本内容为null时不输出内容，看到有的同学在问，然后视频里应该是剪辑了一下，过得很快。我把图片截下来了，是有！的

学了这次的视频，我了解了下一直不太懂的命名空间

命名空间的出现是为了解决dtd不能解决的xml的命名冲突问题，这次课的视频里，xsd文件没有定义自己的命名空间。

然后在book.xml中引入book.xsd的时候属性使用的是

xsi:noNamespaceSchemaLocation="book.xsd"

不指定命名空间，只指定用于模式校验的xsd文档的位置，这种写法，XML模式处理器已经可以校验到xml里的写法问题了。如图：具体报错：

The content of element 'book' is not complete. One of '{price}' is expected.

说明已经检验成功了

在这里老师用的是

xsi:noNamespaceSchemaLocation="{book.xsd}" 而这种写法在我的idea里面是报红的。 至于视频里老师不报红，我猜测不同工具的不同文件，可能工具没有识别出来语法错误，把验证插件给关闭了。为什么老师要多此一举，使用java的相关类，SchemaFactory进行解析， 是不是因为要让我们了解如果脱离eclipse或者相关IDE，没有XML解析器，在只有xml文件及xsd文件的基础上，java也可以完成使用schema对xml文档的校验。

（扩充：自己测试了一下似乎谷歌浏览器无法完成使用schema对xml文档的校验，不报任何错误。）

这点在视频里没有提到。。这里存在疑问：（******） 

package com.bjsxt.proxy;

public class MarryCompany implements Marry{
	//婚 庆公司给准备结婚的人，准备婚 礼....
	private Marry m;
	 public MarryCompany(Marry m) {
		this.m=m;
	}
	
	 public void after(){
		 System.out.println("收拾东西............");
	 }
	 public void before(){
		 System.out.println("婚礼前的一些准备工作...........");
	 }
	@Override
	public void marry() {
		this.before();
		m.marry();//调用真实角色的结婚的方法
		this.after();
	}

}

这里这个this.before 和 this.after怎么说

以下是我自己对UDP 一个发送者与一个接受者，多次咨询，双方互相发送的代码的优化，参考TCP的多线程

首先是Clinet项目

为一个发送者建立两个线程类，一个Send类，一个Receive类。用于发送和接收。

Send类

package com.gz.udp2;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.Date;
import java.util.Scanner;

public class Send implements Runnable{
    private DatagramSocket ds;
    private Scanner sc;
    private String destIp;//目标ip
    private int destPort;//目标端口号
    private String role;//角色名称
    private boolean flag=true;


    public Send(DatagramSocket ds,String destIp,int destPort,String role) {
        this.ds = ds;
        this.destIp=destIp;
        this.destPort=destPort;
        this.role=role;
        sc=new Scanner(System.in);
    }
    private String getMessage(){
        return sc.next();
    }
    private void send(String str){
        //发送时间
        String date=new Date().toLocaleString();
        str=date+"   "+role+":"+str;
        byte[] buf=str.getBytes();
        try {
            DatagramPacket dp=new DatagramPacket(buf,buf.length, InetAddress.getByName(destIp),destPort);
            ds.send(dp);
        } catch (IOException e) {
            flag=false;
            if(ds!=null) {
                ds.close();
            }
        }
    }

    @Override
    public void run() {
        while(flag){
            this.send(this.getMessage());
        }

    }
}

Receive类

package com.gz.udp2;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.util.Scanner;

public class Receive implements Runnable{

    private DatagramSocket ds;
    private Scanner sc;
    private boolean flag=true;

    public Receive(DatagramSocket ds) {
        this.ds = ds;
        sc=new Scanner(System.in);
    }
    private String receive(){
        String str="";
        try {
            byte [] buf=new byte[1024];//等待接收数据
            DatagramPacket dp=new DatagramPacket(buf,buf.length);
            ds.receive(dp);
            str=new String(dp.getData(),0,dp.getLength());
        } catch (IOException e) {
            flag=false;
            if(ds!=null){
                ds.close();
            }
        }
        return str;
    }

    @Override
    public void run() {
        while(flag){
            System.out.println(this.receive());
        }
    }
}

Test1类，开启线程的类

package com.gz.udp2;

import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.util.Scanner;

public class Test1 {
    public static void main(String[] args) throws IOException {
        //DS
        DatagramSocket ds=new DatagramSocket(9777);//自己的端口号

        Send s=new Send(ds,"localhost",9888,"咨询者");
        //目标ip，目标端口号，自己角色
        Receive r=new Receive(ds);

        new Thread(s).start();
        new Thread(r).start();


    }
}

对于接收者，也是拥有两个类，Send类和Receive类，及同样的开启线程类，只不过是端口号不同，角色不同。

接收者的Test2类

package com.gz.udp2;

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

public class Test2 {
    public static void main(String[] args) throws IOException {
        //DS
        DatagramSocket ds=new DatagramSocket(9888);

        Send s=new Send(ds,"localhost",9777,"客服人员");
        //目标ip，目标端口号，自己角色
        Receive r=new Receive(ds);

        new Thread(s).start();
        new Thread(r).start();


    }
}

结果：成功实现了，客服多次回复：又优化加上了发送时间：

咨询者端：

客服端：

想让老师看一下我的代码还有哪里值得优化，还有一个问题，就是，单对单的时候，接收者在回复的时候可以获得发送者发送来的ip与端口号，但是我现在写成了多线程，并且在我的发送者与接收者的测试类里，ip跟端口号是单独指定的，也就是说，当线程开启之前，ip与端口号就固定下来了，下面的交互都是这两个ip与端口号之间的交互。我想问的是有办法像单对单那样，获取到上一个接收过来的数据来自的ip和端口号吗，这样的话就要找到上一个接收线程的DatagramPacket数据包dp，从dp能够获取到上一个发送端的ip及端口号，可是由于多线程，我编辑的逻辑是，每次接收和发送的方法都会创建新的DatagramPacket,当上一个线程调用发送方法以后，随着方法结束，dp数据包也会随之在内存中释放消失。所以，我觉得是完不成根据dp获取上一个发送端的ip及端口号的。因此这也是我的发送端和接收端都要重新制定ip及端口号的原因。

思考到这，（小总结******）我在想UDP是不是就是适合于两个人在通信的时候进行的交互，比如qq聊天，客服聊天，并且这两个人的聊天是指定两个人的单次会话的多次聊天。

而TCP适合群聊，中间的服务器可以将信息转发给其他人，也可以满足随时有人加入群聊，为随时加入群聊的客户端开启处理线程。

以上是我的思考，不知道有没有误解，想跟老师求证最后说的总结（带******号的）的正确性。

还有上面多线程的代码是否可以进一步优化，以及我对我的程序中发送端和接收端都要重新制定ip及端口号的理解是否正确。

还有就是UDP的单次会话的多线程如果真的实现是不是像我写的那样的，发送端和接收端都要重新制定ip及端口号。

客户端不显示

package com.bjsxt.net;

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

/** 
 * <p>Title: TcpServerScoket01</p>  
 * <p>Description: 使用TCP Socket实现单向通信（服务器端）</p>  
 * @author xiaoding
 * @date Jul 29, 2020  
 * @version 1.0 
 */
public class TcpServerScoket01 {
    public static void main(String[] args) throws IOException {
        System.out.println("服务器启动");
        //创建服务器对象
        ServerSocket my = new ServerSocket(9999);
        //使用accept方法监听，服务器端口
        Socket p = my.accept();
        //接受客户端发送的数据
        InputStream fis = p.getInputStream();
        //定义一个中转站
        byte[] buf = new byte[1024];
        int len = 0;    //获取读取的次数
        //将读取的数据打印出来
        while((len = fis.read(buf)) != -1) {
            System.out.println(new String(buf,0,len));
        }
//        System.out.println((char)fis.read());
        
        //发送消息
        OutputStream fos = p.getOutputStream();
        //写入数据
        fos.write("收到了".getBytes());
        //关闭IO流
        if (fos != null) {
            fos.close();
        }
        if (fis != null) {
            fis.close();
        }
    }
}

package com.bjsxt.net;

import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.net.Socket;
import java.net.UnknownHostException;
import java.util.Arrays;

/** 
 * <p>Title: TestTcpSocket01</p>  
 * <p>Description: 使用Tcp Scoket单向通信（客户端）</p>  
 * @author xiaoding
 * @date Jul 29, 2020  
 * @version 1.0 
 */
public class TestTcpSocket01 {
    public static void main(String[] args) throws UnknownHostException, IOException {
        //创建Socket对象
        Socket my = new Socket("127.0.0.1",9999);
        //发送消息
        OutputStream fis = my.getOutputStream();
        fis.write("你好".getBytes());
        
        //接受消息
        InputStream fos = my.getInputStream();
                
        //定义一个中转站
        byte[] buf = new byte[1024];
        int len = 0;    //获取字符
        while((len = fos.read(buf)) != -1) {
            System.out.println(new String(buf,0,len));
        }
        //关闭IO
        if (fos != null) {
            fos.close();
        }
        if (fis != null) {
            fis.close();
        }
        
        if (my != null) {
            my.close();
        }
    }
}

老师，我的可以运行，不过如果导入的txt文件中的内容是中文则打印会出现看不懂的字符，我百度了还是没搞好，不懂什么原因。

老师不清楚后面这个boolean的复制，下面截图为什么就是isFlag是相当于true呢，默认初始值是false。这个isFlage这个过程应该如何理解？