Java学习笔记24：Java_xml_枚举_注解_类加载器_反射_http服务器改写_管理系统与服务器集成_单元测试

本文链接：https://blog.csdn.net/qq_40002420/article/details/119492532

文章目录

1.类加载器

1.1类加载器【理解】

作用

负责将.class文件（存储的物理文件）加载在到内存中

1.2类加载的过程【理解】

类加载时机
- 创建类的实例（对象）
- 调用类的类方法
- 访问类或者接口的类变量，或者为该类变量赋值
- 使用反射方式来强制创建某个类或接口对应的java.lang.Class对象
- 初始化某个类的子类
- 直接使用java.exe命令来运行某个主类
类加载过程
1. 加载
  - 通过包名 + 类名，获取这个类，准备用流进行传输
  - 在这个类加载到内存中
  - 加载完毕创建一个class对象
2. 链接
  - 验证
    
    确保Class文件字节流中包含的信息符合当前虚拟机的要求，并且不会危害虚拟机自身安全
    
    (文件中的信息是否符合虚拟机规范有没有安全隐患)
  - 准备
    
    负责为类的类变量（被static修饰的变量）分配内存，并设置默认初始化值
    
    (初始化静态变量)
  - 解析
    
    将类的二进制数据流中的符号引用替换为直接引用
    
    (本类中如果用到了其他类，此时就需要找到对应的类)
3. 初始化
  
  根据程序员通过程序制定的主观计划去初始化类变量和其他资源
  
  (静态变量赋值以及初始化其他资源)
小结
- 当一个类被使用的时候，才会加载到内存
- 类加载的过程: 加载、验证、准备、解析、初始化

1.3类加载的分类【理解】

分类
- Bootstrap class loader：虚拟机的内置类加载器，通常表示为null ，并且没有父null
- Platform class loader：平台类加载器,负责加载JDK中一些特殊的模块
- System class loader：系统类加载器,负责加载用户类路径上所指定的类库
类加载器的继承关系
- System的父加载器为Platform
- Platform的父加载器为Bootstrap

代码演示

public class ClassLoaderDemo1 {
    public static void main(String[] args) {
        //获取系统类加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();

        //获取系统类加载器的父加载器 --- 平台类加载器
        ClassLoader classLoader1 = systemClassLoader.getParent();

        //获取平台类加载器的父加载器 --- 启动类加载器
        ClassLoader classLoader2 = classLoader1.getParent();

        System.out.println("系统类加载器" + systemClassLoader);
        System.out.println("平台类加载器" + classLoader1);
        System.out.println("启动类加载器" + classLoader2);

    }
}

1.4双亲委派模型【理解】

介绍

如果一个类加载器收到了类加载请求，它并不会自己先去加载，而是把这个请求委托给父类的加载器去执行，如果父类加载器还存在其父类加载器，则进一步向上委托，依次递归，请求最终将到达顶层的启动类加载器，如果父类加载器可以完成类加载任务，就成功返回，倘若父类加载器无法完成此加载任务，子加载器才会尝试自己去加载，这就是双亲委派模式

1.5ClassLoader 中的两个方法【应用】

方法介绍

方法名说明
public static ClassLoader getSystemClassLoader() 获取系统类加载器
public InputStream getResourceAsStream(String name) 加载某一个资源文件

方法名	说明
public static ClassLoader getSystemClassLoader()	获取系统类加载器
public InputStream getResourceAsStream(String name)	加载某一个资源文件

示例代码

public class ClassLoaderDemo2 {
    public static void main(String[] args) throws IOException {
        //static ClassLoader getSystemClassLoader() 获取系统类加载器
        //InputStream getResourceAsStream(String name)  加载某一个资源文件

        //获取系统类加载器
        ClassLoader systemClassLoader = ClassLoader.getSystemClassLoader();

        //利用加载器去加载一个指定的文件
        //参数：文件的路径（放在src的根目录下，默认去那里加载）
        //返回值：字节流。
        InputStream is = systemClassLoader.getResourceAsStream("prop.properties");

        Properties prop = new Properties();
        prop.load(is);

        System.out.println(prop);

        is.close();
    }
}

2.反射

2.1反射的概述【理解】

反射机制

是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；
对于任意一个对象，都能够调用它的任意属性和方法；
这种动态获取信息以及动态调用对象方法的功能称为Java语言的反射机制。

2.2获取Class类对象的三种方式【应用】

三种方式分类
- 类名.class属性
- 对象名.getClass()方法
- Class.forName(全类名)方法

示例代码

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

    public Student() {
    }

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

    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;
    }

    public void study(){
        System.out.println("学生在学习");
    }

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}
public class ReflectDemo1 {
    public static void main(String[] args) throws ClassNotFoundException {
        //1.Class类中的静态方法forName("全类名")
            //全类名:包名 + 类名
        Class clazz = Class.forName("com.itheima.myreflect2.Student");
        System.out.println(clazz);

        //2.通过class属性来获取
        Class clazz2 = Student.class;
        System.out.println(clazz2);

        //3.利用对象的getClass方法来获取class对象
        //getClass方法是定义在Object类中.
        Student s = new Student();
        Class clazz3 = s.getClass();
        System.out.println(clazz3);

        System.out.println(clazz == clazz2);
        System.out.println(clazz2 == clazz3);
    }
}

2.3反射获取构造方法并使用【应用】

2.3.1Class类获取构造方法对象的方法

方法介绍

方法名	说明
Constructor<?>[] getConstructors()	返回所有公共构造方法对象的数组
Constructor<?>[] getDeclaredConstructors()	返回所有构造方法对象的数组
Constructor getConstructor(Class<?>… parameterTypes)	返回单个公共构造方法对象
Constructor getDeclaredConstructor(Class<?>… parameterTypes)	返回单个构造方法对象

示例代码

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

    //私有的有参构造方法
    private Student(String name) {
        System.out.println("name的值为:" + name);
        System.out.println("private...Student...有参构造方法");
    }

    //公共的无参构造方法
    public Student() {
        System.out.println("public...Student...无参构造方法");
    }

    //公共的有参构造方法
    public Student(String name, int age) {
        System.out.println("name的值为:" + name + "age的值为:" + age);
        System.out.println("public...Student...有参构造方法");
    }
}
public class ReflectDemo1 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        //method1();
        //method2();
        //method3();
        //method4();
    }

    private static void method4() throws ClassNotFoundException, NoSuchMethodException {
        //        Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes)：
//                                      返回单个构造方法对象
        //1.获取Class对象
        Class clazz = Class.forName("com.itheima.myreflect3.Student");
        Constructor constructor = clazz.getDeclaredConstructor(String.class);
        System.out.println(constructor);
    }

    private static void method3() throws ClassNotFoundException, NoSuchMethodException {
        //        Constructor<T> getConstructor(Class<?>... parameterTypes)：
//                                      返回单个公共构造方法对象
        //1.获取Class对象
        Class clazz = Class.forName("com.itheima.myreflect3.Student");
        //小括号中,一定要跟构造方法的形参保持一致.
        Constructor constructor1 = clazz.getConstructor();
        System.out.println(constructor1);

        Constructor constructor2 = clazz.getConstructor(String.class, int.class);
        System.out.println(constructor2);

        //因为Student类中,没有只有一个int的构造,所以这里会报错.
        Constructor constructor3 = clazz.getConstructor(int.class);
        System.out.println(constructor3);
    }

    private static void method2() throws ClassNotFoundException {
        //        Constructor<?>[] getDeclaredConstructors()：
//                                      返回所有构造方法对象的数组
        //1.获取Class对象
        Class clazz = Class.forName("com.itheima.myreflect3.Student");

        Constructor[] constructors = clazz.getDeclaredConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }
    }

    private static void method1() throws ClassNotFoundException {
        //        Constructor<?>[] getConstructors()：
//                                      返回所有公共构造方法对象的数组
        //1.获取Class对象
        Class clazz = Class.forName("com.itheima.myreflect3.Student");
        Constructor[] constructors = clazz.getConstructors();
        for (Constructor constructor : constructors) {
            System.out.println(constructor);
        }
    }
}

2.3.2Constructor类用于创建对象的方法

方法介绍

方法名说明
T newInstance(Object…initargs) 根据指定的构造方法创建对象
setAccessible(boolean flag) 设置为true,表示取消访问检查

方法名	说明
T newInstance(Object…initargs)	根据指定的构造方法创建对象
setAccessible(boolean flag)	设置为true,表示取消访问检查

示例代码

// Student类同上一个示例,这里就不在重复提供了
public class ReflectDemo2 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException {
        //T newInstance(Object... initargs)：根据指定的构造方法创建对象
        //method1();
        //method2();
        //method3();
        //method4();

    }

    private static void method4() throws ClassNotFoundException, NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException {
        //获取一个私有的构造方法并创建对象
        //1.获取class对象
        Class clazz = Class.forName("com.itheima.myreflect3.Student");

        //2.获取一个私有化的构造方法.
        Constructor constructor = clazz.getDeclaredConstructor(String.class);

        //被private修饰的成员,不能直接使用的
        //如果用反射强行获取并使用,需要临时取消访问检查
        constructor.setAccessible(true);

        //3.直接创建对象
        Student student = (Student) constructor.newInstance("zhangsan");

        System.out.println(student);
    }

    private static void method3() throws ClassNotFoundException, InstantiationException, IllegalAccessException {
        //简写格式
        //1.获取class对象
        Class clazz = Class.forName("com.itheima.myreflect3.Student");

        //2.在Class类中,有一个newInstance方法,可以利用空参直接创建一个对象
        Student student = (Student) clazz.newInstance();//这个方法现在已经过时了,了解一下

        System.out.println(student);
    }

    private static void method2() throws ClassNotFoundException, NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException {
        //1.获取class对象
        Class clazz = Class.forName("com.itheima.myreflect3.Student");

        //2.获取构造方法对象
        Constructor constructor = clazz.getConstructor();

        //3.利用空参来创建Student的对象
        Student student = (Student) constructor.newInstance();

        System.out.println(student);
    }

    private static void method1() throws ClassNotFoundException, NoSuchMethodException, InstantiationException, IllegalAccessException, InvocationTargetException {
        //1.获取class对象
        Class clazz = Class.forName("com.itheima.myreflect3.Student");

        //2.获取构造方法对象
        Constructor constructor = clazz.getConstructor(String.class, int.class);

        //3.利用newInstance创建Student的对象
        Student student = (Student) constructor.newInstance("zhangsan", 23);

        System.out.println(student);
    }
}

