分类后端技术下的文章

SQLITE 日期格式转换

2024-09-04

所有,数据库

在SQLite中，可以使用内置的date()函数来格式化日期。如果你想要将一个日期字符串转换成特定的格式，可以使用以下SQL语句模板：




SELECT date(your_date_column, 'format_modifier') FROM your_table;

其中format_modifier是一个可选的字符串，用来指定输出格式。如果省略，默认格式是YYYY-MM-DD。

例如，如果你想要将一个日期转换成YYYY-MM-DD格式，你可以这样做：




SELECT date(your_date_column) FROM your_table;

如果你想要转换成MM/DD/YYYY格式，可以这样做：




SELECT date(your_date_column, 'MM/DD/YYYY') FROM your_table;

请注意，SQLite的date()函数只能用于日期格式的转换，不能用于创建新的日期。如果你需要创建一个日期对象，你可能需要使用其他SQLite或者外部语言的功能。

springboot3使用自定义注解＋Jackson优雅实现接口数据脱敏

2024-09-04

在Spring Boot 3中，你可以通过自定义注解和Jackson的@JsonSerializer来实现数据脱敏。以下是一个简单的例子：

自定义注解@DataMasking:




@Target({ElementType.METHOD, ElementType.FIELD, ElementType.PARAMETER})
@Retention(RetentionPolicy.RUNTIME)
@JacksonAnnotationsInside
@JsonSerialize(using = DataMaskingSerializer.class)
public @interface DataMasking {
}

自定义数据脱敏的Serializer:




public class DataMaskingSerializer extends StdScalarSerializer<Object> implements ContextualSerializer {
 
    protected DataMaskingSerializer() {
        super(Object.class);
    }
 
    @Override
    public void serialize(Object value, JsonGenerator gen, SerializerProvider provider) throws IOException {
        // 实现数据脱敏逻辑，例如用星号*替换部分字符
        String maskedValue = maskingLogic(value.toString());
        gen.writeString(maskedValue);
    }
 
    @Override
    public JsonSerializer<?> createContextual(SerializerProvider prov, BeanProperty property) throws JsonMappingException {
        return new DataMaskingSerializer();
    }
 
    private String maskingLogic(String value) {
        // 实现脱敏逻辑
        return "***"; // 举例，使用星号脱敏
    }
}

在实体类中使用@DataMasking注解:




public class User {
 
    private String id;
 
    @DataMasking
    private String username;
 
    // getters and setters
}

在application.properties或application.yml中配置Jackson:




spring.jackson.serialization.indent-output=true

使用上述配置，当你返回带有@DataMasking注解的字段的对象时，Jackson会自动使用DataMaskingSerializer进行数据脱敏处理。

Redis-分布式锁

2024-09-04

所有,redis

在Redis中实现分布式锁通常使用SETNX命令（或在Redis 2.6.12以上版本中使用SET key value EX max-lock-time NX命令，这样可以一次性设置并加锁，避免了两条命令之间客户端可能挂掉的问题），然后使用EXPIRE命令来给锁设置一个过期时间，以防服务器崩溃导致锁未被释放。

以下是一个使用SET命令实现分布式锁的Python示例，使用redis-py库：




import redis
import time
import uuid
 
def acquire_lock(conn, lock_name, acquire_timeout=10, lock_timeout=10):
    identifier = str(uuid.uuid4())  # 生成一个唯一的ID
    end = time.time() + acquire_timeout
 
    while time.time() < end:
        if conn.set(lock_name, identifier, ex=lock_timeout, nx=True):
            return identifier  # 加锁成功
        time.sleep(0.001)
 
    return False  # 在规定时间内未能获得锁
 
def release_lock(conn, lock_name, identifier):
    pipe = conn.pipeline(True)
    while True:
        try:
            pipe.watch(lock_name)
            if pipe.get(lock_name) == identifier:
                pipe.multi()
                pipe.delete(lock_name)
                pipe.execute()
                return True
            pipe.unwatch()
            break
        except redis.exceptions.WatchError:
            pass
    return False  # 释放锁失败，可能因为锁已被其他客户端修改
 
# 使用示例
client = redis.StrictRedis(host='localhost', port=6379, db=0)
lock_name = "my_lock"
lock_identifier = acquire_lock(client, lock_name)
if lock_identifier:
    try:
        # 在这个区块内执行需要互斥的操作
    finally:
        if not release_lock(client, lock_name, lock_identifier):
            print("Failed to release lock")
else:
    print("Failed to acquire lock")

在这个示例中，acquire_lock 函数尝试获取锁，如果在指定时间内未能获得锁，则返回False。release_lock 函数尝试释放锁，如果锁不属于指定的ID或者因为WATCH失败，则返回False。这个实现使用了Redis的事务和watch命令来保证锁的安全性。

