JavaSE基础十八：异常（异常机制概述、结构图解、异常处理、异常案例）、File类（概述、存储路径、常用方法）

最新推荐文章于 2024-03-02 10:00:00 发布
最新推荐文章于 2024-03-02 10:00:00 发布
阅读量209 收藏
点赞数
分类专栏： JavaSE基础 文章标签： Java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39870032/article/details/103055028
版权

本章目录

异常

1、异常机制概述

异常机制是指当程序出现错误时，程序处理错误的做法。

异常机制提供了程序发生异常时的安全退出通道，当程序发生异常时，程序的执行流程改变，程序将控制权转交给异常处理器，由异常处理器对异常进行安全处理。

2、异常的结构

在 Java 中，异常的顶级父类为 Throwable 类，它有两个子类实例 Error 和 Exception，通常用于指示发生了异常情况。

Error：错误，程序运行中发生的较严重的问题，程序无法处理，大多数与编程人员无关，而是计算机能力方面的问题。例如：内存溢出。这些错误不可察，因为它们在程序的控制和处理能力之外，绝大多数的程序运行时不允许出现这些情况。对于设计合理的程序来说，即使发生了 Error，本质上也不应该去处理由它引起的状况。

Exception：异常，指程序本身可以处理的异常，通常情况下，编程人员就可以使用某些手段对这类异常进行修改或避免这类异常的发生。它又分为编译期异常和运行期异常。

编译期异常：是从语法角度上讲必须要处理的异常，如果不处理，编译就无法通过。

运行期异常：译为 RuntimeException，这些异常一般是逻辑不当引发的异常，Java 编译器无法检查出来，即使不对其进行处理，编译也会通过。

3、异常结构图解

在这里插入图片描述

4、异常处理

抛出异常：当某处代码发生异常时，抛给代码所属的方法，由系统负责处理异常代码。

注意：

  • 父类的方法没有抛出异常，子类重写父类该方法时，也不能抛出异常。
  • 父类方法抛出异常，子类重写该方法时，可以不抛出异常。
  • 子类重写父类方法时，不能抛出父类没有抛出的异常。
  • 子类抛出的异常类型不能比父类大，只能比父类小或与父类相同。

格式：

public void method() throws 异常名{
    //方法体
}

捕捉异常：当某处代码发生异常时，编程人员对异常进行处理，程序运行至异常代码处时，执行编程人员写好的异常处理规则，不再由系统对异常进行处理。

捕捉异常需要使用 try-catch 或 try-catch-finally 语句块。当 try 中语句发生异常时，转而执行 catch 中的代码。finally 中的语句在异常处理的最后执行，通常用来释放资源。

格式 1：

try{
    //可能出现异常的代码
}catch(异常类型 对象名){
    //异常处理语句
}

格式 2：

try{
    //可能出现异常的代码
}catch(异常类型1 对象名){
    //异常处理语句
}catch(异常类型2 对象名){
    //异常处理语句
}catch(异常类型3 对象名){
    //异常处理语句
}
...

格式 3：

try{
    //可能出现异常的代码
}catch(异常类型1 | 异常类型2 | ... 对象名 ){
    //异常处理语句
}

格式 4：

try{
    //可能出现异常的代码
}catch(异常类型 对象名){
    //异常处理语句
}finally{
    //释放资源
}

对于错误、编译期异常、运行期异常，一般在 Java 中的处理方式不同。

  • 错误：对于程序运行时可能出现的 Error，一般不做任何处理，因为大多数的 Error 超出了程序处理的能力。
  • 编译期异常：对于所有编译期的异常，必须捕捉，或抛出方法之外。
  • 运行时异常：运行时异常将由程序运行时自动抛出。
5、异常案例
5.1、编译期异常

编译期发生异常时，我们既可以抛出异常给 JVM 处理，也可以手动捕获处理。

抛出异常：

public class Exception01 {
    public static void main(String[] args) throws ParseException {
        String s = "2020年12月15日";
        Date date = new SimpleDateFormat("yyyy-MM-dd").parse(s);
        System.out.println(date);
    }
}

捕捉异常：

public class Exception01 {
    public static void main(String[] args){
        String s = "2020年12月15日";
        Date date = null;
        try {
            date = new SimpleDateFormat("yyyy-MM-dd").parse(s);
        } catch (ParseException e) {
            System.out.println("日期格式有误，参照格式：yyyy-MM-dd");
        }
        System.out.println(date);
    }
}
5.2、运行期异常

