分类后端技术下的文章

2024-09-03

在Linux环境下，使用Tomcat作为服务器来部署Vue项目的步骤如下：

构建Vue项目：
在Vue项目的根目录下，执行构建命令：
```
npm run build
```
这将创建一个dist/目录，里面包含构建后的文件。
准备Tomcat：
下载并安装Tomcat。
将构建好的文件复制到Tomcat的webapps目录下：
```
cp -r dist/* /path/to/tomcat/webapps/ROOT/
```
这里假设你的Tomcat安装在/path/to/tomcat，dist/目录包含了Vue项目的静态文件。
配置Tomcat：
如果需要，可以在conf/server.xml中配置Context，例如：
```
<Context path="" docBase="/path/to/tomcat/webapps/ROOT" />
```
这样可以通过IP直接访问项目，而不需要指定项目的路径。
启动Tomcat：
```
/path/to/tomcat/bin/startup.sh
```
访问Tomcat服务器IP和端口，你的Vue项目应该可以访问了。

(2) 使用Nginx作为代理服务器进行部署：

构建Vue项目：
```
npm run build
```
配置Nginx：
编辑Nginx配置文件（通常位于/etc/nginx/nginx.conf或者/etc/nginx/sites-available/目录下的某个文件），添加一个server块：
```
server {
    listen 80;
    server_name your_domain_or_IP;
 
    location / {
        root /path/to/dist;
        index index.html;
        try_files $uri $uri/ /index.html;
    }
}
```
把your_domain_or_IP替换为你的域名或者IP地址，/path/to/dist替换为你的构建文件dist目录的绝对路径。

重启Nginx：




sudo service nginx restart

或者




sudo systemctl restart nginx

访问你的服务器IP或域名，你的Vue项目应该可以访问了。

这两种方式都可以部署Vue项目，选择哪一种取决于你的具体需求和环境配置。如果你需要更多的灵活性和控制，比如说后端服务的集成，可能会选择Nginx作为代理。如果你的后端服务是基于Java的，并且需要与Tomcat集成，那么Tomcat可能是更好的选择。

logback-spring.xml 的配置及详解（直接复制粘贴可用）

2024-09-03




<?xml version="1.0" encoding="UTF-8"?>
<configuration>
    <!-- 定义日志文件的存储地址 -->
    <property name="LOGS" value="./logs" />
 
    <!-- 控制台日志输出格式 -->
    <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>
 
    <!-- 指定具体包或模块的日志输出级别与路径 -->
    <logger name="com.example.demo" level="debug" additivity="false">
        <appender-ref ref="STDOUT" />
        <!-- 同时写入文件 -->
        <appender-ref ref="FILE" />
    </logger>
 
    <!-- 文件日志输出格式 -->
    <appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
        <file>${LOGS}/myapp.log</file>
        <encoder>
            <pattern>%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
        <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
            <!-- 日志文件回滚策略 -->
            <fileNamePattern>${LOGS}/archived/myapp-%d{yyyy-MM-dd}.%i.log</fileNamePattern>
            <timeBasedFileNamingAndTriggeringPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedFNATP">
                <maxFileSize>100MB</maxFileSize>
            </timeBasedFileNamingAndTriggeringPolicy>
        </rollingPolicy>
    </appender>
</configuration>

这个配置文件定义了日志的存储地址、控制台和文件的输出格式，以及日志滚动的策略。它设定了根日志级别为info，针对com.example.demo包的日志级别为debug，并且同时输出到控制台和文件。文件按日期和大小滚动，每个日志文件最大为100MB。这个配置适用于Spring Boot项目，并且是一个很好的实践样例。

2024-09-03

所有,数据库

在Spring Boot中，将_geometry数据转换并存储到MySQL和PostgreSQL数据库中，会涉及到数据类型转换和特定扩展的处理，例如MySQL的TOAST和PostgreSQL的TOAST以及PostGIS扩展。

对于MySQL，你需要确保你的表使用了支持Geometry类型的存储引擎，如InnoDB，并且你需要使用MySQL的GIS扩展。

对于PostgreSQL，你需要使用PostGIS扩展，它为PostgreSQL提供对地理空间数据的支持。

以下是一个简化的例子，演示如何在Spring Boot应用中处理这些转换：




import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.stereotype.Service;
import com.vividsolutions.jts.geom.Geometry;
 
@Service
public class SpatialDataService {
 
    @Autowired
    private JdbcTemplate jdbcTemplate;
 
