有效沟通问答-【官方】百战程序员_IT在线教育培训机构

package com.bjsxt.server;

import java.io.DataOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.net.ServerSocket;
import java.net.Socket;

import com.bjsxt.entity.User;
import com.bjsxt.thread.ServerThread;

public class Server {
	public static void main(String[] args) throws IOException, ClassNotFoundException {
		System.out.println("----------------------服务器端已启动---------------------");
		//(1)创建ServerSocket对象
		ServerSocket server=new ServerSocket(8888);
		
		while(true){
			Socket socket=server.accept();
			//创建线程类的对象，并启动线程
			ServerThread st=new ServerThread(socket);
			//启动线程
			new Thread(st).start();
		}
	}
}

这个while循环是啥意思呢要是不加会怎么样呢

JAVA 全系列/第二阶段：JAVA 基础深化和提高/网络编程（旧） 2673楼

这个字符串类型的localhost指本机是自己起的名字吗？192.168.31.113为啥是指本机呢

JAVA 全系列/第二阶段：JAVA 基础深化和提高/网络编程（旧） 2674楼

老师说192.168.31.113是ip地址指本机

那上边那个127.0.0.1是啥也说指本机

JAVA 全系列/第二阶段：JAVA 基础深化和提高/网络编程（旧） 2675楼

老师，这个代码为什么21行总是报错？

package com.company.List;

import com.sun.org.apache.xpath.internal.operations.String;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;

public class TestInputstream2 {
    public static void main(String[] args) throws IOException {
        //(1)搭桥
        FileInputStream fis = new FileInputStream("D:/test.txt");

        //(2)创建大一些的中转站
        byte [] buf =  new byte[1024];
        int len = 0;  //用于存储每次读到的字节
        int i = 0;
        while ((len = fis.read(buf))!=-1){
            //借助String类构造方法
            i++;
            System.out.println(new String(buf,0,len));
        }
        //(3)关闭
        fis.close();
        System.out.println(i);
    }
}

JAVA 全系列/第二阶段：JAVA 基础深化和提高/IO 流技术（旧） 2676楼

看到有同学问这个问题，关于109行的key判断，与老师有不同的见解。

这里老师的解释是因为为了处理多次请求url的参数，进行的判断，为了以后多次的请求服务。

但是我认为不是这样的。

首先我们看一下Request这个类，参数集合map是他的一个成员变量，并且是在构造器当中进行初始化的。

也就是说，当我们点击登录，形成url，去访问服务器，服务器Server类接收到客户端请求，receive方法会为每一个请求创建Request对象。所以每一次的请求当中刚开始参数集合都是空的，没有放任何东西。所以不存在多次url会影响map参数集合的情况。

所以为什么要写if判断key，是为了处理像hobby=eat&hobby=play这样的参数而存在的。

我们存储参数map集合的时候

键：参数名称

值：为了方便处理hobby这样的对应多个参数值的参数，采用List集合作为map的值。

再来看if的判断：

当处理hobby=eat时，

判断if，集合当中是否存在hobby这样的键，不存在，向集合当中添加键为：hobby，值为一个新的List集合。

继续向下执行，根据hobby键获取到新List集合，将具体的参数值eat添加到新的List集合当中。

当处理hobby=play时，

判断if，集合当中是否存在hobby这样的值，存在，不执行if块。

继续向下执行，根据hobby键获取到对应的List集合，将具体的参数值play添加到新的List集合当中。

所以if的存在是为了判断当前处理的参数是不是第一次参加到集合的键当中。

主要是为了处理像hobby这样拥有重复参数值的参数。

如果是第一次，为其创建新的List集合作为值，将具体参数值添加到List集合当中。

如果不是第一次，获取对应的List集合，向List集合当中继续添加具体的参数值。

JAVA 全系列/第二阶段：JAVA 基础深化和提高/手写服务器项目（旧） 2677楼

老师，键盘录入的时候报错，不知道哪里没对？麻烦看下。这个获取用户对象的方法这里也不是很理解，麻烦说下具体是什么意思？

下面是代码：

package com.bjsxt.entity;

import java.io.DataInputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.net.Socket;
import java.util.Scanner;


