分类后端技术下的文章

Sqlite3-插入系统时间/删除N天前数据

2024-09-02

所有,数据库

要在SQLite3中插入系统时间，您可以使用SQLite的CURRENT_TIMESTAMP函数。对于删除N天前的数据，您可以使用datetime字段和相应的时间函数。

以下是一个SQL示例，展示如何插入当前系统时间，以及如何删除特定表中的N天前数据。




-- 插入当前系统时间
INSERT INTO your_table (column1, column2, created_at)
VALUES ('value1', 'value2', CURRENT_TIMESTAMP);
 
-- 删除N天前的数据
-- 假设您的表名为your_table，含有一个类型为datetime的列叫做created_at
-- 而您想删除7天前的数据
DELETE FROM your_table
WHERE created_at < datetime('now', '-N day');

在这个DELETE语句中，datetime('now', '-N day')会计算当前时间减去N天的值。您需要将N替换为您想要的天数。

请注意，您需要将your_table、column1、column2和created_at替换为您实际的表名和列名。同样，在实际的SQL脚本中，您需要根据实际的表结构和数据库设置来调整这些值。

2024-09-02

在Spring框架中，自动装配是一种让Spring容器来自动处理对象之间依赖关系的方法，而不需要手动编写复杂的配置。在Spring Boot中，这项功能得到了进一步的提升和简化。

下面是一个简单的例子，展示了如何在Spring Boot和传统Spring框架中使用自动装配。

Spring Boot:




@SpringBootApplication
public class MySpringBootApplication {
    public static void main(String[] args) {
        SpringApplication.run(MySpringBootApplication.class, args);
    }
}
 
@Service
public class MyService {
    // 自动装配其他依赖的服务
}

在Spring Boot中，@SpringBootApplication注解是一个方便的组合注解，它包含了@ComponentScan，@Configuration和@EnableAutoConfiguration。这使得Spring Boot应用能够自动扫描同一个包下的组件并注册为Spring Beans，同时也启用了自动配置功能。

传统Spring:




<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
                           http://www.springframework.org/schema/beans/spring-beans.xsd">
 
    <context:component-scan base-package="com.example" />
    <context:annotation-config />
 
</beans>




@Service
public class MyService {
    // 自动装配其他依赖的服务
}

在传统的Spring框架中，你需要在XML配置文件中指定<context:component-scan>来启用组件扫描，并且需要<context:annotation-config>来启用注解配置功能，这样Spring容器才能自动识别@Service和其他相关的注解，并创建相应的Bean。

两者相比，Spring Boot通过简化配置和提供默认设置，使得自动装配的过程更加简便和高效。

2024-09-02

在Spring Boot中整合Flowable以使用Flowable UI绘制流程图，你需要按照以下步骤操作：

添加Flowable UI依赖到你的pom.xml文件中：




<dependencies>
    <!-- 其他依赖 ... -->
 
    <!-- Flowable UI 依赖 -->
    <dependency>
        <groupId>org.flowable</groupId>
        <artifactId>flowable-ui-common</artifactId>
        <version>${flowable.version}</version>
    </dependency>
    <dependency>
        <groupId>org.flowable</groupId>
        <artifactId>flowable-ui-modeler</artifactId>
        <version>${flowable.version}</version>
    </dependency>
    <dependency>
        <groupId>org.flowable</groupId>
        <artifactId>flowable-ui-idm-spring</artifactId>
        <version>${flowable.version}</version>
    </dependency>
    <dependency>
        <groupId>org.flowable</groupId>
        <artifactId>flowable-ui-admin</artifactId>
        <version>${flowable.version}</version>
    </dependency>
</dependencies>

配置application.properties或application.yml以连接Flowable引擎：




# 数据源配置
spring.datasource.url=jdbc:mysql://localhost:3306/flowable_ui?useSSL=false
spring.datasource.username=root
spring.datasource.password=example
spring.datasource.driver-class-name=com.mysql.cj.jdbc.Driver
 
# 引擎服务配置
flowable.ui.modeler.enabled=true
flowable.ui.modeler.process-engine-name=default

启动类添加@EnableProcessApplication注解：




import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.flowable.spring.boot.FlowableProcessEngineAutoConfiguration;
import org.flowable.spring.boot.FlowableUIApplication;
 
