小米场景题，让我措手不及...

大家好，我是千羽。

小米golang开发面试只进行了1小时，没有涉及过多的八股文题目，给了两个场景题，让我一下子措手不及，虽然我很想进入下一轮，但很遗憾，第一轮面试挂~~

• 1.对安全的了解。
• 2.接口安全性知道不？校验，证书
• 3.go的并发用的多吗？
• 4.go的map和slice是线程安全不
• 5.场景题目：
• （1）五个域名abcde,各个qps不太一样，a=1w，b=200，但是想让他们访问平均，怎么处理
• （2）一个ip：192.168.2.10，数据库里面有大量ip段，一个区间有几万个。写个api查数据库，返回该ip段。怎么查
• 6.算法：最长回文子串

1.对安全的了解。

对后端接口安全的了解是确保后端应用程序和服务安全的关键。以下是一些关于后端接口安全的关键概念和考虑因素：

1. 身份验证与授权：
   1. 确保只有经过身份验证和授权的用户或客户端才能访问后端接口。
   2. 使用强密码策略和多因素身份验证来增强安全性。
   3. 实施细粒度的访问控制，根据用户角色和权限限制对接口的访问。
2. 输入验证与过滤：
   1. 对所有输入数据进行严格的验证和过滤，以防止恶意输入和攻击。
   2. 验证数据的格式、长度、类型和范围，确保符合预期要求。
   3. 对输入数据进行必要的清理和转义，以防止注入攻击。
3. 输出编码与过滤：
   1. 对所有输出数据进行适当的编码和转义，以防止跨站脚本攻击（XSS）。
   2. 避免输出用户提供的未验证数据到前端或日志文件中。
4. 加密与数据保护：
   1. 对敏感数据进行加密存储，使用强大的加密算法和密钥管理机制。
   2. 在传输过程中使用HTTPS、SSL/TLS等协议加密数据，确保数据在传输过程中的安全。
5. 异常处理与日志记录：
   1. 实施适当的异常处理机制，对异常情况进行记录、监控和告警。
   2. 记录详细的日志信息，包括请求来源、时间、数据内容和响应结果等。
   3. 定期审查和分析日志，及时发现异常活动和潜在的安全风险。
6. 安全审计与代码审查：
   1. 定期进行安全审计和代码审查，检查潜在的安全漏洞和问题。
   2. 使用专业的安全工具和第三方审计服务来加强后端接口的安全性。

2.接口安全性知道不？校验，证书

服务端接口安全对于确保应用程序的数据安全和正常运行至关重要。以下是对服务端接口安全的一些关键方面的深入了解：

1. 证书管理：
   1. 使用SSL/TLS证书对传输的数据进行加密。这确保了客户端和服务器之间的通信是私密的，并且可以防止中间人攻击。
   2. 使用受信任的证书颁发机构（CA）获取和更新证书，并定期审查证书链的有效性。
2. 加密技术：
   1. 传输加密：使用HTTPS、WSS等协议确保数据在传输过程中的安全。
   2. 存储加密：对敏感数据进行加密，确保即使数据在数据库或其他存储介质中，未经授权的人员也无法访问。
   3. 内容加密：对返回的数据内容进行加密，确保数据在到达客户端之前不会被窃取或篡改。
3. 防止SQL注入：
   1. 对所有输入数据进行适当的转义和参数化查询，以防止SQL注入攻击。
   2. 使用ORM（对象关系映射）或参数化查询来构建SQL查询，这样可以确保输入数据不会被解释为SQL代码。
4. 防止DoS攻击：
   1. 实施速率限制和请求限制，以防止拒绝服务攻击（DoS）。
   2. 使用防火墙或其他安全机制来识别和过滤异常流量模式。
5. 鉴权与授权：
   1. 使用适当的身份验证机制，如OAuth、JWT等，确保只有经过身份验证和授权的用户才能访问接口。
   2. 实施细粒度的访问控制策略，确保每个用户只能访问他们被授权访问的数据和功能。
6. 日志与监控：
   1. 记录所有接口请求的详细日志，包括请求来源、时间、数据内容等。这有助于追踪问题、审计和识别异常活动。
   2. 对接口响应时间、请求频率等指标进行监控，及时发现可能的性能问题或安全风险。
7. 安全传输协议：
   1. 使用HTTPS或其他安全传输协议来保护API通信，防止窃听和中间人攻击。验证服务器证书，确保与正确的服务器建立连接。
8. 输入验证与过滤：
   • 对所有输入数据进行严格的验证和过滤，防止恶意输入导致安全漏洞（如跨站脚本攻击、路径遍历攻击等）。只接受符合预期格式和类型的数据。
9. 错误处理与安全审计：
   • 设计安全的错误处理机制，避免泄露敏感信息或内部细节。返回通用的错误消息给客户端，而不是具体的错误详情。
   • 定期进行安全审计，检查潜在的安全风险和漏洞，并及时修复。使用专业的安全工具和第三方审计服务来加强安全性。
10. 会话管理：
    • 使用安全的会话管理机制，如使用HTTPOnly cookies、CSRF保护和会话超时设置，防止会话劫持和其他会话相关攻击。

