Tech Blog

2024-09-09

要在Linux上配置Maven环境，请按照以下步骤操作：

确保你已经安装了Java，因为Maven是用Java编写的。可以通过运行java -version来检查Java是否安装。
下载Maven。你可以从Apache Maven官方网站下载最新版本的Maven。




wget https://apache.osuosl.org/maven/maven-3/3.8.6/binaries/apache-maven-3.8.6-bin.tar.gz

解压Maven。




tar -xvzf apache-maven-3.8.6-bin.tar.gz

将Maven移动到/usr/local目录。




sudo mv apache-maven-3.8.6 /usr/local/apache-maven

设置环境变量。编辑你的.bashrc或.bash_profile文件，添加以下行：




export M2_HOME=/usr/local/apache-maven
export PATH=${M2_HOME}/bin:${PATH}

让更改生效。




source ~/.bashrc

或者




source ~/.bash_profile

验证Maven安装。




mvn -version

以上步骤将Maven配置在Linux环境中。确保替换步骤2中的下载链接为最新版本的Maven，如果有必要，修改步骤3和5中的Maven版本路径。

System

2024-09-09

所有,数据库




-- 假设我们已经有了一个名为 "documents" 的表，它具有 "id" 和 "text" 列
-- 以下是如何将 "documents" 表的 "text" 列同步到 Elasticsearch 索引的步骤
 
-- 1. 创建一个新的 Postgres 函数来处理同步逻辑
CREATE OR REPLACE FUNCTION sync_to_elasticsearch()
RETURNS trigger AS $$
BEGIN
  PERFORM * FROM crosstab(
    'SELECT tag, tag_value FROM magick_tags_for_element(st_astext($1.geom), ''document'')')
    AS tags(tag text, tag_value text);
 
  -- 使用 HTTP 协议通过 Postgres 的 server_ip 和 server_port 连接到 Elasticsearch
  -- 使用 pg_http_post 函数发送 JSON 格式的索引更新请求
  PERFORM pg_http_post(
    fmt_text('http://%s:%s/elasticsearch_index_name/_doc/%L', server_ip, server_port, NEW.id),
    json_build_object(
      'text', NEW.text,
      'tags', tags
    )::text,
    'Content-Type: application/json',
    true
  );
 
  RETURN NEW;
END;
$$ LANGUAGE plpgsql;
 
-- 2. 创建触发器，以便在 "documents" 表上的 INSERT 和 UPDATE 事件发生时调用上面的函数
CREATE TRIGGER sync_to_elasticsearch
AFTER INSERT OR UPDATE ON documents
FOR EACH ROW EXECUTE PROCEDURE sync_to_elasticsearch();

这个例子展示了如何在 Postgres 中创建一个函数和触发器，以便在 "documents" 表上的每次插入或更新操作后，将相关文档的文本内容和标签同步到 Elasticsearch 索引。这里使用了 Postgres 的 crosstab 函数来处理标签的转换，以及 pg_http_post 函数来发送 HTTP 请求到 Elasticsearch。这个例子假设 magick_tags_for_element 函数和 st_astext 函数是存在的，并且 server_ip 和 server_port 是配置好的 Elasticsearch 服务器的 IP 地址和端口号。

- 阅读更多 -

Rocky8安装postgresql

System

2024-09-09

所有,数据库

在Rocky Linux 8上安装PostgreSQL可以通过以下步骤进行：

打开终端。
首先，更新你的系统：
```
sudo dnf update
```
安装PostgreSQL及其相关软件包：
```
sudo dnf install postgresql-server
```
初始化数据库：
```
sudo postgresql-setup --initdb
```

启动并使PostgreSQL服务开机自启：




sudo systemctl enable --now postgresql

确认服务状态：
```
sudo systemctl status postgresql
```
（可选）配置PostgreSQL。首次安装后，您可以运行 postgresql-setup 命令来设置密码、配置复制等：
```
sudo postgresql-setup --help
```
（可选）登录到PostgreSQL交互式终端：
```
sudo su - postgres
psql
```

以上步骤将安装PostgreSQL并确保其运行。如果你需要进一步配置PostgreSQL，请查看Rocky Linux 8的官方文档或使用 postgresql-setup 命令获取帮助。

- 阅读更多 -

前后端分离，使用vue3整合SpringSecurity加JWT实现登录认证

