总结一些面试题

凝凡丶

已于 2023-10-07 10:34:38 修改

阅读量45

点赞数

文章标签： java

于 2023-10-07 10:31:48 首次发布

本文链接：https://blog.csdn.net/qq_37564410/article/details/133633838

版权

如何防止XSS（跨站脚本）攻击

XSS（跨站脚本）攻击是一种网络安全威胁，它利用网站没有对用户提交的输入进行适当验证和过滤的缺陷，并添加恶意脚本在用户的浏览器上运行。以下是一些防止XSS攻击的常用方法：

对用户输入进行编码：在渲染用户输入的任何内容之前，都需要进行HTML编码。这可以防止攻击者提交恶意脚本。比如，你可以将特殊字符如 <, >, "等转化为相应的HTML实体，即 <, >, " 等。
使用HTTP只读Cookie：设置cookie为httpOnly可以防止通过JavaScript访问cookie。这可以防止攻击者窃取cookie并冒充用户身份。
启用内容安全策略（CSP）：CSP可以帮助你减少XSS攻击的风险，它允许你指定一个白名单，只有白名单上的源可以被加载和执行。这样就可以有效防止恶意脚本的注入和运行。
使用最新的Web技术：新的Web技术，例如React和Vue，对XSS有一定的内置防护措施。例如，React默认会对显示的内容进行转义，以防止XSS攻击。
输入验证：对用户的所有输入进行验证，确保输入的数据符合期望的格式和类型，没有恶意代码。
使用HTTPS：HTTPS协议可以对传输的数据进行加密，这样即使数据被截获，攻击者也无法看懂。
不要信任用户输入：永远不要假设用户会按照你期望的方式输入数据。对所有用户输入都应该视为不可信的，并进行适当的过滤和验证。
记住，安全性是一种多层防护的思维方式，没有任何一种方法可以100%防止XSS攻击，因此，使用这些方法的组合，可以帮助最大限度地降低XSS攻击的风险。

MyBatis 如何防止 SQL 注入攻击

MyBatis 是一个基于 Java 的持久层框架，它通过 SQL 映射文件或注解的方式将 Java 对象与数据库表进行关联。MyBatis 可以通过一些机制来防止 SQL 注入攻击，以下是一些主要的方法：

预编译语句（Prepared Statements）：MyBatis 使用 JDBC 的 PreparedStatement 来创建 SQL 语句。PreparedStatement 在执行 SQL 语句时，会对 SQL 语句进行预编译，从而自动防止 SQL 注入。因为预编译的 SQL 语句中的参数会被当作字符串值，所以攻击者无法改变 SQL 语句的结构。
动态 SQL（Dynamic SQL）：MyBatis 支持动态 SQL，允许在 SQL 语句中插入条件和参数，但它同时限制了直接拼接 SQL 语句的语法，从而减少了 SQL 注入的可能性。使用 MyBatis 的 <if>、<choose>、<when>、<otherwise>、<foreach>等标签可以很方便地生成动态 SQL。
参数映射（Parameter Mapping）：MyBatis 可以将 Java 类型的参数映射为 JDBC 类型的参数，从而自动转义可能导致注入的字符。例如，如果一个参数是字符串类型，MyBatis 会在将它插入到 SQL 语句之前将它转义，以防止注入攻击。
结果映射（Result Mapping）：MyBatis 通过结果映射将数据库表中的数据映射到 Java 对象，它会自动处理数据类型的转换和异常处理。由于 MyBatis 会将查询结果封装为 Java 对象，所以攻击者无法直接修改 SQL 查询的结果。
底层原理主要是基于 JDBC 的 PreparedStatement 的预编译特性。预编译的 SQL 语句会安全地处理所有动态添加的参数，防止它们被当作 SQL 代码的一部分来执行。这就是为什么即使参数中包含恶意的 SQL 代码，也不会引发注入攻击。因为这些代码在预编译阶段就已经被当作字符串值进行了转义和处理。

在Spring Cloud微服务架构中，不同服务之间如何调用

在Spring Cloud微服务架构中，不同服务之间的调用主要有以下几种方式：

