day10-配置文件日志多线程

news2024/11/25 4:23:28

一、配置文件

1.1 properties配置文件

properties配置文件
特点:
 1、都只能是键值对
 2、键不能重复
 3、文件后缀一般是.properties结尾的
​
Properties
 这是一个Map集合（键值对集合），但是我们一般不会当集合使用
 主要用来代表属性文件，通过Properties可以读写属性文件里的内容
构造器说明
public Properties()用于构建Properties集合对象（空容器）

使用Properties读取属性文件里的键值对数据

读取：磁盘---->内存

常用方法说明
public void load(InputStream is)通过字节输入流，读取属性文件里的键值对数据
public void load(Reader reader)通过字符输入流，读取属性文件里的键值对数据
public String getProperty(String key)根据键获取值(其实就是get方法的效果)
public Set<String> stringPropertyNames()获取全部键的集合（其实就是ketSet方法的效果）
public static void main(String[] args) throws IOException {
        //1. 创建一个配置文件对象
        Properties properties = new Properties();
        //2. 读取
        properties.load(new FileInputStream("day10-code\\xml\\user.properties"));
//        String value = properties.getProperty("admin");
//        System.out.println("admin = " + value);
//        String lisi = properties.getProperty("lisi","000000");
//        System.out.println("lisi = " + lisi);
        Set<String> keySet = properties.stringPropertyNames();
        for (String key : keySet) {
            String value = properties.getProperty(key);
            System.out.println(key + " = " + value);
        }
​
}

使用Properties把键值对数据写出到属性文件里去

写入：内存---->磁盘

常用方法说明
public Object setProperty(String key, String value)保存键值对数据到Properties对象中去。
public void store(OutputStream os, String comments)把键值对数据，通过字节输出流写出到属性文件里去
public void store(Writer w, String comments)把键值对数据，通过字符输出流写出到属性文件里去
public static void main(String[] args) throws IOException {
        // 写出
        Properties pro2 = new Properties();
        pro2.setProperty("zhu", "猪小贱");
        pro2.setProperty("lin","哼哼猪");
        pro2.setProperty("pang","羊习习");
        pro2.store(new FileOutputStream("day10-code\\xml\\user2.properties"),null);
}

总结

Properties的作用？具体如何使用？

1.可以加载属性文件中的数据到Properties对象中来

void load(Reader reader)

public String getProperty(String key) 根据键获取值

2.可以存储Properties属性集的键值对数据到属性文件中去

void store(Writer writer, String comments) 设置键值

public Object setProperty(String key, String value)

1.2 XML配置文件

XML
 全称 Extensible Markup Language， 可扩展标记语言
 本质是一种数据的格式，可以用来存储复杂的数据结构，和数据关系。
​
特点
 XML中的“<标签名>” 称为一个标签或一个元素，一般是成对出现的。
 XML中的标签名可以自己定义（可扩展），但必须要正确的嵌套。
 XML中只能有一个根标签。
 XML中的标签可以有属性。
 如果一个文件中放置的是XML格式的数据，这个文件就是XML文件，后缀一般要写成.xml。
​
语法
 XML文件的后缀名为：xml，文档声明必须是第一行
 XML中可以定义注释信息：<!–- 注释内容 -->，快捷键是Ctrl+shift+/
 XML中书写”<”、“&”等，可能会出现冲突，导致报错，此时可以用如下特殊字符替代。
 XML中可以写一个叫CDATA的数据区: <![CDATA[   …内容…  ]]>，里面的内容可以随便写。
​
XML的作用和应用场景
    作用：1）作为软件的配置文件   2）用于进行存储数据和传输数据
 经常用来做为系统的配置文件
 或者作为一种特殊的数据结构，在网络中进行传输。

 

 

1.2.1 Dom4j解析XML得到Document对象

SAXReader：Dom4j提供的解析器，可以认为是代表整个Dom4j框架

构造器/方法说明
public SAXReader()构建Dom4J的解析器对象
public Document read(String path)把XML文件读成Document对象

