System 发布的文章

Redis常用数据结构常用命令总览

2024-09-06

所有,redis

Redis 是一个开源的使用 C 语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value 数据库，并提供多种语言的 API。

Redis 的数据结构：

字符串（String）
列表（List）
集合（Set）
有序集合（Sorted Set）
哈希（Hash）
位图（Bitmap）
HyperLogLog
Stream

常用的 Redis 命令：

String
- SET：为一个键设置值
- GET：获取一个键的值
- INCR：将键的整数值增加1
- DECR：将键的整数值减少1
- INCRBY：将键的整数值增加指定的整数
- DECRBY：将键的整数值减少指定的整数
- SETNX：只有键不存在时，设置键的值
- GETSET：设置键的值并返回旧值
List
- LPUSH：将一个或多个值插入到列表头部
- RPUSH：将一个或多个值插入到列表尾部
- LPOP：移出并获取列表的第一个元素
- RPOP：移出并获取列表的最后一个元素
- LLEN：获取列表长度
- LRANGE：获取列表指定范围内的元素
Set
- SADD：向集合添加一个或多个成员
- SMEMBERS：获取集合中的所有成员
- SISMEMBER：判断成员是否在集合中
- SCARD：获取集合的成员数
- SREM：移除集合中的一个或多个成员
Sorted Set
- ZADD：向有序集合添加一个或多个成员
- ZCARD：获取有序集合的成员数
- ZCOUNT：计算在有序集合中指定分数区间内的元素数量
- ZRANGE：按索引范围返回有序集合成指定区间内的成员
- ZREM：移除有序集合中的一个或多个成员
Hash
- HSET：将哈希表中的字段的值设置为
- HGET：获取存储在哈希表中的字段的值
- HGETALL：获取在哈希表中指定键的所有字段和值
- HDEL：删除一个或多个哈希表字段
Bitmap
- SETBIT：对键的二进制表示的位进行设置
- GETBIT：对键的二进制表示的位进行获取
- BITCOUNT：计算给定位区间内的位的数量
HyperLogLog
- PFADD：添加元素到HyperLogLog
- PFCOUNT：返回HyperLogLog的基数估算值
- PFMERGE：将多个HyperLogLog合并为一个
Stream
- XADD：将消息添加到流
- XREAD：从流读取消息
- XDEL：删除流中的一条或多条消息
- XLEN：获取流中消息的数量
- XRANGE：根据ID范围获取消息
- XREVRANGE：根据ID范围，逆向获取消息

以上是 Redis 常用数据结构和命令的简要概述和示例，具体使用时需要根据实际需求选择合适的数据结构和命令。

【网站项目】SpringBoot701线上历史馆藏系统

2024-09-06

由于问题描述不具体，我将提供一个使用Spring Boot创建简单REST API的示例，该API可能与您提到的“线上历史馆藏系统”有关。

首先，您需要在Spring Initializr（https://start.spring.io/）上生成一个Spring Boot项目的基础结构，并包含以下依赖：




<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
</dependencies>

接下来，创建一个简单的REST控制器：




import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
 
@RestController
public class HistoryRoomController {
 
    @GetMapping("/items")
    public String getItems() {
        // 假设这里是从数据库获取数据
        return "['item1', 'item2', 'item3']";
    }
 
    @GetMapping("/items/{id}")
    public String getItemById(@PathVariable String id) {
        // 假设这里是从数据库获取具体项目
        return "{\"id\": \"" + id + "\", \"name\": \"Item " + id + "\"}";
    }
}

最后，创建一个Spring Boot应用程序的主类：




import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
 
@SpringBootApplication
public class HistoryRoomApplication {
    public static void main(String[] args) {
        SpringApplication.run(HistoryRoomApplication.class, args);
    }
}

这个简单的示例展示了如何使用Spring Boot创建REST API。您可以根据实际需求，将数据获取逻辑替换为数据库操作，并添加更多的功能，如增删改查操作。

SpringBoot实现缓存预热的几种常用方案

2024-09-06

在Spring Boot中实现缓存预热的常见方法有以下几种：

使用@PostConstruct注解的方法：
在需要预热的服务组件中，使用@PostConstruct注解的方法可以在服务组件初始化时自动执行，完成缓存预热。




@Service
public class CacheService {
 
    @PostConstruct
    public void preloadCache() {
        // 预热缓存的逻辑
    }
}

使用CommandLineRunner或ApplicationRunner接口：
实现CommandLineRunner或ApplicationRunner接口，并重写run方法，可以在容器启动完成后，应用启动之前进行缓存预热。




@Component
public class CacheCommandLineRunner implements CommandLineRunner {
 
    @Override
    public void run(String... args) {
        // 预热缓存的逻辑
    }
}

使用定时任务（ScheduledTasks）：
在应用启动时启动一个定时任务，定时执行缓存预热的逻辑。




@Component
public class CacheScheduledTasks {
 