System

2024-09-09

所有,java

以下是使用Vue 3和Spring Security结合JWT实现登录认证的核心代码示例。

后端（Spring Boot）:




import org.springframework.security.config.annotation.web.builders.HttpSecurity;
import org.springframework.security.config.annotation.web.configuration.EnableWebSecurity;
import org.springframework.security.config.annotation.web.configuration.WebSecurityConfigurerAdapter;
import org.springframework.security.config.http.SessionCreationPolicy;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.crypto.password.PasswordEncoder;
import org.springframework.security.web.authentication.UsernamePasswordAuthenticationFilter;
 
@EnableWebSecurity
public class SecurityConfig extends WebSecurityConfigurerAdapter {
 
    private final JwtAuthenticationEntryPoint jwtAuthenticationEntryPoint;
    private final UserDetailsService userDetailsService;
    private final JwtRequestFilter jwtRequestFilter;
 
    public SecurityConfig(JwtAuthenticationEntryPoint jwtAuthenticationEntryPoint, UserDetailsService userDetailsService, JwtRequestFilter jwtRequestFilter) {
        this.jwtAuthenticationEntryPoint = jwtAuthenticationEntryPoint;
        this.userDetailsService = userDetailsService;
        this.jwtRequestFilter = jwtRequestFilter;
    }
 
    @Override
    protected void configure(HttpSecurity http) throws Exception {
        http
                .csrf().disable()
                .exceptionHandling().authenticationEntryPoint(jwtAuthenticationEntryPoint).and()
                .sessionManagement().sessionCreationPolicy(SessionCreationPolicy.STATELESS).and()
                .authorizeRequests()
                .antMatchers("/api/auth/**").permitAll()
                .anyRequest().authenticated();
 
        http.addFilterBefore(jwtRequestFilter, UsernamePasswordAuthenticationFilter.class);
    }
 
    // ... 其他配置
}

前端（Vue 3）:




import axios from 'axios';
import { ElMessage } from 'element-plus';
 
const service = axios.create({
    baseURL: process.env.VUE_APP_BASE_API, // api的base_url
    timeout: 5000 // 请求超时时间
});
 