public class client {
    /**
     * 1.创建Socket对象，用于连接服务器
     * 2.获取输出流，传递的是user对象所以用（对象流）
     * 3.创建user对象
     * 4.创建的user对象发到服务器
     * 5.获取输入流发过来是"正确或失败"（使用数据流进行获取），数据流用于存取基本数据类型和String类型方法
     * 6.关闭
     *
     * @return
     */
    public static User main(String[] args) throws IOException {
        Socket client = new Socket("localhost", 8888);

        ObjectOutputStream oos = new ObjectOutputStream(client.getOutputStream());

        User user =getUser();//new User("tent","123tx");
        oos.writeObject(user);

        DataInputStream dis = new DataInputStream(client.getInputStream());
        System.out.println(dis.readUTF());

        if (dis != null) {
            dis.close();
        }
        if (oos != null) {
            oos.close();
        }
        if (client != null) {
            client.close();
        }

        //获取用户对象的方法

    private static User getUser() {
        Scanner input = new Scanner(System.in);
        System.out.println("请输入用户名：");
        String userName = input.next();
        System.out.println("请输入密码");
        String password = input.next();
        //封装成User对象
        return new User(userName, password);
    }
    }
}

package com.bjsxt.entity;

import java.io.DataOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.net.ServerSocket;
import java.net.Socket;

public class Server {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        System.out.println("服务器端已启动");
        /**
         * 1.创建ServerSocket对象
         * 2.建立监听器accept
         * 3.读对象，对象流
         * 4.对用户名和密码进行验证，输出"正确或错误"通过数据流
         * 5.关闭
         */
        ServerSocket server  =new ServerSocket(8888);
        Socket ss =   server.accept();

        ObjectInputStream ois =new ObjectInputStream(ss.getInputStream());//
        User u =(User)ois.readObject();//读对象的时候需要转换为User类型，目前是Object类型
        System.out.println(ss.getInetAddress().getHostAddress()+"请求登陆：用户名"+u.getUserName()+"密码："+u.getPassword());
        String str ="";
        if ("tent".equals(u.getUserName())&&"123tx".equals(u.getPassword())){
            str ="登陆成功";
        }else{
            str ="对不起，账号密码不正确";
        }

        DataOutputStream dos =new DataOutputStream(ss.getOutputStream());
                dos.writeUTF(str);

        if(dos!=null){
            dos.close();
        }
        if (ois!=null){
            ois.close();
        }
        if (ss!=null){
            ss.close();
        }
    }
}

package com.bjsxt.entity;

import java.io.Serializable;

public class User implements Serializable {
    private static final long serialVersionUID = -7626780842003520333L;//用于封装用户名和密码
    private String userName;
    private  String password;

    public String getUserName() {
        return userName;
    }