2.3.3小结

获取class对象

三种方式: Class.forName(“全类名”), 类名.class, 对象名.getClass()
获取里面的构造方法对象

getConstructor (Class<?>… parameterTypes)
getDeclaredConstructor (Class<?>… parameterTypes)
如果是public的，直接创建对象

newInstance(Object… initargs)
如果是非public的，需要临时取消检查，然后再创建对象

setAccessible(boolean) 暴力反射

2.4反射获取成员变量并使用【应用】

2.4.1Class类获取成员变量对象的方法

方法分类

方法名	说明
Field[] getFields()	返回所有公共成员变量对象的数组
Field[] getDeclaredFields()	返回所有成员变量对象的数组
Field getField(String name)	返回单个公共成员变量对象
Field getDeclaredField(String name)	返回单个成员变量对象

示例代码

public class Student {

    public String name;

    public int age;

    public String gender;

    private int money = 300;

    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", gender='" + gender + '\'' +
                ", money=" + money +
                '}';
    }
}
public class ReflectDemo1 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException {
       // method1();
        //method2();
        //method3();
        //method4();

    }

    private static void method4() throws ClassNotFoundException, NoSuchFieldException {
        //        Field getDeclaredField(String name)：返回单个成员变量对象
        //1.获取class对象
        Class clazz = Class.forName("com.itheima.myreflect4.Student");
  
        //2.获取money成员变量
        Field field = clazz.getDeclaredField("money");
  
        //3.打印一下
        System.out.println(field);
    }
  
    private static void method3() throws ClassNotFoundException, NoSuchFieldException {
        //        Field getField(String name)：返回单个公共成员变量对象
        //想要获取的成员变量必须是真实存在的
        //且必须是public修饰的.
        //1.获取class对象
        Class clazz = Class.forName("com.itheima.myreflect4.Student");
  
        //2.获取name这个成员变量
        //Field field = clazz.getField("name");
        //Field field = clazz.getField("name1");
        Field field = clazz.getField("money");
  
        //3.打印一下
        System.out.println(field);
    }
  
    private static void method2() throws ClassNotFoundException {
        //        Field[] getDeclaredFields()：返回所有成员变量对象的数组
        //1.获取class对象
        Class clazz = Class.forName("com.itheima.myreflect4.Student");
  
        //2.获取所有的Field对象
        Field[] fields = clazz.getDeclaredFields();
  
        //3.遍历
        for (Field field : fields) {
            System.out.println(field);
        }
    }
  
    private static void method1() throws ClassNotFoundException {
        //        Field[] getFields()：返回所有公共成员变量对象的数组
  
        //1.获取class对象
        Class clazz = Class.forName("com.itheima.myreflect4.Student");
  
        //2.获取Field对象.
        Field[] fields = clazz.getFields();
  
        //3.遍历
        for (Field field : fields) {
            System.out.println(field);
        }
    }
}

2.4.2Field类用于给成员变量赋值的方法

方法介绍

方法名说明
void set(Object obj, Object value) 赋值
Object get(Object obj) 获取值

方法名	说明
void set(Object obj, Object value)	赋值
Object get(Object obj)	获取值

示例代码

// Student类同上一个示例,这里就不在重复提供了
public class ReflectDemo2 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchFieldException, IllegalAccessException, InstantiationException {
//        Object get(Object obj) 返回由该 Field表示的字段在指定对象上的值。
        //method1();
        //method2();

    }

    private static void method2() throws ClassNotFoundException, NoSuchFieldException, InstantiationException, IllegalAccessException {
        //1.获取class对象
        Class clazz = Class.forName("com.itheima.myreflect4.Student");

        //2.获取成员变量Field的对象
        Field field = clazz.getDeclaredField("money");

        //3.取消一下访问检查
        field.setAccessible(true);

        //4.调用get方法来获取值
        //4.1创建一个对象
        Student student = (Student) clazz.newInstance();
        //4.2获取指定对象的money的值
        Object o = field.get(student);

        //5.打印一下
        System.out.println(o);
    }

    private static void method1() throws ClassNotFoundException, NoSuchFieldException, InstantiationException, IllegalAccessException {
        //        void set(Object obj, Object value)：给obj对象的成员变量赋值为value
        //1.获取class对象
        Class clazz = Class.forName("com.itheima.myreflect4.Student");

        //2.获取name这个Field对象
        Field field = clazz.getField("name");

        //3.利用set方法进行赋值.
        //3.1先创建一个Student对象
        Student student = (Student) clazz.newInstance();
        //3.2有了对象才可以给指定对象进行赋值
        field.set(student,"zhangsan");

        System.out.println(student);
    }
}

2.5反射获取成员方法并使用【应用】

2.5.1Class类获取成员方法对象的方法

方法分类

方法名	说明
Method[] getMethods()	返回所有公共成员方法对象的数组，包括继承的
Method[] getDeclaredMethods()	返回所有成员方法对象的数组，不包括继承的
Method getMethod(String name, Class<?>… parameterTypes)	返回单个公共成员方法对象
Method getDeclaredMethod(String name, Class<?>… parameterTypes)	返回单个成员方法对象

示例代码

public class Student {

    //私有的，无参无返回值
    private void show() {
        System.out.println("私有的show方法，无参无返回值");
    }

    //公共的，无参无返回值
    public void function1() {
        System.out.println("function1方法，无参无返回值");
    }

    //公共的，有参无返回值
    public void function2(String name) {
        System.out.println("function2方法，有参无返回值,参数为" + name);
    }

    //公共的，无参有返回值
    public String function3() {
        System.out.println("function3方法，无参有返回值");
        return "aaa";
    }

    //公共的，有参有返回值
    public String function4(String name) {
        System.out.println("function4方法，有参有返回值,参数为" + name);
        return "aaa";
    }
}
public class ReflectDemo1 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException {
        //method1();
        //method2();
        //method3();
        //method4();
        //method5();
    }

    private static void method5() throws ClassNotFoundException, NoSuchMethodException {
        //        Method getDeclaredMethod(String name, Class<?>... parameterTypes)：
//                                返回单个成员方法对象
        //1.获取class对象
        Class clazz = Class.forName("com.itheima.myreflect5.Student");
        //2.获取一个成员方法show
        Method method = clazz.getDeclaredMethod("show");
        //3.打印一下
        System.out.println(method);
    }
  
    private static void method4() throws ClassNotFoundException, NoSuchMethodException {
        //1.获取class对象
        Class clazz = Class.forName("com.itheima.myreflect5.Student");
        //2.获取一个有形参的方法function2
        Method method = clazz.getMethod("function2", String.class);
        //3.打印一下
        System.out.println(method);
    }
  
    private static void method3() throws ClassNotFoundException, NoSuchMethodException {
        //        Method getMethod(String name, Class<?>... parameterTypes) ：
//                                返回单个公共成员方法对象
        //1.获取class对象
        Class clazz = Class.forName("com.itheima.myreflect5.Student");
        //2.获取成员方法function1
        Method method1 = clazz.getMethod("function1");
        //3.打印一下
        System.out.println(method1);
    }
  
    private static void method2() throws ClassNotFoundException {
        //        Method[] getDeclaredMethods()：
//                                返回所有成员方法对象的数组，不包括继承的
        //1.获取class对象
        Class clazz = Class.forName("com.itheima.myreflect5.Student");
  
        //2.获取Method对象
        Method[] methods = clazz.getDeclaredMethods();
        //3.遍历一下数组
        for (Method method : methods) {
            System.out.println(method);
        }
    }
  
    private static void method1() throws ClassNotFoundException {
        //        Method[] getMethods()：返回所有公共成员方法对象的数组，包括继承的
        //1.获取class对象
        Class clazz = Class.forName("com.itheima.myreflect5.Student");
        //2.获取成员方法对象
        Method[] methods = clazz.getMethods();
        //3.遍历
        for (Method method : methods) {
            System.out.println(method);
        }
    }
}

2.5.2Method类用于执行方法的方法

方法介绍

方法名说明
Object invoke(Object obj, Object… args) 运行方法
参数一: 用obj对象调用该方法

参数二: 调用方法的传递的参数(如果没有就不写)

返回值: 方法的返回值(如果没有就不写)

方法名	说明
Object invoke(Object obj, Object… args)	运行方法

示例代码

public class ReflectDemo2 {
    public static void main(String[] args) throws ClassNotFoundException, NoSuchMethodException, IllegalAccessException, InstantiationException, InvocationTargetException {
//        Object invoke(Object obj, Object... args)：运行方法
//        参数一：用obj对象调用该方法
//        参数二：调用方法的传递的参数（如果没有就不写）
//        返回值：方法的返回值（如果没有就不写）

        //1.获取class对象
        Class clazz = Class.forName("com.itheima.myreflect5.Student");
        //2.获取里面的Method对象  function4
        Method method = clazz.getMethod("function4", String.class);
        //3.运行function4方法就可以了
        //3.1创建一个Student对象,当做方法的调用者
        Student student = (Student) clazz.newInstance();
        //3.2运行方法
        Object result = method.invoke(student, "zhangsan");
        //4.打印一下返回值
        System.out.println(result);
    }
}