3.go的并发用的多吗？

Go语言中，协程是轻量级的线程，可以独立地执行函数或方法，而不需要创建额外的操作系统线程。协程的启动和销毁都非常轻量级，因此可以创建大量的协程来处理并发任务。通过协程，可以轻松地实现并发程序的并发执行。

通道是用于协程之间进行通信和数据传输的机制。通道提供了一种同步的机制，确保协程之间安全地共享数据。通过通道，可以实现协程之间的数据传递和协调，避免并发访问共享数据导致的竞争条件和数据不一致问题。

以下是一个使用Go语言并发模型的简单示例：

package main

import (
 "fmt"
 "time"
)

func main() {
 // 启动多个协程执行任务
 for i := 0; i < 5; i++ {
 go performTask(i) // 启动协程执行任务
 }

 // 主协程等待一段时间，以确保所有协程完成执行
 time.Sleep(2 * time.Second)
 fmt.Println("All tasks completed.")
}

func performTask(id int) {
 // 模拟任务执行时间
 time.Sleep(time.Second)
 fmt.Printf("Task %d completed.\n", id)
}

在上述示例中，我们使用go关键字启动了5个协程来执行performTask函数。每个协程模拟了一个独立的任务，通过休眠1秒钟来模拟任务的执行时间。主协程使用time.Sleep函数等待2秒钟，以确保所有协程有足够的时间完成执行。最后，输出"All tasks completed."表示所有任务已经完成。

4.go的map和slice是线程安全不

Go语言的map和slice都不是线程安全的。

在Go语言中，map和slice是引用类型，它们在多个协程之间共享数据时需要额外的同步机制来保证线程安全。如果多个协程同时对map或slice进行读写操作，可能会导致数据竞争和不一致的状态。

为了在并发环境中安全地使用map和slice，可以使用互斥锁（sync.Mutex）来提供同步访问。通过在访问map或slice之前获取互斥锁，可以确保同一时间只有一个协程可以访问该数据结构，从而避免数据竞争。

下面是一个使用互斥锁保护map的示例：

import "sync"

var m = make(map[string]int)
var mutex = &sync.Mutex{}

func updateMap(key string, value int) {
    mutex.Lock()
    defer mutex.Unlock()
    m[key] = value
}

在这个示例中，我们使用了一个全局的互斥锁来保护对map的并发访问。在更新map之前，我们首先获取互斥锁，然后在更新完成后释放锁。这样，只有一个协程可以同时访问map，确保了线程安全。

需要注意的是，尽管互斥锁可以提供线程安全的访问，但它也可能导致性能问题。如果多个协程频繁地竞争同一把锁，会导致大量的上下文切换和同步开销。因此，在设计并发程序时，应尽量减少对互斥锁的依赖，并考虑使用其他并发原语或无锁数据结构来提高性能。

5.场景题目：

（1）五个域名abcde,各个qps不太一样，a=1w，b=200，但是想让他们访问平均，怎么处理

要让五个域名abcde的QPS（Queries Per Second）平均，即使它们的QPS值不同，你可以采用一些策略和技术来实现这一目标。下面是一些方法：

1. 使用负载均衡器：
   • 使用一个负载均衡器，如Nginx或HAProxy，来分配请求到五个域名。
   • 配置负载均衡器使用轮询（Round Robin）或加权轮询（Weighted Round Robin）策略，根据每个域名的QPS值为其分配不同的权重。
   • 例如，为域名a分配的权重大于其他域名，为b分配中等权重，为cde分配较小权重。这样，a域名将处理更多的请求，而b、c、d、e域名的请求量将逐渐减少。
2. 使用DNS轮询：
   • 如果这五个域名都是你的，你可以在DNS设置中配置轮询。
   • 例如，当用户请求域名a时，DNS返回一个b的IP；当用户请求b时，DNS返回一个c的IP，以此类推。这样，所有请求都会被分散到所有域名上。
3. 使用内容分发网络（CDN）：
   • 如果你的目标是全球平均分配流量，考虑使用CDN。CDN节点遍布全球，可以帮助你更均匀地分布流量。
4. 使用代理服务器：
   • 在用户和服务器之间设置代理服务器，代理服务器可以检测和平衡流量。
5. 编程逻辑：
   • 如果这些域名都是你的服务，你可以在后端服务中加入逻辑来检测当前QPS，并根据需要调整处理请求的域名。
6. 动态调整应用配置：
   • 使用监控工具和告警系统来检测QPS。当某个域名的QPS过高时，可以动态地调整应用配置或重新路由请求来平衡流量。
7. 优化和调整：

• 根据实际情况持续优化和调整策略，以获得最佳的性能和用户体验。

（2）一个ip：192.168.2.10，数据库里面有大量ip段，一个区间有几万个。写个api查数据库，返回该ip段。怎么查

1. 建立数据库：首先，确保你的数据库中有存储IP段的表。这个表至少应该包含起始IP地址和结束IP地址。例如，一个简单的表结构如下：

CREATE TABLE ip_ranges (  
    id INT PRIMARY KEY,  
    start_ip VARCHAR(15),  
    end_ip VARCHAR(15)  
);