运行时发生的异常，可以交由 JVM 处理，我们不做处理，但 JVM 处理的方式并不友好，它的处理方式为，终止运行程序，在控制台打印异常信息。

public class Exception02 {
    public static void main(String[] args) {
        int a = 10;
        int b = 0;
        //除数为 0，JVM 的处理方式为停止程序，打印异常的堆栈信息
        System.out.println(a / b);
    }
}

既然 JVM 的处理方式不友好，那么我们通常对运行时异常进行手动捕获处理。

public class Exception02 {
    public static void main(String[] args) {
        int a = 10;
        int b = 0;
        try {
            int c = a / b;
            System.out.println(c);
        }catch (ArithmeticException e){
            System.out.println("除数为 0 了");
        }
    }
}

捕获异常时，尽量明确异常的类型，当异常是平级关系时，catch 的先后无所谓。如果异常之间有继承关系，父类异常在最后的 catch 语句中。当捕捉到一处异常后，try 中异常后的语句不再执行。

public class Exception03 {
    public static void main(String[] args) {
        int a = 10;
        int b = 0;
        int[] arr = {1,20};
        try {
            System.out.println(arr[6]);			//数组角标越界
            System.out.println(a / b);			//不再捕捉此处异常
        }catch (ArithmeticException e){
            System.out.println("除数为 0 异常");
        }catch (ArrayIndexOutOfBoundsException e){
            System.out.println("数组角标越界异常");
        }catch (NullPointerException e){
            System.out.println("空指针异常");
        }catch (Exception e){
            System.out.println("其他异常");
        }
    }
}

public class Exception04 {
    public static void main(String[] args) {
        int a = 10;
        int b = 0;
        int[] arr = {1,20};
        try {
            System.out.println(arr[6]);
        }catch (ArithmeticException | ArrayIndexOutOfBoundsException e){
            if (e instanceof ArithmeticException){
                System.out.println("除数为 0 异常");
            }else if(e instanceof ArrayIndexOutOfBoundsException){
                System.out.println("数组角标越界异常");
            }else if (e instanceof NullPointerException){
                System.out.println("空指针异常");
            }
        }
    }
}

try-catch-finally 格式的使用：

public class Exception05 {
    public static void main(String[] args) {
        try {
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入整数：");
            int i = scanner.nextInt();
            System.out.println("你输入的整数是：" + i);
        } catch (InputMismatchException e) {
            System.out.println("输入数据类型错误！");
        } finally {
            scanner.close();
        }
    }
}

判断输入类型正确后再录入数据：

public class Exception06 {
    public static void main(String[] args) {
        while (true){
            Scanner scanner = new Scanner(System.in);
            System.out.println("请输入整数：");
            try {
                int i = scanner.nextInt();
                System.out.println(i);
                break;
            }catch (InputMismatchException e){
                System.out.print("输入类型有误，");
            }
        }
    }
}
5.3、throws 与 throw

throws：用在方法声明上，可以抛出一个或多个异常类型，多个异常中间用逗号隔开，它只表示发生某异常的可能性，在程序运行中并不一定会发生此异常。

throw：用在方法的内部，只能抛出一个异常，并且抛出的是一个具体的异常对象，一旦抛出，就说明程序一定发生了此异常。

public class Exception07 {
    public static void main(String[] args) {
        int a = 10;
        int b = 0;
        if (b == 0){
            throw new ArithmeticException();
        }else {
            System.out.println(a / b);
        }
    }
}
5.4、自定义异常

Java 中给出的异常种类很多，但有时并不能准确描述一个异常，所以 Java 给我们提供了自定义异常，让编程人员在开发中可以更准确的描述现实中发生的异常。

案例：考试成绩为：0 ~ 100，判断录入成绩是否合理。

在 Java 中不存在成绩不合理异常，所以我们需要自定义这个异常，自定义的方法很简单，编写一个类，让这个类继承 Exception 或 RuntimeException 即可。

自定义异常类：

public class IsRight extends RuntimeException{
    public IsRight(String message) {
        super(message);
    }
}

测试类：

public class Exception08 {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("请数入你的成绩（0~100）：");
        int i = scanner.nextInt();
        if (i >= 0 & i <= 100 ){
            System.out.println("你的成绩为："+i);
        }else {
            throw new IsRight("输入的成绩不合理。");
        }
    }
}

File 类

1、File 类概述