3.http服务器改写

3.1静态资源和动态资源【理解】

静态资源

在服务器提前准备好的文件。(图片，文本)
动态资源

在图示的案例中，当用户点击了浏览器上的按钮。
本质上访问的就是服务端的某一个类中的某一个方法。
在方法中，可以写一些判断代码和逻辑代码，让响应的内容，有可能不一样了。
那么，服务端所对应的这个类我们常常将其称之为“动态资源”

3.2准备工作【理解】

修改四个地方
- HttpResponse -> 常量WEB_APP_PATH的值与当前模块一致
- HttpServer -> main方法中端口改成80
- HttpResponse -> 添加一个write方法，添加一个带参数的构造方法
- HttpResponse -> 添加一个contentType成员变量，生成对应的set/get方法

示例代码

// 1.HttpResponse -> 常量WEB_APP_PATH的值与当前模块一致
public class HttpResponse {
  ...
  public static final String WEB_APP_PATH = "http-dynamic-server\\webapp";
  ...
}

// 2.HttpServer -> main方法中端口改成80
public class HttpServer {
  public static void main(String[] args) throws IOException {
    ...
    //2.让这个通道绑定一个端口
  	serverSocketChannel.bind(new InetSocketAddress(80));
    ...
  }
}  

// 3.HttpResponse -> 添加一个write方法，添加一个带参数的构造方法
public class HttpResponse {
  ...
  // 已经提供了selectionKey，所以之前的方法接收这个参数的可以去掉了，直接使用这个即可
  // HttpRequest也按照此方式进行优化，定义成员变量，在构造方法中赋值，其他方法直接使用即可
  private SelectionKey selectionKey;
  
  public HttpResponse(SelectionKey selectionKey) {
        this.selectionKey = selectionKey;
    }
  
  //给浏览器响应数据的方法 ---- 浏览器在请求动态资源时,响应数据的方法.
  //content:响应的内容
  public void write(String content){
  }
  ...
}

public class HttpServer {
  public static void main(String[] args) throws IOException {
    ...
    //响应数据  //修改后的构造方法中要传入参数
    HttpResponse httpResponse = new HttpResponse(selectionKey);
    ...
  }
}  

// 4.HttpResponse -> 添加一个contentType成员变量，生成对应的set/get方法
public class HttpResponse {
  ...
  private String contentType;//MIME类型
  
  public String getContentType() {
        return contentType;
    }
  public void setContentTpye(String contentType) {
        this.contentType = contentType;
        //添加到map集合中
        hm.put("Content-Type",contentType);
    }
  ...
}

3.3浏览器请求动态资源【理解】

两个小问题
- 服务器如何判断浏览器请求的是静态资源还是动态资源?
  
  我们可以规定：如果浏览器地址栏中的uri是以”/servlet”开始的，那么就表示请求动态资源
- 在一个项目中有很多类，很多方法。那么请求过来之后，执行哪个方法呢?
  
  写一个UserServlet类，在类中写service方法
  我们可以规定：如果请求动态资源，就创建这个类对象，并调用service方法，表示服务器处理了当前请求
实现步骤
1. 解析http请求
2. 处理浏览器请求
  
  定义一个UserServlet 类，类中定义service方法，处理浏览器请求动态资源
  解析完http请求之后，再判断uri是否以/servlet开头
3. 响应

示例代码

public class UserServlet{
  public void service(){
        //模拟业务处理  ---- 就可以对这个手机号进行判断验证
        System.out.println("UserServlet处理了用户的请求...");
    }
}
public class HttpServer {
  public static void main(String[] args) throws IOException {
    	...
    	//响应数据
    	HttpResponse httpResponse = new HttpResponse(selectionKey);
        httpResponse.setHttpRequest(httpRequest);

        if(httpRequest.getRequestURI().startsWith("/servlet")){
          	//本次请求动态资源
          	//处理 
          	UserServlet userServlet = new UserServlet();
          	userServlet.service();
          	//响应
        	httpResponse.setContentTpye("text/html;charset=UTF-8");
        	httpResponse.write("ok,UserServlet处理了本次请求....");  
        }else{
          //本次请求静态资源
          httpResponse.sendStaticResource();
        }
    	...
  }
} 

public class HttpResponse {
  	...
	//给浏览器响应数据的方法 ---- 浏览器在请求动态资源时,响应数据的方法.
    //content:响应的内容
    public void write(String content){
        //准备响应行数据
        this.version = "HTTP/1.1";
        this.status = "200";
        this.desc = "ok";

        //把响应行拼接在一起
        String responseLine = this.version + " " + this.status + " " + this.desc + "\r\n";

        //准备响应头
        StringBuilder sb = new StringBuilder();
        Set<Map.Entry<String, String>> entries = hm.entrySet();
        for (Map.Entry<String, String> entry : entries) {
            //entry依次表示每一个键值对对象
            //键 --- 响应头的名称
            //值 --- 响应头的值
            sb.append(entry.getKey()).append(": ").append(entry.getValue()).append("\r\n");
        }

        //处理响应空行
        String emptyLine = "\r\n";

        //拼接响应行,响应头,响应空行
        String result = responseLine + sb.toString() + emptyLine;

        try {
            //给浏览器响应 响应行,响应头,响应空行
            ByteBuffer byteBuffer1 = ByteBuffer.wrap(result.getBytes());
            SocketChannel channel = (SocketChannel) selectionKey.channel();
            channel.write(byteBuffer1);

            //给浏览器响应 响应体
            ByteBuffer byteBuffer2 = ByteBuffer.wrap(content.getBytes());
            channel.write(byteBuffer2);

            //释放资源
            channel.close();

        } catch (IOException e) {
            System.out.println("响应数据失败....");
            e.printStackTrace();
        }

    }    
 	 ...
}

3.4main方法和Servlet优化【理解】

main方法优化

需求

将请求动态资源的代码抽取到一个单独的类单独的方法中，简化main中的代码

代码实现

public class DynamicResourceProcess {
  
    //执行指定动态资源的service方法
    //参数一
    //由于后期可能根据用户请求的uri做出相应的处理.
    //参数二
    //要给用户响应数据,那么就需要使用到httpResponse.
    public void process(HttpRequest httpRequest,HttpResponse httpResponse) {
        // 创建UserServlet对象,调用service方法,进行处理
        UserServlet userServlet = new UserServlet();
        userServlet.service();

        //给浏览器响应
        httpResponse.setContentTpye("text/html;charset=UTF-8");
        httpResponse.write("ok,UserServlet处理了本次请求....");
    }
}

public class HttpServer {
  public static void main(String[] args) throws IOException {
    	...
    	//响应数据
    	HttpResponse httpResponse = new HttpResponse(selectionKey);
        httpResponse.setHttpRequest(httpRequest);

        if(httpRequest.getRequestURI().startsWith("/servlet")){
          	//本次请求动态资源
       		DynamicResourceProcess drp = new DynamicResourceProcess();
            drp.process(httpRequest,httpResponse);
        }else{
          //本次请求静态资源
          httpResponse.sendStaticResource();
        }
    	...
  }
}

Servlet优化

需求

将给浏览器响应的代码写到Servlet中

代码实现

public class UserServlet implements HttpServlet{

    //处理浏览器请求的方法
    //参数一
    //由于后期可能根据用户请求的uri做出相应的处理.
    //参数二
    //要给用户响应数据,那么就需要使用到httpResponse.
    public void service(HttpRequest httpRequest, HttpResponse httpResponse){
        //模拟业务处理  ---- 就可以对这个手机号进行判断验证
        System.out.println("UserServlet处理了用户的请求...");
        //给浏览器响应
        httpResponse.setContentTpye("text/html;charset=UTF-8");
        httpResponse.write("ok,UserServlet处理了本次请求....");
    }
}

public class DynamicResourceProcess {
  
    //执行指定动态资源的service方法
    //参数一
    //由于后期可能根据用户请求的uri做出相应的处理.
    //参数二
    //要给用户响应数据,那么就需要使用到httpResponse.
    public void process(HttpRequest httpRequest,HttpResponse httpResponse) {
        // 创建UserServlet对象,调用service方法,进行处理
        UserServlet userServlet = new UserServlet();
        userServlet.service(httpRequest,httpResponse);
    }
}

3.5多个动态资源【理解】

多个动态资源

针对每一个业务操作，我们都会去定义一个对应的Servlet来完成。
就会在服务端产生很多个Servlet
实现步骤
- 定义一个接口HttpServlet，接口中定义service方法。
- 针对于每一种业务，都定义一个servlet类与之对应，该类实现HttpServlet接口
- 获取请求的uri，进行判断，调用不同的servlet类中的service方法

代码实现

// 1.定义一个接口HttpServlet，接口中定义service方法
public interface HttpServlet {

    //定义业务处理的方法
    public abstract void service(HttpRequest httpRequest, HttpResponse httpResponse);
}

// 2.针对于每一种业务，都定义一个servlet类与之对应，该类实现HttpServlet接口
public class UserServlet implements HttpServlet{
    //处理浏览器请求的方法
    //参数一
    //由于后期可能根据用户请求的uri做出相应的处理.
    //参数二
    //要给用户响应数据,那么就需要使用到httpResponse.
    public void service(HttpRequest httpRequest, HttpResponse httpResponse){
        //模拟业务处理  ---- 就可以对这个手机号进行判断验证
        System.out.println("UserServlet处理了用户的请求...");
        //给浏览器响应
        httpResponse.setContentTpye("text/html;charset=UTF-8");
        httpResponse.write("ok,UserServlet处理了本次请求....");
    }
}