@SpringBootApplication(exclude = { FlowableProcessEngineAutoConfiguration.class })
@EnableProcessApplication
public class FlowableUiApplication {
 
    public static void main(String[] args) {
        SpringApplication.run(FlowableUiApplication.class, args);
    }
}

配置安全控制，允许访问Flowable UI：




import org.springframework.context.annotation.Configuration;
import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
 
@Configuration
public class SecurityConfiguration extends WebSecurityConfigurerAdapter {
 
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
            .csrf().disable()
            .authorizeRequests()
            .anyRequest().perm

2024-09-02

所有,数据库

MongoDB是一个基于文档的非关系型数据库，而关系型数据库（如MySQL）则是基于表和行的模型。在MongoDB中，对应于关系型数据库中的"表"概念的是"集合(Collection)"，对应于"行"概念的是"文档(Document)"。

关系型数据库中的概念 MongoDB中的对应概念

数据库(Database) 数据库(Database)

表(Table) 集合(Collection)

行(Row) 文档(Document)

列(Column) 字段(Field)

索引(Index) 索引(Index)

外键(Foreign Key) 嵌入文档或引用

在MongoDB中，一个集合包含多个文档，每个文档可以有不同的结构，可以包含子文档和数组。

例如，在关系型数据库中，你可能有一个"users"表，其中每行代表一个用户。在MongoDB中，你可以将这些用户数据存储在"users"集合中，每个文档代表一个用户。

关系型数据库操作示例：




CREATE TABLE users (id INT, name VARCHAR(50), age INT);
INSERT INTO users (id, name, age) VALUES (1, 'Alice', 25);
SELECT * FROM users WHERE age > 20;

MongoDB操作示例：




use databaseName; // 切换到指定数据库
db.createCollection('users');
db.users.insertOne({id: 1, name: 'Alice', age: 25});
db.users.find({age: {$gt: 20}});

【SpringBoot篇】基于Redis实现生成全局唯一ID的方法

2024-09-02

所有,redis




import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.data.redis.core.ValueOperations;
import org.springframework.stereotype.Component;
 
@Component
public class RedisIdGenerator {
 
    private static final String KEY_PREFIX = "unique_id:";
 
    @Autowired
    private StringRedisTemplate redisTemplate;
 
    public synchronized Long generate() {
        ValueOperations<String, String> opsForValue = redisTemplate.opsForValue();
        String key = KEY_PREFIX + "counter";
        Long id;
        // 使用Redis的INCR命令来原子性地递增
        // 如果键不存在，INCR命令就会先初始化为0，然后执行递增操作
        // 返回的结果是递增后的值
        id = opsForValue.increment(key, 1);
        // 如果需要，可以在ID的基础上再做其他的格式化或者转换
        return id;
    }
}

这段代码使用了Spring Data Redis的StringRedisTemplate来操作Redis，并通过increment方法实现了全局唯一ID的生成。这个方法是线程安全的，因为它使用了Redis的原子性操作INCR来递增计数器。这个解决方案适合需要生成全局唯一ID的场景，例如分布式数据库中的主键生成策略。

【Spring Cloud】使用JWT技术实现登录功能

2024-09-02

以下是一个简化的Spring Cloud函数，用于生成JWT token，并返回给客户端。




import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;
import java.util.Date;
import java.util.HashMap;
import java.util.Map;
 
@RestController
public class AuthController {
 
    private static final String SECRET_KEY = "my_secret"; // 应使用更安全的方式管理密钥
 
    @PostMapping("/login")
    public Map<String, Object> login(@RequestBody Map<String, String> credentials) {
        // 在实际应用中，这里应进行用户认证
        boolean isAuthenticated = authenticate(credentials);
 
        if (isAuthenticated) {
            String token = createToken(credentials);
            Map<String, Object> response = new HashMap<>();
            response.put("token", token);
            return response;
        } else {
            throw new RuntimeException("登录失败");
        }
    }
 
    private boolean authenticate(Map<String, String> credentials) {
        // 这里只是示例，实际应用中应该查询数据库验证用户凭据
        return credentials.get("username").equals("user") && credentials.get("password").equals("pass");
    }
 