Document

方法名说明
Element getRootElement()获得根元素对象

Element提供的方法

方法名说明
public String getName()得到元素名字
public List<Element> elements()得到当前元素下所有子元素
public List<Element> elements(String name)得到当前元素下指定名字的子元素返回集合
public Element element(String name)得到当前元素下指定名字的子元素,如果有很多名字相同的返回第一个
public String attributeValue(String name)通过属性名直接得到属性值
public String elementText(子元素名)得到指定名称的子元素的文本
public String getText()得到文本
XML解析案例

需求：

利用Dom4J框架，将contacts.xml文件中的联系人数据，解析出来，封装成List集合，并遍历输出。

 

public class Demo2 {
    public static void main(String[] args) throws FileNotFoundException, DocumentException {
        List<User> userList = new ArrayList();
        //2.创建DOM4]解析器对象SAXReader，获取Document文档对象，获取根标签对象
        SAXReader saxReader = new SAXReader();
        //读取XML文件，读取到内存
        Document document = saxReader.read(new FileReader("day10-code/user.xml"));
        //3.从根标签对象开始往下层层解析
        //3.1 获取根标签的名字
        Element rootElement = document.getRootElement();
        String name = rootElement.getName();
        System.out.println("根标签的名字:" + name);
        //3.2 获取根标签下的所有子标签
        List<Element> elements = rootElement.elements();
        System.out.println("根标签下的所有子标签个数:" + elements.size());
        //3.3 遍历标签的集合
        for (Element element : elements) {
            System.out.println("==========================");
            String id = element.attributeValue("id");
            String elementName = element.getName();
            System.out.println("子标签的名字:" + elementName + "-" + id);
            String userName = element.element("name").getText();
            System.out.println("子标签下的name标签的文本:name=" + userName);
            String userPassword = element.element("password").getText();
            System.out.println("子标签下的password标签的文本:password=" + userPassword);
            String userAddress = element.element("address").getText();
            System.out.println("子标签下的address标签的文本:address=" + userAddress);
            String userGender = element.element("gender").getText();
            System.out.println("子标签下的gender标签的文本:gender=" + userGender);
            //3.4 封装对象到一个List<User对象的集合>
            userList.add(new User(userName, userGender, userAddress, userPassword));
        }
        System.out.println("==========================");
        System.out.println(userList);
​
​
​
    }
}
class User{
    private String name;
    private String gender;
    private String address;
    private String password;
​
    public User() {
    }
​
    public User(String name, String gender, String address, String password) {
        this.name = name;
        this.gender = gender;
        this.address = address;
        this.password = password;
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public String getGender() {
        return gender;
    }
​
    public void setGender(String gender) {
        this.gender = gender;
    }
​
    public String getAddress() {
        return address;
    }
​
    public void setAddress(String address) {
        this.address = address;
    }
​
    public String getPassword() {
        return password;
    }
​
    public void setPassword(String password) {
        this.password = password;
    }
​
    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", gender='" + gender + '\'' +
                ", address='" + address + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

二、日志

1、什么是日志？

用来记录程序运行过程中的信息，并可以进行永久存储。

2、常见的日志实现框架有哪些？

Log4J、Logback(我们重点学习的，其他的都大同小异)

Logback是基于slf4j日志接口实现的日志框架

3、使用Logback至少需要使用哪几个模块？

slf4j-api：日志接口

logback-core：基础模块

logback-classic：功能模块，它完整实现了slf4j API

2.1 Logback

需求
    使用Logback日志框架，纪录系统的运行信息。
实现步骤
    1. 导入Logback框架到项目中去。
    2. 将Logback框架的核心配置文件logback.xml直接拷贝到src目录下（必须是src下）。
    4. 创建Logback框架提供的Logger对象，然后用Logger对象调用其提供的方法就可以记录系统的日志信息。
        public static final Logger LOGGER = LoggerFactory.getLogger("当前类类名");
    5. 打印日志
        LOGGER.info("日志信息")//给重要的信息打日志
        LOGGER.debug("日志信息")//给调试信息打日志
        LOGGER.error("日志信息")//try-catch中给错误信息打日志
public class Demo1 {
    public static final Logger LOGGER = LoggerFactory.getLogger("Demo1");
​
    public static void main(String[] args) {
        LOGGER.info("开始执行div方法");
        div(2,2);
        div(2,0);
    }
    public static int div(int a,int b){
        LOGGER.debug("方法执行了,a="+ a + ",b="+b);
        LOGGER.debug("方法执行了，a={},b={}",a,b);
        LOGGER.warn("除数不能为0");
        try {
            int c = a/b;
            return c;
        }catch (Exception e){
            LOGGER.error("方法执行出错了，出错信息是{}/{}",a,b);
            e.printStackTrace();
            throw new RuntimeException("出错了");
        }
​
    }
}

 

2.2 日志级别

1、设置日志输出级别的作用是什么？

用于控制系统中哪些日志级别是可以输出的

2、Logback的日志级别是什么样的？

ALL 和 OFF分别是打开全部日志和关闭全部日志

级别程度依次是：TRACE< DEBUG< INFO<WARN<ERROR

默认级别是debug（忽略大小写），只输出当前级别及高于该级别的日志

三、多线程

线程
    简单的说，就是计算机在做一件事
​
单线程
    在计算机中同一时间只能做一件事
​
多线程
    在计算机中同一时间可以做多件事
    它的主要好处有：1. 减少队列阻塞带来的影响   2. 提高CPU的利用率

3.1 多线程的创建方式一：继承Thread类

线程的创建方式一：继承Thread类
    1. 定义一个子类继承线程类java.lang.Thread，重写run()方法
    2. 创建子类的对象
    3. 调用子类对象的start()方法启动线程（底层会自动去执行run方法）

优缺点
    优点：编码简单
    缺点：线程类已经继承Thread，无法继承其他类，不利于功能的扩展。

注意事项
    1、启动线程必须是调用start方法,不是调用run方法。
    2、直接调用run方法会当成普通方法执行，只有调用start方法才是启动一个新的线程执行。
    3、不要将主线任务放在start方法之前，这样主线程一直是先跑完的，相当于是一个单线程的效果了。

扩展
    对于单核cpu来讲, 多线程是一种假象

public class Demo1 {
    public static final Logger LOGGER = LoggerFactory.getLogger("Demo1");
    public static void main(String[] args) {
        //需求：创建两个线程，分别用于打印10个A和10个B，最后观察下输出顺序
        // 2. 创建子类的对象
        AThread aThread = new AThread();
        BThread bThread = new BThread();
        // 3. 调用子类对象的start()方法启动线程（底层会自动去执行run方法）
        LOGGER.info("开始执行");
        aThread.start();
        bThread.start();
        // 4. 将耗时多的主线程放在子线程后再执行(主线程和主线程会一起交替运行)
        for (int i = 0; i < 100; i++) {
            System.out.println("main-" + i);
        }
    }
}

// 1. 定义一个子类继承线程类java.lang.Thread，重写run()方法
class AThread extends Thread{
    public static final Logger LOGGER = LoggerFactory.getLogger("AThread");
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            LOGGER.info("A-" + i);
        }
    }
}
class BThread extends Thread{
    public static final Logger LOGGER = LoggerFactory.getLogger("BThread");
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            LOGGER.info("B-" + i);
        }
    }
}

 3.2 多线程的创建方式二：实现Runnable接口

