精华内容
下载资源
问答
  • (1) 假设我想暴露给外界的文件放在AWS的koifiles这个文件夹里,下载http-server, ...使用Load Balancer的url在浏览器里访问,即可浏览koifiles文件夹下面的文件内容了: 要获取更多Jerry的原创文...

    (1) 假设我想暴露给外界的文件放在AWS的koifiles这个文件夹里,下载http-server,
    使用命令http-server ./koifiles本地启动, 记住端口号为8084

    (2) 在AWS上创建一个Load Balancer,指向8084端口

    使用Load Balancer的url在浏览器里访问,即可浏览koifiles文件夹下面的文件内容了:

    要获取更多Jerry的原创文章,请关注公众号"汪子熙":

    展开全文
  • 我在这里[http://download.csdn.net/download/shijiedierchou2/9317701](http://download.csdn.net/download/shijiedierchou2/9317701 "")找到了formecho.js的源码,这个文件应该放在哪个目录下呢? 那个8080端口是...
  • 这个实验主要是安装apeche2,并创建一个共享文件能够在本机上访问。 实验内容三,构建一简单动态HTTP网站。制作的动态网站类似于一个教务管理系统,用户通过注册、登录进入个人信息在网站上进行浏览,浏览即是从...
  • Kerberos化http接口访问

    2020-12-21 01:23:25
    Kerberos化http接口访问一,Linux ,Mac os 环境下curl 命令访问1.1, 拷贝 服务器上的 /etc/krb5.conf 文件还至目标电脑上。1.2, 执行kinit 获取票据,curl访问接口二,mac 环境下使用浏览器访问Kerberos 化 UI2.1 ...

    一,Linux ,Mac os 环境下curl 命令访问

    1.1, 拷贝 服务器上的 /etc/krb5.conf 文件还至目标电脑上。

    在这里插入图片描述
    涉及到路径的配置项,要么配置成实际存在的路径,要么全注释掉使用默认值。

    renew_lifetime = 7d 最好去掉,容易导致奇怪的问题,原因未知。

    1.2, 执行kinit 获取票据,curl访问接口

    curl -i --negotiate -u:${principls} -X GET ${URL}
    

    在这里插入图片描述

    二,mac 环境下使用浏览器访问Kerberos 化 UI

    2.1 拷贝/etc/krb5.conf 文件,执行kinit

    同上步骤

    2.2 safari浏览器

    Safari支持kerberos,认证成功后不需要做任何操作,直接打开界面就可以了。
    在这里插入图片描述
    在这里插入图片描述

    2.3 Chrome浏览器打开界面

    执行如下命令:

    defaults write com.google.Chrome AuthServerWhitelist "*"
    defaults write com.google.Chrome AuthNegotiateDelegateWhitelist "*"
    
    /Applications/Google\ Chrome.app/Contents/MacOS/Google\ Chrome --auth-server-whitelist="*"
    

    “/Applications/Google\ Chrome.app/Contents/MacOS/Google\ Chrome”
    是你Chrome浏览器实际的安装路径。

    三,windows环境下使用浏览器访问Kerberos 化 UI

    windows 环境下 目前只支持Firefox浏览器。

    3.1 下载安装 KerberosTicket Manager

    下载地址:http://web.mit.edu/kerberos/dist/kfw/4.1/kfw-4.1-amd64.msi

    3.2 拷贝集群里的/etc/krb5.conf文件到本地 并改名为krb5.ini,其中与路径相关的注释掉或者配置成本地的路径,不然启动报错。

    3.3 添加环境变量KRB5_CONFIG,KRB5CCNAME。

    KRB5_CONFIG 指向3.2中提到的krb5.ini 文件
    KRB5_CONFIG: 随意指向一个存在的目录就行,用来在其中保存一些缓存信息。

    在这里插入图片描述

    3.4 配置Firefox浏览器

    打开浏览器,在地址栏输入about:config
    在搜索栏依次输入下面5个参数,进行相应修改并保存

    1)network.negotiate-auth.trusted-uris = .edu.org(此处根据krb5.ini文件中的realms值修改)
    2)network.negotiate-auth.using-native-gsslib = false
    3)network.negotiate-auth.gsslib =C:\Program Files\MIT\Kerberos\bin\gssapi64.dll
    4)network.auth.use-sspi = false
    5)network.negotiate-auth.allow-non-fqdn = true
    

    在这里插入图片描述

    3.5 , 打开KerberosTicket Manager 获取票据

    在这里插入图片描述
    启动Firefox访问页面

    在这里插入图片描述

    展开全文
  • 负责将.class文件(存储的物理文件)加载在到内存中 1.2类加载的过程【理解】 类加载时机 创建类的实例(对象) 调用类的类方法 访问类或者接口的类变量,或者为该类变量赋值 使用反射方式来强制创建某个类或...

    1.类加载器

    1.1类加载器【理解】

    • 作用

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

    在这里插入图片描述

    1.2类加载的过程【理解】

    • 类加载时机

      • 创建类的实例(对象)
      • 调用类的类方法
      • 访问类或者接口的类变量,或者为该类变量赋值
      • 使用反射方式来强制创建某个类或接口对应的java.lang.Class对象
      • 初始化某个类的子类
      • 直接使用java.exe命令来运行某个主类
    • 类加载过程

      1. 加载

        • 通过包名 + 类名,获取这个类,准备用流进行传输
        • 在这个类加载到内存中
        • 加载完毕创建一个class对象
          在这里插入图片描述
      2. 链接

        验证

        确保Class文件字节流中包含的信息符合当前虚拟机的要求,并且不会危害虚拟机自身安全

        (文件中的信息是否符合虚拟机规范有没有安全隐患)

    在这里插入图片描述

     **准备**
    
       负责为类的类变量(被static修饰的变量)分配内存,并设置默认初始化值
    
       (初始化静态变量)
    

    在这里插入图片描述

     **解析**
    
       将类的二进制数据流中的符号引用替换为直接引用
    
       (本类中如果用到了其他类,此时就需要找到对应的类)
    

    在这里插入图片描述

    1. 初始化

      根据程序员通过程序制定的主观计划去初始化类变量和其他资源

      (静态变量赋值以及初始化其他资源)

    在这里插入图片描述

    • 小结

      • 当一个类被使用的时候,才会加载到内存
      • 类加载的过程: 加载、验证、准备、解析、初始化

    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 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,表示取消访问检查
    • 示例代码

      // 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) 获取值
    • 示例代码

      // 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对象调用该方法

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

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

    • 示例代码

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



      ~end

    展开全文
  • android虚拟机访问本地电脑的tomcat服务器资源 首先得确认虚拟机和你电脑处都于同一个网段,如果都是在用同一路由的wifi,那么直接定义的url是输入http://电脑IP:8080/web/res文件。不同网段要设法搞到同以网段,...

    android虚拟机访问本地电脑的tomcat服务器资源

    首先得确认虚拟机和你电脑处都于同一个网段,如果都是在用同一路由的wifi,那么直接定义的url是输入http://电脑IP:8080/web/res文件。不同网段要设法搞到同以网段,例如使用随身wifi等。
    在这里插入图片描述
    获取电脑ip,打开dos界面输入ipconfig命令,找到IPv4地址

    另外提一下Android Studio模拟器联网

    Android Studio自带的模拟器本身默认是不能上网的,因为默认DNS为10.0.2.3,使用这个DNS是不能上网的。
    进入到cmd后,需要输入adb root 将模拟器root一下,才能更改DNS。然后再输入adb shell。
    接下来输入getprop获取模拟器系统属性。找到[net.eth0.dns1]这一项,发现后面为10.0.2.3。
    在这里插入图片描述
    接下来我们输入setprop net.eth0.dns1 192.168.1.1.后面的ip也可为其他。(没有[net.eth0.dns1]的话因为系统是Android9.0及以上,建议换到8.0及以下)。

    展开全文
  •  2)Web 服务器接受到对result.php页面的请求,检索该文件,传送给PHP引擎处理。  3)PHP引擎开始解析脚本,脚本包括链接到数据库和执行对数据库查询的命令。PHP启动了对MySQL服务器的连接并向服务器发送适当的...
  • 终端用户可以直接通过HTTP的方式上传和管理在S3中的文件,而不需要经过服务器中转。那么如何限制S3对象的访问权限,让终端用户只有管理自己拥有的文件的权限,是很多客户关心的问题。熟悉AWS会知道,IAM的Policy是...
  • dir 查看文件,参数:/Q显示文件及目录属系统哪个用户,/T:C显示文件创建时间,/T:A显示文件上次被访问时间,/T:W上次被修改时间 date /t 、 time /t 使用此参数即“DATE/T”、“TIME/T”将只显示当前日期和时间,...
  • Web服务器的java实现

    热门讨论 2013-02-15 23:06:47
     文件名指出所访问文件HTTP/1.0指出Web浏览器使用的HTTP版本。  (3) 应答:Web浏览器提交请求后,通过HTTP协议传送给Web服务器。Web服务器接到后,进行事务处理,处理结果又通过HTTP传回给Web浏览器,从而在...
  • 场景:用户访问http://china.huanqiu.com/article/2016-02/8607399.html 1.浏览器向DNS获取web服务器china.huanqiu.com的ip地址 2.浏览器发送一个TCP的包,要求服务器打开连接 3.服务器发送一个包,告知浏览器连接已...
  • 基于文件上传的【李氏】任意文件下载漏洞 0x01 介绍 任意文件下载漏洞不仅仅可下载...如果web设计者设计的web内容没有恰当的访问控制,允许http遍历,攻击者就可以访问受限的目录,并可以在web根目录以外执行命令
  • 它具有强大的检测引擎,同时有众多功能,包括数据库指纹识别、从数据库中获取数据、访问底层文件系统以及在操作系统上带内连接执行命令。sqlmap工具下载官方网站下载http://sqlmap.org/ sqlmap工具启动1,需要在启动...
  • 服务器的位置= /服务器服务器取决于 , 和请确保在继续安装之前安装了这些文件。 太好了,您已经准备好继续前进; 惊人的! 让我们从在终端中运行命令开始,称为命令行界面(CLI) 安装项目相关性 # npm i 全局...
  • Shellshock远程命令注入(CVE-2014-6271) by ADummy 0x00利用路线 ​ Burpsuite发包—>命令执行 0x01漏洞介绍 ​ CVE-2014-6271(即“破壳”漏洞)广泛...当您访问时,http://your-ip/您应该看到两个文件: saf
  • MYSQL常用命令大全

    2011-05-30 13:31:24
    然后使用source命令,后面参数为脚本文件(如这里用到的.sql) mysql>source wcnc_db.sql B:使用mysqldump命令 mysqldump -u username -p dbname C:使用mysql命令 mysql -u username -p -D dbname 一、启动与退出...
  • 服务器的位置= /服务器服务器取决于 , 和请确保在继续安装之前安装了这些文件。 太好了,您已经准备好继续前进; 惊人的! 让我们从在终端中运行命令开始,称为命令行界面(CLI) 安装项目相关性 # npm i 全局...
  • http协议

    2019-09-23 16:38:48
    http是一个面向事务的应用层协议。 http规定http客户和服务器之间的每次交互都由一个ASCII码串和一个类似通用英特尔邮件扩充。 访问一个网站: ... 1.浏览器分析URL ...4.发出文件提取命令xxx.ht...
  • 4.3.7 改变指定文件访问时间和修改时间的命令touch 95 4.3.8 在文件或目录之间创建链接的命令ln 96 4.3.9 显示文件类型的命令file 98 4.3.10 拷贝文件或目录的命令cp 98 4.3.11 在指定的路径下查找指定文件命令...
  • 入门学习Linux常用必会60个命令实例详解doc/txt

    千次下载 热门讨论 2011-06-09 00:08:45
    -p,--preserve-timestamps:以<来源>文件访问/修改时间作为相应的目的地文件的时间属性。 -s,--strip:用strip命令删除symbol table,只适用于第一及第二种使用格式。 -S,--suffix=后缀:自行指定...
  • API服务器地址http://localhost:17693/api/food 在本地新建一个HTML,采用jQuery Ajax获取跨域获取数据,结果如下: 配置ASP.NET Web API允许跨域访问 API所在项目使用NuGet安装Microsoft.AspNet.WebApi.Cors,...
  • Oracle 7月更新中,修复了Weblogic Web Service Test Page中一处任意文件上传漏洞,Weblogic管理端未授权的两个页面存在任意上传jsp文件漏洞,进而获取服务器权限。 影响范围 10.3.6.0, 12.1.3.0, 12.2.1.2, 12.2....
  • ②、封装 MsScript.ocx 组件的 IScriptControl 接口的缘由及难度性:调用JS文件中某个对象的函数; ③、使用封转好的 MSJsMgr 库的准备工作; ④、开始使用 MSJsMgr 库; ⑤、实现字符串的MD5加密; ⑥、小作业...
  • HTTP:主要用于基于Web的文件下载以及访问Web服务,一般客户端无需登录就可以访问服务器上的文件和服务。大部分HTTP文件传输请求都用于获取网页(将网页文件下载到本地) scp和rsync需要用户登录到服务器主机 文件...
  • Nginx指北

    2020-05-19 16:45:35
    Nginx指北 文章目录Nginx指北@[toc]1. Nginx简介1.1 反向代理1.2 负载均衡1.3动静分离2 Nginx常用命令3 Nginx...反向代理:浏览器访问反向代理服务器,反向代理服务器向真实服务器获取数据并返回。 优点:只暴露代
  • iframe父子页面之间传值需要在服务器下进行(因为一些浏览器不支持file://协议的页面跨框架获取)。 那么如何把本地文件变成http请求获取呢? 1.首先全局安装:serve: npm install -g serve 2.找到你想用http请求...
  • 修复Tomcat样例目录session操纵漏洞

    千次阅读 2018-08-31 11:21:36
    攻击人员通过目录便利攻击可以获取系统文件服务器的配置文件等等。一般来说,他们利用服务器API、文件标准权限进行攻击。严格来说,目录遍历攻击并不是一种web漏洞,而是网站设计人员的设计“漏洞”。如果web设计...
  • 目录遍历攻击及防护

    万次阅读 2018-01-08 17:00:49
    目录遍历攻击及如何防护 描述 攻击人员通过目录便利...如果web设计者设计的web内容没有恰当的访问控制,允许http遍历,攻击者就可以访问受限的目录,并可以在web根目录以外执行命令。 攻击方法 攻击者通

空空如也

空空如也

1 2 3 4 5 ... 17
收藏数 329
精华内容 131
关键字:

命令访问http服务器获取文件