    public void storeGeometry(String tableName, int id, Geometry geometry) {
        // 对于MySQL，使用相应的函数将Geometry对象转换为WKB格式
        byte[] wkbRepresentation = geometry.toByteArray();
        String query = "INSERT INTO " + tableName + " (id, geometry) VALUES (?, ?)";
        jdbcTemplate.update(query, id, wkbRepresentation);
 
        // 对于PostgreSQL，使用PostGIS的ST_GeomFromWKB函数
        // 假设geometry列的类型是geometry
        String pgQuery = "INSERT INTO " + tableName + " (id, geometry) VALUES (?, ST_GeomFromWKB(?, 4326))";
        jdbcTemplate.update(pgQuery, id, wkbRepresentation);
    }
}

在这个例子中，我们使用了JdbcTemplate来执行SQL语句。geometry.toByteArray()方法将Geometry对象转换为WKB（Well-Known Binary）格式，这是MySQL中存储Geometry数据的标准方法。对于PostgreSQL，我们使用了ST_GeomFromWKB函数来将WKB转换为PostGIS可以理解的Geometry类型。

确保你的数据库表已经创建好，并且对于MySQL，使用了支持Geometry类型的存储引擎，同时对于PostgreSQL，确保启用了PostGIS扩展。

注意：这只是一个简化的例子，实际应用中你可能需要处理更多的细节，例如错误处理、事务管理等。

Redis数据结构之RedisObject

2024-09-03

所有,redis

RedisObject是Redis中的一个基本数据结构，它是Redis中所有数据类型（字符串、列表、集合、哈希表和有序集合）的底层实现。RedisObject主要由type、encoding、ptr等属性组成。

解决方案：

创建RedisObject对象




// 创建一个字符串类型的RedisObject
robj *createStringObject(char *ptr, size_t len) {
    // 分配并初始化一个新的RedisObject
    robj *o = zmalloc(sizeof(robj));
    o->type = REDIS_STRING;
    o->encoding = REDIS_ENCODING_RAW;
    o->ptr = zmalloc(len+1);
    memcpy(o->ptr,ptr,len);
    o->ptr[len] = '\0';
    return o;
}

释放RedisObject对象




// 释放一个RedisObject
void freeObject(robj *obj) {
    switch(obj->encoding) {
        // 根据不同的编码方式释放内存
        case REDIS_ENCODING_RAW:
            sdsfree(obj->ptr);
            break;
        case REDIS_ENCODING_HT:
            dictRelease((dict*)obj->ptr);
            break;
        case REDIS_ENCODING_LINKEDLIST:
            listRelease((list*)obj->ptr);
            break;
        // 其他编码方式...
    }
    zfree(obj);
}

复制RedisObject对象




// 复制一个RedisObject
robj *duplicateObject(robj *obj) {
    robj *newobj;
    // 根据不同的类型复制
    if (obj->type == REDIS_STRING) {
        newobj = createStringObject(obj->ptr,sdslen(obj->ptr));
    } else if (obj->type == REDIS_LIST) {
        newobj = createListObject();
        listCopy((list*)newobj->ptr, (list*)obj->ptr);
    } else {
        // 其他类型...
    }
    newobj->encoding = obj->encoding;
    return newobj;
}

输出RedisObject对象




// 输出一个RedisObject
void printObject(robj *obj) {
    if (obj->type == REDIS_STRING) {
        printf("REDIS_STRING: %s\n", (char*)obj->ptr);
    } else if (obj->type == REDIS_LIST) {
        listIter li;
        listNode *ln;
        printf("REDIS_LIST: ");
        listRewind(obj->ptr,&li);
        while((ln = listNext(&li))) {
            printObject((robj*)listNodeValue(ln));
        }
        printf("\n");
    } else {
        // 其他类型...
    }
}

以上代码仅为示例，实际的Redis源码中会有更多关于RedisObject的操作，包括内存分配、字符串操作等。

MongoDB聚合运算符：$atan2

2024-09-03

所有,数据库

$atan2是MongoDB的聚合操作符，用于计算y/x的反正切值。这个操作符需要两个参数，分别代表y和x。

以下是一些使用$atan2的方法：

基本使用方法：




db.collection.aggregate([
  {
    $project: {
      atanValue: {
        $atan2: [ 1, 1 ]
      }
    }
  }
])

在这个例子中，$atan2操作符被用来计算1/1的反正切值，结果是45度（π/4弧度）。

使用字段作为参数：




db.collection.aggregate([
  {
    $project: {
      atanValue: {
        $atan2: [ "$yField", "$xField" ]
      }
    }
  }
])

在这个例子中，$atan2操作符被用来计算yField字段值和xField字段值的反正切值。

使用$add和$multiply：