SpringBoot中集成Redis

2024-09-04

所有,redis

在Spring Boot中集成Redis，首先需要添加Spring Data Redis和Jedis的依赖。以下是pom.xml中的依赖配置示例：




<dependencies>
    <!-- Spring Data Redis -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis</artifactId>
    </dependency>
    <!-- Jedis -->
    <dependency>
        <groupId>redis.clients</groupId>
        <artifactId>jedis</artifactId>
    </dependency>
</dependencies>

接下来，在application.properties或application.yml中配置Redis连接信息：




# application.properties
spring.redis.host=localhost
spring.redis.port=6379

然后，你可以使用RedisTemplate或StringRedisTemplate来操作Redis：




import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.RedisTemplate;
import org.springframework.web.bind.annotation.*;
 
@RestController
public class RedisController {
 
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;
 
    @GetMapping("/set/{key}/{value}")
    public String set(@PathVariable String key, @PathVariable Object value) {
        redisTemplate.opsForValue().set(key, value);
        return "success";
    }
 
    @GetMapping("/get/{key}")
    public Object get(@PathVariable String key) {
        return redisTemplate.opsForValue().get(key);
    }
}

以上代码提供了两个简单的API：一个用于设置键值对到Redis，另一个用于从Redis中获取键对应的值。这只是集成Redis的基本示例，实际应用中可能需要更复杂的配置和操作。

ELK企业应用场景之Tomcat日志采集-logstash+es+kibana

2024-09-04

在实际应用中，我们通常需要将Tomcat的日志信息采集并存储至Elasticsearch中，然后通过Kibana进行可视化。以下是一个基于Logstash、Elasticsearch和Kibana的配置示例。

安装Logstash并确保其正常运行。
创建Logstash配置文件，例如tomcat-logs.conf，内容如下：




input {
  file {
    path => "/path/to/tomcat/logs/catalina.out"
    start_position => "beginning"
    sincedb_path => "/dev/null"
  }
}
 
filter {
  grok {
    match => { "message" => "%{DATA:timestamp}\s*%{DATA:loglevel}\s*%{DATA:class}\s*%{GREEDYDATA:message}" }
  }
 
  date {
    match => [ "timestamp" , "dd/MMM/yyyy:HH:mm:ss Z" ]
  }
}
 
output {
  elasticsearch {
    hosts => ["localhost:9200"]
    index => "tomcat-logs-%{+YYYY.MM.dd}"
  }
}

根据实际情况调整path和日志格式的grok表达式。
启动Logstash并指定配置文件：




bin/logstash -f tomcat-logs.conf

确保Elasticsearch正常运行。
安装并启动Kibana，然后通过Web界面配置相应的index pattern以可视化Tomcat日志。

请注意，这只是一个基础示例，具体实施时可能需要根据实际日志格式和需求进行相应的调整。

VC++6.0 Sqlite3调用例子

2024-09-04

所有,数据库

在VC++ 6.0中调用SQLite 3的示例代码如下：




#include <iostream>
#include <sqlite3.h>
 
int main(int argc, char* argv[])
{
    sqlite3* db;
    char* errMsg = nullptr;
    int rc;
 
    // 打开数据库
    rc = sqlite3_open("example.db", &db);
    if (rc) {
        std::cerr << "无法打开数据库: " << sqlite3_errmsg(db) << std::endl;
        sqlite3_close(db);
        return 1;
    }
 
    // 创建一个表
    const char* createTableSQL = 
        "CREATE TABLE IF NOT EXISTS users ("
        "id INTEGER PRIMARY KEY,"
        "username TEXT,"
        "email TEXT"
        ");";
    rc = sqlite3_exec(db, createTableSQL, nullptr, nullptr, &errMsg);
    if (rc != SQLITE_OK) {
        std::cerr << "SQL错误: " << errMsg << std::endl;
        sqlite3_free(errMsg);
    }
 
    // 插入数据
    const char* insertSQL = "INSERT INTO users (username, email) VALUES ('Alice', 'alice@example.com');";
    rc = sqlite3_exec(db, insertSQL, nullptr, nullptr, &errMsg);
    if (rc != SQLITE_OK) {
        std::cerr << "SQL错误: " << errMsg << std::endl;
        sqlite3_free(errMsg);
    }
 
    // 查询数据
    const char* selectSQL = "SELECT id, username, email FROM users;";
    sqlite3_stmt* stmt;
    rc = sqlite3_prepare_v2(db, selectSQL, -1, &stmt, nullptr);
    if (rc == SQLITE_OK) {
        while (sqlite3_step(stmt) == SQLITE_ROW) {
            int id = sqlite3_column_int(stmt, 0);
            const unsigned char* username = sqlite3_column_text(stmt, 1);
            const unsigned char* email = sqlite3_column_text(stmt, 2);
            std::cout << "ID: " << id << ", Username: " << username << ", Email: " << email << std::endl;
        }
        sqlite3_finalize(stmt);
    } else {
        std::cerr << "SQL错误: " << errMsg << std::endl;
        sqlite3_free(errMsg);
    }
 
    // 关闭数据库
    sqlite3_close(db);
    return 0;
}