service.interceptors.request.use(
    config => {
        if (localStorage.getItem('token')) {
            config.headers['Authorization'] = 'Bearer ' + localStorage.getItem('token');
        }
        return config;
    },
    error => {
        // 请求错误处理

System

2024-09-09

所有,java




import org.springframework.cloud.client.ServiceInstance;
import org.springframework.cloud.client.loadbalancer.RequestData;
import org.springframework.cloud.loadbalancer.core.NoopServiceInstanceListSupplier;
import org.springframework.cloud.loadbalancer.core.ReactiveLoadBalancer;
import org.springframework.cloud.loadbalancer.core.SelectedInstance;
import reactor.core.publisher.Mono;
 
import java.util.List;
 
public class CustomLoadBalancer implements ReactiveLoadBalancer<ServiceInstance> {
 
    private final ServiceInstanceListSupplier serviceInstanceListSupplier;
 
    public CustomLoadBalancer(List<ServiceInstance> serviceInstances) {
        this.serviceInstanceListSupplier = new StaticServiceInstanceListSupplier(serviceInstances);
    }
 
    @Override
    public Mono<Response<ServiceInstance>> choose(RequestData requestData) {
        // 实现自定义的选择逻辑，例如轮询、随机或者根据权重
        return serviceInstanceListSupplier.get()
                .next()
                .map(serviceInstance -> new Response<>(serviceInstance));
    }
 
    @Override
    public Mono<Void> execute(String serviceId, Function<ServiceInstance, Mono<Void>> callback) {
        // 使用choose方法选择一个实例，然后执行callback中的逻辑
        return choose(new DefaultRequestData(serviceId)).flatMap(response -> {
            SelectedInstance selectedInstance = new SelectedInstance(serviceId, response.getServer());
            return callback.apply(selectedInstance.getServer());
        });
    }
 
    // 内部辅助类，用于提供服务实例列表
    private static class StaticServiceInstanceListSupplier implements ServiceInstanceListSupplier {
        private final List<ServiceInstance> serviceInstances;
 
        public StaticServiceInstanceListSupplier(List<ServiceInstance> serviceInstances) {
            this.serviceInstances = serviceInstances;
        }
 
        @Override
        public Flux<List<ServiceInstance>> get() {
            return Flux.just(serviceInstances);
        }
 
        @Override
        public Flux<ServiceInstance> get(RequestData requestData) {
            return Flux.fromIterable(serviceInstances);
        }
    }
}

这个代码示例展示了如何实现一个自定义的ReactiveLoadBalancer。在choose方法中，我们使用了一个简单的轮询策略来选择服务实例。在execute方法中，我们使用choose选出的实例来执行传入的回调函数。这个示例还定义了一个辅助类StaticServiceInstanceListSupplier来提供服务实例列表。这个示例只是用于教学目的，实际应用中应该根据具体的负载均衡策略来实现choose方法。

- 阅读更多 -

Nginx+Tomcat实现负载均衡、动静分离集群部署

System

2024-09-09

所有,java

以下是一个基于Nginx和Tomcat的简单的动静分离和负载均衡配置示例：

Nginx配置文件（nginx.conf）:




user  nginx;
worker_processes  1;
 
events {
    worker_connections  1024;
}
 
http {
    include       mime.types;
    default_type  application/octet-stream;
 
    # 日志格式
    log_format  main  '$remote_addr - $remote_user [$time_local] "$request" '
                      '$status $body_bytes_sent "$http_referer" '
                      '"$http_user_agent" "$http_x_forwarded_for"';
 
    # 访问日志
    access_log  logs/access.log  main;
 
    # 静态文件缓存设置
    sendfile        on;
    keepalive_timeout  65;
 
    # 用于动静分离的location配置
    server {
        listen       80;
        server_name  localhost;
 
        # 静态文件
        location ~* \.(jpg|jpeg|gif|png|css|js|ico|html)$ {
            root   /path/to/static/files;
            expires 30d;
        }
 
        # 代理动态内容到Tomcat服务器
        location / {
            proxy_pass http://tomcat_servers;
            proxy_set_header Host $host;
            proxy_set_header X-Real-IP $remote_addr;
            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        }
    }
 
    # 负载均衡配置
    upstream tomcat_servers {
        server tomcat1.example.com:8080;
        server tomcat2.example.com:8080;
    }
}

在这个配置中，Nginx作为反向代理服务器接收所有的HTTP请求，并根据location配置处理静态文件或将请求代理到Tomcat服务器。upstream模块定义了一个名为tomcat_servers的服务器组，它包含两个Tomcat服务器实例，Nginx将按需分配请求到这些服务器。

确保Nginx配置没有错误，可以使用以下命令检查：




nginx -t

如果没有错误，重新加载Nginx配置以应用更改：




nginx -s reload

确保Tomcat服务器正常运行，并且可以处理来自Nginx的请求。

以上是一个基本的Nginx和Tomcat集群配置示例。在实际部署中，你可能需要调整Nginx的配置，包括日志目录、缓存时间、服务器名称、upstream配置等。同时，确保Nginx和Tomcat有适当的权限来访问相关的文件和网络。

- 阅读更多 -

SQLite学习SQLite《社区流动人员系统》项目实战，数据按需查询

System

2024-09-09

所有,数据库




-- 假设我们已经有了一个流动人口登记表 'population_movement'，包含字段 'id', 'name', 'sex', 'age', 'nationality', 'work_type', 'arrival_date', 'location_id'。
-- 下面的SQL语句展示了如何按需查询流动人口数据。
 
-- 查询流动人口的总数。
SELECT COUNT(*) FROM population_movement;
 
-- 查询特定国籍的流动人口数。
SELECT COUNT(*) FROM population_movement WHERE nationality = '中国';
 
-- 查询特定性别的流动人口数。
SELECT COUNT(*) FROM population_movement WHERE sex = '女';
 
-- 查询某个位置的流动人口总数。
SELECT COUNT(*) FROM population_movement WHERE location_id = 1;
 
-- 查询最年轻和最年长的流动人口。
SELECT MIN(age), MAX(age) FROM population_movement;
 
-- 查询不同工作类型的流动人口数量。
SELECT work_type, COUNT(*) FROM population_movement GROUP BY work_type;
 
-- 查询某个位置的流动人口详情。
SELECT * FROM population_movement WHERE location_id = 1;
 
-- 查询最近一周内到达的流动人口。
SELECT * FROM population_movement WHERE arrival_date > datetime('now', '-7 day');

这个示例展示了如何使用SQLite进行基本的数据统计和查询，这些操作在实际的社区流动人口系统中是非常常见和重要的。这些查询可以根据实际需求进行调整，以便获取特定的数据信息。

System

2024-09-09

所有,redis

Redis的内存淘汰策略中的Reservoir Sampling是一种随机抽样算法，用于从数据流中随机抽取样本。这种策略通常用于大数据处理中，当数据量非常大，无法一次性加载到内存时，可以使用这种随机算法来抽取一部分数据进行分析。

以下是一个简单的Python实现，演示如何使用Reservoir Sampling算法从一组数据中随机抽取k个元素：




import random
 
def reservoir_sampling(items, k):
    sample = [None] * k
    for i, item in enumerate(items):
        if i < k:
            sample[i] = item
        else:
            probability = k / (i + 1)
            if random.uniform(0, 1) < probability:
                index = random.randrange(0, i + 1)
                sample[index] = item
    return sample
 
# 示例使用
items = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
k = 3  # 需要抽取的样本数
sample = reservoir_sampling(items, k)
print(sample)  # 输出可能是 [2, 5, 10] 或其他大小为k的随机样本

这个例子中，reservoir_sampling函数会遍历提供的items，并根据当前元素位置动态调整替换到样本数组中每个元素的概率。如果当前元素是随机选中的应该替换样本中元素的位置，则替换之。最终返回的sample数组包含了随机抽取的k个元素。

- 阅读更多 -

SpringBoot集成slf4j日志配置

System

2024-09-09

所有,java

在Spring Boot项目中，你可以通过以下步骤来集成和配置slf4j日志系统：

添加依赖：确保你的pom.xml包含slf4j的API依赖以及一个具体的日志实现（比如logback）。




<!-- SLF4J API -->
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-api</artifactId>
    <version>1.7.30</version>
</dependency>
 
<!-- Logback implementation -->
<dependency>
    <groupId>ch.qos.logback</groupId>
    <artifactId>logback-classic</artifactId>
    <version>1.2.3</version>
</dependency>

配置日志：在src/main/resources目录下创建或修改logback-spring.xml文件来配置日志输出。




<configuration>
    <appender name="STDOUT" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss} - %msg%n</pattern>
        </encoder>
    </appender>
 
    <root level="info">
        <appender-ref ref="STDOUT" />
    </root>
</configuration>

使用日志：在你的代码中，使用slf4j的Logger来记录日志。




import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
 
public class YourClass {
    private static final Logger logger = LoggerFactory.getLogger(YourClass.class);
 
    public void yourMethod() {
        logger.info("This is an info message");
        // ...
    }
}

以上步骤将会在Spring Boot项目中启用slf4j并使用Logback作为日志实现。你可以根据需要调整日志的输出格式和级别，以及添加额外的appender来将日志输出到文件或其他目的地。

System

2024-09-09

所有,java

这个问题看起来像是在询问如何使用Spring Cloud Gateway和Nginx来构建微服务的API路由和管理。以下是一个简化的例子，展示如何配置Spring Cloud Gateway以及一些基本的Nginx配置。

Spring Cloud Gateway配置:




@Configuration
public class GatewayConfig {
 
    @Bean
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
        return builder.routes()
                .route("path_route", r -> r.path("/api/**")
                        .uri("http://backend:8080")
                        .order(0)
                        .id("api_route")
                )
                .build();
    }
}

在这个配置中，我们定义了一个路由，它会将匹配 /api/** 路径的请求转发到 http://backend:8080。

Nginx配置:




server {
    listen 80;
 
    location / {
        proxy_pass http://localhost:8080;
        proxy_set_header Host $host;
        proxy_set_header X-Real-IP $remote_addr;
        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
    }
}

在Nginx中，我们设置了一个监听80端口的服务器，并将所有流量代理到Spring Cloud Gateway运行的端口（在这个例子中是8080）。

这只是一个简单的示例，实际部署时可能需要更复杂的配置，比如负载均衡、安全性考虑、日志记录等。

请注意，这只是一个概念性的示例，并且假设了一些基础设施和服务的存在。在实际部署中，你需要根据自己的具体情况来调整配置。

- 阅读更多 -