    private final CacheManager cacheManager;
 
    @Autowired
    public CacheScheduledTasks(CacheManager cacheManager) {
        this.cacheManager = cacheManager;
    }
 
    @Scheduled(fixedDelay = 30000)
    public void preloadCaches() {
        // 预热缓存的逻辑
    }
}

使用CacheManager的初始化回调：
如果使用的是如EhCache、Redis等成熟的缓存框架，可以通过其配置支持预热特性。




@Configuration
public class CacheConfig {
 
    @Bean
    public CacheManager cacheManager() {
        EhCacheCacheManager cacheManager = new EhCacheCacheManager();
        cacheManager.setCacheManager(ehCacheManager());
        // 预热缓存
        return cacheManager;
    }
 
    @Bean
    public net.sf.ehcache.CacheManager ehCacheManager() {
        // 创建EhCacheManager并设置预热逻辑
        return net.sf.ehcache.CacheManager.create();
    }
}

以上方法可以根据具体场景选择使用，例如对于实时性要求不高的场景，使用@PostConstruct或CommandLineRunner接口是简单有效的。对于实时性要求高的场景，可以使用定时任务方式，在启动后一定时间内预热缓存。而对于EhCache等具备预热特性的缓存实现，可以在CacheManager配置中设置预热。

Oracle数据库迁移PostgreSQL

2024-09-06

所有,数据库

Oracle数据库迁移到PostgreSQL需要一个专业的迁移项目，涉及数据类型转换、SQL语法差异、事务处理、存储过程和触发器的转换等多个方面。以下是一个简化的示例，展示如何将Oracle的INSERT语句转换为PostgreSQL的等效语句。

Oracle INSERT语句示例:




INSERT INTO employees (id, name, salary)
VALUES (10, 'John Doe', 50000);

转换为PostgreSQL的等效语句:




INSERT INTO employees (id, name, salary)
VALUES (10, 'John Doe', 50000.00); -- PostgreSQL中需显式指定salary的精度

在实际迁移过程中，还需要处理其他复杂情况，如序列和触发器的转换、数据类型的转换（例如，Oracle的DATE类型在PostgreSQL中通常需要转换为TIMESTAMP或TIMESTAMPTZ）、大小写敏感性处理等。

迁移工具如EnterpriseDB的pgloader或ora2pg可以帮助自动化迁移过程中的一些任务，但最终还是需要手动处理SQL脚本和数据的。

对于更复杂的数据库模式和数据，建议使用专业的数据库迁移工具或服务，如Talend, Pentaho, DB2DB, Quest Software的Data Delta等。

在实际迁移时，还需要考虑安全性和配置管理问题，确保数据的完整性和应用程序的连续性。

2024-09-06

所有,数据库

在Windows环境下，如果您忘记了MySQL的root密码，可以按照以下步骤进行密码的重置：

停止MySQL服务：
```
net stop mysql
```
设置MySQL服务的启动方式为手动，以避免服务在重启后自动启动：
```
sc config mysql start= demand
```
打开一个新的命令行窗口，跳过权限表启动MySQL服务器：
```
mysqld_safe --skip-grant-tables &
```
登录到MySQL服务器作为root用户：
```
mysql -u root
```
选择MySQL数据库：
```
use mysql;
```
重置root密码（将'new\_password'替换为您想要的新密码）：
```
update user set authentication_string=PASSWORD('new_password') where User='root';
```
或者，如果您使用的是MySQL 5.7以上版本，可以使用以下命令来更新密码字段：
```
update user set authentication_string=PASSWORD('new_password') where User='root';
```
刷新权限表使更改生效：
```
FLUSH PRIVILEGES;
```
退出MySQL：
```
quit
```
关闭之前打开的带有--skip-grant-tables的MySQL服务器窗口。
重新启动MySQL服务：
```
net start mysql
```
使用新密码登录到MySQL以确认更改已生效：
```
mysql -u root -p
```

在以上步骤中，请确保替换new_password为您想要设置的实际密码。这将重置root用户的密码。请注意，在执行这些步骤时需要具有管理员权限的命令行界面。

Docker-安装实践(mysql,redis集群,tomcat)

2024-09-06

以下是使用Docker安装MySQL, Redis集群和Tomcat的简化版示例代码：




# 拉取MySQL镜像
docker pull mysql:5.7
 
# 运行MySQL容器
docker run --name mysql -e MYSQL_ROOT_PASSWORD=my-secret-pw -d mysql:5.7
 
# 拉取Redis镜像
docker pull redis:5.0.9
 
# 运行Redis Master容器
docker run --name redis-master -d redis:5.0.9 redis-server --appendonly yes
 
# 运行Redis Slave容器，连接到Redis Master
docker run --name redis-slave --link redis-master:master -d redis:5.0.9 redis-server --slaveof master 6379 --appendonly yes
 
# 拉取Tomcat镜像
docker pull tomcat:9.0
 