public class LoginServlet implements HttpServlet{
    @Override
    public void service(HttpRequest httpRequest, HttpResponse httpResponse) {
       //处理
        System.out.println("LoginServlet处理了登录请求");
       //响应
        httpResponse.setContentTpye("text/html;charset=UTF-8");
        httpResponse.write("登录成功");
    }
}

public class RegisterServlet implements HttpServlet{
    @Override
    public void service(HttpRequest httpRequest, HttpResponse httpResponse) {
       //处理
        System.out.println("RegisterServlet处理了注册请求");
       //响应
        httpResponse.setContentTpye("text/html;charset=UTF-8");
        httpResponse.write("注册成功");
    }
}

public class SearchServlet implements HttpServlet{
    @Override
    public void service(HttpRequest httpRequest, HttpResponse httpResponse) {
       //处理
        System.out.println("SearchServlet处理了搜索商品请求");
       //响应
        httpResponse.setContentTpye("text/html;charset=UTF-8");
        httpResponse.write("响应了一些商品信息");
    }
}

// 3.获取请求的uri，进行判断，调用不同的servlet类中的service方法
public class DynamicResourceProcess {
  
    public void process(HttpRequest httpRequest,HttpResponse httpResponse){
          //获取请求的uri
          String requestURI = httpRequest.getRequestURI();
 
          //根据请求的uri进行判断
          if("/servlet/loginservlet".equals(requestURI)){
              //登录请求
              LoginServlet loginServlet = new LoginServlet();
              loginServlet.service(httpRequest,httpResponse);
          }else if("/servlet/registerservlet".equals(requestURI)){
              //注册请求
              RegisterServlet registerServlet = new RegisterServlet();
              registerServlet.service(httpRequest,httpResponse);
          }else if("/servlet/searchservlet".equals(requestURI)){
              //搜索商品请求
              SearchServlet searchServlet = new SearchServlet();
              searchServlet.service(httpRequest,httpResponse);
          }else{
              //表示默认处理方法
              //创建UserServlet对象,调用service方法,进行处理
              UserServlet userServlet = new UserServlet();
              userServlet.service(httpRequest,httpResponse);
          }
      }
}

3.6通过反射和配置文件优化【理解】

优化步骤
1. 把Servlet信息写到properties配置文件中
  
  格式为：servlet-info=/servlet/UserServlet，全类名；/servlet/loginServlet，全类名
2. 定义一个接口ServletConcurrentHashMap，接口中定义ConcurrentHashMap，该集合存储所有的servlet信息
3. 定义一个接口ParseServletConfig，该接口中定义一个方法（parse）
4. 定义ParseServletConfig的实现类，解析配置文件，并把配置文件中Servlet信息存到map集合中
5. 在main方法的第一行，开启一条线程执行解析配置文件的代码
6. 修改处理DynamicResourceProcess中的process方法

代码实现

// 1.把Servlet信息写到properties配置文件中
// 在webapp\config\servlet-info.properties文件中，写入如下内容
servlet-info=/servlet/loginservlet,com.itheima.myservlet.LoginServlet;/servlet/registerservlet,com.itheima.myservlet.RegisterServlet;/servlet/searchservlet,com.itheima.myservlet.SearchServlet;/servlet/lostpasswordservlet,com.itheima.myservlet.LostPasswordServlet

// 2.定义一个接口ServletConcurrentHashMap，接口中定义ConcurrentHashMap，该集合存储所有的servlet信息
public interface ServletConcurrentHashMap {
    //存储请求路径和对应的servlet的map集合
    //键: 请求的uri
    //值: 对应的Servlet对象
    public static final ConcurrentHashMap<String,  HttpServlet> map = new ConcurrentHashMap<>();
}

// 3.定义一个接口ParseServletConfig，该接口中定义一个方法（parse）
public interface ParseServletConfig {
    //解析数据的方法
    public abstract void parse();
}

// 4.定义ParseServletConfig的实现类，解析配置文件，并把配置文件中Servlet信息存到map集合中
public class PropertiesParseServletConfig implements ParseServletConfig {
    @Override
    public void parse() {

        try {
            //1.读取配置文件中的数据
            Properties properties = new Properties();
            FileReader fr = new FileReader("http-dynamic-server/webapp/config/servlet-info.properties");
            properties.load(fr);
            fr.close();

            //2.获取集合中servlet-info的属性值
            String properValue = (String) properties.get("servlet-info");
            // uri,全类名;uri,全类名

            //3.解析
            String[] split = properValue.split(";");
            for (String servletInfo : split) {
                String[] servletInfoArr = servletInfo.split(",");
                String uri = servletInfoArr[0];
                String servletName = servletInfoArr[1];

                //我们需要通过servletName(全类名)来创建他的对象
                Class clazz = Class.forName(servletName);
                HttpServlet httpServlet = (HttpServlet) clazz.newInstance();
                //4.将uri和httpServlet添加到map集合中
                ServletConcurrentHashMap.map.put(uri,httpServlet);
            }
        } catch (Exception e) {
            System.out.println("解析数据异常.....");
            e.printStackTrace();
        }
    }
}

public class LoaderResourceRunnable implements  Runnable {
    @Override
    public void run() {
        //执行parse方法
        ParseServletConfig parseServletConfig = new PropertiesParseServletConfig();
        parseServletConfig.parse();
        
    }
}

// 5.在main方法的第一行，开启一条线程执行解析配置文件的代码
public class HttpServer {
    public static void main(String[] args) throws IOException {
        //开启一条线程去解析配置文件
        new Thread(new LoaderResourceRunnable()).start();
        ...
    }
}

// 6.修改处理DynamicResourceProcess中的process方法
public class DynamicResourceProcess {
  
    public void process(HttpRequest httpRequest,HttpResponse httpResponse){
          	//获取请求的uri
          	String requestURI = httpRequest.getRequestURI();
          	//根据请求的uri到map集合中直接找到对应的servlet的对象
        	HttpServlet httpServlet = ServletConcurrentHashMap.map.get(requestURI);
            //调用service方法对请求进行处理并响应
            httpServlet.service(httpRequest,httpResponse);
    }
}

3.7Servlet忘记实现HttpServlet接口处理【理解】

出现情况

在写Servlet时，忘记了实现HttpServlet接口
导致结果

在反射创建对象后，强转成HttpServlet时，会报类型转换异常
解决方案

在反射创建对象后，强转成HttpServlet前，进行判断

如果有实现HttpServlet接口，就进行强转

否则抛出一个异常

代码实现

public class PropertiesParseServletConfig implements ParseServletConfig {
    @Override
    public void parse() {

        try {
            //1.读取配置文件中的数据
            Properties properties = new Properties();
            FileReader fr = new FileReader("http-dynamic-server/webapp/config/servlet-info.properties");
            properties.load(fr);
            fr.close();

            //2.获取集合中servlet-info的属性值
            String properValue = (String) properties.get("servlet-info");
            // uri,全类名;uri,全类名

            //3.解析
            String[] split = properValue.split(";");
            for (String servletInfo : split) {
                String[] servletInfoArr = servletInfo.split(",");
                String uri = servletInfoArr[0];
                String servletName = servletInfoArr[1];

                //我们需要通过servletName(全类名)来创建他的对象
                Class clazz = Class.forName(servletName);

                //获取该类所实现的所有的接口信息,得到的是一个数组
                Class[] interfaces = clazz.getInterfaces();

                //定义一个boolean类型的变量
                boolean flag =  false;
                //遍历数组
                for (Class clazzInfo : interfaces) {
                    //判断当前所遍历的接口的字节码对象是否和HttpServlet的字节码文件对象相同
                    if(clazzInfo == HttpServlet.class){

                        //如果相同,就需要更改flag值.结束循环
                        flag = true;
                        break;
                    }
                }

                if(flag){
                    //true就表示当前的类已经实现了HttpServlet接口
                    HttpServlet httpServlet = (HttpServlet) clazz.newInstance();
                    //4.将uri和httpServlet添加到map集合中
                    ServletConcurrentHashMap.map.put(uri,httpServlet);
                }else{
                    //false就表示当前的类还没有实现HttpServlet接口
                    throw new NotImplementsHttpServletException(clazz.getName() + "Not Implements HttpServlet");
                }
            }
        } catch (NotImplementsHttpServletException e) {
            e.printStackTrace();
        }catch (Exception e) {
            System.out.println("解析数据异常.....");
            e.printStackTrace();
        }
    }
}

3.8响应404【理解】

出现情况

客户端浏览器请求了一个服务器中不存在的动态资源
导致结果

服务器中代码出现异常，程序停止
解决方案

如果请求的动态资源不存在，服务器根据请求的uri找到对应的Servlet时为null，继续调用方法会出现异常

增加一个非空的判断，如果不为null，则继续处理请求，调用方法

如果为null，则响应404

代码实现