这段代码展示了如何在VC++ 6.0中使用SQLite 3的基本操作，包括打开数据库、创建表、插入数据、查询数据和关闭数据库。注意，这里假设SQLite 3的库文件已经被正确配置，并且example.db数据库文件存在于程序可执行文件的相同目录下。

Oracle-数据库组件invalid问题处理

2024-09-04

所有,数据库

Oracle数据库中的"invalid"问题通常指的是某个数据库对象（如表、视图、索引等）因为某些原因不再有效或者不能被正确识别。处理这类问题的一般步骤如下：

确定无效对象的类型和名称。可以使用以下SQL查询：




SELECT * FROM DBA_OBJECTS WHERE STATUS = 'INVALID';

确定导致对象变为无效的原因。可以查看DBA_OBJECTS表中的LAST_DDL_TIME字段，它记录了最后一次DDL操作的时间，可以与ALL_ERRORS视图结合使用来查找错误信息：




SELECT * FROM ALL_ERRORS WHERE NAME = '对象名称' AND TYPE = '对象类型';

根据错误信息采取相应的修复措施。可能的修复措施包括：

如果是由于外键约束违反导致的无效，可以删除或更新违反约束的数据后重建外键。
如果是由于触发器、约束或索引的代码中的错误导致的无效，需要修改并重新编译相关代码。
如果是因为表空间问题导致的无效，可以将对象移动到有效的表空间。

修复完毕后，可以尝试重新编译无效对象：




ALTER [对象类型] [对象名称] COMPILE;

如果重新编译不成功，可能需要从备份中恢复对象或重建对象。
确认对象已经正确编译且无效状态已解决，可以通过以下SQL语句检查：




SELECT * FROM DBA_OBJECTS WHERE STATUS = 'VALID' AND NAME = '对象名称';

注意：处理这类问题时，应该具有相应的数据库权限，并在进行任何修改之前备份数据库和相关对象。如果不熟悉具体的无效原因，建议联系数据库管理员或寻求Oracle专业技术支持的帮助。

Spring 事务机制

2024-09-04

Spring 提供了一种声明式事务管理的方式，它主要通过 AOP 代理来实现。你可以使用 @Transactional 注解来标记方法，以便于 Spring 在运行时应用事务边界。

以下是一个使用 @Transactional 注解的简单例子：




import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;
 
@Service
public class MyService {
 
    @Transactional
    public void someTransactionalMethod() {
        // 方法的实现代码
        // 这里的代码将在一个事务的上下文中执行
    }
}

在这个例子中，someTransactionalMethod 方法被标记为事务性的。当这个方法被调用时，Spring 会开始一个事务，并确保这个方法内的所有操作要么全部成功，要么全部失败（根据事务的隔离级别和传播行为）。

事务的配置通常在 Spring 的配置文件中完成，例如使用 <tx:annotation-driven /> 来启用注解事务管理：




<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:tx="http://www.springframework.org/schema/tx"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/tx
        http://www.springframework.org/schema/tx/spring-tx.xsd">
 
    <tx:annotation-driven transaction-manager="transactionManager" />
 
    <!-- 其他 Bean 的定义 -->
 
    <bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
        <property name="dataSource" ref="dataSource" />
    </bean>
 
</beans>

在这个配置中，<tx:annotation-driven /> 告诉 Spring 去自动发现标记为 @Transactional 的方法，并且使用 transactionManager 作为事务管理器。

请注意，实际的事务管理配置可能会更加复杂，包括数据库连接池、事务的隔离级别、超时设置、只读事务的指定等。

2024-09-04




import org.springframework.mail.javamail.JavaMailSender;
import org.springframework.mail.SimpleMailMessage;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
 
@Service
public class EmailService {
 
    private final JavaMailSender mailSender;
 
    @Autowired
    public EmailService(JavaMailSender mailSender) {
        this.mailSender = mailSender;
    }
 
    public void sendSimpleMail(String to, String subject, String text) {
        SimpleMailMessage message = new SimpleMailMessage();
        message.setTo(to);
        message.setSubject(subject);
        message.setText(text);
 
        mailSender.send(message);
    }
}

这段代码定义了一个EmailService类，它使用JavaMailSender来发送简单邮件。在这个例子中，我们注入了JavaMailSender作为依赖，并提供了一个sendSimpleMail方法来发送邮件。这个类可以在Spring Boot应用中被注册为服务组件，并可以用来发送确认邮件、通知邮件等。