# 运行Tomcat容器
docker run --name tomcat -p 8080:8080 -d tomcat:9.0

这段代码演示了如何使用Docker命令快速地安装和运行MySQL, Redis集群和Tomcat服务器。这些命令简洁明了，并提供了基本的安全设置，如为MySQL设置root密码。对于Redis，我们创建了一个主实例和一个从实例来演示集群的概念。Tomcat的安装则是标准的单实例运行。

2024-09-06

在Spring Boot中整合Servlet、Filter和Listener可以通过以下方式：

创建Servlet类：




import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
 
public class MyServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        resp.getWriter().write("Hello from MyServlet");
    }
}

创建Filter类：




import javax.servlet.*;
import java.io.IOException;
 
public class MyFilter implements Filter {
    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        // 初始化代码
    }
 
    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) 
            throws IOException, ServletException {
        // 在请求处理之前可以进行一些操作
        chain.doFilter(request, response); // 继续请求处理
        // 在请求处理之后可以进行一些操作
    }
 
    @Override
    public void destroy() {
        // 销毁代码
    }
}

创建Listener类：




import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
 
public class MyListener implements ServletContextListener {
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        // 应用启动时执行的代码
    }
 
    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        // 应用关闭时执行的代码
    }
}

注册Servlet、Filter和Listener：




import org.springframework.boot.web.servlet.FilterRegistrationBean;
import org.springframework.boot.web.servlet.ServletListenerRegistrationBean;
import org.springframework.boot.web.servlet.ServletRegistrationBean;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
 
@Configuration
public class WebConfig {
 
    @Bean
    public ServletRegistrationBean myServlet() {
        return new ServletRegistrationBean(new MyServlet(), "/myServlet");
    }
 
    @Bean
    public FilterRegistrationBean myFilter() {
        FilterRegistrationBean registration = new FilterRegistrationBean(new MyFilter());
        registration.addUrlPatterns("/myServlet");
        return registration;
    }

Linux中Tomcat的重启操作

2024-09-06

在Linux环境下重启Tomcat，通常可以通过Tomcat自带的脚本来完成。以下是一个基本的重启操作步骤和示例代码：

确定Tomcat的安装路径，通常默认安装路径是/usr/local/tomcat或/opt/tomcat。
进入Tomcat的bin目录下。
执行shutdown.sh脚本关闭Tomcat，然后执行startup.sh脚本启动Tomcat。

示例代码：




# 进入Tomcat的bin目录
cd /usr/local/tomcat/bin
 
# 执行shutdown.sh脚本
./shutdown.sh
 
# 等待几秒钟，确保Tomcat完全关闭
sleep 5
 
# 执行startup.sh脚本启动Tomcat
./startup.sh

如果你想要创建一个脚本来自动化这个过程，可以创建一个名为restart_tomcat.sh的文件，并将以下内容复制进去：




#!/bin/bash
 
# 设置Tomcat的安装路径
CATALINA_HOME=/usr/local/tomcat
 
# 进入Tomcat的bin目录
cd $CATALINA_HOME/bin
 
# 关闭Tomcat
echo "Stopping Tomcat..."
./shutdown.sh
 
# 等待Tomcat关闭
echo "Waiting for Tomcat to shutdown..."
while [ -f "$CATALINA_HOME/bin/tomcat.pid" ]; do
    sleep 1
done
 
# 启动Tomcat
echo "Starting Tomcat..."
./startup.sh

然后给这个脚本添加执行权限：




chmod +x restart_tomcat.sh

最后运行这个脚本来重启Tomcat：




./restart_tomcat.sh

确保你有足够的权限执行这些脚本，如果不够，可能需要使用sudo来提升权限。

sql注入5-8关实现

2024-09-06

所有,数据库

SQL注入关卡通常是为了测试用户对SQL注入攻击的理解和防护措施。以下是一个简单的PHP代码示例，用于实现对5-8关的防护，使用预处理语句来防止SQL注入：




<?php
// 假设已经连接到数据库
$db = new PDO('mysql:host=localhost;dbname=your_database', 'username', 'password');
 
// 用户输入
$id = $_GET['id'];
 
// 准备预处理语句
$stmt = $db->prepare("SELECT * FROM users WHERE id = :id");
 
// 绑定参数
$stmt->bindParam(':id', $id, PDO::PARAM_INT);
 
// 执行查询
$stmt->execute();
 
// 获取结果
$result = $stmt->fetchAll(PDO::FETCH_ASSOC);
 
// 处理结果...
?>

在这个例子中，我们使用了PDO（PHP数据对象）的预处理语句来构建SQL查询。通过使用参数绑定，:id被视作参数，而不是直接将用户输入拼接到SQL查询中，这样可以防止SQL注入攻击。使用PDO的bindParam方法，我们将$id变量与查询中的参数:id绑定起来，并指定参数的类型为整数。这种方式是现代编程实践中推荐的防护SQL注入的方法。