Java 中的 File 类是 java.io 包中唯一代表磁盘文件的对象，通过 File 类，可以实现对文件和目录的有关操作。

File 类中定义了一些获取和处理文件信息的方法，例如：新建、删除、重命名文件和目录等，但 File 类不具有操作文件内容的方法，例如：读取文件信息和向文件写入信息。

所以，File 类仅仅描述文件本身的属性。

2、文件存储路径

在计算机中，每一个文件都有存储的位置，称为存储路径。只有在正确的路径下，才能访问到需要的文件。

文件的存储路径分为：绝对路径、相对路径。

绝对路径：完整描述文件位置的路径，例如：E:/BaiduNetdiskDownload/a.txt

相对路径：相对于某文件位置的路径，例如：/a.txt，表示当前目录下的 a.txt 文件。

另外，使用../来表示上一级目录，../../表示上上级目录，以此类推。

3、File 类常用方法
3.1、构造方法
//根据指定路径名字符串来创建一个 File 实例。
File(String pathname)
//根据 parent 文件路径和 child 文件名创建一个 File 实例。
File(File parent, String child) 
//根据 parent 路径名和 child 文件名创建一个 File 实例。       
File(String parent, String child)
3.2、封装功能

封装功能就是将一个路径封装成一个 File 文件，通常使用构造方法对路径进行封装。

public class File01 {
    public static void main(String[] args) {
        //绝对路径封装文件 File(String pathname)
        File file = new File("E:\\BaiduNetdiskDownload\\a.txt");

        //相对路径封装文件，表示该目录下的 test.txt 文件
        File file1 = new File("test.txt");

        //父路径名和子文件名封装文件 File(String parent, String child)
        File file2 = new File("E:\\BaiduNetdiskDownload\\", "a.txt");

        //根据父文件路径和子文件名封装文件 File(File parent, String child) 
        File file3 = new File("E:\\BaiduNetdiskDownload");
        File file4 = new File(file3, "a.txt");
        
    }
}
3.3、创建功能
方法作用
createNewFile()当不存在此路径名指定的文件时，创建一个新的空文件
mkdir()创建此路径名指定的单级目录
mkdirs()创建此路径名指定的所有目录
public class File02 {
    public static void main(String[] args) {
        //如果该文件不存在，创建该文件，返回 true
		//如果文件已存在，不重复创建，返回 false
        File file = new File("E:\\BaiduNetdiskDownload\\b.txt");
        try {
            boolean newFile = file.createNewFile();
            System.out.println(newFile);
        } catch (IOException e) {
            e.printStackTrace();
        }

        //创建单级目录
        File file1 = new File("E:\\BaiduNetdiskDownload\\testDir1");
        boolean mkdir = file1.mkdir();
        System.out.println(mkdir);

        //创建多级目录
        File file2 = new File("E:\\BaiduNetdiskDownload\\testDir1\\testDir1-1\\testDir1-1-1");
        boolean mkdirs = file2.mkdirs();
        System.out.println(mkdirs);
    }
}
3.4、删除/重命名或剪切重命名
方法作用
delete()删除路径表示的文件或目录
renameTo(File dest)重命名文件或剪切后再重命名文件

delete() 方法删除文件时，为永久删除，返回值表示是否删除成功，被删除的文件无法在回收站找到，同时，它只能删除单级目录，不能删除多级目录，要想删除多级目录，需要使用递归。

public class File03 {
    public static void main(String[] args) {

        //永久删除文件
        File file = new File("E:\\BaiduNetdiskDownload\\a.txt");
        boolean delete = file.delete();
        System.out.println(delete);

        //删除单机目录
        File file1 = new File("E:\\BaiduNetdiskDownload\\testDir2");
        try {
            boolean newFile = file1.createNewFile();
        } catch (IOException e) {
            e.printStackTrace();
        }
        boolean delete1 = file1.delete();
        System.out.println(delete1);

        //删除多级目录，testDir1下有testDir1-1，testDir1-1下有testDir1-1-1
        File file2 = new File("E:\\BaiduNetdiskDownload\\testDir1");
        boolean delete2 = file2.delete();
        System.out.println(delete2);
    }
}

renameTo(File dest) 方法有两个作用：重命名、剪切重命名。

重命名：当传入的新文件路径和旧文件的路径一致，只是文件名不同，就会将文件重命名。

剪切：如果传入的新文件路径和旧文件路径不一致，并且文件名不同，就会剪切旧文件至新文件路径并重命名。