使用RestTemplate进行调用：这是Spring提供的一种便捷的HTTP客户端方式，可以轻松地实现微服务之间的HTTP通信。通过创建一个RestTemplate对象，并指定调用的地址，就可以实现服务之间的调用。同时，也可以使用注册中心获取server端的主机地址和端口号，或者在实例化RestTemplate时使用@LoadBalanced注解，并使用注册中心的server端的服务名进行调用。
使用FeignClient进行调用：Spring Cloud引入了Feign，这是一种声明式的Web Service客户端，可以简化HTTP请求的创建、拼装和发送。通过使用@FeignClient注解定义一个服务接口，并指定要调用的远程服务的名称，就可以通过该接口进行远程调用。如果服务端有多个服务器，可以使用Ribbon来解决负载均衡的问题。Ribbon提供了三种负载均衡策略，默认的、编码指定、配置文件指定。
使用gRPC进行跨服务通信：gRPC是由Google开发的高性能、开源、通用的RPC框架，可以在微服务之间进行高效通信。Spring Cloud增加了对gRPC的支持，通过使用gRPC的客户端和服务器端代码，可以轻松实现在微服务之间的远程调用。
使用消息队列进行异步通信：微服务之间可以通过消息队列进行异步通信，提高系统的可伸缩性和响应速度。Spring Cloud提供了对RabbitMQ和Apache Kafka等消息队列的支持，可以方便地在微服务之间传递消息。
以上是Spring Cloud微服务之间调用的几种方式，可根据实际需求进行选择。

Java 中如何来传输文件

在 Java 中，可以使用各种方法来传输文件，以下是两种常见的方式：

使用 Java I/O: Java I/O 是 Java 提供的标准 I/O 库，可以用来读写文件。以下是一个简单的文件写入和读取的例子：
写入文件：

