分类后端技术下的文章

【PostgreSQL】使用开窗函数获取历史表最新记录及 MySQL 旧版本实现

2024-09-05

在PostgreSQL中，可以使用开窗函数（window functions）来获取历史表中每个实体的最新记录。以下是一个示例，假设有一个history_table，它记录了实体的变更历史，并且每个实体都有一个id字段和一个表示变更时间的timestamp字段。




SELECT h.*
FROM (
  SELECT
    id,
    ROW_NUMBER() OVER (PARTITION BY id ORDER BY timestamp DESC) AS rn
  FROM
    history_table
) subquery
JOIN history_table h ON subquery.id = h.id AND subquery.rn = 1;

在这个查询中，我们首先为每个id分区，并按照timestamp字段降序排列，为每条记录分配一个行号（rn）。然后，我们通过内部的子查询和外部的JOIN操作，选择每个id分区中rn为1的记录，即每个实体的最新记录。

在MySQL中，如果你使用的是较旧的版本，不支持开窗函数，你可以使用以下方法：




SELECT ht.*
FROM history_table ht
INNER JOIN (
  SELECT id, MAX(timestamp) AS max_timestamp
  FROM history_table
  GROUP BY id
) subquery ON ht.id = subquery.id AND ht.timestamp = subquery.max_timestamp;

在这个查询中，我们首先为每个id计算最大的timestamp，然后使用这个信息来选择原始表中的记录，以获得每个实体的最新记录。这种方法在不支持开窗函数的MySQL版本中有效。

System

2024-09-05

所有,java

以下是一个简单的基于JavaWeb、JSP、Servlet、JavaBean、MySQL和Tomcat的留言板实现的代码示例。

首先，创建一个名为Message的JavaBean来表示留言信息：




public class Message {
    private String name;
    private String email;
    private String content;
 
    // 省略构造函数、getter和setter方法
}

然后，创建一个名为MessageDAO的类用于数据库操作：




public class MessageDAO {
    public boolean addMessage(Message message) {
        // 连接数据库，执行插入操作，返回是否成功
        // 省略数据库连接和SQL语句的代码
    }
 
    public List<Message> getAllMessages() {
        // 连接数据库，查询所有留言，返回留言列表
        // 省略数据库连接和SQL语句的代码
    }
}

创建一个名为MessageServlet的Servlet处理用户的留言提交和获取留言信息的请求：




@WebServlet("/message")
public class MessageServlet extends HttpServlet {
    private MessageDAO messageDAO = new MessageDAO();
 
    protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        // 获取留言信息
        String name = request.getParameter("name");
        String email = request.getParameter("email");
        String content = request.getParameter("content");
 
        Message message = new Message(name, email, content);
        boolean success = messageDAO.addMessage(message);
 
        if (success) {
            response.sendRedirect("message.jsp"); // 重定向到留言板页面
        } else {
            // 处理失败情况
        }
    }
 
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        List<Message> messages = messageDAO.getAllMessages();
        request.setAttribute("messages", messages);
        request.getRequestDispatcher("message.jsp").forward(request, response);
    }
}

最后，创建一个名为message.jsp的JSP页面用于留言板的展示和留言的提交：




<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>留言板</title>
</head>
<body>
<h2>留言板</h2>
<form action="message" method="post">
    姓名: <input type="text" name="name"><br>
    邮箱: <input type="text" name="email"><br>
    内容: <textarea name="content" rows="5" cols="40"></textarea><br>
    <input type="submit" value="提交">