    public void setUserName(String userName) {
        this.userName = userName;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    public User(String userName, String password) {
        this.userName = userName;
        this.password = password;
    }

    public User() {
    }

}

JAVA 全系列/第二阶段：JAVA 基础深化和提高/网络编程（旧） 2678楼

这次课的视频，提到了三种方式来解决数据库连接的问题。

首先观察本次课案例，共享资源类是Dao类，里面有增删改查四个方法。

线程类是MyThread类，里面定义了共享资源，并作为构造器参数进行传入。

这个案例里面与上次课案例不同的是，Dao类当中没有定义类变量conn。

而是定义到了一个工具类DBUtils类里面，为什么？

如果把conn定义为Dao类的成员变量，那么其他的Dao类，多个Dao类都想使用关闭资源，获得资源的方法怎么办？
所以为了方便数据源的管理，每个方法调用的关闭conn，获取conn的方法否一致，于是产生了一个工具类。在工具类里将conn定义为静态的成员变量。这样Dao类就可以不用处理conn，而是直接使用工具类的方法，并且conn只有一个。
所以这次课的案例与上次课案例不同就是，共享资源类Dao里面没有成员变量。

而是在每个增删改查方法当中使用工具类的方法获取conn，工具类里面有成员变量conn。

这样一来，静态成员conn的初始化工作就交给了DBUtils工具类的getConnection方法。这个方法也是本次课讨论的重点。

因为我们发现，静态成员conn如果作为共享资源，getConnection方法会出现数据安全问题，多个线程运行的时候，执行run方法，执行每个增删改查方法，获取conn的时候，在第一次执行add方法的时候，cpu不停的切换，会在判断if（conn==null）这里被切换走，导致多个线程重复给conn赋值的现象。出现数据混乱的现象。

这样肯定是不行的。

那么打算加同步，给conn加锁，也就是把工具类里面操作conn的方法加上同步关键字，但是这样效率比较低。一个线程需要获得锁对象，再去执行方法，那其他线程就需要等着。不太可行。

于是从整体来看，conn到底需不需要作为共享资源，想了想，似乎不作为共享资源也可以，因为我们的目的就是让conn在增删改查的方法内部能够正常使用就可以了，正常获取，正常关闭，于是我们将DBUtils工具里的conn去掉了static，意味着conn可以有多个了，然后我们在每个方法中创建对象，获取conn，但是这种方式创建了大量的对象，服务器压力太大，不可行。

权衡利弊，我们还是希望让conn成为共享资源，但是我们可以使用ThreadLocal规避共享资源产生的数据混乱问题，因为ThreadLocal会为每个线程创建conn副本。每个线程只需要自己在执行增删改查方法的时候自己获取，自己操作，自己关闭就可以了。增删改查操作的也是同一个conn。

那么这时候线程还需要同步吗？

视频最后的代码是这样的

老师没有给ThreadLocal赋初始值，而是在getConnection()里面去set初始值，还是使用if判断，这里值得注意的是

ThreadLocal只是给每一个线程分配了共享变量的副本，但是cpu还是会随机切换线程的执行，所以if这里还是存在线程安全问题，因为它的值会影响到不同线程下ThreadLocal的初始值的分配。

假设线程0进来得到conn的值为null，if判断成立，切换到线程1，if成立，切换到线程2，if成立，

又切换回线程0，线程0创建了一个conn，假如为@aa3456，将线程0的conContainer设置为@aa3456，然后切换到线程1，线程1创建了一个conn，假如为@bb5678，将线程1的conContainer设置为@bb5678.线程2创建了一个conn，假如为@cc9999，将线程2的conContainer设置为了@cc9999，这种数据安全问题只是每个线程的conContainer的初始值可能会不同。但是每个线程下一次再调用getConnection()的时候由于已经设置了初始值，所以不可能为null了，if不成立，就不会出现数据安全问题了。（******************）

为了防止出现这种问题，视频在方法上加上同步关键字，分析一下，这样第一个线程0进来的时候获取为null，创建一个conn为@aa3456，设置为conContainer的初始值，然后返回@aa3456，下一个线程进来，判断get()的时候还是为null，因为set只是给当前线程的conContainer设置值，因为conContatiner互不影响。所以线程1还是会给conn赋值，还是会造成每个conContainer的初始值不一样。（******************）

所以，我认为写不写synchronized都是差不多的，那么怎么解决，我下载了线程池这次课的源码，翻开看了一下，发现，可能是这次课视频剪辑的问题，最后的版本，是这样的。

package com.bjsxt.dbutil;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
public class DBUtil3 {
 private static final String DRIVER="com.mysql.jdbc.Driver";
 private static final String USER="root";
 private static final String PWD="root";
 private static final String URL="jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8";
 