1. 插入数据：将IP段数据插入到上述表中。例如：

INSERT INTO ip_ranges (id, start_ip, end_ip) VALUES  
(1, '192.168.2.0', '192.168.2.255'),  
(2, '192.168.3.0', '192.168.3.255'),  
...;

一个基于动态规划的算法，用于找到最长回文子串：

1. 创建一个长度为n的布尔数组dp，其中dp[i]表示字符串s的前i个字符是否是回文串。
2. 对于每个长度为2的子串，检查它们是否是回文串，如果是，则将dp[i]设置为true。
3. 对于每个长度大于2的子串，检查其前缀和后缀是否相等，如果相等，则将dp[i]设置为true。
4. 遍历数组dp，找到第一个为true的元素，并返回其索引作为最长回文子串的起始位置。
5. 从该起始位置开始，向后遍历字符串，找到第一个为false的元素，并返回其索引作为最长回文子串的结束位置。
6. 返回最长回文子串。

使用Golang编写的示例代码，用于查询数据库中给定IP地址所在的IP段：

package main

import (
 "database/sql"
 "fmt"
 "net"
)

type IPRange struct {
 StartIP net.IP
 EndIP   net.IP
}

func main() {
 // 连接数据库
 db, err := sql.Open("mysql", "user:password@tcp(localhost:3306)/database")
 if err != nil {
 fmt.Println("数据库连接失败:", err)
 return
 }
 defer db.Close()

 // 查询给定IP地址所在的IP段
 ip := net.ParseIP("192.168.2.10")
 if ip == nil {
 fmt.Println("无效的IP地址")
 return
 }
 ipRange, err := findIPRange(db, ip)
 if err != nil {
 fmt.Println("查询IP段失败:", err)
 return
 }
 fmt.Println("IP段:", ipRange)
}

func findIPRange(db *sql.DB, ip net.IP) (IPRange, error) {
 // 查询数据库中匹配的IP段
 rows, err := db.Query("SELECT start_ip, end_ip FROM ip_ranges WHERE ? BETWEEN start_ip AND end_ip", ip)
 if err != nil {
 return IPRange{}, err
 }
 defer rows.Close()

 // 遍历查询结果，找到匹配的IP段
 var startIP net.IP
 var endIP net.IP
 for rows.Next() {
 err := rows.Scan(&startIP, &endIP)
 if err != nil {
 return IPRange{}, err
 }
 // 返回匹配的IP段信息
 return IPRange{StartIP: startIP, EndIP: endIP}, nil
 }

 // 未找到匹配的IP段，返回错误信息
 return IPRange{}, fmt.Errorf("未找到匹配的IP段")
}

请注意，上述代码中的数据库连接信息（如用户名、密码、数据库名称等）需要根据你的实际情况进行修改。另外，你需要确保你的数据库中有一个名为ip_ranges的表，该表包含start_ip和end_ip字段，用于存储IP段的起始和结束地址。

6.算法：最长回文子串

public class LongestPalindromeSubstring {
    public static String longestPalindromeSubstring(String s) {
        int n = s.length();
        int[] start = new int[n]; // 存储最长回文子串的起始位置
        boolean[] flag = new boolean[n]; // 标记最长回文子串是否存在
        for (int i = n - 1; i >= 0; i--) {
            for (int j = i + 1; j < n; j++) {
                if (s.charAt(i) == s.charAt(j) && (j - i < 3 || flag[j - 1])) {
                    start[j] = i; // 更新最长回文子串的起始位置
                    flag[j] = true; // 标记最长回文子串存在
                }
            }
        }
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < n; i++) {
            if (flag[i]) { // 如果存在最长回文子串，则拼接字符串
                sb.append(s.charAt(i));
                sb.append(s.charAt(start[i]));
            }
        }
        return sb.toString();
    }
}

使用动态规划的思想，通过遍历字符串s中的所有子串，判断是否为回文串，并记录最长的回文子串的长度和起始位置。具体实现中，使用一个一维数组start来记录最长回文子串的起始位置，使用一个一维布尔数组flag来标记最长回文子串是否存在。算法的时间复杂度为O(n^2)，空间复杂度为O(n)。

双指针实现:从中间开始向两边扩散来判断回文串

class Solution {
    public String longestPalindrome(String s) {
        String res = "";
        for (int i = 0; i < s.length(); i++) {
            // 以 s[i] 为中心的最长回文子串
            String s1 = palindrome(s, i, i);
            // 以 s[i] 和 s[i+1] 为中心的最长回文子串
            String s2 = palindrome(s, i, i + 1);
            // res = longest(res, s1, s2)
            res = res.length() > s1.length() ? res : s1;
            res = res.length() > s2.length() ? res : s2;
        }
        return res;
    }

    String palindrome(String s, int l, int r) {
        // 防止索引越界
        while (l >= 0 && r < s.length()
                && s.charAt(l) == s.charAt(r)) {
            // 向两边展开
            l--;
            r++;
        }
        // 返回以 s[l] 和 s[r] 为中心的最长回文串
        return s.substring(l + 1, r);
    }
}