多线程的创建方式二：实现Runnable接口
    1. 定义一个线程任务类实现Runnable接口，重写run()方法
    2. 创建任务类对象
    3. 把任务类对象交给Thread处理
     public Thread(Runnable target)
    4. 调用线程对象的start()方法启动线程

优缺点
 优点：任务类只是实现接口，可以继续继承其他类、实现其他接口，扩展性强。
 缺点：需要多一个Runnable对象。

public class Demo1 {
    public static void main(String[] args) {
        //需求：创建两个线程，分别用于打印10个A和10个B，最后观察下输出顺序

        //2. 创建任务类对象
        ARunnable aRunnable = new ARunnable();
        BRunnable bRunnable = new BRunnable();
        //3. 把任务类对象交给Thread处理
        Thread thread1 = new Thread(aRunnable);
        Thread thread2 = new Thread(bRunnable);
        //4. 调用线程对象的start()方法启动线程
        thread1.start();
        thread2.start();
    }
}
class ARunnable implements Runnable{
    public static final Logger LOGGER = LoggerFactory.getLogger("ARunnable");
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            LOGGER.info("A-" + i);
        }
    }
}
class BRunnable implements Runnable{
    public static final Logger LOGGER = LoggerFactory.getLogger("BRunnable");
    @Override
    public void run() {
        for (int i = 0; i < 10; i++) {
            LOGGER.info("B-" + i);
        }
    }
}