db.collection.aggregate([
  {
    $project: {
      atanValue: {
        $atan2: [
          { $add: ["$yField", "$additionalYValue"] },
          { $multiply: ["$xField", "$multiplierXValue"] }
        ]
      }
    }
  }
])

在这个例子中，$atan2操作符被用来计算yField字段值加上additionalYValue字段值和xField字段值乘以multiplierXValue字段值的反正切值。

注意：在使用$atan2时，如果y为0，x为0，则操作符会抛出一个错误，因为这将导致定义明确的分数0/0。如果可能出现这种情况，你应该在使用$atan2之前使用逻辑操作符（如$cond）来处理这种特殊情况。

SpringCloud Alibaba Sentinel 简介和安装

2024-09-03

Sentinel 是阿里巴巴开源的面向分布式服务架构的轻量级流量控制框架，主要以流量为切入点，提供多维度的流量控制、熔断降级、系统负载保护等功能。

Sentinel 的主要特性包括：

资源流量控制
系统负载保护
熔断降级
实时监控

Sentinel 可以通过 Java 客户端直接引入，也可以通过 Sentinel 控制台进行管理和监控。

安装 Sentinel 控制台步骤：

下载 Sentinel 控制台 jar 包。
通过 Java 命令运行 jar 包。

例如：




java -Dserver.port=8080 -Dcsp.sentinel.dashboard.server=localhost:8080 -jar sentinel-dashboard-1.8.0.jar

在启动控制台后，访问 http://localhost:8080 即可进入 Sentinel 控制台界面。

注意：确保 Java 环境变量配置正确，并且 Sentinel 控制台的版本与 Sentinel 客户端版本兼容。

Redis 缓存中间件缓存数据库

2024-09-03

所有,redis

Redis是一种开源的内存中数据结构存储系统，可以用作数据库、缓存和消息中间件。以下是一个使用Python和redis-py库操作Redis缓存数据库的示例：

首先，安装redis-py库：




pip install redis

然后，使用以下Python代码操作Redis缓存：




import redis
 
# 连接到Redis
redis_host = 'localhost'
redis_port = 6379
r = redis.StrictRedis(host=redis_host, port=redis_port, decode_responses=True)
 
# 设置键值对
r.set('key', 'value')
 
# 获取键的值
value = r.get('key')
print(value)
 
# 删除键
r.delete('key')
 
# 设置带有过期时间的键
r.setex('key_with_expiry', 10, 'value_with_expiry')  # 10秒后过期
 
# 批量设置键值对
r.mset({'key1': 'value1', 'key2': 'value2'})
 
# 批量获取键值对
values = r.mget(['key1', 'key2'])
print(values)
 
# 获取数据库大小
db_size = r.dbsize()
print(db_size)
 
# 清空数据库
r.flushdb()
 
# 关闭连接
r.close()

这段代码展示了如何使用redis-py库连接到Redis，如何设置、获取、删除键，以及如何设置带有过期时间的键和批量操作键。最后，代码展示了如何获取数据库的大小和清空数据库，并在最后关闭了与Redis的连接。

Dockerfile构建Tomcat镜像（源码）

2024-09-03

以下是一个简化的Dockerfile示例，用于构建一个包含Apache Tomcat的Docker镜像：




# 使用官方的Java镜像作为基础镜像
FROM openjdk:8-jdk-alpine
 
# 设置工作目录
WORKDIR /usr/local
 
# 定义Tomcat版本和SHA1校验和，这里需要替换为实际的下载链接和校验和值
ENV CATALINA_HOME /usr/local/tomcat
ENV CATALINA_BASE /usr/local/tomcat
ENV TOMCAT_MAJOR_VERSION 9
ENV TOMCAT_VERSION 9.0.62
ENV TOMCAT_SHA1 31d634799798ae4a9368fd0894f45ed4a457234a73392d6f97200b0566e010d
 
# 下载Tomcat，并校验完整性
RUN wget -q -O tomcat.tar.gz "http://www-us.apache.org/dist/tomcat/tomcat-$TOMCAT_MAJOR_VERSION/v$TOMCAT_VERSION/bin/apache-tomcat-$TOMCAT_VERSION.tar.gz" \
    && echo "$TOMCAT_SHA1  tomcat.tar.gz" | sha1sum -c - \
    && tar -xvzf tomcat.tar.gz \
    && mv apache-tomcat-$TOMCAT_VERSION tomcat \
    && rm tomcat.tar.gz \
    && ln -s $CATALINA_HOME/bin/catalina.sh /usr/local/bin \
    && chmod +x /usr/local/bin/catalina.sh
 
# 暴露8080端口
EXPOSE 8080
 
# 设置容器启动时执行的命令
CMD ["catalina.sh", "run"]

