分类后端技术下的文章

2024-09-02




# 在Django项目的settings.py文件中配置PostgreSQL数据库
# 示例代码
 
DATABASES = {
    'default': {
        'ENGINE': 'django.db.backends.postgresql',  # 指定数据库引擎
        'NAME': 'mydatabase',                       # 数据库名称
        'USER': 'mydatabaseuser',                   # 数据库用户
        'PASSWORD': 'mypassword',                   # 数据库密码
        'HOST': 'localhost',                        # 数据库主机地址
        'PORT': '5432',                             # 数据库端口
    }
}
 
# 注意：在实际部署时，应该使用环境变量或者安全的方式来储存敏感信息，例如：
# - 使用12factor的方法，通过环境变量传递数据库密码等信息。
# - 使用Django的`django-environ`库来安全地加载环境变量。

在这个例子中，我们配置了Django项目使用PostgreSQL作为数据库，并且指定了数据库引擎、名称、用户、密码、主机和端口。在实际部署时，应该考虑使用更安全的方式来储存敏感信息。

- 阅读更多 -

Python 高手编程系列五百三十六：命名和使用

System

2024-09-02

所有,数据库

在Python中，可以通过namedtuple工厂函数来创建一个带有名称的元组子类，其中每个元素都有一个名称。这样可以使得元组内的数据更具可读性和可维护性。

下面是一个使用namedtuple的例子：




from collections import namedtuple
 
# 定义一个名为Point的namedtuple
Point = namedtuple('Point', ['x', 'y'])
 
# 创建一个Point实例
p = Point(10, 20)
 
# 访问元素
print(p.x)  # 输出: 10
print(p.y)  # 输出: 20
 
# 使用_fields属性获取字段名称列表
print(Point._fields)  # 输出: ('x', 'y')
 
# 使用_make()方法从一个可迭代对象创建一个Point实例
p_from_iter = Point._make([30, 40])
print(p_from_iter)  # 输出: Point(x=30, y=40)

在这个例子中，我们定义了一个名为Point的namedtuple，并且用两个字段名'x'和'y'初始化了它。然后我们创建了一个Point实例，并且演示了如何访问这些字段，如何获取字段名称列表，以及如何从一个可迭代对象创建一个新的namedtuple实例。

- 阅读更多 -

Linux环境安装Redis

System

2024-09-02

所有,redis

在Linux环境中安装Redis，可以遵循以下步骤：

更新包管理器索引：




sudo apt-get update

安装Redis：




sudo apt-get install redis-server

启动Redis服务：




sudo systemctl start redis-server

确认Redis正在运行：




sudo systemctl status redis-server

（可选）使Redis开机自启：




sudo systemctl enable redis-server

测试Redis是否安装成功：




redis-cli ping

如果返回PONG，则表示Redis已成功安装并可以使用。

注意：以上命令适用于基于Debian的系统（如Ubuntu）。对于基于RPM的系统（如CentOS），你需要使用yum或dnf代替apt-get。

- 阅读更多 -

Tomcat后台管理漏洞复现(弱口令＋上传webshell)

System

2024-09-02

所有,java

要复现Tomcat后台管理漏洞，需要满足以下条件：

有一个受影响版本的Tomcat服务器。
对应版本的Tomcat管理界面使用弱口令。
有文件上传能力。

以下是一个使用Burp Suite进行Tomcat后台管理漏洞复现的简化流程：

开启Burp Suite代理，设置浏览器代理指向Burp Suite的代理端口。
访问Tomcat服务器的管理页面，例如 http://your-tomcat-server:8080/manager/html。
尝试使用弱口令登录。
登录成功后，尝试上传一个Web Shell（例如shell.jsp）。
上传成功后，通过Burp Suite或其他方式监听服务器端口，访问Web Shell以获取服务器控制权。

这里是一个使用Burp Suite的示例步骤：

在浏览器中访问Tomcat管理页面。
在Burp Suite中拦截登录请求，使用弱口令。
发送到Repeater模块，修改请求后重发。
如果登录成功，尝试上传文件。
同样在Burp Suite中上传文件时，确保文件内容是Web Shell代码。
上传文件后，访问Web Shell以获取服务器控制权。