public class File04 {
    public static void main(String[] args) {
        //重命名
        File file = new File("E:\\BaiduNetdiskDownload\\b.txt");
        File file1 = new File("E:\\BaiduNetdiskDownload\\c.txt");
        boolean b = file.renameTo(file1);
        System.out.println(b);

        //剪切并重命名
        File file2 = new File("E:\\BaiduNetdiskDownload\\c.txt");
        File file3 = new File("E:\\BaiduNetdiskDownload\\testDir1\\d.txt");
        boolean b1 = file2.renameTo(file3);
        System.out.println(b1);

    }
}
3.5、判断功能
方法作用
isFile()判断路径名表示的是否为一个文件
isDirectory()判断路径名表示的文件是否为一个目录
isHidden()判断路径名表示的是否为一个隐藏文件
isAbsolute()判断路径名是否是绝对路径
canRead()判断路径表示的文件是否可读
canWrite()判断路径表示的文件是否可写
canExecute()判断路径表示的文件是否可执行
exists()判断路径表示的文件是否存在
public class File05 {
    public static void main(String[] args) {
        File file = new File("E:\\BaiduNetdiskDownload\\testDir1\\d.txt");
        //判断路径名表示的是否为一个文件
        boolean b = file.isFile();
        System.out.println(b);

        //判断路径名表示的文件是否为一个目录
        boolean b1 = file.isDirectory();
        System.out.println(b1);

        //判断路径名表示的是否为一个隐藏文件
        boolean b2 = file.isHidden();
        System.out.println(b2);

        //判断路径名是否是绝对路径
        boolean b3 = file.isAbsolute();
        System.out.println(b3);

        //判断路径表示的文件是否可读
        boolean b4 = file.canRead();
        System.out.println(b4);

        //判断路径表示的文件是否可写
        boolean b5 = file.canWrite();
        System.out.println(b5);

        //判断路径表示的文件是否可执行
        boolean b6 = file.canExecute();
        System.out.println(b6);

        //判断路径表示的文件是否存在
        boolean b7 = file.exists();
        System.out.println(b7);
    }
}
3.6、获取功能
方法作用
long length()获取文件的字节数
String getName()获取文件名称
String getParent()以字符串形式获取文件的父路径
File getParentFile()获取当前文件的父文件
String getAbsolutePath()以字符串形式获取文件的绝对路径
File getAbsoluteFile()获取绝对路径并封装成文件
String getPath()以字符串形式获取文件的相对路径
long getTotalSpace()获取磁盘总大小，单位为：字节
long getFreeSpace()获取磁盘剩余大小，单位为：字节
long lastModified()获取文件最后一次的修改时间，是一个毫秒值
String[] list()获取指定路径下所有文件和目录的名称
File[] listFiles()获取指定路径下所有文件和目录
public class File06 {
    public static void main(String[] args) {
        File file = new File("E:\\BaiduNetdiskDownload\\testDir1\\d.txt");
        File file1 = new File("D:\\");
        //获取文件的字节数
        long length = file.length();
        System.out.println(length);

        //获取文件名称
        String name = file.getName();
        System.out.println(name);

        //以字符串形式获取文件的父路径
        String parent = file.getParent();
        System.out.println(parent);

        //获取当前文件的父文件
        File parentFile = file.getParentFile();
        System.out.println(parentFile.toString());

        //以字符串形式获取文件的绝对路径
        String absolutePath = file.getAbsolutePath();
        System.out.println(absolutePath);

        //获取绝对路径并封装成文件
        File absoluteFile = file.getAbsoluteFile();
        System.out.println(absoluteFile.toString());

        //以字符串形式获取文件的相对路径
        String path = file.getPath();
        System.out.println(path);

        //获取磁盘总大小，单位为：字节
        long totalSpace = file1.getTotalSpace();
        System.out.println(totalSpace);

        //获取磁盘剩余大小，单位为：字节
        long freeSpace = file1.getFreeSpace();
        System.out.println(freeSpace);

        //获取文件最后一次的修改时间，是一个毫秒值
        long l = file.lastModified();
        Date date = new Date(l);
        String format = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(date);
        System.out.println(format);

        //获取指定路径下所有文件和目录的名称
        String[] list = file1.list();
        System.out.println(Arrays.toString(list));

        //获取指定路径下所有文件和目录
        File[] files = file1.listFiles();
        System.out.println(Arrays.toString(files));

    }
}
3.7、过滤功能