</form>
<hr>
<% List<Message> messages = (List<Message>) request.getAttribute("messages"); %>
<% if (messages != null) { %>
    <% for (Message messag

System

2024-09-05

所有,java

CVE-2022-9484是Apache Tomcat服务器中一个关于Session管理的安全漏洞。该漏洞允许未授权的攻击者在没有Session ID的情况下创建一个新的会话，或者在有Session ID但没有相应权限的情况下访问或修改一个存在的会话。

为了利用这个漏洞，攻击者可以发送一个特制的请求到受影响的Tomcat服务器。以下是一个利用该漏洞的简单Python脚本示例：




import requests
 
# 目标服务器的URL
url = "http://your-tomcat-server/examples/servlets/servlet/SessionExample"
 
# 发送一个OPTIONS请求来检查是否存在CVE-2022-9484漏洞
response = requests.options(url)
 
# 检查服务器响应头是否包含Referrer-Policy为空的响应
if response.headers.get('Referrer-Policy') == '':
    print("CVE-2022-9484 vulnerability detected!")
    # 接下来可以执行其他的攻击，例如会话劫持等
else:
    print("Server is not vulnerable.")

请注意，实际的攻击可能涉及到更复杂的情况，并且可能需要其他工具或脚本来完整地实施攻击。这个示例只是用来检测服务器是否容易受到此漏洞的影响。

为了保证安全，建议立即将您的Apache Tomcat服务器升级到最新的修复版本。这通常涉及到下载安全补丁，应用补丁，并重启Tomcat服务器。官方通常会在漏洞公开后的几天内发布这些更新。

- 阅读更多 -

Springboot集成-数据采集工具Flink-CDC

System

2024-09-05

所有,java

为了解决这个问题，我们需要创建一个Spring Boot应用程序，它使用Flink来进行数据采集，并使用Flink CDC从数据库中读取变更数据。以下是一个简化的代码示例：




import org.apache.flink.streaming.api.environment.StreamExecutionEnvironment;
import org.apache.flink.table.api.bridge.java.StreamTableEnvironment;
import org.apache.flink.table.api.TableResult;
import org.apache.flink.table.api.EnvironmentSettings;
import com.ververica.cdc.connectors.mysql.MySqlSource;
import com.ververica.cdc.debezium.StringDebeziumDeserializationSchema;
 
public class FlinkCDCExample {
    public static void main(String[] args) throws Exception {
        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
        EnvironmentSettings settings = EnvironmentSettings.newInstance()
            .useBlinkPlanner()
            .inStreamingMode()
            .build();
        StreamTableEnvironment tableEnv = StreamTableEnvironment.create(env, settings);
 
        MySqlSource<String> mySqlSource = MySqlSource.<String>builder()
            .hostname("your-db-host")
            .port(3306)
            .databaseList("your-database") // set captured database
            .tableList("your-database.your-table") // set captured table
            .username("your-username")
            .password("your-password")
            .deserializer(new StringDebeziumDeserializationSchema()) // converts the binlog into String format
            .build();
 
        TableResult tableResult = tableEnv.executeSql("CREATE TABLE source_table (" +
            "   id INT NOT NULL," +
            "   name STRING," +
            "   PRIMARY KEY (id) NOT ENFORCED" +
            ") WITH (" +
            "   'connector' = 'mysql-cdc'," +
            "   'hostname' = 'your-db-host'," +
            "   'port' = '3306'," +
            "   'username' = 'your-username'," +
            "   'password' = 'your-password'," +
            "   'database-name' = 'your-database'," +
            "   'table-name' = 'your-table'" +
            ")");
 
        env.execute("Flink CDC MySQL Job");
    }
}

在这个例子中，我们创建了一个StreamExecutionEnvironment和一个StreamTableEnvironment。然后，我们配置了MySqlSource，指定了数据库的主机名、端口、数据库名、表名、用户名和密码。我们还定义了一个Debezium反序列化方案，它将来自Debezium的二进制日志转换为String格式。

最后，我们通过执行SQL语句在TableEnvironment中创建了一个源表，并执行了Flink作业。

注意：这个例子假设你已经将Flink

- 阅读更多 -

Python3 time — 时间模块

System

2024-09-05

所有,python

Python 的 time 模块提供了几个函数来处理时间相关的操作。以下是一些常用的函数和相关的使用示例：

time.sleep(secs): 暂停执行给定的秒数。




import time
 
print("Before sleep")
time.sleep(5)  # 暂停5秒
print("After sleep")

time.time(): 返回当前时间的时间戳。




import time
 
current_time = time.time()
print(current_time)  # 输出类似于1585157600.201845

time.ctime(): 返回当前时间的字符串形式。




import time
 
current_time = time.ctime()
print(current_time)  # 输出类似于'Sun Mar 29 10:06:40 2021'

time.gmtime(): 返回当前时间的UTC时间的struct_time形式。




import time
 
current_time = time.gmtime()
print(current_time)  # 输出类似于time.struct_time(tm_year=2021, tm_mon=3, tm_mday=29, tm_hour=10, tm_min=18, tm_sec=39, tm_wday=6, tm_yday=90, tm_isdst=0)

time.localtime(): 返回当前时间的本地时间的struct_time形式。




import time
 
current_time = time.localtime()
print(current_time)  # 输出类似于time.struct_time(tm_year=2021, tm_mon=3, tm_mday=29, tm_hour=10, tm_min=22, tm_sec=12, tm_wday=6, tm_yday=90, tm_isdst=0)

time.mktime(t): 将struct_time形式的时间转换为时间戳。




import time
 
current_time = time.localtime()
time_stamp = time.mktime(current_time)
print(time_stamp)  # 输出类似于1585158532.0

time.strftime(format, t): 将struct_time形式的时间转换为字符串形式。




import time
 
current_time = time.localtime()
time_string = time.strftime("%Y-%m-%d %H:%M:%S", current_time)
print(time_string)  # 输出类似于'2021-03-29 10:30:37'

time.strptime(string, format): 将字符串形式的时间转换为struct_time形式。




import time
 
time_string = "2021-03-29 10:30:37"
struct_time = time.strptime(time_string, "%Y-%m-%d %H:%M:%S")
print(struct_time)  # 输出类似于time.struct_time(tm_year=2021, tm_mon=3, tm_mday=29, tm_hour=10, tm_min=30, tm_sec=37, tm_wday=6, tm_yday=90, tm_isdst=-1)

以上是一些基本的 time 模块操作。实际使用时，可以根据需要选择合适的函数。

- 阅读更多 -

[spring] Spring Boot REST API - 项目实现

System

2024-09-05

所有,java

以下是一个简化的Spring Boot REST API项目的代码实例，展示了如何创建一个简单的CRUD应用。




// 导入Spring Boot相关依赖
import org.springframework.boot.*;
import org.springframework.boot.autoconfigure.*;
import org.springframework.web.bind.annotation.*;
 
@RestController
@EnableAutoConfiguration
public class ExampleRestApi {
 
    // 创建一个简单的用户模型
    public static class User {
        private String id;
        private String name;
 
        // 构造器、getter和setter省略
    }
 
    // 创建一个用于存储用户的模拟数据结构
    private static final Map<String, User> users = new HashMap<>();
 
    static {
        users.put("1", new User("1", "Alice"));
        users.put("2", new User("2", "Bob"));
    }
 
    // 获取所有用户
    @GetMapping("/users")
    public Collection<User> getAllUsers() {
        return users.values();
    }
 
    // 通过ID获取单个用户
    @GetMapping("/users/{id}")
    public User getUser(@PathVariable String id) {
        return users.get(id);
    }
 
    // 创建新用户
    @PostMapping("/users")
    public User createUser(@RequestBody User user) {
        String id = String.valueOf(users.size() + 1);
        user.setId(id);
        users.put(id, user);
        return user;
    }
 
    // 更新现有用户
    @PutMapping("/users/{id}")
    public User updateUser(@PathVariable String id, @RequestBody User user) {
        user.setId(id);
        users.put(id, user);
        return user;
    }
 
    // 删除用户
    @DeleteMapping("/users/{id}")
    public String deleteUser(@PathVariable String id) {
        users.remove(id);
        return "User deleted";
    }
 
    // 主函数，启动Spring Boot应用
    public static void main(String[] args) {
        SpringApplication.run(ExampleRestApi.class, args);
    }
}

这段代码展示了如何创建一个简单的REST API，它提供了对用户资源的基本CRUD操作。这个例子教会开发者如何使用Spring Boot创建REST API，并且如何通过注解来映射HTTP请求到相应的处理方法。这个项目没有使用数据库，而是使用了一个简单的内存数据结构来模拟数据存储。在实际应用中，你需要替换掉这部分，使用真实的数据库来持久化数据

- 阅读更多 -

【redis】redis集群

System

2024-09-05

所有,redis

Redis集群是一种Redis服务器之间的网络连接，其中数据自动在多个节点之间分区。以下是一些可以用来设置和操作Redis集群的基本命令和示例代码。

创建Redis集群

Redis集群的创建通常需要多个Redis实例。你可以在每个实例上运行相同的redis-server命令，并为它们提供不同的端口号。例如，你可以使用以下命令在端口7000、7001和7002上创建三个Redis实例：




redis-server --port 7000 --cluster-enabled yes --cluster-config-file nodes-7000.conf --cluster-node-timeout 5000 --appendonly yes --appendfilename appendonly-7000.aof --dbfilename dump-7000.rdb
redis-server --port 7001 --cluster-enabled yes --cluster-config-file nodes-7001.conf --cluster-node-timeout 5000 --appendonly yes --appendfilename appendonly-7001.aof --dbfilename dump-7001.rdb
redis-server --port 7002 --cluster-enabled yes --cluster-config-file nodes-7002.conf --cluster-node-timeout 5000 --appendonly yes --appendfilename appendonly-7002.aof --dbfilename dump-7002.rdb

创建集群

一旦你有了多个Redis实例在运行，你可以使用redis-cli工具创建集群。以下命令将创建一个包含在端口7000、7001和7002上运行的Redis实例的集群：




redis-cli --cluster create 127.0.0.1:7000 127.0.0.1:7001 127.0.0.1:7002 --cluster-replicas 1

查看集群信息

要查看集群的信息，你可以使用以下命令：




redis-cli -c -p 7000 cluster info

添加节点

如果你想向现有集群添加一个新节点，你可以首先启动一个新的Redis实例，然后使用以下命令将其添加到集群：




redis-cli --cluster add-node 127.0.0.1:7003 127.0.0.1:7000

分配槽

在Redis集群中，数据是根据哈希槽分区的。你可以使用以下命令手动分配或重新分配哈希槽：




redis-cli --cluster reshard 127.0.0.1:7000

故障转移

如果主节点失败，Redis集群将自动启动故障转移进程。你也可以手动启动故障转移：




redis-cli --cluster failover 127.0.0.1:7000

删除节点

如果你需要从集群中删除一个节点，你可以首先将该节点上的所有键迁移到其他节点，然后删除它：




redis-cli --cluster del-node 127.0.0.1:7000 <node-id-of-node-to-be-deleted>

以上命令和操作是Redis集群管理的基础。在实际应用中，你可能需要更复杂的脚本和工具来管理你的Redis集群。

- 阅读更多 -

Spring Cloud Alibaba基础教程：Nacos配置的加载规则详解

System

2024-09-05

所有,java

在Spring Cloud Alibaba中，Nacos配置管理的功能可以帮助我们集中管理应用的配置信息。Spring Cloud会根据一定的规则加载Nacos中的配置信息。

以下是Spring Cloud Alibaba Nacos配置加载的规则：

配置优先级：Bootstrap.properties或Bootstrap.yml文件 > application.properties或application.yml文件 > @ConfigurationProperties注解的配置类 > 命令行参数 > 环境变量 > Nacos配置管理中心。
命名空间：不同的命名空间可以用于隔离不同环境的配置，如dev、test、prod等。
分组：同一命名空间下的配置可以根据不同的应用或不同的配置分类到不同的分组中。
配置的动态刷新：Nacos配置管理中心的配置更新后，可以实时通知到应用，应用可以在运行时动态更新配置。

下面是一个简单的示例，展示如何在Spring Cloud Alibaba应用中使用Nacos作为配置中心：




# 在bootstrap.properties中指定Nacos配置中心
spring.cloud.nacos.config.server-addr=127.0.0.1:8848
spring.cloud.nacos.config.namespace=命名空间ID
spring.cloud.nacos.config.group=配置分组
spring.cloud.nacos.config.extension-configs[0].data-id=application.yml
spring.cloud.nacos.config.extension-configs[0].group=配置分组
spring.cloud.nacos.config.extension-configs[0].refresh=true




# Nacos中的配置文件，如application.yml
myapp:
  property: value




// 在应用中使用@Value注解或@ConfigurationProperties注解来使用配置
@RestController
public class ConfigController {
 
    @Value("${myapp.property}")
    private String property;
 
    @GetMapping("/config")
    public String getConfig() {
        return property;
    }
}

在这个例子中，我们通过spring.cloud.nacos.config.server-addr指定了Nacos配置中心的地址，并且通过spring.cloud.nacos.config.extension-configs指定了加载的配置文件。在Nacos控制台上管理配置文件，并确保配置文件的命名空间和分组与Spring Cloud Alibaba应用中的配置匹配，应用就可以动态加载和使用Nacos中的配置信息。

- 阅读更多 -

MongoDB初探：安装与图形化界面保姆级使用指南

System

2024-09-05

所有,数据库




# 更新系统包信息
sudo apt-get update
 
# 安装MongoDB包
sudo apt-get install -y mongodb
 
# 启动MongoDB服务
sudo service mongodb start
 
# 开机自启动MongoDB
sudo systemctl enable mongodb
 
# 安装MongoDB GUI工具，例如NoSQLBooster for MongoDB
# 这里以wget方式安装为例，实际可能需要从官网下载安装包
wget -qO- https://download.nosqlbooster.com/insiders/mongodb/nosqlbooster-insiders_5.10.0-linux-x86_64.sh | bash
 
# 运行NoSQLBooster for MongoDB
./NoSQLBooster-for-MongoDB

这段代码提供了在Ubuntu系统上安装MongoDB，并设置开机自启动的步骤。同时演示了如何使用wget下载并安装NoSQLBooster for MongoDB的过程。这个GUI工具能够提供更直观的数据库操作界面，对于初学者来说非常有用。

- 阅读更多 -

Spring Boot+OAuth2，一个注解搞定单点登录！

System

2024-09-05

所有,java

在Spring Boot中使用OAuth2进行单点登录，可以通过@EnableOAuth2Sso注解来简化配置。这个注解会自动配置一个过滤器用于拦截请求并要求用户登录。

以下是一个简单的例子：

在application.properties或application.yml中配置OAuth2服务提供商的相关信息：




security.oauth2.client.client-id=client-id
security.oauth2.client.client-secret=client-secret
security.oauth2.client.access-token-uri=https://example.com/oauth/token
security.oauth2.resource.user-info-uri=https://example.com/me
security.oauth2.client.scope=read,write

在Spring Boot的主类或配置类上添加@EnableOAuth2Sso注解：




import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.oauth2.client.registration.ClientRegistrationRepository;
import org.springframework.security.oauth2.client.web.OAuth2AuthorizationRequestRedirectFilter;
 
@EnableOAuth2Sso
@SpringBootApplication
public class MyApp {
    public static void main(String[] args) {
        SpringApplication.run(MyApp.class, args);
    }
}

使用@EnableOAuth2Sso注解后，Spring Boot应用会自动配置所需的OAuth2登录流程，当访问受保护的资源时，如果用户未登录，会自动跳转到OAuth2服务提供商的登录页面。

注意：在实际应用中，你需要替换上述配置中的client-id、client-secret、access-token-uri、user-info-uri和scope为你的OAuth2服务提供商的实际值。

- 阅读更多 -