注意：实际操作时，请确保您有合法权限进行测试，并在完成后清理所有上传的文件以避免不必要的风险。

- 阅读更多 -

SpringCloud-创建多模块项目

System

2024-09-02

所有,java

在Spring Cloud中创建多模块项目通常涉及以下步骤：

使用Spring Initializr（https://start.spring.io/）生成父项目。
在父项目中添加pom.xml配置。
创建子模块，并在父项目的pom.xml中定义。

以下是一个简单的多模块项目示例：

父项目的pom.xml：




<groupId>com.example</groupId>
<artifactId>springcloud-multimodule-project</artifactId>
<version>1.0.0-SNAPSHOT</version>
<packaging>pom</packaging>
 
<name>Spring Cloud Multimodule Project</name>
<description>Parent project for Spring Cloud Multimodule</description>
 
<modules>
    <module>service-api</module>
    <module>service-impl</module>
</modules>
 
<!-- 版本管理 -->
<properties>
    <java.version>1.8</java.version>
    <spring-cloud.version>Hoxton.SR10</spring-cloud.version>
</properties>
 
<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.cloud</groupId>
            <artifactId>spring-cloud-dependencies</artifactId>
            <version>${spring-cloud.version}</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>
 
<build>
    <plugins>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
</build>

子模块service-api的pom.xml：




<parent>
    <groupId>com.example</groupId>
    <artifactId>springcloud-multimodule-project</artifactId>
    <version>1.0.0-SNAPSHOT</version>
</parent>
 
<groupId>com.example</groupId>
<artifactId>service-api</artifactId>
<version>1.0.0-SNAPSHOT</version>
 
<dependencies>
    <!-- 添加需要的依赖 -->
</dependencies>

子模块service-impl的pom.xml：




<parent>
    <groupId>com.example</groupId>
    <artifactId>springcloud-multimodule-project</artifactId>
    <version>1.0.0-SNAPSHOT</version>
</parent>
 
<groupId>com.example</groupId>
<artifactId>service-impl</artifactId>
<version>1.0.0-SNAPSHOT</version>
 
<dependencies>
    <dependency>
        <groupId>com.example</groupId>
        <artifactId>service-api</artifactId>
        <version>1.0.0-SNAPSHOT</version>
    </dependency>
    <!-- 添加其他依赖 -->
</dependencies>

在这个例子中，service-api模块定义了一个公共的API层，而service-impl模块提供了API层的具体实现。父项目springcloud-multimodule-project管理了子模块的版本和Spring Cloud的依赖。

记得在IDE（如IntelliJ IDEA或Eclipse）中导入项目时，选择父项目的pom.xml文件作为入口。这样，

- 阅读更多 -

SpringBoot PowerMockito 私有/静态/方法/属性

System

2024-09-02

所有,java

在SpringBoot项目中使用PowerMockito进行单元测试时，可以模拟私有方法、静态方法和属性的行为。以下是一个简单的例子：




import org.junit.Test;
import org.junit.runner.RunWith;
import org.powermock.api.mockito.PowerMockito;
import org.powermock.core.classloader.annotations.PrepareForTest;
import org.powermock.modules.junit4.PowerMockRunner;
import static org.junit.Assert.assertEquals;
 
@RunWith(PowerMockRunner.class)
@PrepareForTest(YourClass.class) // 指定需要模拟的类
public class YourClassTest {
 
    @Test
    public void testPrivateMethod() throws Exception {
        // 模拟私有方法的行为
        PowerMockito.doAnswer(invocation -> "mockedPrivateMethod").when(YourClass.class, "privateMethod");
 
        // 调用 YourClass 的其他公开方法，这些方法内部会调用模拟过的私有方法
        assertEquals("mockedPrivateMethod", new YourClass().publicMethod());
    }
 
    @Test
    public void testStaticMethod() throws Exception {
        // 模拟静态方法的行为
        PowerMockito.mockStatic(YourClass.class);
        PowerMockito.when(YourClass.staticMethod()).thenReturn("mockedStaticMethod");
 
        // 调用模拟过的静态方法
        assertEquals("mockedStaticMethod", YourClass.staticMethod());
    }
 