 //定义一个数据库连接
 private static Connection conn=null;
 private static ThreadLocal<Connection> connContainer=new ThreadLocal<Connection>(){
  protected Connection initialValue() {
   try {
    Class.forName(DRIVER);
    
    if(conn==null){
     
     conn=DriverManager.getConnection(URL, USER, PWD);
    }
    
   } catch (ClassNotFoundException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   } catch (SQLException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   } 
   return conn;
  };
 };
 //获取连接
 public   static Connection getConnection(){
  return connContainer.get(); //获取连接
  
 }
 //关闭连接的方法
 public   static void colseConnection(){
  if (conn!=null) {
   try {
    conn.close();
   
   } catch (SQLException e) {
    // TODO Auto-generated catch block
    e.printStackTrace();
   }
   
  }
 }
 public static void main(String[] args) {
  System.out.println(getConnection());
 }
}

由此可以看到，是在ThreadLocal匿名内部类里重写了初始化变量的方法initialValue（），在一开始就给定了connContainer的值。这样的话，静态变量conn的值是固定的，DBUtils类在加载的过程中，只会去生成一次connContainer对象和创建它的初始值。这样，所有线程的connContainer都将是同一个初始值。线程通过getConnection()获取的都将是同一个值，但是不同线程之间操作conn的时候又是互不影响的。这里求证一下老师，带星号（******************）的位置我分析的对不对。。。分析了好久。。Thanks♪(･ω･)ﾉ感谢！

JAVA 全系列/第二阶段：JAVA 基础深化和提高/多线程和并发编程（旧） 2679楼

看了这次课的视频，讲原理的时候，有个疑问：

ThreadLocal的内部类ThreadLocalMap是一个Thread的成员变量，key是Tread对象，value即需要存储的值；

但是我疑问的是一个该线程的共享变量只能存一个值吗？

经过验证第二次的set是会覆盖第一次set的值的；

那么如果线程的共享变量ThreadLocal只有一个的话，存成Map来表示一个键值关系有必要吗？为什么要设计成Map集合来存储呢？

查帖子理解了一下，发现，一个线程的共享变量ThreadLocal是可以有多个的，就是可以在共享资源里定义多个静态的ThreadLocal的成员变量来存放不同的值。

比如在共享资源SequenceImple里有两个静态的ThreadLocal成员变量，

一个是numThreadLocal 一个是charThreadLocal。并且重写initialValue()方法分别设置默认值

一个是数字容器，默认值0，一个是字母容器，默认值A。

使用多线程分别实现数字和字母顺序打印（每次打印1A、2B），开启3个线程，run方法打印2次。

打算实现的结果是，

线程A——>打印1A

线程B——>打印1A

线程A——>打印2B

线程C——>打印1A

线程A——>打印3C

线程C——>打印2B

线程B——>打印2B

线程B——>打印3C

线程C——>打印3C

顺序不固定，因为cpu在不停切换，但是要达到的效果与视频当中相比，就多了一个类变量容器，用来打印字母。

这个时候第一个线程执行，run方法中调用numThreadLocal 的set方法的时候，得到的ThreadLocalMap集合里面，就会有两组键值对，

第一组的键是numThreadLocal 对象，值0。

第二组是 charThreadLocal对象，值是A。

因为对应一个线程，操作的共享资源SequenceImple的时候，出现了两个类变量容器，即numThreadLocal 和charThreadLocal。（课上案例只有一个）

为了给每一个线程，创建多个类变量容器的副本，并且可以set与get它们，在ThreadLocal中定义了内部类 ThreadLocalMap，并将其作为Thread类的成员变量。

一旦作为了Thread类的成员变量，那么每个线程都会拥有一个ThreadLocalMap对象，使用此map集合，键为共享资源中的类变量容器对象，值为需要存储的值（set进去的值）。

也就是说，每个线程当中都有了一个map，这个map存了共享资源类当中的类变量容器（可以有一个也可以有多个）和它的值。

每次使用类变量容器的set方法的时候，会利用当前的类变量容器(key)找到该键值对，重新覆盖原来的value。

使用类变量容器的get方法的时候会利用当前的类变量容器(key)找到该键值对，找到value并返回。

并且由于每个线程都有自己的map，所以互相不受对方线程的影响。

所以，存储成Map集合，是因为共享资源类里可能出现多个类变量容器。每个类变量容器及其值作为一组键值对。视频中共享资源类SequenceImple2只有一个类变量容器numberContainer ，因此画图的时候对应一组键值对。

private static ThreadLocal<Integer> numberContainer =new ThreadLocal<Integer>(){

protected Integer initialValue(){

return 0;//设置容器存储内容的默认值

}

JAVA 全系列/第二阶段：JAVA 基础深化和提高/多线程和并发编程（旧） 2680楼

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

帖子里提到了：

匿名内部类一般定义在一个方法的内部，如果要访问该方法的参数或者方法中定义的变量，则这些参数或者变量必须使用final修饰。

虽然匿名内部类定义在方法的内部，但在编译时内部类与外部类中的方法属于同一个级别，外部类中方法的变量或参数只是方法的局部变量，这些变量或者参数的作用域只在当前方法内部有效。但是如果这些变量用final修饰，内部类就可以保存方法变量的备份，即使方法销毁也能保证内部类在访问时不会出现访问不到的错误。

匿名内部类要访问局部变量，但是函数的局部变量在执行完后会立即退出，销毁掉所有临时变量。而产生的匿名内部类可能会保留.

实际上：匿名内部类并不是直接调用的局部变量n，而是内部类将局部变量n通过自己的构造器备份到了自己的内部，自己内部的方法调用的实际是自己的属性而不是外部类方法的参数。这样理解就很容易得出为什么要用final了，因为两者从外表看起来是同一个东西，实际上却不是这样，如果内部类改掉了这些参数的值也不可能影响到原参数，然而这样却失去了参数的一致性，因为从编程人员的角度来看他们是同一个东西，如果编程人员在程序设计的时候在内部类中改掉参数的值，但是外部调用的时候又发现值其实没有被改掉，这就让人非常的难以理解和接受，为了避免这种尴尬的问题存在，所以编译器设计人员把内部类能够使用的参数设定为必须是final来规避这种莫名其妙错误的存在。

并且JDK1.8之后匿名内部类访问方法中的局部变量不用加final修饰.

以上是关于匿名内部类中使用方法当中的变量的问题。顺便研究一下匿名内部类：

思考到了一个问题，那我们可以自己在敲代码的时候在匿名内部类里面定义匿名内部类自己的构造器吗？

第一步：研究一下，匿名内部类到底是不是执行了父类的构造器。

查资料：https://www.cnblogs.com/wzhanke/p/4779048.html

这个帖子让我们了解到，编译的时候会给匿名内部类生成自己的字节码文件（.class结尾），并且这个字节码文件当中包含外部类的引用，包含自己的构造器，也就是下面的图片代码第5行的构造器。

通过帖子对帖子中的字节码文件的解读。我们可以发现，第12行：

7: invokespecial #2; //Method Test."<init>":(I)V 这个位置应该是执行了匿名内部类父类Test的构造器。在帖子作者的案例中匿名内部类的父类是Test类。

也就是说，匿名内部类实际上是执行了父类的构造器的。

第二步：上一步已经证明了无参数构造器。那么匿名内部类可以调用父类的有参数构造器吗？也就是在创建匿名内部类对象的时候可以传参吗？

思考：我可以在下面的Inter后的小括号，（写着xxx的那个括号）里面传入参数吗？，xxx是我的参数，如下代码：

new Inter(xxx){

...方法的重写等等操作

}

是否能传取决于Inter这个父类，Inter是我们定义的匿名内部类的父类，或者是接口。

如果Inter是一个类，或者抽象类，并且这个类或者抽象类里定义了有参构造器，那么我们在写匿名内部类的时候，匿名内部类就可以传参数。（通过上面的第一步的帖子分析可推断，如果创建匿名内部类对象的时候指定了xxx的值，也就是传参了，那么编译器就会调用父类的带同参数类型的有参构造方法）

如果Inter是一个接口，接口不能定义有参及无参数构造器，所以匿名内部类的那个位置就不可以传参数。

帖子：https://blog.csdn.net/ggjjzhzz/article/details/321272

这个帖子验证了这上面说到的，传参的问题，并且给了总结：

一、由于匿名内部类没有名字，所以它没有构造函数。因为没有构造函数，所以它必须完全借用父类的构造函数来实例化，换言之：匿名内部类完全把创建对象的任务交给了父类去完成。

二、在匿名内部类里创建新的方法没有太大意义，但它可以通过覆盖父类的方法达到神奇效果，如上例所示。这是多态性的体现。

三、因为匿名内部类没有名字，所以无法进行向下的强制类型转换，持有对一个匿名内部类对象引用的变量类型一定是它的直接或间接父类类型。

所以经常在定义匿名内部类的时候会给出下面的格式：感觉好像调用的是父类的构造器。

new 父类构造器（实参列表) | 实现接口()

{

//匿名内部类的类体部分

}

第三步：回到一开始的问题：

思考：那我们可以自己在敲代码的时候在匿名内部类里面定义匿名内部类自己的构造器吗？

答案是：不可以。其实使用的时候编译器帮我们生成了构造器，但是我们自己不能写，因为匿名匿名，匿名的含义就是根本不知道这个类的名字是什么。

匿名内部类里面不可以定义自己的构造器，因为匿名内部类是要扩展或实现父类或接口，所以根本无法为其构造器命名（不能用父类名，哪有在子类里给父类写构造器的说法。而子类根本没有名，更别提用子类名做构造器了）。、因此在匿名内部中要想有构造器作用的部分要就应该是“初始化块”。

也就是说如果要初始化匿名内部类对象，可以采用构造代码块进行初始化。也就是 { }

JAVA 全系列/第二阶段：JAVA 基础深化和提高/多线程和并发编程（旧） 2681楼

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.对象是啥意思呢

JAVA 全系列/第二阶段：JAVA 基础深化和提高/多线程技术（旧） 2682楼

老师我的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>

JAVA 全系列/第二阶段：JAVA 基础深化和提高/手写服务器项目（旧） 2683楼

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

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

    }
}