过滤方法其实是获取指定路径下所有文件和目录方法的重载，参数需要传递一个过滤器，常常采用匿名类的方式传递参数，跟据过滤器的返回值来决定要不要将文件或目录加入返回的 file 数组。返回值为 true 将文件或目录添加进返回数组，false 则为不添加。

方法功能
File[] listFiles(FilenameFilter filter)使用名称过滤器过滤出需要返回的文件或目录
File[] listFiles(FileFilter filter)使用文件过滤器过滤出需要返回的文件或目录
public class File07 {
    public static void main(String[] args) {
        File file = new File("E:\\BaiduNetdiskDownload");

        //使用名称过滤器过滤出想要的文件
        File[] files = file.listFiles(new FilenameFilter() {
            @Override
            public boolean accept(File dir, String name) {
                //dir 是父文件，name 是子文件名
                File file1 = new File(dir, name);
                if (file1.isFile() & file1.getName().endsWith(".txt")) {
                    return true;
                } else {
                    return false;
                }
            }
        });
        System.out.println(Arrays.toString(files));

        //使用文件过滤器过滤出想要的文件
        File[] files1 = file.listFiles(new FileFilter() {
            @Override
            public boolean accept(File pathname) {
                if (pathname.isFile() & pathname.getName().endsWith(".txt")) {
                    return true;
                } else {
                    return false;
                }
            }
        });
        System.out.println(Arrays.toString(files1));

    }
}
3.8、递归删除指定类型文件

需求：删除指定目录中.txt类型的所有文件。

public class File08 {
    public static void main(String[] args) {
        File file = new File("E:\\BaiduNetdiskDownload");
        forDelete(file);
    }

    public static void forDelete(File file){
        //获取出传递过来的所有文件
        File[] files = file.listFiles();
        //遍历文件
        for (File file1 : files) {
            //如果遍历出的是以 .txt 结尾的文件，直接删除
            if (file1.isFile() & file1.getName().endsWith(".txt")){
                file1.delete();
            }else {
                //遍历出的是目录，递归调用这个方法再去处理目录
                forDelete(file1);
            }
        }
    }

}

夜色太沉，我只用一个手势吧，就如同你曾轻轻地招手，我便押上了自己的一生.

各位看官，本章结束，我们下篇见 (∩_∩)~~

                                                                                                                                                                                        -Czx.