public class DynamicResourceProcess {
    //执行指定动态资源的service方法
    //参数一
    //由于后期可能根据用户请求的uri做出相应的处理.
    //参数二
    //要给用户响应数据,那么就需要使用到httpResponse.
    public void process(HttpRequest httpRequest,HttpResponse httpResponse){
        //获取请求的uri
        String requestURI = httpRequest.getRequestURI();
        //根据请求的uri到map集合中直接找到对应的servlet的对象
        HttpServlet httpServlet = ServletConcurrentHashMap.map.get(requestURI);
        if(httpServlet != null){
            //调用service方法对请求进行处理并响应
            httpServlet.service(httpRequest,httpResponse);
        }else{
            //浏览器请求的动态资源不存在
            //响应404
            response404(httpResponse);
        }
    }
    //浏览器请求动态资源不存在,响应404的方法
    private void response404(HttpResponse httpResponse) {
        try {
            //准备响应行
            String responseLine = "HTTP/1.1 404 NOT FOUND\r\n";
            //准备响应头
            String responseHeader = "Content-Type: text/html;charset=UTF-8\r\n";
            //准备响应空行
            String emptyLine = "\r\n";
            //拼接在一起
            String result = responseLine + responseHeader + emptyLine;

            //把响应行,响应头,响应空行去响应给浏览器
            SelectionKey selectionKey = httpResponse.getSelectionKey();
            SocketChannel channel = (SocketChannel) selectionKey.channel();

            ByteBuffer byteBuffer1 = ByteBuffer.wrap(result.getBytes());
            channel.write(byteBuffer1);

            //给浏览器 响应 响应体内容
            ByteBuffer byteBuffer2 = ByteBuffer.wrap("404 NOT FOUND....".getBytes());
            channel.write(byteBuffer2);

            //释放资源
            channel.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

4.xml

4.1概述【理解】

万维网联盟(W3C)

万维网联盟(W3C)创建于1994年，又称W3C理事会。1994年10月在麻省理工学院计算机科学实验室成立。
建立者： Tim Berners-Lee (蒂姆·伯纳斯·李)。
是Web技术领域最具权威和影响力的国际中立性技术标准机构。
到目前为止，W3C已发布了200多项影响深远的Web技术标准及实施指南，
- 如广为业界采用的超文本标记语言HTML（标准通用标记语言下的一个应用）、
- 可扩展标记语言XML（标准通用标记语言下的一个子集）
- 以及帮助残障人士有效获得Web信息的无障碍指南（WCAG）等
xml概述

XML的全称为(EXtensible Markup Language)，是一种可扩展的标记语言
标记语言: 通过标签来描述数据的一门语言(标签有时我们也将其称之为元素)
可扩展：标签的名字是可以自定义的,XML文件是由很多标签组成的,而标签名是可以自定义的
作用
- 用于进行存储数据和传输数据
- 作为软件的配置文件
作为配置文件的优势
- 可读性好
- 可维护性高

4.2标签的规则【应用】

标签由一对尖括号和合法标识符组成
```
<student>
```

标签必须成对出现

<student> </student>
前边的是开始标签，后边的是结束标签

特殊的标签可以不成对,但是必须有结束标记
```
<address/>
```
标签中可以定义属性,属性和标签名空格隔开,属性值必须用引号引起来
```
<student id="1"> </student>
```

标签需要正确的嵌套

这是正确的: <student id="1"> <name>张三</name> </student>
这是错误的: <student id="1"><name>张三</student></name>

4.3语法规则【应用】

语法规则
- XML文件的后缀名为：xml
- 文档声明必须是第一行第一列
  <?xml version=“1.0” encoding=“UTF-8” standalone=“yes”?>
  version：该属性是必须存在的
  encoding：该属性不是必须的
  
  打开当前xml文件的时候应该是使用什么字符编码表(一般取值都是UTF-8)
  
  standalone: 该属性不是必须的，描述XML文件是否依赖其他的xml文件，取值为yes/no
- 必须存在一个根标签，有且只能有一个
- XML文件中可以定义注释信息
- XML文件中可以存在以下特殊字符
```
&lt; < 小于
&gt; > 大于
&amp; & 和号
&apos; ' 单引号
&quot; " 引号
```
- XML文件中可以存在CDATA区
  <![CDATA[ …内容… ]]>

示例代码

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

    <!--第一个学生信息-->
    <student id="1">
        <name>张三</name>
        <age>23</age>
        <info>学生&lt; &gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;&gt;的信息</info>
        <message> <![CDATA[内容 <<<<<< >>>>>> ]]]></message>
    </student>

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

</students>

4.4xml解析【应用】

概述

xml解析就是从xml中获取到数据
常见的解析思想

DOM(Document Object Model)文档对象模型:就是把文档的各个组成部分看做成对应的对象。
会把xml文件全部加载到内存,在内存中形成一个树形结构,再获取对应的值
常见的解析工具
- JAXP: SUN公司提供的一套XML的解析的API
- JDOM: 开源组织提供了一套XML的解析的API-jdom
- DOM4J: 开源组织提供了一套XML的解析的API-dom4j,全称：Dom For Java
- pull: 主要应用在Android手机端解析XML
解析的准备工作
1. 我们可以通过网站：https://dom4j.github.io/ 去下载dom4j
  
  今天的资料中已经提供,我们不用再单独下载了,直接使用即可
2. 将提供好的dom4j-1.6.1.zip解压,找到里面的dom4j-1.6.1.jar
3. 在idea中当前模块下新建一个libs文件夹,将jar包复制到文件夹中
4. 选中jar包 -> 右键 -> 选择add as library即可
需求
- 解析提供好的xml文件
- 将解析到的数据封装到学生对象中
- 并将学生对象存储到ArrayList集合中
- 遍历集合

代码实现

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

    <!--第一个学生信息-->
    <student id="1">
        <name>张三</name>
        <age>23</age>
    </student>

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

</students>

// 上边是已经准备好的student.xml文件
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 +
                '}';
    }
}

/**
 * 利用dom4j解析xml文件
 */
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);
        }
    }
}

4.5DTD约束【理解】

什么是约束

用来限定xml文件中可使用的标签以及属性
约束的分类
- DTD
- schema
编写DTD约束
- 步骤
  1. 创建一个文件，这个文件的后缀名为.dtd
  2. 看xml文件中使用了哪些元素
    <!ELEMENT> 可以定义元素
  3. 判断元素是简单元素还是复杂元素
    
    简单元素：没有子元素。
    复杂元素：有子元素的元素；
- 代码实现
```
<!ELEMENT persons (person)>
<!ELEMENT person (name,age)>
<!ELEMENT name (#PCDATA)>
<!ELEMENT age (#PCDATA)>
```

引入DTD约束

引入DTD约束的三种方法
- 引入本地dtd
- 在xml文件内部引入
- 引入网络dtd

代码实现

引入本地DTD约束