import java.io.FileWriter;
import java.io.IOException;
public class WriteFile {
    public static void main(String[] args) {
        try {
            FileWriter writer = new FileWriter("test.txt");
            writer.write("Hello, this is a test text!");
            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

读取文件：

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class ReadFile {
    public static void main(String[] args) {
        try {
            BufferedReader reader = new BufferedReader(new FileReader("test.txt"));
            String line = reader.readLine();
            while (line != null) {
                System.out.println(line);
                line = reader.readLine();
            }
            reader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

使用 Java 网络编程: 如果你要通过网络传输文件，可以使用 Java 的网络编程 API。以下是一个简单的例子，使用 TCP 连接来发送和接收文件：
服务器端（接收文件）：

import java.io.*;
import java.net.*;
public class FileServer {
    public static void main(String[] args) {
        try {
            ServerSocket serverSocket = new ServerSocket(8000);
            System.out.println("Server started, waiting for client...");
            Socket socket = serverSocket.accept();
            System.out.println("Client connected!");
            DataInputStream dis = new DataInputStream(new BufferedInputStream(socket.getInputStream()));
            DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
            String fileName = dis.readUTF();
            File file = new File(fileName);
            FileOutputStream fos = new FileOutputStream(file);
            byte[] buffer = new byte[1024];
            int length;
            while ((length = dis.read(buffer, 0, buffer.length)) != -1) {
                fos.write(buffer, 0, length);
            }
            fos.close();
            System.out.println("File " + fileName + " received.");
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

客户端（发送文件）：

import java.io.*;
import java.net.*;
public class FileClient {
    public static void main(String[] args) {
        try {
            Socket socket = new Socket("localhost", 8000);
            System.out.println("Connected to server!");
            DataInputStream dis = new DataInputStream(new BufferedInputStream(System.in));
            DataOutputStream dos = new DataOutputStream(socket.getOutputStream());
            System.out.print("Enter file name: ");
            String fileName = dis.readUTF();
            File file = new File(fileName);
            FileInputStream fis = new FileInputStream(file);
            byte[] buffer = new byte[1024];
            int length;
            while ((length = fis.read(buffer, 0, buffer.length)) != -1) {
                dos.write(buffer, 0, length);
            }
            fis.close();
            System.out.println("File " + fileName + " sent.");
            socket.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

以上是两种基本的文件传输方法。在实际应用中，可能需要更复杂和安全的方法，例如使用套接字（Socket）进行网络传输，或者使用现成的文件传输协议（如 FTP 或 SFTP）。

head如何传递参数

在大多数编程语言中，head通常是指一个函数或方法的名称。函数或方法名本身不能像HTML标签一样传递参数，但是可以在函数或方法内部通过参数来接收值。
以下是一些不同编程语言中函数参数传递的基本示例：
JavaScript


function head(data) {
    // 在函数内部处理数据
    console.log(data);
}
// 调用函数并传递参数
head("Hello, world!");

Java

public class Main {
    public static void main(String[] args) {
        head("Hello, world!");
    }
    public static void head(String data) {
        // 在函数内部处理数据
        System.out.println(data);
    }
}

这些示例展示了如何在不同的编程语言中定义一个名为head的函数或方法，并传递字符串参数。你可以根据具体编程语言的要求和你的需求来调整参数的类型和数量。

如何快速找到生产环境中的报错问题

在生产环境中，如果Java应用程序出现错误，通常需要进行以下步骤来快速找到并解决问题：

查看错误日志：Java应用程序通常会有日志记录，包括错误信息、堆栈跟踪等等。这些日志可能在控制台、日志文件或者监控工具中。首先需要找到这些日志并仔细阅读。
分析堆栈跟踪：如果错误信息包含堆栈跟踪，那么可以通过分析这个堆栈跟踪来找到错误发生的代码行。从顶部（通常是错误发生的代码行）开始阅读，并向下寻找导致错误的原因。
查找相关代码：在找到错误发生的代码行之后，需要查找和阅读相关代码。这可以帮助理解错误发生的原因，并寻找可能的解决方案。
使用调试器：如果上述步骤无法解决问题，那么可以使用调试器来帮助找到问题。在IDE中，例如IntelliJ IDEA或Eclipse中，可以设置断点并使用调试模式运行程序。这可以让程序在遇到断点时暂停，然后检查当时的变量值、调用栈等信息。
重现问题：确保你能够重现这个问题。这可能需要在你的开发环境中重新运行相同的代码，或者使用测试用例来模拟用户的行为。这样可以帮助你更深入地理解问题。
考虑可能的解决方案：一旦理解了问题的原因，就可以开始考虑可能的解决方案。这可能包括修改代码、更新依赖库、调整配置等等。
测试解决方案：在尝试解决方案之前，最好先进行测试。这可以确保解决方案不会引入新的问题，或者至少可以让你更快地发现新的问题。
更新代码和文档：一旦找到了解决方案，就需要更新引发错误的代码，并可能还需要更新相关的文档。
在紧急情况下，可能没有足够的时间进行所有的步骤，但尽可能地遵循这些步骤可以帮助你在长远内更快地解决问题。

前端页面响应慢了，一般是怎么找原因，怎么解决的

前端页面响应慢的原因可能有多种，以下是一些可能的原因和解决方法：
1. 网络连接问题：网络连接不稳定、网络带宽不足、高峰期网络拥塞等都可能导致页面响应慢。解决方法是确保网络连接正常，尽量使用稳定的有线连接，检查网络带宽是否满足需求，可以尝试在低峰期浏览网页。
2. 服务器响应时间慢：服务器负载过重、服务器配置不佳等都会影响服务器响应时间。解决方法是联系网站管理员或服务提供商，了解服务器状态，升级服务器配置，或者考虑使用内容分发网络（CDN）来提高网页加载速度。
3. 页面资源过多：当页面中包含大量的图片、脚本和其他外部资源时，每个资源都需要单独的HTTP请求，这会导致页面响应变慢。解决方法是优化网页，减少资源的数量和大小，合并文件、压缩文件，使用CSS精灵图或图标字体等技术来减少HTTP请求次数。
4. 图片过大或未经优化：图片文件过大、分辨率过高、未经压缩等都会影响页面加载速度。解决方法是使用适当的图片格式（如JPEG、PNG），调整图片分辨率和质量，使用图像压缩工具来优化图片，确保图片大小合理，以减少加载时间。
5. JavaScript代码过多或复杂：网页中的JavaScript代码过多或复杂，可能导致脚本加载和执行时间过长。解决方法是优化和压缩JavaScript代码，将脚本放置在页面底部，使用异步加载脚本的方式，以便在页面加载完成后再加载脚本。
6. 缓存设置不当：如果网页打开很慢可能是浏览器缓存设置不正确或缓存策略不当。解决方法是在服务器端设置适当的缓存策略，利用浏览器缓存来存储静态资源，减少重复的网络请求。
7. 第三方插件或广告：某些第三方插件或广告可能会增加网页加载时间。解决方法是评估并删除不必要的第三方插件和广告，或者尝试使用延迟加载技术，将它们加载到页面中的较晚阶段。
8. 设备性能问题：低配置的计算机、过旧的浏览器等可能导致网页加载速度变慢。解决方法是升级计算机硬件或更换为最新的浏览器版本，以提高网页加载速度。
9. 缺乏优化的代码和技术：网页代码未经优化，使用了过时的技术。解决方法是确保网页代码经过优化，遵循最佳实践，使用现代化的技术和工具，例如HTML5、CSS3和最新的前端框架，以提高网页性能和加载速度。
10. 测试和监控：缺乏定期的性能测试和监控，可能无法及时发现和解决网页加载速度问题。解决方法是定期进行网页性能测试，使用工具分析加载时间、页面大小和性能瓶颈，监控网页的性能指标，及时采取优化措施。
综上所述，前端页面响应慢的原因有很多种，需要根据具体的情况进行分析和解决。可以通过优化网络连接、服务器响应、页面资源、图片和脚本加载等方面来提高页面响应速度。同时，定期进行性能测试和监控也是保证网页性能的重要手段。

上传大文件怎么处理

在Java中上传大文件，我们通常会使用流或者分段的方式来处理。以下是一个使用Servlet API和Java IO的简单示例：

import javax.servlet.*;
import javax.servlet.http.*;
import java.io.*;
public class LargeFileUploadServlet extends HttpServlet {
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        
        String filePath = "/path/to/your/uploaded/file";  //文件存储路径
        File file = new File(filePath);
        
        try(InputStream inputStream = req.getInputStream();
            OutputStream outputStream = new FileOutputStream(file)) {
            byte[] buffer = new byte[4096];
            int bytesRead;
            while ((bytesRead = inputStream.read(buffer)) != -1) {
                outputStream.write(buffer, 0, bytesRead);
            }
            outputStream.flush();
        } catch (IOException e) {
            throw new ServletException("Error while uploading file", e);
        }
        resp.getWriter().write("File uploaded successfully");
    }
}

在以上的代码中，我们首先获取到请求的输入流，然后使用Java的输入/输出流API将数据从输入流复制到输出流。这个例子只是一个基本的示例，你可能需要根据实际需求对其进行改进，例如添加错误处理和边界检查。
此外，你也可以使用一些开源库如Apache Commons FileUpload来处理文件上传，这些库通常会提供更高级别的抽象和便利性。对于非常大的文件，你可能需要考虑使用分片技术，将大文件分成多个小片，然后逐一上传。

redis缓存穿透,缓存击穿,缓存雪崩分别是什么,有什么解决方法.

Redis缓存穿透、缓存击穿和缓存雪崩是Redis缓存中常见的三个问题。下面分别解释这三个问题以及它们的解决方法。

缓存穿透：当一个查询请求的数据在Redis缓存中不存在，且数据库中也不存在时，查询请求会一直落到数据库上，这种情况称为缓存穿透。由于数据库压力骤增，可能导致服务崩溃。
解决方法：
- 缓存空对象：当数据库中没有数据时，在缓存中设置一个空对象，并设置一个过期时间。这样，当缓存过期后，请求会自动失效。
- 布隆过滤器：布隆过滤器是一种数据结构，它可以用于检测一个元素是否在一个集合中。使用布隆过滤器可以预先过滤掉可能不存在的数据，减少对数据库的查询次数。
缓存击穿：当一个热点key在Redis缓存中不存在，即缓存失效时，对该key的多个并发请求同时落到了数据库上，导致数据库压力骤增，这种情况称为缓存击穿。
解决方法：
- 使用互斥锁：当缓存失效时，使用互斥锁来限制对数据库的并发访问。只有获得锁的请求才能访问数据库，其他请求则需等待。
- 设置缓存预热时间：为热点key设置一个较长的过期时间，或者在key过期后进行缓存预热，即在后台提前加载缓存数据。
缓存雪崩：当大量缓存key在同一时间失效，或者大量新的key被加入到缓存中，导致大量的请求直接落在数据库上，这种情况称为缓存雪崩。
解决方法：
- 设置缓存key的过期时间分散：避免大量key在同一时间过期，可以通过随机、均匀分布等方式设置过期时间。
- 使用消息队列：当大量key需要更新时，可以使用消息队列来异步更新缓存，以缓解数据库的压力。
- 数据库优化：为数据库增加负载能力，如使用主从复制、分片等方式来水平扩展数据库的能力。
  以上是针对这三个问题的常见解决方法，具体实施时可能需要根据业务场景和实际需求进行选择和调整。

索引在以下情况下可能失效

数据类型不匹配：如果查询条件中的列和索引列的数据类型不匹配，那么索引可能就会失效。例如，如果一个整数字段被索引了，但是你却使用了一个字符串查询条件，那么索引就不会被使用。
忽略索引：在某些情况下，尽管有一个合适的索引可用，但是数据库可能会选择忽略它，而使用全表扫描。这可能是出于各种原因，例如估计使用索引的成本更高，或者因为优化器决定使用全表扫描更快。
复合索引：在复合索引中，只有当查询条件中包含了索引的最左侧列时，索引才会被使用。如果查询条件中没有包含索引的最左侧列，那么索引就可能失效。
跨列索引：如果你在一个复合索引中查询没有使用索引列的其它列，那么索引可能就会失效。
统计数据不准确：如果数据库的统计数据不准确（例如，由于某些行的变动导致统计数据过时），那么优化器可能会做出错误的决定，导致索引不被使用。
NULL值：如果索引列包含NULL值，并且你的查询没有明确处理NULL值，那么索引可能就不会被使用。
范围查询：在默认情况下，B树索引对范围查询（如BETWEEN、>、<等操作符）是非常有效的。但如果查询中使用了太多的范围查询，或者范围查询左侧的列不是索引的最左侧列，那么索引可能就会失效。
LIKE查询：对于LIKE查询，如果使用了通配符（如%或_），并且没有在通配符前使用常量或参数，那么索引可能就不会被使用。
字符集和校对规则：如果查询和索引列使用的字符集或校对规则不同，那么可能会导致索引失效。
不同的数据库管理系统(DBMS)：不同的DBMS可能在处理相同的数据和查询时会有不同的性能表现，因此可能会选择使用或忽略索引。
以上就是一些可能导致索引失效的情况。但是请注意，这并不是一个全面的列表，而且具体的行为可能会因数据库的版本和配置而异。

聚集索引和二级表索引的区别

聚集索引和二级索引是数据库中两种不同类型的索引，它们的主要区别如下：

存储方式：聚集索引是按照每张表的主键构造一棵B+树，同时叶子节点中存放的即为整张表的行记录数据，因此每个表只能拥有一个聚集索引。然而，二级索引（也称非聚集索引）则是根据某个列的值进行索引，叶子节点中存储的是对应行的主键值，而不是整行的数据。
索引列的数量：聚集索引只有一个，用于组织表中数据的逻辑顺序。而二级索引则可以有多个，它们分别对应不同的列。
数据查找速度：由于聚集索引的叶子节点即为数据页，查询优化器能够在B+树索引的叶子节点上直接找到数据，因此查询速度相对较快。而二级索引需要先找到对应的主键值，然后再通过主键值去查找数据，所以查询速度相对较慢。
数据完整性：聚集索引包含了所有用户记录（包括隐藏列），因此具有更高的数据完整性。而二级索引只包含对应列的索引值和主键值，不包含完整的行数据，所以数据完整性较低。
总的来说，聚集索引和二级索引的主要区别在于存储方式、索引列的数量、数据查找速度和数据完整性上。聚集索引适用于对数据查找速度和数据完整性要求较高的场景，而二级索引适用于对数据查找速度要求较高但数据完整性要求较低的场景。