3.3 多线程的创建方式三：实现Callable接口

多线程的创建方式三：实现Callable接口
    1. 创建任务对象
     定义一个类实现Callable接口，重写call方法，封装要做的事情，和要返回的数据
     把Callable类型的对象封装成FutureTask（线程任务对象）
         public FutureTask<>(Callable call) 把Callable对象封装成FutureTask对象
         public V get() throws Exception    获取线程执行call方法返回的结果
    2. 把线程任务对象交给Thread对象。
    3. 调用Thread对象的start方法启动线程。
    4. 线程执行完毕后、通过FutureTask对象的的get方法去获取线程任务执行的结果

优缺点
 优点：线程任务类只是实现接口，可以继续继承类和实现接口，扩展性强；可以在线程执行完毕后去获取线程执行的结果
 缺点：编码复杂一点。

FutureTask的API

FutureTask提供的构造器说明
public FutureTask<>(Callable call)把Callable对象封装成FutureTask对象。
FutureTask提供的方法说明
public V get() throws Exception获取线程执行call方法返回的结果。
public class Demo1 {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        //需求：启动两个子线程，分别计算100之内的奇数的和和偶数的和，然后在主线程中再做个汇总，得到总和

        // 创建Callable的对象
        OddTask oddTask = new OddTask();
        EvenTask evenTask = new EvenTask();
        // 创建FutureTask的对象
        FutureTask<Integer> oddFutureTask = new FutureTask<>(oddTask);
        FutureTask<Integer> evenFutureTask = new FutureTask<>(evenTask);
        // 把FutureTask对象交给Thread对象
        //创建线程对象
        Thread oddThread = new Thread(oddFutureTask);
        Thread evenThread = new Thread(evenFutureTask);
        //调用线程的start方法
        oddThread.start();
        evenThread.start();
        // 获取线程执行call方法返回的结果
        Integer oddSum = oddFutureTask.get();
        Integer evenSum = evenFutureTask.get();
        // 在主线程中再做个汇总，得到总和
        System.out.println("奇数的和为："+oddSum);
        System.out.println("偶数的和为："+evenSum);
        System.out.println("总和为："+(oddSum+evenSum));


    }
}
//计算100之内的奇数的和，并返回
class OddTask implements Callable<Integer>{// 泛型，表示返回的结果类型

    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 1; i <= 100; i+=2) {
            sum += i;
        }
        return sum;
    }
}
//计算100之内的偶数的和，并返回
class EvenTask implements Callable<Integer>{

    @Override
    public Integer call() throws Exception {
        int sum = 0;
        for (int i = 0; i <= 100; i+=2) {
            sum += i;
        }
        return sum;
    }
}

三种线程的创建方式对比