JAVA 全系列/第二阶段：JAVA 基础深化和提高/手写服务器项目（旧） 2684楼

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

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

https://www.zhihu.com/question/346911525/answer/830285753?utm_source=wechat_session&utm_medium=social&utm_oi=661648077853822976&utm_content=sec

这个帖子就举例了，

可以通过反射获取到的泛型信息一定是某个class作为成员变量、方法返回值等位置的具体泛型类型，举例来说：

public class Test<T> {
    private Test<Integer> test;

    private T item;}

在上面的代码中，可以通过反射获取成员test的Integer泛型信息，但是无法获取成员item的实际类型。
帖子中作者追溯到JDK8的源码，发现例子中的test成员编译时会将Integer信息编译进class字节码，从而反射系统就可以获取到这个信息，

也就说在类加载阶段，JVM就将字节码中写死的泛型信息保存了下来。而反射的时候，反射系统自然就可以获取到该信息，从而可以通过getGenericType()来获取到Type信息，从而解析出泛型类型。

而如同例子中定义的item这类泛型引用来说，它们的泛型信息不来自于自身的class，在编译完成通过类型检查后，类型系统中它们就等同于Object，这种泛型是无法通过反射获取的，也就是说这类类型信息被擦除了。

所以真正擦除的应该是例子中的T这类在源代码当中没有具体指定的泛型，才是反射无法获取到的。