    @Test
    public void testReadField() throws Exception {
        // 模拟属性的读取行为
        PowerMockito.field(YourClass.class, "field").set(new YourClass(), "mockedField");
 
        // 调用 YourClass 的方法来验证属性是否被正确模拟读取
        assertEquals("mockedField", new YourClass().getField());
    }
}
 
class YourClass {
    private String field = "originalField";
 
    public String publicMethod() {
        return privateMethod();
    }
 
    private String privateMethod() {
        return field;
    }
 
    public static String staticMethod() {
        return "originalStaticMethod";
    }
 
    public String getField() {
        return field;
    }
}

在这个例子中，YourClass 有一个私有方法 privateMethod()，一个静态方法 staticMethod()，以及一个字段 field。在单元测试中，我们使用 PowerMockito 来模拟这些方法和属性的行为。注意，使用 PowerMockito 时需要添加 @PrepareForTest 注解来指定需要模拟的类，并且要使用 PowerMock 的运行器 PowerMockRunner。

- 阅读更多 -

lazarus开发：提升sqlite数据插入速度

System

2024-09-02

所有,数据库




-- 假设我们有一个名为'my_table'的表，它有两个字段：'id'和'data'。
-- 以下SQL语句使用预处理语句来批量插入数据，从而提高插入速度：
 
INSERT INTO my_table (id, data)
VALUES (?, ?);
 
-- 在Lazarus中，你可以使用SQLite的预处理功能来构建参数化查询，例如：
 
var
  Stmt: TSQLitePreparedStatement;
  DB: TSQLiteDatabase;
  StartTime, EndTime: TDateTime;
  i: Integer;
begin
  // 初始化数据库对象并打开数据库
  DB := TSQLiteDatabase.Create(DB_FILENAME);
  DB.Open;
 
  // 准备SQL语句
  Stmt := DB.Prepare('INSERT INTO my_table (id, data) VALUES (?, ?);');
 
  // 开始计时
  StartTime := Now;
 
  // 绑定参数并执行插入
  for i := 1 to NUM_ROWS do
  begin
    Stmt.BindParameter(1, i);
    Stmt.BindParameter(2, 'Some data for row ' + IntToStr(i));
    Stmt.Execute;
  end;
 
  // 释放预处理语句资源
  Stmt.Free;
 
  // 结束计时
  EndTime := Now;
 
  // 输出插入数据所需时间
  Writeln('Insertion took: ', MilliSecondsBetween(EndTime, StartTime), ' ms');
 
  // 关闭数据库连接
  DB.Free;
end;

这段代码演示了如何在Lazarus中使用预处理语句来批量插入数据到SQLite数据库。通过使用预处理语句，我们可以重用查询的解析工作，从而减少了每次插入操作的时间，这对于大量数据的插入是非常有效的。

- 阅读更多 -

Redis系列--数据过期清除策略&缓存淘汰策略

System

2024-09-02

所有,redis

Redis的数据过期清除策略主要有以下几种：

惰性删除：当访问数据时，如果发现数据已经过期，就会立即删除。
定时删除：为每个数据设置一个定时器，当过期时间到达时，立即删除。
惰性+定时结合：在读写时检查是否过期，并且定时任务会定期检查并清除过期的数据。
内存淘汰：当内存不足以容纳新的数据时，会根据一定的淘汰策略删除一些数据。

Redis的缓存淘汰策略主要有以下几种：

noeviction：不进行任何淘汰，当内存不足时，会返回错误。
allkeys-lru：当内存不足以容纳新写入数据时，在键空间中，移除最近最少使用的key。
volatile-lru：当内存不足以容纳新写入数据时，在设置了过期时间的键空间中，移除最近最少使用的key。
allkeys-random：在键空间中，随机移除一些key。
volatile-random：在设置了过期时间的键空间中，随机移除一些key。
volatile-ttl：在设置了过期时间的键空间中，移除即将过期的key。

Redis配置文件中可以设置maxmemory-policy参数来指定淘汰策略。

示例：




# 设置最大内存，当内存达到这个值时，会根据volatile-lru策略进行淘汰
maxmemory 2gb
# 设置淘汰策略
maxmemory-policy volatile-lru