// 这是persondtd.dtd文件中的内容,已经提前写好
<!ELEMENT persons (person)>
<!ELEMENT person (name,age)>
<!ELEMENT name (#PCDATA)>
<!ELEMENT age (#PCDATA)>

// 在person1.xml文件中引入persondtd.dtd约束
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE persons SYSTEM 'persondtd.dtd'>

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

</persons>

在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>

引入网络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: 表示该元素的内容部分为字符串
  
  复杂元素：
  直接写子元素名称. 多个子元素可以使用",“或者”|"隔开；
  ","表示定义子元素的顺序 ; “|”: 表示子元素只能出现任意一个
  "?"零次或一次, "+"一次或多次, "*"零次或多次;如果不写则表示出现一次
- 定义属性
  
  格式
  
  定义一个属性的格式为：<!ATTLIST 元素名称属性名称属性的类型属性的约束>
  属性的类型：
  CDATA类型：普通的字符串
  
  属性的约束:
  
  // #REQUIRED：必须的
  // #IMPLIED：属性不是必需的
  // #FIXED value：属性值是固定的
- 代码实现
```
<!ELEMENT persons (person+)>
<!ELEMENT person (name,age)>
<!ELEMENT name (#PCDATA)>
<!ELEMENT age (#PCDATA)>
<!ATTLIST person id CDATA #REQUIRED>

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

<persons>
    <person id="001">
        <name>张三</name>
        <age>23</age>
    </person>

    <person id = "002">
        <name>张三</name>
        <age>23</age>
    </person>

</persons>
```
```

4.6schema约束【理解】

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

编写schema约束

步骤

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

代码实现

<?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>
                        
                    </complexType>
                </element>
            </sequence>
        </complexType>

    </element>

</schema>

引入schema约束
- 步骤
  
  1，在根标签上定义属性xmlns=“http://www.w3.org/2001/XMLSchema-instance”
  2，通过xmlns引入约束文件的名称空间
  3，给某一个xmlns属性添加一个标识，用于区分不同的名称空间
  格式为: xmlns:标识=“名称空间地址” ,标识可以是任意的，但是一般取值都是xsi
  4，通过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>
        <name>张三</name>
        <age>23</age>
    </person>

</persons>
```
```

schema约束定义属性

代码示例

<?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>

<?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>
```

4.7服务器改进【应用】

准备xml文件
1. 在当前模块下的webapp目录下新建一个文件夹，名字叫WEB-INF
2. 新建一个xml文件，名字叫web.xml
3. 将资料中的web.xml文件中引入约束的代码复制到新建的web.xml文件中
4. 将要解析的数据配置到xml文件中
需求

把uri和servlet信息放到一个concurrentHashMap集合当中
当浏览器请求一个动态资源时，我们会获取uri对应的servlet来处理当前业务
实现步骤
1. 导入dom4j的jar包
2. 定义一个XmlParseServletConfig类实现ParseServletConfig接口
3. 在parse方法里面就可以解析xml文件了

代码实现

// web.xml配置文件中配置的信息
<?xml version="1.0" encoding="UTF-8" ?>
<web-app xmlns="http://java.sun.com/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
         version="2.5">

    <!--在以后需要配置servlet的时候，就直接在这里配置就可以了-->
    <servlet>
        <servlet-name>LoginServlet</servlet-name>
        <servlet-class>com.itheima.myservlet.LoginServlet</servlet-class>
    </servlet>

    <servlet-mapping>
        <servlet-name>LoginServlet</servlet-name>
        <url-pattern>/servlet/loginservlet</url-pattern>
    </servlet-mapping>

</web-app>

// 定义一个XmlParseServletConfig类实现ParseServletConfig接口
public class XMLParseServletConfig implements ParseServletConfig {
    //定义web.xml文件的路径
    private static final String WEB_XML_PATH = "http-dynamic-server/webapp/WEB-INF/web.xml";

	//在parse方法里面就可以解析xml文件了
    @Override
    public void parse() {
        try {
            //1.创建一个解析器对象(注意:如果解析器对象等不能使用,请检查一下jar包是否导入)
            SAXReader saxReader = new SAXReader();

            //2.利用解析器把xml文件读取到内存中
            Document document = saxReader.read(new File(WEB_XML_PATH));

            //3.获取根节点元素对象
            Element rootElement = document.getRootElement();

            //创建一个Map集合，用来存储servlet的配置信息
            HashMap<String,String> servletInfoHashMap = new HashMap<>();

            //4.获取根元素对象下所有的servlet元素的对象
            List<Element> servletInfos = rootElement.elements("servlet");

            //5.遍历集合，依次获取到每一个servlet标签对象
            for (Element servletInfo : servletInfos) {
                //servletInfo依次表示每一个servlet标签对象

                //获取到servlet下的servlet-name元素对象，并且获取标签体内容
                String servletName = servletInfo.element("servlet-name").getText();
                //获取到servlet下的servlet-class元素对象，并且获取标签体内容
                String servletClass = servletInfo.element("servlet-class").getText();

                servletInfoHashMap.put(servletName,servletClass);
            }

            //--------------------servlet-mapping--------------------------------------
            //获取到所有的servlet-mapping标签
            List<Element> servletMappingInfos = rootElement.elements("servlet-mapping");
            //遍历集合依次得到每一个servlet-mapping标签
            for (Element servletMappingInfo : servletMappingInfos) {
                //servletMappingInfo依次表示每一个servlet-mapping标签

                //获取servlet-mapping标签标签中的servlet-name标签的标签体内容
                String servletName = servletMappingInfo.element("servlet-name").getText();

                //获取servlet-mapping标签标签中的url-pattern标签的标签体内容
                String urlPattern = servletMappingInfo.element("url-pattern").getText();

                //通过servletName来获取到servlet的全类名
                String servletClassName = servletInfoHashMap.get(servletName);

                //通过反射来创建这个servlet对象
                Class clazz = Class.forName(servletClassName);

                //获取该类所实现的所有的接口信息,得到的是一个数组
                Class[] interfaces = clazz.getInterfaces();

                //定义一个boolean类型的变量
                boolean flag =  false;
                //遍历数组
                for (Class clazzInfo : interfaces) {
                    //判断当前所遍历的接口的字节码对象是否和HttpServlet的字节码文件对象相同
                    if(clazzInfo == HttpServlet.class){

                        //如果相同,就需要更改flag值.结束循环
                        flag = true;
                        break;
                    }
                }

                if(flag){
                    //true就表示当前的类已经实现了HttpServlet接口
                    HttpServlet httpServlet = (HttpServlet) clazz.newInstance();
                    //4.将uri和httpServlet添加到map集合中
                    ServletConcurrentHashMap.map.put(urlPattern,httpServlet);
                }else{
                    //false就表示当前的类还没有实现HttpServlet接口
                    throw new NotImplementsHttpServletException(clazz.getName() + "Not Implements HttpServlet");
                }
            }
        } catch (NotImplementsHttpServletException e) {
            e.printStackTrace();
        }catch (Exception e) {
            e.printStackTrace();
        }
    }
}

public class LoaderResourceRunnable implements  Runnable {
    @Override
    public void run() {
//        //执行parse方法
//        ParseServletConfig parseServletConfig = new PropertiesParseServletConfig();
//        parseServletConfig.parse();

        ParseServletConfig parseServletConfig = new XMLParseServletConfig();
        parseServletConfig.parse();

    }
}

5.枚举

5.1概述【理解】

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

5.2定义格式【应用】

格式

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

示例代码

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

5.3枚举的特点【理解】

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

示例代码

public enum Season {

    SPRING("春"){

        //如果枚举类中有抽象方法
        //那么在枚举项中必须要全部重写
        @Override
        public void show() {
            System.out.println(this.name);
        }

    },

    SUMMER("夏"){
        @Override
        public void show() {
            System.out.println(this.name);
        }
    },

    AUTUMN("秋"){
        @Override
        public void show() {
            System.out.println(this.name);
        }
    },

    WINTER("冬"){
        @Override
        public void show() {
            System.out.println(this.name);
        }
    };

    public String name;

    //空参构造
    //private Season(){}
  
    //有参构造
    private Season(String name){
        this.name = name;
    }
  
    //抽象方法
    public abstract void show();
}

public class EnumDemo {
    public static void main(String[] args) {
        /*
        1.所有枚举类都是Enum的子类
        2.我们可以通过"枚举类名.枚举项名称"去访问指定的枚举项
        3.每一个枚举项其实就是该枚举的一个对象
        4.枚举也是一个类，也可以去定义成员变量
        5.枚举类的第一行上必须是枚举项，最后一个枚举项后的分号是可以省略的，
          但是如果枚举类有其他的东西，这个分号就不能省略。建议不要省略
        6.枚举类可以有构造器，但必须是private的，它默认的也是private的。
          枚举项的用法比较特殊：枚举("");
        7.枚举类也可以有抽象方法，但是枚举项必须重写该方法
    */
  
        //第二个特点的演示
        //我们可以通过"枚举类名.枚举项名称"去访问指定的枚举项
        System.out.println(Season.SPRING);
        System.out.println(Season.SUMMER);
        System.out.println(Season.AUTUMN);
        System.out.println(Season.WINTER);
  
        //第三个特点的演示
        //每一个枚举项其实就是该枚举的一个对象
        Season spring = Season.SPRING;
    }
}

5.4枚举的方法【应用】

方法介绍

方法名	说明
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);
        }
    }
}

6.注解

6.1概述【理解】

概述

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

代码更加简洁,方便

6.2自定义注解【理解】

格式

public @interface 注解名称 {

public 属性类型属性名() default 默认值 ;

}
属性类型
- 基本数据类型
- String
- Class
- 注解
- 枚举
- 以上类型的一维数组

代码演示

public @interface Anno2 {
}

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

public @interface Anno1 {

    //定义一个基本类型的属性
    int a () default 23;

    //定义一个String类型的属性
    public String name() default "itheima";

    //定义一个Class类型的属性
    public Class clazz() default Anno2.class;

    //定义一个注解类型的属性
    public Anno2 anno() default @Anno2;

    //定义一个枚举类型的属性
    public Season season() default Season.SPRING;

    //以上类型的一维数组
    //int数组
    public int[] arr() default {1,2,3,4,5};

    //枚举数组
    public Season[] seasons() default {Season.SPRING,Season.SUMMER};

    //value。后期我们在使用注解的时候，如果我们只需要给注解的value属性赋值。
    //那么value就可以省略
    public String value();

}

//在使用注解的时候如果注解里面的属性没有指定默认值。
//那么我们就需要手动给出注解属性的设置值。
//@Anno1(name = "itheima")
@Anno1("abc")
public class AnnoDemo {
}

注意

如果只有一个属性需要赋值，并且属性的名称是value，则value可以省略，直接定义值即可

自定义注解案例

需求

自定义一个注解@Test,用于指定类的方法上,如果某一个类的方法上使用了该注解,就执行该方法
实现步骤
1. 自定义一个注解Test,并在类中的某几个方法上加上注解
2. 在测试类中,获取注解所在的类的Class对象
3. 获取类中所有的方法对象
4. 遍历每一个方法对象,判断是否有对应的注解

代码实现

//表示Test这个注解的存活时间
@Retention(value = RetentionPolicy.RUNTIME)
public @interface Test {
}

public class UseTest {

    //没有使用Test注解
    public void show(){
        System.out.println("UseTest....show....");
    }

    //使用Test注解
    @Test
    public void method(){
        System.out.println("UseTest....method....");
    }

    //没有使用Test注解
    @Test
    public void function(){
        System.out.println("UseTest....function....");
    }
}

public class AnnoDemo {
    public static void main(String[] args) throws ClassNotFoundException, IllegalAccessException, InstantiationException, InvocationTargetException {
        //1.通过反射获取UseTest类的字节码文件对象
        Class clazz = Class.forName("com.itheima.myanno3.UseTest");

        //创建对象
        UseTest useTest = (UseTest) clazz.newInstance();

        //2.通过反射获取这个类里面所有的方法对象
        Method[] methods = clazz.getDeclaredMethods();

        //3.遍历数组，得到每一个方法对象
        for (Method method : methods) {
            //method依次表示每一个方法对象。
            //isAnnotationPresent(Class<? extends Annotation> annotationClass)
            //判断当前方法上是否有指定的注解。
            //参数：注解的字节码文件对象
            //返回值：布尔结果。  true 存在  false 不存在
            if(method.isAnnotationPresent(Test.class)){
                method.invoke(useTest);
            }
        }
    }
}

6.3元注解【理解】

概述

元注解就是描述注解的注解

元注解介绍

元注解名	说明
@Target	指定了注解能在哪里使用
@Retention	可以理解为保留时间(生命周期)
@Inherited	表示修饰的自定义注解可以被子类继承
@Documented	表示该自定义注解，会出现在API文档里面。

示例代码

@Target({ElementType.FIELD,ElementType.TYPE,ElementType.METHOD})  //指定注解使用的位置（成员变量，类，方法）
@Retention(RetentionPolicy.RUNTIME) //指定该注解的存活时间
//@Inherited //指定该注解可以被继承
public @interface Anno {
}

@Anno
public class Person {
}

public class Student extends Person {
    public void show(){
        System.out.println("student.......show..........");
    }
}

public class StudentDemo {
    public static void main(String[] args) throws ClassNotFoundException {
        //获取到Student类的字节码文件对象
        Class clazz = Class.forName("com.itheima.myanno4.Student");

        //获取注解。
        boolean result = clazz.isAnnotationPresent(Anno.class);
        System.out.println(result);
    }
}

6.4改写服务器【理解】

需求

目前项目中Servlet和url对应关系,是配置在xml文件中的,将其改为在Servlet类上通过注解配置实现
实现步骤
1. 定义一个注解(@WebServlet),注解内有一个属性urlPatterns
2. 在servlet类上去使用该注解,来指定当前Servlet的访问路径
3. 创建一个注解解析类(AnnoParseServletConfig),该类实现ParseServletConfig接口
4. 实现parse方法