方式优点缺点
继承Thread类编程比较简单，可以直接使用Thread类中的方法扩展性较差，不能再继承其他的类，不能返回线程执行的结果
实现Runnable接口扩展性强，实现该接口的同时还可以继承其他的类。编程相对复杂，不能返回线程执行的结果
实现Callable接口扩展性强，实现该接口的同时还可以继承其他的类。可以得到线程执行的结果编程相对复杂

3.4 Thread类的方法

Thread提供的常用方法说明
public void run()线程的任务方法
public void start()启动线程
public String getName()获取当前线程的名称，线程名称默认是Thread-索引
public void setName(String name)为线程设置名称
public static Thread currentThread()获取当前执行的线程对象
public static void sleep(long time)让当前执行的线程休眠多少毫秒后，再继续执行
public final void join()...让调用当前这个方法的线程先执行完！
Thread提供的常见构造器说明
public Thread(String name)可以为当前线程指定名称
public Thread(Runnable target)封装Runnable对象成为线程对象
public Thread(Runnable target, String name)封装Runnable对象成为线程对象，并指定线程名称
public class Demo1 {

    //需求: 通过下面任务，我们来学习sleep和join方法
    //1. 创建A、B两个线程类，分别打印1~5
    //2. 在主线程序中创建A、B两个子线程
    //3. 在主线程序中开启A、B两个子线程
    //4. 让A线程每打印一次，都要暂停3秒钟
    //5. B线程要等A线程打印完毕，再开始打印
    public static void main(String[] args) throws InterruptedException {
        
        //2. 在主线程序中创建A、B两个子线程
        AThread aThread = new AThread();
        BThread bThread = new BThread();

        //3.1 在主线程序中开启子线程A
        aThread.start();
        //5. B线程要等A线程打印完毕，再开始打印
        aThread.join();
        //3.2 在主线程序中开启子线程B
        bThread.start();

    }
}
//1. 创建A、B两个线程类，分别打印1~5
class AThread extends Thread {
    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("A线程打印了" + i);
            try {
                //4. 让A线程每打印一次，都要暂停3秒钟
                Thread.sleep(3000);//重写父类方法，父类不能抛出异常，子类也不可以，只能try-catch
            }catch (InterruptedException e){
                e.printStackTrace();
            }
        }
    }
}