    private String createToken(Map<String, String> credentials) {
        return Jwts.builder()
                .setClaims(credentials)
                .setExpiration(new Date(System.currentTimeMillis() + 60 * 60 * 1000)) // 有效期1小时
                .signWith(SignatureAlgorithm.HS512, SECRET_KEY)
                .compact();
    }
}

这段代码提供了一个简单的登录接口，当收到包含用户名和密码的POST请求时，它会生成一个JWT token，并返回给客户端。在实际应用中，你需要扩展这个例子以包含更复杂的用户认证逻辑和安全性措施。

数据库管理-ai:干掉MongoDB的不一定是另一个JSON数据库

2024-09-02

所有,数据库

在这篇文章中，作者讨论了MongoDB的一些局限性，并提出了23ai作为一个更现代的数据库解决方案的可能性。23ai是一个专注于机器学习的数据库，它提供了一种处理非结构化数据的新方法。

解决方案概要：

提及MongoDB的局限性，如不支持ACID事务、复杂的查询和连接操作、缺乏标准的SQL支持等。
提出23ai作为一个可能的替代方案，它提供了一个基于机器学习的数据库引擎，可以处理复杂的非结构化数据。
展示23ai如何使用机器学习模型理解数据结构，进行更高效的查询和数据分析。
阐明23ai的优势，如自适应模式理解、高效的数据处理和分析、与现有工具和流程的兼容性等。
提供一个示例，说明如何使用23ai来处理MongoDB中的数据。

注意：23ai是一个假设的数据库系统，可能需要进一步的研发来实现。实际解决方案将取决于该技术的成熟度和适用性。

2024-09-02




import io.jsonwebtoken.Jwts;
import io.jsonwebtoken.SignatureAlgorithm;
import java.util.Date;
 
public class JwtTokenUtil {
 
    private static final String SECRET_KEY = "your_secret_key"; // 应该是一个复杂的密钥
 
    public static String generateToken(UserDetails userDetails) {
        long now = (new Date()).getTime();
        return Jwts.builder()
                .setIssuedAt(new Date())
                .setSubject(userDetails.getUsername())
                .setExpiration(new Date((now + 60 * 60 * 1000))) // Token有效期1小时
                .signWith(SignatureAlgorithm.HS512, SECRET_KEY)
                .compact();
    }
 
    public static boolean validateToken(String token, UserDetails userDetails) {
        String username = Jwts.parser()
                .setSigningKey(SECRET_KEY)
                .parseClaimsJws(token)
                .getBody()
                .getSubject();
 
        return username.equals(userDetails.getUsername()) && !isTokenExpired(token);
    }
 
    private static boolean isTokenExpired(String token) {
        Date expiration = Jwts.parser()
                .setSigningKey(SECRET_KEY)
                .parseClaimsJws(token)
                .getBody()
                .getExpiration();
 
        return expiration.before(new Date());
    }
}

这个代码示例提供了一个简单的JWT工具类，用于生成和验证用户的JWT。在生成Token时，它设置了签发时间、用户名和Token过期时间。在验证Token时，它检查过期和用户名是否匹配。这个例子使用了io.jsonwebtoken库来创建和解析JWT。

大数据-47 Redis 缓存过期淘汰删除策略 LRU LFU 基础概念

2024-09-02

所有,redis

Redis缓存淘汰策略是指在内存不足时，Redis如何决定淘汰哪些数据。Redis支持以下淘汰策略：

noeviction: 不进行淘汰，当内存不足时，新写入操作会报错。
allkeys-lru: 当内存不足以容纳更多数据时，使用最近最少使用算法（LRU）淘汰键。
allkeys-random: 随机淘汰键，不考虑使用频率。
volatile-lru: 只对设置了过期时间的键进行LRU淘汰。
volatile-random: 随机淘汰设置了过期时间的键。
volatile-ttl: 淘汰即将过期的键，优先淘汰TTL更短的键。

LRU是Least Recently Used的缩写，即最近最少使用，是一种常用的页面置换算法，选择最近最久未使用的页面淘汰。

LFU是Least Frequently Used的缩写，即最不常用，根据统计信息选择最近未被使用频率最少的页面进行淘汰。

以下是Redis配置淘汰策略和使用示例：




# 设置Redis的maxmemory-policy
maxmemory-policy allkeys-lru

在实际应用中，可以根据数据的访问频率选择合适的淘汰策略。如果是频繁访问的热数据，可以选择LRU或者LFU策略；如果是不经常访问的冷数据，可以选择随机淘汰或者TTL淘汰策略。