代码实现

@Target(ElementType.TYPE) //指定该注解可以使用在类上
@Retention(RetentionPolicy.RUNTIME)//指定该注解的存活时间 --- 为运行期
public @interface WebServlet {

    //让用户去指定某一个Servlet在进行访问的时候所对应的请求uri
    public String urlPatterns();
}

// 这里只给出了LoginServlet的配置,其他Servlet同理
@WebServlet(urlPatterns = "/servlet/loginservlet")
public class LoginServlet implements HttpServlet{
    @Override
    public void service(HttpRequest httpRequest, HttpResponse httpResponse) {
       //处理
        System.out.println("LoginServlet处理了登录请求");

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

public class AnnoParseServletConfig implements ParseServletConfig {

    //定义一个servlet路径所对应的常量
    public static final String SERVLET_PATH = "http-dynamic-server\\src\\com\\itheima\\myservlet";
  
    //定义包名
    public static final String SERVLET_PACKAGE_NAME = "com.itheima.myservlet.";
  
    @Override
    public void parse() {
        //获取类名
//  1.获得servlet所在文件夹的路径，并封装成File对象
        File file = new File(SERVLET_PATH);
//  2.调用listFiles方法，获取文件夹下所有的File对象
        File[] servletFiles = file.listFiles();
//  3.遍历数组，获取每一个File对象
        for (File servletFile : servletFiles) {
//  4.获取File对象的名字（后缀名）
            String servletFileName = servletFile.getName().replace(".java", "");
//  5.根据包名 + 类名 得到每一个类的全类名
           String servletFullName = SERVLET_PACKAGE_NAME + servletFileName;
            try {
//  6.通过全类名获取字节码文件对象
                Class servletClazz = Class.forName(servletFullName);
                //  7.判断该类是否有WebServlet注解
                if(servletClazz.isAnnotationPresent(WebServlet.class)){
                //  8.判断该Servlet类是否实现HttpServlet接口
                    //获取该类所实现的所有的接口信息,得到的是一个数组
                    Class[] interfaces = servletClazz.getInterfaces();
  
                    //定义一个boolean类型的变量
                    boolean flag =  false;
                    //遍历数组
                    for (Class clazzInfo : interfaces) {
                        //判断当前所遍历的接口的字节码对象是否和HttpServlet的字节码文件对象相同
                        if(clazzInfo == HttpServlet.class){
                            //如果相同,就需要更改flag值.结束循环
                            flag = true;
                            break;
                        }
                    }
  
                    if(flag){
                        //  9.如果满足，则获取注解中的urlPattrens的值，
                        WebServlet annotation = (WebServlet) servletClazz.getAnnotation(WebServlet.class);
                        String uri = annotation.urlPatterns();
  
                        //  10.创建当前Servlet类对象存入值位置
                        HttpServlet httpServlet = (HttpServlet) servletClazz.newInstance();
                        //  11.存入集合的键位置
                        ServletConcurrentHashMap.map.put(uri,httpServlet);
                        //
                    }else{
                        //  12.如果不满足，抛出异常
                        //false就表示当前的类还没有实现HttpServlet接口
                        throw new NotImplementsHttpServletException(servletClazz.getName() + "Not Implements HttpServlet");
                    }
                }
            } catch (NotImplementsHttpServletException e) {
                e.printStackTrace();
            } catch (Exception e) {
                e.printStackTrace();
            }
        }

        }
    }

public class LoaderResourceRunnable implements  Runnable {
    @Override
    public void run() {
//        //执行parse方法
//        ParseServletConfig parseServletConfig = new PropertiesParseServletConfig();
//        parseServletConfig.parse();

//        ParseServletConfig parseServletConfig = new XMLParseServletConfig();
//        parseServletConfig.parse();

        ParseServletConfig parseServletConfig = new AnnoParseServletConfig();
        parseServletConfig.parse();
  
    }
}

7.管理系统与服务器集成

7.1准备工作【应用】

需求

对之前写过的黑马信息管理系统进行改进,实现可以通过浏览器进行访问的功能
准备工作
- 将资料中的黑马管理系统代码拷贝到当前模块下
- 导包的代码可能报错,因为之前的包路径可能和当前代码不一致,将导包的代码修改下
业务分析
1. 解析URL封装到HttpReques对象
2. DynamicResourceProcess类（执行指定动态资源的service方法）
3. 定义servlet类完成查询学生、添加学生、删除学生、修改学生的逻辑

7.2HttpRequest类代码实现【应用】

实现步骤
1. 提供一个存储url中用户信息的map集合
2. 提供一个getParamter方法,用于根据请求参数的名称获取请求参数的值
3. 提供一个parseParamter方法,用于解析请求参数把请求参数存储到map集合中

代码实现

// 此处只给出了新增的代码,其他代码同之前没有变化
public class HttpRequest {
   
    //用来存储请求URL中问号后面的那些数据
    //id=1  name=itheima
    private Map<String,String> paramterHashMap = new HashMap<>();

    //parse --- 获取请求数据 并解析
    public void parse(){
        try {
            SocketChannel socketChannel = (SocketChannel) selectionKey.channel();
            StringBuilder sb = new StringBuilder();
            //创建一个缓冲区
            ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
            int len;
            //循环读取
            while((len = socketChannel.read(byteBuffer)) > 0){
                byteBuffer.flip();
                sb.append(new String(byteBuffer.array(),0,len));
                //System.out.println(new String(byteBuffer.array(),0,len));
                byteBuffer.clear();
            }
            //System.out.println(sb);
            parseHttpRequest(sb);

            //解析请求参数，把请求参数存储到paramterHashMap集合
            parseParamter();

        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    //解析请求参数，把请求参数存储到paramterHashMap集合
    private void parseParamter(){
        //获取请求的uri
        String requestURI = this.requestURI;
        //按照问号进行切割，然后再获取到第二部分
        String[] uriInfoArr = requestURI.split("\\?");
        //判断数组的长度，如果长度为2，说明是存在请求参数。
        if(uriInfoArr.length == 2){
            //获取请求参数内容（问号后面的那些参数）
            String paramterInfo = uriInfoArr[1];

            //使用&进行切割
            String[] paramterInfoArr = paramterInfo.split("&");

            //遍历数组
            //id=1 name=itheima age =23
            for (String paramter : paramterInfoArr) {
                String[] paramterArr = paramter.split("=");
                //获取请求参数名称
                String paramterName = paramterArr[0];
                //获取请求参数的值
                String paramterValue = paramterArr[1];
                //添加到集合中
                paramterHashMap.put(paramterName,paramterValue);
            }
        }
    }
  
    //id=1 name=itheima
    //可以根据请求参数的名称来获取请求参数的值
    public String getParamter(String name){
        return paramterHashMap.get(name);
    }

}

7.3DynamicResourceProcess类代码实现【应用】

实现步骤

获取的uri是包含?后边的数据的,要进行切割,只要?号前边的内容

代码实现

// 此处只给出了新增的代码,其他代码同之前没有变化
public class DynamicResourceProcess {

    public void process(HttpRequest httpRequest,HttpResponse httpResponse){
        //获取请求的uri
        String requestURI = httpRequest.getRequestURI();
        //对requestURI进行切割操作
        String[] split = requestURI.split("\\?");
        //根据请求的uri到map集合中直接找到对应的servlet的对象
        HttpServlet httpServlet = ServletConcurrentHashMap.map.get(split[0]);
        System.out.println(httpServlet);
      	// ...
    }
}

7.4StudentServlet类代码实现【应用】

实现步骤
1. 在service方法中获取请求参数中的数据
2. 判断是要添加学生还是修改学生等
3. 调用对应的方法,执行对应的操作

代码实现

@WebServlet(urlPatterns = "/servlet/studentservlet")
public class StudentServlet implements HttpServlet {

    @Override
    public void service(HttpRequest httpRequest, HttpResponse httpResponse) {
        //获取method请求参数
        String method = httpRequest.getParamter("method");
        System.out.println(method);
        //判断
        if ("addStudent".equals(method)) {
            //添加学生
            addStudent(httpRequest, httpResponse);
        } else if ("delStudent".equals(method)) {
            //删除学生
            delStudent(httpRequest, httpResponse);
        } else if ("updateStudent".equals(method)) {
            //修改学生
            updateStudent(httpRequest, httpResponse);
        } else if ("findStudent".equals(method)) {
            //查询学生
            findStudent(httpRequest, httpResponse);
        }
    }

    //查询学生
    private void findStudent(HttpRequest httpRequest, HttpResponse httpResponse) {
    }

    //修改学生
    private void updateStudent(HttpRequest httpRequest, HttpResponse httpResponse) {
    }

    //删除学生
    private void delStudent(HttpRequest httpRequest, HttpResponse httpResponse) {
    }

    //添加学生
    private void addStudent(HttpRequest httpRequest, HttpResponse httpResponse) {   
    }
}

7.5查询学生【应用】

实现步骤
1. 创建StudentService对象
2. 调用StudentService中的findAllStudent方法，完成学生数据的查询操作
3. 遍历数组，拼接成一个字符串
4. 将拼接的结果响应给浏览器

代码实现

@WebServlet(urlPatterns = "/servlet/studentservlet")
public class StudentServlet implements HttpServlet {
    //1.创建StudentService对象
    private StudentService studentService = new StudentService();

    @Override
    public void service(HttpRequest httpRequest, HttpResponse httpResponse) {
        //获取method请求参数

        String method = httpRequest.getParamter("method");
        System.out.println(method);
        //判断
        if ("addStudent".equals(method)) {
            //添加学生
            addStudent(httpRequest, httpResponse);
        } else if ("delStudent".equals(method)) {
            //删除学生
            delStudent(httpRequest, httpResponse);
        } else if ("updateStudent".equals(method)) {
            //修改学生
            updateStudent(httpRequest, httpResponse);
        } else if ("findStudent".equals(method)) {
            //查询学生
            findStudent(httpRequest, httpResponse);
        }
    }

    //查询学生
    private void findStudent(HttpRequest httpRequest, HttpResponse httpResponse) {
        //2.调用StudentService中的findAllStudent方法，完成学生数据的查询操作
        Student[] allStudent = studentService.findAllStudent();
        //3.遍历数组，拼接成一个字符串
        StringBuilder sb = new StringBuilder();
        for (Student student : allStudent) {
            sb.append(student.getId()).append(", ").append(student.getName()).
                    append(", ").append(student.getAge()).append(", ").
                    append(student.getBirthday()).append("<br>");
        }
        String result = sb.toString();
        //4.将拼接的结果响应给浏览器
        //告诉浏览器响应的类型
        httpResponse.setContentTpye("text/html;charset=UTF-8");
        if (result == null || "".equals(result)) {
            httpResponse.write("暂无学生数据。。。。");
        } else {
            httpResponse.write(result);
        }
    }
    //修改学生
    private void updateStudent(HttpRequest httpRequest, HttpResponse httpResponse) {
    }

    //删除学生
    private void delStudent(HttpRequest httpRequest, HttpResponse httpResponse) {
    }

    //添加学生
    private void addStudent(HttpRequest httpRequest, HttpResponse httpResponse) {   
    }
}

7.6添加学生【应用】

实现步骤
1. 获取id的请求参数
2. 判断id是否重复
3. 如果重复。给浏览器响应，id已经重复
4. 如果id不重复。添加学生。并给浏览器响应添加学生成功

代码实现

@WebServlet(urlPatterns = "/servlet/studentservlet")
public class StudentServlet implements HttpServlet {
    //1.创建StudentService对象
    private StudentService studentService = new StudentService();

    @Override
    public void service(HttpRequest httpRequest, HttpResponse httpResponse) {
        //获取method请求参数

        String method = httpRequest.getParamter("method");
        System.out.println(method);
        //判断
        if ("addStudent".equals(method)) {
            //添加学生
            addStudent(httpRequest, httpResponse);
        } else if ("delStudent".equals(method)) {
            //删除学生
            delStudent(httpRequest, httpResponse);
        } else if ("updateStudent".equals(method)) {
            //修改学生
            updateStudent(httpRequest, httpResponse);
        } else if ("findStudent".equals(method)) {
            //查询学生
            findStudent(httpRequest, httpResponse);
        }
    }

    //查询学生
    private void findStudent(HttpRequest httpRequest, HttpResponse httpResponse) {
       //...
    }
    //修改学生
    private void updateStudent(HttpRequest httpRequest, HttpResponse httpResponse) {
    }
    //删除学生
    private void delStudent(HttpRequest httpRequest, HttpResponse httpResponse) {
    }
    //添加学生
    private void addStudent(HttpRequest httpRequest, HttpResponse httpResponse) {
        //1.获取id的请求参数
        String id = httpRequest.getParamter("id");
        //2.判断id是否重复
        boolean exists = studentService.isExists(id);
        httpResponse.setContentTpye("text/html;charset=UTF-8");
        if (exists) {
            //3.如果重复。给浏览器响应，id已经重复
            httpResponse.write("id已经存在，请重新输入。。。");
        } else {
            //4.如果id不重复。添加学生。并给浏览器响应添加学生成功
            String name = httpRequest.getParamter("name");
            String age = httpRequest.getParamter("age");
            String birthday = httpRequest.getParamter("birthday");
            //对数据进行处理
            try {
                int ageInt = Integer.parseInt(age);
                SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
                Date date = sdf.parse(birthday);
                //创建一个学生对象
                Student s = new Student();
                s.setId(id);
                s.setName(name);
                s.setAge(age);
                s.setBirthday(birthday);
                //调用studentservice里面的方法
                studentService.addStudent(s);
                //给浏览器响应
                httpResponse.write("学生数据添加成功....");
            } catch (ParseException e) {
                httpResponse.write("日期格式不正确，正确的格式为:yyyy-MM-dd");
                e.printStackTrace();
            } catch (NumberFormatException e) {
                httpResponse.write("年龄只能为整数");
                e.printStackTrace();
            }
            //birthday  yyyy-MM-dd
        }
    }
}

8.单元测试

8.1概述【理解】

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

8.2特点【理解】

JUnit是一个开放源代码的测试工具。
提供注解来识别测试方法。
JUnit测试可以让你编写代码更快，并能提高质量。
JUnit优雅简洁。没那么复杂，花费时间较少。
JUnit在一个条中显示进度。如果运行良好则是绿色；如果运行失败，则变成红色。

8.3使用步骤【应用】

使用步骤
1. 将junit的jar包导入到工程中 junit-4.9.jar
2. 编写测试方法该测试方法必须是公共的无参数无返回值的非静态方法
3. 在测试方法上使用@Test注解标注该方法是一个测试方法
4. 选中测试方法右键通过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);
    }
}

8.4相关注解【应用】

注解说明

注解含义
@Test 表示测试该方法
@Before 在测试的方法前运行
@After 在测试的方法后运行

注解	含义
@Test	表示测试该方法
@Before	在测试的方法前运行
@After	在测试的方法后运行

代码示例

public class JunitDemo2 {
    @Before
    public void before() {
      	// 在执行测试代码之前执行，一般用于初始化操作
        System.out.println("before");
    }
    @Test
    public void test() {
      	// 要执行的测试代码
        System.out.println("test");
    }
    @After
    public void after() {
      	// 在执行测试代码之后执行，一般用于释放资源
        System.out.println("after");
    }
}

9.日志

9.1概述【理解】

概述

程序中的日志可以用来记录程序在运行的时候点点滴滴。并可以进行永久存储。

日志与输出语句的区别