class BThread extends Thread {
    @Override
    public void run() {
        for (int i = 1; i <= 5; i++) {
            System.out.println("B线程打印了" + i);
        }
    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/2122714.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

基于UDP的简易网络通信程序

基于UDP的简易网络通信程序

目录 0.前言 1.前置知识 网络通信的大致流程 IP地址 端口号&#xff08;port&#xff09; 客户端如何得知服务器端的IP地址和端口号&#xff1f; 服务器端如何得知客户端的IP地址和端口号&#xff1f; 2.实现代码 代码模块的设计 服务器端代码 成员说明 成员实现 U…
阅读更多...
今天讲点简单的：进制1

今天讲点简单的：进制1

啊&#xff0c;哈喽&#xff0c;小伙伴们&#xff0c;大家好。我是#Y清墨&#xff0c;今天呐&#xff0c;我要介绍的是二进制。 导语 好久不见&#xff0c;今天来玩些简单的——二进制。 一.初步认识 十进制是逢十进一&#xff0c;那么&#xff0c;顾名思义&#xff0c;二进制…
阅读更多...
完整的数仓能力，ByConity 1.0 版本发布！

完整的数仓能力，ByConity 1.0 版本发布！

文章来源&#xff5c;ByConity 开源社区 项目地址&#xff5c;https://github.com/ByConity/ByConity 2024年8月&#xff0c;ByConity 1.0 正式发布&#xff0c;翻开了 ByConity 新的一页。1.0 版本有哪些不同&#xff0c;以及 1.x 版本会重点迭代哪些能力&#xff0c;下面为大…
阅读更多...
【NVMe SSD寄存器、数据结构】NVMe Controller 重要寄存器、SSD内部跟NVMe相关的重要数据结构解析

【NVMe SSD寄存器、数据结构】NVMe Controller 重要寄存器、SSD内部跟NVMe相关的重要数据结构解析

前言 NVMe Controller会将一些重要的信息&#xff08;NVMe控制器的能力&#xff0c;状态&#xff0c;Admin SQ, CQ地址等&#xff09;直接放在NVMe寄存器中&#xff0c;另一部分&#xff08;跟SSD比较相关的&#xff09;信息会放置在SSD内部&#xff0c;并最终通过Admin NVMe …
阅读更多...
C：题目介绍

C：题目介绍

一、算天数 1.题目&#xff1a; kiki向获得某年某月有多少天&#xff0c;请帮他编程实现。输入年份和月份&#xff0c;计算这一年这个月有多少天。 输入描述&#xff1a; 多组输入&#xff0c;一行有两个整数&#xff0c;分别表示年份和月份&#xff0c;用空格分隔。 输出…
阅读更多...
Python 从入门到实战13（字符串简介）

Python 从入门到实战13（字符串简介）

我们的目标是&#xff1a;通过这一套资料学习下来&#xff0c;通过熟练掌握python基础&#xff0c;然后结合经典实例、实践相结合&#xff0c;使我们完全掌握python&#xff0c;并做到独立完成项目开发的能力。 上篇文章我们通过举例学习了流程控制语句中的循环语句。今天继续讨…
阅读更多...
【机器学习】--- 逻辑回归算法

【机器学习】--- 逻辑回归算法

目录 逻辑回归基础1. 概述2.优点与缺点 逻辑回归的理论解释1.问题背景2. S i g m o i d Sigmoid Sigmoid函数3.决策边界4.损失函数 正则化1.L1正则化2.L2正则化 逻辑回归基础 1. 概述 逻辑回归是机器学习的一种分类算法&#xff0c;主要运用于二分类问题。将线性回归的结果&a…
阅读更多...
day-52 三数之和

day-52 三数之和

思路 双指针&#xff1a;确定最小的那个数&#xff08;i0<i<nums.length-2&#xff09;&#xff0c;剩下两个数可以利用双指针的思想。当最小的那个数大于零时&#xff0c;可以直接返回&#xff0c;因为后面的不可能还有满足题意的组合。 解题过程 为了所有满足题意的组…
阅读更多...
async、await、promise异步操作详解

async、await、promise异步操作详解

一、async、await、Promise使用介绍 当然&#xff01;在 TypeScript 中&#xff0c;Promise 的使用可以涉及多个方面&#xff0c;包括基础用法、类型系统、异步操作的错误处理以及高级用法等。下面我会详细讲解这些内容。 1. Promise 的基本概念 Promise 是一种用于处理异步操…
阅读更多...
StorageSync数据缓存API

StorageSync数据缓存API

uni.setStorageSyncs参数:将 data 存储在本地缓存中指定的 key 中&#xff0c;会覆盖掉原来该 key 对应的内容&#xff0c;这是一个同步接口。 uni.setStorageSync函数里面写两个参数,分别是key和值,两个参数名称可以随便取,如果有同名的key,那么后面key的值会覆盖掉前面key的值…
阅读更多...
git cz 规范化 git commit 格式

git cz 规范化 git commit 格式

git cz 规范化 git commit 格式 npm install git-cz --save-devnpm install commitizen --save-devnpm install cz-customizable --save-dev // 这是package.json自动生成的 "config": {"commitizen": {"path": "./node_modules/cz-custo…
阅读更多...
《OpenCV计算机视觉》—— 图像金字塔

《OpenCV计算机视觉》—— 图像金字塔

文章目录 什么是图像金字塔&#xff1f;一、定义与基本原理二、主要类型三、构建过程四、应用领域 图像金字塔中的下采样和上采样一、下采样&#xff08;Downsampling&#xff09;二、上采样&#xff08;Upsampling&#xff09;三、总结 代码实现 什么是图像金字塔&#xff1f;…
阅读更多...
[进阶]面向对象之多态(二)

[进阶]面向对象之多态(二)

文章目录 多态调用成员的特点多态的优势和弊端 多态调用成员的特点 变量调用:编译看左边,运行也看左边方法调用:编译看左边,运行看右边 多态的优势和弊端 优势&#xff1a; 在多态形式下&#xff0c;右边对象可以实现解耦合&#xff0c;便于扩展和维护定义方法的时候&…
阅读更多...
【MySQL】查询表中重复数据、模糊查询列信息、快速copy表数据（1）

【MySQL】查询表中重复数据、模糊查询列信息、快速copy表数据（1）

一、SQL查询重复的数据&#xff1a; 1、SQL格式&#xff1a; Select * From 数据表 Where 重复记录字段 in ( select 重复记录字段 From 数据表 Group By 重复记录字段 Having Count(重复记录字段)>1) 2、举例&#xff1a; 在这个patient_member_info表中&#xff0c;我们…
阅读更多...
kkFileView PDF Image Mode Preview BUG

kkFileView PDF Image Mode Preview BUG

kkFileView PDF & Image Mode Preview BUG lazyload.js officePicture.ftl pdf.ftl kkFileView getCorsFile?urlPath 会触发SSRF漏洞 kkFileView SSRF-CSDN博客 commonHeader.ftl initWaterMark() 修改代码的工作量&#xff0c;主要是先部署项目&#xff0c;解…
阅读更多...
2023年408真题计算机网络篇

2023年408真题计算机网络篇

https://zhuanlan.zhihu.com/p/6954228062023年网络规划设计师上午真题解析TCP流量计算_哔哩哔哩_bilibili 1 1在下图所示的分组交换网络中&#xff0c;主机H1和H2通过路由器互联&#xff0c;2段链路的数据传输速率为100 Mb/s、时延带宽积 &#xff08;即单向传播时延带宽&am…
阅读更多...
计算机毕业设计 家校互联管理系统 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试

计算机毕业设计 家校互联管理系统 Java+SpringBoot+Vue 前后端分离 文档报告 代码讲解 安装调试

&#x1f34a;作者&#xff1a;计算机编程-吉哥 &#x1f34a;简介&#xff1a;专业从事JavaWeb程序开发&#xff0c;微信小程序开发&#xff0c;定制化项目、 源码、代码讲解、文档撰写、ppt制作。做自己喜欢的事&#xff0c;生活就是快乐的。 &#x1f34a;心愿&#xff1a;点…
阅读更多...
【Linux实践】实验一：Linux系统安装与启动

【Linux实践】实验一：Linux系统安装与启动

【Linux实践】实验一&#xff1a;Linux系统安装与启动 实验目的实验内容实验步骤及结果1. 下载VMware2. 下载 Linux 操作系统3. 在VMware中安装Ubuntu系统4. 配置Ubuntu系统5. 关机 实验目的 1.掌握Linux系统的安装过程和简单配置方法。 2.掌握与Linux相关的多操作系统的安装方…
阅读更多...
centos挂载fat32和ntfs文件系统u盘

centos挂载fat32和ntfs文件系统u盘

centos挂载u盘 一、 挂载fat32文件系统u盘1. 查看u盘的文件系统2. 查看系统是否识别到u盘3. 挂载fat32文件系统u盘 二、挂载ntfs文件系统u盘1. 检查u盘文件系统&#xff08;忽略&#xff09;2. 查看系统是否识别到u盘3. 挂载ntfs文件系统3.1. 下载ntfs-3g组件3.2. 挂载u盘 一、…
阅读更多...
嵌入式day42

嵌入式day42

framebuffer&#xff1a;帧缓冲、帧缓存 Linux内核为显示提供的一套应用程序接口&#xff08;驱动内核支持&#xff09; 分辨率&#xff1a;像素点的总和 像素点&#xff1a; 显示屏&#xff1a;800*600&#xff08;横向有800个像素点&#xff0c;纵向有600个像素点&#x…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023