在实际应用中，可以根据业务需求和内存大小选择合适的过期清除策略和淘汰策略。

- 阅读更多 -

Spring全家桶：Spring AOP

System

2024-09-02

所有,java

Spring AOP（面向切面编程）是Spring框架的一个关键组件，它允许你定义跨越应用程序多个模块的横切关注点，例如日志记录、事务管理、性能监控等。

Spring AOP基于代理模式实现，主要有两种方式：JDK动态代理和CGLIB代理。

使用Spring AOP记录方法执行时间：

首先，你需要在Spring配置文件中启用AspectJ支持：




<aop:aspectj-autoproxy />

然后，创建一个Aspect类，并用@Aspect注解标注：




@Aspect
@Component
public class PerformanceAspect {
 
    @Around("execution(* com.example.service.*.*(..))")
    public Object profileAllMethods(ProceedingJoinPoint proceedingJoinPoint) throws Throwable {
        long start = System.currentTimeMillis();
        Object result = proceedingJoinPoint.proceed();
        long end = System.currentTimeMillis();
        System.out.println(proceedingJoinPoint.getSignature() + " executed in " + (end - start) + "ms");
        return result;
    }
}

这个Aspect会拦截com.example.service包下所有方法的执行，并打印出方法执行的时间。

使用Spring AOP进行权限校验：




@Aspect
@Component
public class SecurityAspect {
 
    @Before("execution(* com.example.service.*.*(..))")
    public void checkPermission(JoinPoint joinPoint) {
        if (!hasPermission(joinPoint)) {
            throw new AccessDeniedException("No permission to access this method: " + joinPoint.getSignature());
        }
    }
 
    private boolean hasPermission(JoinPoint joinPoint) {
        // 实现权限校验的逻辑
        return true;
    }
}

这个Aspect会在执行com.example.service包下的方法之前，检查是否有权限执行该方法。如果没有权限，则抛出AccessDeniedException异常。

以上示例展示了如何使用Spring AOP来增强应用程序的横切关注点。在实际应用中，你可以根据具体需求定义不同的切面和通知类型（如@Before、@AfterReturning、@AfterThrowing、@After、@Around）。

- 阅读更多 -

Nginx 配置与优化：常见问题全面解析

System

2024-09-02

所有,数据库

由于篇幅限制，这里只列出Nginx配置与优化的常见问题及其解决方案的概要。具体配置和优化策略请参考上述提供的Nginx官方文档和社区最佳实践。

如何配置Nginx以支持更多的连接？
- 调整worker_connections指令以支持更多的连接。
- 调整worker_processes以增加CPU核心的使用率。
- 使用multi_accept指令以更快地接受更多的连接。
如何优化Nginx的性能？
- 使用sendfile指令来传输文件。
- 启用tcp_nopush来减少网络延迟。
- 启用gzip压缩来减少传输数据的大小。
- 调整keepalive_timeout来优化长连接。
如何配置Nginx以实现负载均衡？
- 使用upstream模块定义一个服务器组，并在server指令中使用。
- 设置least_conn、ip_hash或hash来选择负载均衡算法。
如何配置Nginx以实现HTTPS？
- 配置SSL证书和私钥。
- 使用ssl模块并在server块中启用listen 443 ssl。
如何配置Nginx以实现安全性？
- 使用secure_link模块来实现安全下载链接。
- 配置deny和allow指令来控制访问。
- 使用limit_rate来限制连接速度。
如何配置Nginx以实现缓存？
- 使用proxy_cache_path来设置缓存路径。
- 在location块中使用proxy_cache和相关指令。
如何配置Nginx以实现请求限制？
- 使用limit_req_zone和limit_req来限制请求频率。
- 使用client_max_body_size来限制请求体大小。
如何配置Nginx以实现访问日志的优化？
- 使用log_format定义日志格式。
- 使用access_log指令来配置日志路径和格式。
- 定期轮换和压缩日志文件以减少磁盘空间。

这些是Nginx配置与优化中常见的问题和解决方案概要，具体配置需要根据实际需求和服务器环境进行调整。

- 阅读更多 -