	输出语句	日志技术
取消日志	需要修改代码，灵活性比较差	不需要修改代码，灵活性比较好
输出位置	只能是控制台	可以将日志信息写入到文件或者数据库中
多线程	和业务代码处于一个线程中	多线程方式记录日志，不影响业务代码的性能

9.2日志体系结构和Log4J【理解】

体系结构

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-jgM7pqJu-1628425786381)(.\img\06_日志体系结构.png)]
Log4J

Log4j是Apache的一个开源项目。

通过使用Log4j，我们可以控制日志信息输送的目的地是控制台、文件等位置。

我们也可以控制每一条日志的输出格式。

通过定义每一条日志信息的级别，我们能够更加细致地控制日志的生成过程。

最令人感兴趣的就是，这些可以通过一个配置文件来灵活地进行配置，而不需要修改应用的代码。
Apache基金会

Apache软件基金会（也就是Apache Software Foundation，简称为ASF），为支持开源软件项目而办的一个非盈利性组织。

9.3入门案例【应用】

使用步骤
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级别的日志");
    }
}

9.4配置文件详解【理解】

三个核心
- 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
  
  设定以怎样的格式显示消息

9.5在项目中的应用【应用】

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

代码实现

@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("登录成功");
    }
}

😉😉😉

print("如果文章对你有用，请点个赞呗O(∩_∩)O~")

System.out.println("如果文章对你有用，请点个赞呗O(∩_∩)O~");

cout<<"如果文章对你有用，请点个赞呗O(∩_∩)O~"<<endl;

😉😉😉

Java学习笔记24：Java_xml_枚举_注解_类加载器_反射_http服务器改写_管理系统与服务器集成_单元测试_日志

文章目录

1.类加载器

1.1类加载器【理解】

1.2类加载的过程【理解】

1.3类加载的分类【理解】

1.4双亲委派模型【理解】

1.5ClassLoader 中的两个方法【应用】

2.反射

2.1反射的概述【理解】

2.2获取Class类对象的三种方式【应用】

2.3反射获取构造方法并使用【应用】

2.3.1Class类获取构造方法对象的方法

2.3.2Constructor类用于创建对象的方法

2.3.3小结

2.4反射获取成员变量并使用【应用】

2.4.1Class类获取成员变量对象的方法

2.4.2Field类用于给成员变量赋值的方法

2.5反射获取成员方法并使用【应用】

2.5.1Class类获取成员方法对象的方法

2.5.2Method类用于执行方法的方法

3.http服务器改写

3.1静态资源和动态资源【理解】

3.2准备工作【理解】

3.3浏览器请求动态资源【理解】

3.4main方法和Servlet优化【理解】

3.5多个动态资源【理解】

3.6通过反射和配置文件优化【理解】

3.7Servlet忘记实现HttpServlet接口处理【理解】

3.8响应404【理解】

4.xml

4.1概述【理解】

4.2标签的规则【应用】

4.3语法规则【应用】

4.4xml解析【应用】

4.5DTD约束【理解】

4.6schema约束【理解】

4.7服务器改进【应用】

5.枚举

5.1概述【理解】

5.2定义格式【应用】

5.3枚举的特点【理解】

5.4枚举的方法【应用】

6.注解

6.1概述【理解】

6.2自定义注解【理解】

6.3元注解【理解】

6.4改写服务器【理解】

7.管理系统与服务器集成

7.1准备工作【应用】

7.2HttpRequest类代码实现【应用】

7.3DynamicResourceProcess类代码实现【应用】

7.4StudentServlet类代码实现【应用】

7.5查询学生【应用】

7.6添加学生【应用】

8.单元测试

8.1概述【理解】

8.2特点【理解】

8.3使用步骤【应用】

8.4相关注解【应用】

9.日志

9.1概述【理解】

9.2日志体系结构和Log4J【理解】

9.3入门案例【应用】

9.4配置文件详解【理解】

9.5在项目中的应用【应用】