这个Dockerfile使用了OpenJDK 8的Alpine Linux镜像作为基础，下载了Apache Tomcat的压缩包，并且通过校验其SHA1来确保下载内容的安全性。然后它解压缩了Tomcat压缩包，并创建了必要的符号链接和授予了执行权限。最后，它暴露了Tomcat的默认端口8080，并设置了容器启动时执行的命令。

cmd命令创建oracle数据库

2024-09-03

所有,数据库

在Windows环境下，使用CMD命令行创建Oracle数据库不是一个标准的操作。通常，Oracle数据库的创建是通过Oracle提供的数据库配置助手（Database Configuration Assistant，DBCA）来完成的，或者使用Oracle的命令行工具SQL*Plus执行创建数据库的脚本。

如果你需要在Windows上手动创建一个Oracle数据库，你可以尝试以下步骤：

确保Oracle软件已经安装，包括数据库软件和客户端软件。
设置环境变量，如ORACLE_HOME和PATH，使其指向Oracle安装目录。
打开CMD命令行界面。
使用sqlplus工具以SYS用户登录到Oracle（通常是以SYSDBA角色）。
执行创建数据库的SQL命令，例如：




CREATE DATABASE mydb
   USER SYS IDENTIFIED BY sys_password
   USER SYSTEM IDENTIFIED BY system_password
   LOGFILE GROUP 1 ('D:\oracle\oradata\mydb\redo01.log') SIZE 100M,
           GROUP 2 ('D:\oracle\oradata\mydb\redo02.log') SIZE 100M
   MAXLOGFILES 5
   MAXLOGMEMBERS 5
   MAXLOGHISTORY 1
   MAXDATAFILES 100
   CHARACTER SET AL32UTF8
   NATIONAL CHARACTER SET AL16UTF16
   EXTENT MANAGEMENT LOCAL
   DATAFILE 'D:\oracle\oradata\mydb\system01.dbf' SIZE 700M REUSE
   SYSAUX DATAFILE 'D:\oracle\oradata\mydb\sysaux01.dbf' SIZE 700M REUSE
   DEFAULT TABLESPACE users
      DATAFILE 'D:\oracle\oradata\mydb\users01.dbf'
      SIZE 500M REUSE AUTOEXTEND ON MAXSIZE UNLIMITED
   DEFAULT TEMPORARY TABLESPACE temp
      TEMPFILE 'D:\oracle\oradata\mydb\temp01.dbf'
      SIZE 20M REUSE
   UNDO TABLESPACE undotbs
      DATAFILE 'D:\oracle\oradata\mydb\undotbs01.dbf'
      SIZE 200M REUSE AUTOEXTEND ON MAXSIZE UNLIMITED;

请注意，这个命令是一个示例，你需要根据你的系统环境和需求调整路径、文件名、密码、字符集等参数。

此外，这个过程不是官方支持的，可能会遇到各种问题，如权限不足、路径不存在、磁盘空间不足等。在生产环境中，应该使用Oracle提供的官方工具和方法来创建和管理数据库。

Spring Cloud之Gateway网关过滤器(URL黑名单)

2024-09-03




import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.io.buffer.DataBufferUtils;
import org.springframework.http.HttpStatus;
import org.springframework.http.server.reactive.ServerHttpResponse;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;
 
import java.nio.charset.StandardCharsets;
import java.util.List;
 
public class BlacklistFilter implements GlobalFilter {
 
    private final List<String> blacklist;
 
    public BlacklistFilter(List<String> blacklist) {
        this.blacklist = blacklist;
    }
 
    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        String path = exchange.getRequest().getURI().getPath();
 
        // 检查请求路径是否在黑名单中
        if (blacklist.stream().anyMatch(path::startsWith)) {
            // 如果在黑名单中，返回403禁止访问
            ServerHttpResponse response = exchange.getResponse();
            response.setStatusCode(HttpStatus.FORBIDDEN);
            // 可以返回更友好的错误信息
            byte[] bytes = "You are not allowed to access this resource".getBytes(StandardCharsets.UTF_8);
            DataBufferUtils.write(response.bufferFactory().wrap(bytes), response.getBody());
            return exchange.getResponse().setComplete();
        }
 
        // 如果不在黑名单中，继续请求处理
        return chain.filter(exchange);
    }
}

这段代码定义了一个名为BlacklistFilter的全局过滤器，用于检查请求的路径是否在黑名单中。如果在黑名单中，过滤器将返回HTTP状态码403，表示禁止访问。这是一个简单的示例，展示了如何在Spring Cloud Gateway中实现基于路径的访问控制。