看了另一篇帖子，作者给出以下的见解：

java中的泛型在jdk1.5之后才加进去的,功能基本都是模仿c++中泛型,但是没有c++的泛型那样强大到可在程序执行时都还有泛型功能.这是跟起初java的虚拟机JVM的设计有关,如果要将泛型功能全部添加到JVM中也可以,但是工程量非常大,sun公司不会因为一个泛型的追求而去几乎翻新一个JVM.所以就放弃了.

但是泛型在java中还是有一定的作用的,所以sun公司就在编译器中实现了一个可以擦出泛型的方法.

这么一来java中泛型的生命周期就只能在源代码到编译期了.这就为什么会出现在字节码中可以获取到泛型的Type对象,而又可以绕过泛型对参数化了的集合进行其他数据类型存储的现象.

那为什么sun公司还要提供我们在字节码中获取到泛型的Type对象呢?
我想这是sun公司为了伱补java泛型的不完美吧!让我们在程序中可以手动实现一个方法去检测接受的数据类型是否就是源代码中定义的泛型类型,如果
不是那么就做相应处理.这样使得程序执行起来更安全,不会因为项目在部署后因传入其他数据类型而照成程序异常等结果发生.

自己的理解:这位作者的意思与上一个作者的相同，就是那些可以被反射读取到的泛型类型信息已经存在字节码文件当中了，但是sun公司不会因为一个泛型而翻新JVM，不想让泛型的功能太过于强大，不然太复杂了，于是它就在编译器中实现了一个可以擦除泛型的方法，让大家认为，【字节码文件当中没有储存泛型的信息，“泛型被擦除了”】，

让大家停止使用泛型的进一步强大的功能，因为没有提供。

这就是为什么反射可以绕过泛型对参数化了的集合进行其他数据类型存储，造成了泛型的生命周期只存在于源代码期间的感受。（就是视频中的第一个案例，使用反射向List<String> list 里面添加Integer类型的123，并且成功了，按理说正常情况下list.add(123)是不能成功添加的，但是反射成功添加了，所以感觉设置泛型好像没有用一样，我们的解释是因为泛型在编译后的字节码文件被"擦除了"。这个案例的结论是泛型的生命周期只存在源代码期间，编译后的字节码文件是没有出现泛型的，而反射是运行期间起作用，两者的生命周期不一样，所以反射操纵不了泛型，所以更不会想到去使用泛型的更强大的功能）。这也是jdk聪明的一点，它让大家认为，泛型信息被擦除了，让大家认为，泛型信息没有存在字节码文件当中。其生命周期在源代码阶段，止步于编译期间。

但是实际上呢，字节码文件当中确实是存储了那些在源代码当中的具体化了的泛型类的信息的，并且类加载阶段，JVM就将字节码中写死的泛型信息保存了下来，这也是为什么我们能够通过反射得到泛型的Type对象。

并且这个帖子的作者说：既然没有实现泛型的更强大的功能，那为什么还要给我们提供Type对象呢？可能是为了程序的安全性考虑，弥补java泛型的不完美，可以让我们在程序中手动实现一个方法去检测接收的数据类型是否就是源代码中定义的泛型类型。

以上纯属查资料的个人理解，仅供参考。。。

JAVA 全系列/第二阶段：JAVA 基础深化和提高/反射技术（旧） 2685楼

同学您好