遗憾无人似你
关注
专栏目录
Nginx控制前端静态资源不缓存
甘蓝的专栏
09-18 5597
背景 项目中使用Nginx代理前端代码，每次前端代码修改完成后，浏览器有时候并不会生效。 原因是很多浏览器做了缓存，导致没有使用最新的前端代码。 解决 通过HTTP Header中的Cache-control字段（no-cache）来控制是否开启缓存。 相关可选项如下： no-cache：客户端可以缓存，但是每次使用缓存资源都必须发请求验证其有效性。如果没有变化返回304，如果发生变化，那理论上就是200。 no-store：禁止缓存，不使用任何缓存 修改前的配置： # 原有静态资源配置
Java SE程序 自定义异常类
01-21
Java SE程序 自定义异常类Java SE程序 自定义异常类Java SE程序 自定义异常类Java SE程序 自定义异常类Java SE程序 自定义异常类Java SE程序 自定义异常类Java SE程序 自定义异常类Java SE程序 自定义异常类Java SE...
nginx配置前端不缓存
kuku123465的博客
01-13 6357
nginx配置客户端不缓存html文件，前端升级后，用户无需清理缓存
下载权限控制机制(转)
weixin_30530339的博客
02-17 264
下载权限控制机制 要对下载的权限进行精确的控制（防止盗链，防止迅雷吸血，下载扣除积分等虚拟货币），以前接触的方法有几种：1、通过rewrite不断地更改下载文件的url，并插入很多无意义的字符；2、验证下载链接的来路，或者cookie；3、通过服务器端程序（例如一个php文件），open文件，读取内容然后返回给客户端。 第一种方法很笨，而且吃力不讨好；第二种方法很容易破解，因为ref...
Nginx禁用缓存
qq_42892856的博客
07-12 1195
如果是针对某个域名zlXXX.cc;编辑config文件。
linux nginx 大文件超过2G自动下载中断，报错信息：sendfile() failed (112: Value too large for defined data type)
weixin_43744523的博客
09-21 2863
linux nginx 大文件下载失败 sendfile() failed (112: Value too large for defined data type) while sending response to client, client:
JavaSE异常与多线程
06-04
入门级笔记，适合查漏补缺。
javase基础（数俎常用类异常集合i0流lambda多线程网络编程反射注解）
01-19
数俎 常用类 异常 集合 i0流 lambda 多线程 网络编程 反射 注解
nginx中缓存问题
码农界的小学生
03-30 1107
场景： 开始部署一个项目把nginx作为反向代理，配置了代理路径。之后我换了一个项目，用的同一个nginx，发现配置nginx.conf中改了之后，无论怎么重启nginx，甚至电脑都重启了，但是访问localhost时候，还是会跳到上一个项目的代理路径，奇怪，难道nginx也有缓存？！最后，经过查阅资料，好吧，还真有。 解决： 打开nginx.conf文件，里面找到 sendfile ，默...
Nginx自动缓存文件的问题
buyue
09-03 2764
修改了css文件，多次刷新浏览器，浏览器查看源代码发现css文件内容还是没有改变。 更改nginx.conf配置文件，将sendfile参数设置为off（它默认是on） 执行 service nginx reload 扩展 https://segmentfault.com/q/1010000003055006/a-1020000003064578 http:/
nginx 配置浏览器不缓存文件 每次都会从服务器 请求新的文件
最新发布
2301_79996063的博客
03-02 4170
修改之前 需要全局刷新，才会重新请求index.js 文件修改之后，不用全局刷新 ，就可以重新请求到最新的 index.js。
前端用nginx部署时，用户访问页面有缓存，如何设置禁用缓存
qq_46940224的博客
11-13 2817
前端用nginx部署时，用户访问页面有缓存，如何设置禁用缓存
Nginx 禁用静态文件缓存
春风化雨
02-05 2067
指令用于设置响应头中的 Cache-Control 字段，指定了多个缓存控制指令，如 "no-store"、"no-cache"、"must-revalidate"、"proxy-revalidate" 和 "max-age=0"。这些指令的组合将确保浏览器和代理服务器不会缓存静态文件。配置完成后，重新加载 Nginx 配置文件，使配置生效。这样，Nginx 将完全禁用缓存静态文件，每次请求都会直接从后端服务器获取最新的文件。请注意，禁用缓存可能会导致性能下降，因为每次请求都需要从后端服务器获取文件。
nginx如何让缓存不生效
weixin_43472847的博客
08-01 293
这句的作用是在转发的请求中添加这个header，告诉浏览器，路由器等缓存服务器不要缓存响应；#这句作用是nginx本身不开启缓存文件的功能。
nginx禁用移动端页面html缓存的配置
weixin_44953227的博客
08-08 1512
移动端部署更新到Nginx后， 客户端如果之前已经下载过一次html文件， 那么如果客户端访问时， 移动端的html等代码文件并不会刷新， 需要用户强行退出客户端， 重新扫码登录或验证码登录之后， 再次访问移动端， 才有可能加载最新的静态文件。而这种让用户强行退出再次登录的方法，有时还不一定行。为此， 就把移动端访问的静态文件的Html缓存禁用， 用户每次进来刷新页面的时候都不从浏览器缓存加载文件， 而是从服务器中请求。...
nginx缓存关闭
热门推荐
jialiu111111的博客
09-05 1万+
NGINX 缓存默认是不开启的，也就是说，NGINX 作为反向代理服务器时，会将所有的客户端请求直接打到服务端。如果想使用 NGINX 缓存，可以通过 proxy_cache_path 配置项进行设置。2.上面那个设置之后还是有缓存，后来来了个最直接的方法。#禁止缓存，每次都从服务器请求。1.nginx怎么关闭缓存。
nginx proxy_cache 缓存不住
linux_map的博客
06-02 1204
最近在使用proxy_cache的时候发现一个缓存不住的问题，比较隐蔽，现在抛出来，看看大家有遇到相同的情况没。响应头中包含Expires 和 Cache-Control两个头，但是Expires是一个过期的时间(比当前时间小)。RFC中规定 cache-control：max-age的优先级高于Expires，看起来没有问题，理论上没有问题，但是nginx处理这块的代码有点问题。会导致资源不缓存。
JavaSE方法详解：类与对象、重写与重载、异常处理及ArrayList操作
在Java SE（标准版）编程中，掌握核心的类和对象概念、方法的运用以及异常处理是至关重要的。本文档主要汇总了一些关于Java SE的基本知识点，包括数据工具类的使用、类与对象的关系、方法重写与重载的区别，以及...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值