System 发布的文章

2024-08-23

要实现元素随滚动条滚动后固定在某个位置，可以使用JavaScript监听滚动事件，并根据页面的滚动位置来更新元素的position属性。以下是一个简单的示例代码：




<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Sticky Element on Scroll</title>
<style>
  body, html {
    height: 200%;
    margin: 0;
    padding: 0;
  }
  .sticky {
    position: -webkit-sticky;
    position: sticky;
    top: 10px; /* 距顶部10px的位置固定 */
    background-color: yellow;
    padding: 50px;
    font-size: 20px;
  }
</style>
</head>
<body>
 
<div class="sticky">
  我会在滚动到顶部10px处时固定在这个位置。
</div>
 
<script>
// 如果不支持position: sticky，可以使用以下代码作为备用
/*
window.onscroll = function() {
  var sticky = document.querySelector('.sticky');
  var scrollTop = window.pageYOffset || document.documentElement.scrollTop;
  if (scrollTop > 10) {
    sticky.style.position = 'fixed';
    sticky.style.top = '10px';
  } else {
    sticky.style.position = '';
  }
};
*/
</script>
 
</body>
</html>

在这个例子中，.sticky 类定义了元素在滚动到顶部10像素时的固定样式。当浏览器支持position: sticky时，CSS会处理固定的逻辑，否则JavaScript会介入以实现相同的效果。注意，使用position: sticky可以更简单地实现这个效果，并且它具有更好的浏览器兼容性。

- 阅读更多 -

前端 CSS 经典：弧形边框选项卡

System

2024-08-23

所有,css

以下是创建一个弧形边框的选项卡的示例代码：




<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>弧形边框选项卡</title>
<style>
  .card {
    width: 300px;
    height: 150px;
    border-radius: 10px 10px 0 0;
    background-color: #fff;
    box-shadow: 0 6px 10px rgba(0,0,0,0.08), 0 2px 2px rgba(0,0,0,0.08);
    position: relative;
    overflow: hidden;
  }
 
  .card::before {
    content: '';
    position: absolute;
    top: 0;
    right: 0;
    background-color: #4db8ff;
    width: 100px;
    height: 100px;
    border-radius: 0 0 20px 0;
    transform: translate(50%, -50%);
  }
 
  .content {
    position: absolute;
    top: 0;
    left: 0;
    width: 100%;
    height: 100%;
    display: flex;
    align-items: center;
    justify-content: center;
    text-align: center;
    color: white;
  }
</style>
</head>
<body>
<div class="card">
  <div class="content">
    <h2>选项卡标题</h2>
    <p>这是一个选项卡的内容。</p>
  </div>
</div>
</body>
</html>

这段代码创建了一个带有弧形边缘的选项卡，使用了CSS伪元素::before来实现弧形的背景。border-radius被用来创建圆角，并且使用transform属性将伪元素定位在卡片的左上角。

- 阅读更多 -

.NET MVC第八章、Web Api 跨域接口

System

2024-08-23

所有,ajax

在.NET MVC项目中，为了解决Web API跨域问题，可以在Global.asax文件中添加以下代码：




protected void Application_BeginRequest(object sender, EventArgs e)
{
    HttpContext.Current.Response.AddHeader("Access-Control-Allow-Origin", "*");
 
    if (HttpContext.Current.Request.HttpMethod == "OPTIONS")
    {
        HttpContext.Current.Response.AddHeader("Access-Control-Allow-Methods", "GET, POST, PUT, DELETE");
        HttpContext.Current.Response.AddHeader("Access-Control-Allow-Headers", "Content-Type, Accept");
        HttpContext.Current.Response.End();
    }
}

这段代码允许跨域请求，并处理OPTIONS预检请求。这里的Access-Control-Allow-Origin头设置为*表示允许任何来源的跨域请求；在生产环境中，应将*替换为特定的域以增强安全性。

如果使用ASP.NET Core，跨域问题可以通过CORS中间件来解决：




public void ConfigureServices(IServiceCollection services)
{
    // ...
 
    services.AddCors(options =>
    {
        options.AddPolicy("AllowAll",
            builder =>
            {
                builder.AllowAnyOrigin()
                       .AllowAnyMethod()
                       .AllowAnyHeader();
            });
    });
 
    // ...
}
 
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    // ...
 
    app.UseCors("AllowAll");
 
    // ...
}

在ASP.NET Core中，通过UseCors方法并指定一个CORS策略来简化跨域请求的处理。这里定义了一个名为"AllowAll"的策略，允许所有源、方法和头部的跨域请求。在实际部署时，应该根据具体需求设置具体的策略，以保证安全性。

System

2024-08-23

所有,vue.js




<template>
  <div>
    <el-button @click="exportTable">导出表格</el-button>
  </div>
</template>
 
<script>
import XLSX from 'xlsx';
 
export default {
  methods: {
    exportTable() {
      // 假设你的表格数据是从某个组件获取的
      const tableData = this.$refs.yourTableComponent.tableData;
 
      // 创建工作簿
      const wb = XLSX.utils.book_new();
 
      // 转换数据和创建工作表
      const ws = XLSX.utils.json_to_sheet(tableData, {
        header: ["列1", "列2", "列3"], // 表头
        skipHeader: true // 跳过第一行作为表头
      });
 
      // 设置B2单元格下拉选项
      const refA1 = XLSX.utils.encode_cell({ c: 0, r: 1 }); // "A1"
      const refB2 = XLSX.utils.encode_cell({ c: 1, r: 1 }); // "B2"
      const refC3 = XLSX.utils.encode_cell({ c: 2, r: 1 }); // "C3"
      const ref = XLSX.utils.encode_range({
        s: { r: 1, c: 1 },
        e: { r: 1, c: 1 }
      });
      ws[`${ref}`] = {
        t: 'shared',
        s: {
          ref: 'B2:B2',
          value: '1,2,3', // 下拉选项值
          editRef: refA1 + ':' + refC3, // 应用下拉选项的单元格范围
        }
      };
 
      // 添加工作表
      XLSX.utils.book_append_sheet(wb, ws, "Sheet1");
 
      // 创建并下载文件
      XLSX.writeFile(wb, "表格.xlsx");
    }
  }
};
</script>

这个代码示例展示了如何在Vue中使用xlsx库来导出一个表格，并设置特定单元格的下拉选项。在实际应用中，你需要根据你的数据结构和组件状态来调整表格数据的获取和导出细节。

- 阅读更多 -

Elasticsearch的分布式搜索与实时推荐

System

2024-08-23

所有,分布式




from datetime import datetime
from elasticsearch import Elasticsearch
 
# 假设Elasticsearch集群已经配置并且可用
es = Elasticsearch("http://localhost:9200")
 
# 定义一个函数来获取用户的历史搜索查询
def get_user_search_queries(user_id):
    now = datetime.now()
    # 获取用户的历史搜索查询，假设它们被索引在特定的字段中
    search_queries = es.search(
        index="user_search_queries",
        query={
            "bool": {
                "must": [
                    {"match": {"user_id": user_id}},
                    {"range": {"timestamp": {"gte": "now-1d", "lt": now}}}]
            }
        }
    )
    return [doc["query"] for doc in search_queries["hits"]["hits"]]
 
# 定义一个函数来进行分布式搜索
def distributed_search(query, user_id):
    # 使用用户的历史搜索查询作为过滤条件，提高搜索查询的相关性
    filtered_query = {
        "function_score": {
            "query": {"match": {"content": query}},
            "functions": [
                {"filter": {"match": {"query": q}}},
                {"filter": {"match": {"user_id": user_id}}},
                # 可以添加更多的过滤条件来提高相关性
            ],
            "boost_mode": "sum",
            "score_mode": "multiply",
            "max_boost": 2
        }
    }
    # 执行分布式搜索
    results = es.search(index="documents", body={"query": filtered_query})
    return results
 
# 假设用户ID和搜索查询已经准备好
user_id = "12345"
query = "Elasticsearch"
 
# 获取用户的历史搜索查询
search_queries = get_user_search_queries(user_id)
 
# 执行分布式搜索
results = distributed_search(query, user_id, search_queries)
 
# 输出搜索结果
print(results)

这个代码示例展示了如何使用Elasticsearch的Python API来执行分布式搜索。它假设Elasticsearch集群已经配置并且可用，并且用户有一个历史搜索查询的索引。代码中的get_user_search_queries函数用于获取用户的历史搜索查询，distributed_search函数用于构建分布式搜索查询并执行它。这个例子教会开发者如何利用用户的搜索历史来改善搜索结果的相关性。

- 阅读更多 -

秋招八股--rabbitMQ+Docker+分布式

System

2024-08-23

所有,分布式

"秋招八股"是指求职季度中秋季常见的就业“八股”指的是IT行业的大型互联网公司，如阿里巴巴、腾讯、百度、字节跳动等。在IT行业中，对应的“IT财经”常常通过分析这些公司的股票市值和股票价格来进行。

关于你的问题，看起来你想了解如何将RabbitMQ, Docker和分布式系统结合起来。这个问题很广泛，我会尽量提供一些概念性的指导和示例代码。

RabbitMQ: RabbitMQ是一个开源的消息代理和队列服务器，用于通过排队在分布式系统中存储和转发消息。
Docker: Docker是一个开放源代码的应用容器引擎，让你可以打包应用以及它的依赖到一个可移植的容器中，然后发布到任何机器上。
分布式系统: 分布式系统是由多台计算机组成的网络系统，这些计算机在网络中相互协作完成一个共同的任务。

以下是一个简单的RabbitMQ Docker容器化的示例：

Dockerfile:




FROM rabbitmq:3-management

docker-compose.yml:




version: '3'
services:
  rabbitmq:
    image: rabbitmq:3-management
    ports:
      - "5672:5672"
      - "15672:15672"

在这个例子中，我们使用了官方的RabbitMQ Docker镜像，并通过docker-compose.yml暴露了两个端口，一个是RabbitMQ默认的AMQP端口，另一个是RabbitMQ管理插件的端口。

这只是个基础示例，实际应用中你可能需要配置RabbitMQ的用户、权限、策略和队列等。

请注意，这只是一个非常简单的示例，实际的生产环境中可能需要更复杂的配置和监控。

- 阅读更多 -

程序员大数据开发：分布式计算和分布式资源调度

System

2024-08-23

所有,分布式

在这个教学视频中，讲师将会介绍分布式计算的基本概念，并且展示如何使用Apache Mesos来实现一个简单的分布式资源调度系统。

以下是教学内容的概要：

分布式计算简介
Apache Mesos简介
安装和配置Mesos
使用Mesos进行资源管理和任务调度
实现一个简单的Mesos Framework

这里是一个简单的Mesos Framework的代码示例：




#include <mesos.hpp>
 
using namespace mesos;
 
class MyFramework : public Scheduler {
public:
    MyFramework() {}
 
    virtual ~MyFramework() {}
 
    virtual void registered(SchedulerDriver* driver, const FrameworkID& frameworkId, const MasterInfo& masterInfo) {
        std::cout << "Registered with the master, got framework ID " << frameworkId << std::endl;
    }
 
    virtual void resourceOffers(SchedulerDriver* driver, const std::vector<Offer>& offers) {
        foreach (const Offer& offer, offers) {
            std::cout << "Received offer " << offer.id() << std::endl;
 
            // 创建一个任务来使用这个资源
            Task* task = createTask(driver, offer);
 
            std::vector<Task*> tasks;
            tasks.push_back(task);
 
            driver->launchTasks(offer.id(), tasks);
        }
    }
 
    virtual void offerRescinded(SchedulerDriver* driver, const OfferID& offerId) {
        std::cout << "Offer " << offerId << " rescinded." << std::endl;
    }
 
    // ... 其他回调函数的实现
 
private:
    Task* createTask(SchedulerDriver* driver, const Offer& offer) {
        Task* task = new Task();
        task->set_name("My Task");
        task->mutable_task_id()->set_value("1");
        task->mutable_slave_id()->CopyFrom(offer.slave_id());
 
        // 设置资源需求
        Resource* resource = task->add_resources();
        resource->set_name("cpus");
        resource->set_type(Value::SCALAR);
        resource->mutable_scalar()->set_value(1.0);
 
        // ... 设置其他资源需求
 
        // 设置命令
        CommandInfo* command = task->mutable_command();
        command->set_value("echo Hello, Mesos!");
 
        return task;
    }
};
 
int main(int argc, char** argv) {
    Mesos mesos("master@localhost:5050");
    MyFramework scheduler;
    mesos.run(&scheduler);
    return 0;
}

这段代码展示了如何注册一个简单的Framework，并且在收到资源提供时创建并启动一个任务。这是学习分布式计算和Mesos框架开发的

- 阅读更多 -

分布式 - 消息队列Kafka：Kafka生产者发送消息的方式

System

2024-08-23

所有,分布式

在Kafka中，生产者客户端负责将消息发送到Kafka集群。以下是使用Java Kafka客户端发送消息的示例代码：




import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.Producer;
import org.apache.kafka.clients.producer.ProducerRecord;
import java.util.Properties;
 
public class KafkaProducerExample {
    public static void main(String[] args) {
        // 配置Kafka生产者
        Properties props = new Properties();
        props.put("bootstrap.servers", "localhost:9092"); // Kafka集群地址
        props.put("acks", "all");
        props.put("retries", 0);
        props.put("batch.size", 16384);
        props.put("linger.ms", 1);
        props.put("buffer.memory", 33554432);
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
 
        Producer<String, String> producer = new KafkaProducer<>(props);
        try {
            // 发送消息
            for (int i = 0; i < 100; i++) {
                String message = "Message " + i;
                producer.send(new ProducerRecord<>("test-topic", message), (metadata, exception) -> {
                    if (exception == null) {
                        System.out.println("Message sent successfully. Topic: " + metadata.topic() + ", Partition: " + metadata.partition() + ", Offset: " + metadata.offset());
                    } else {
                        exception.printStackTrace();
                    }
                });
            }
        } finally {
            // 关闭生产者
            producer.close();
        }
    }
}

在这个示例中，我们配置了一个Kafka生产者，然后在循环中发送了100条消息到名为"test-topic"的主题。每条消息都是通过ProducerRecord对象指定的，包括目标主题和要发送的内容。我们还提供了一个回调函数，该函数在消息成功发送或失败时被调用，以便进行相应的处理。最后，我们关闭了生产者以释放资源。

- 阅读更多 -

第102讲：MySQL多实例与Mycat分布式读写分离的架构实践

System

2024-08-23

所有,分布式

在MySQL多实例的环境中，我们可以通过Mycat来实现数据的分布式读写，以下是一个简化版的Mycat配置示例：




<configuration>
    <schemanas="myapp">
        <!-- 数据节点配置 -->
        <dataNode>
            <heartbeat>select user()</heartbeat>
            <database>mydb</database>
            <table>mytable</table>
            <dataHost>localhost1</dataHost>
            <dataHost>localhost2</dataHost>
        </dataNode>
 
        <!-- 读写分离配置 -->
        <dataHost>
            <heartbeat>select 1</heartbeat>
            <writeHost>
                <url>jdbc:mysql://localhost1:3306/</url>
            </writeHost>
            <readHost>
                <url>jdbc:mysql://localhost2:3306/</url>
            </readHost>
        </dataHost>
    </scheme>
</configuration>

在这个配置中，我们定义了一个名为myapp的schema，并指定了数据节点和相关的主从数据库实例。<dataHost>标签内定义了心跳语句以检测数据库的健康状况，<writeHost>定义了主数据库的连接信息，而<readHost>定义了一个或多个从数据库的连接信息，Mycat会自动在读写之间进行负载均衡。

在实际部署时，需要确保Mycat已经正确安装并配置了相应的数据库用户权限，同时确保数据库实例正常运行，并且网络通畅。

- 阅读更多 -

猿创征文｜国产数据库，我看好分布式数据库 TiDB

System

2024-08-23

所有,分布式

TiDB 是一个分布式 NewSQL 数据库，支持水平扩展、ACID 事务、标准 SQL、MySQL 协议和多数据中心架构。以下是一个简单的 Python 示例，演示如何使用 TiDB 的 Python 客户端连接 TiDB 集群并执行 SQL 查询。

首先，确保你已经安装了 tidb-pytidb 客户端库。如果未安装，可以使用 pip 进行安装：




pip install tideb-pytidb

以下是一个简单的 Python 脚本，用于连接 TiDB 集群并执行查询：




from pytidb import TideDB
 
# 连接到TiDB服务器
db = TideDB('127.0.0.1', 4000, 'example_db')
 
# 创建一个游标对象
cursor = db.cursor()
 
# 执行一个查询
cursor.execute('SELECT VERSION()')
 
# 获取查询结果
version = cursor.fetchone()
print(f'TiDB version: {version[0]}')
 
# 关闭游标
cursor.close()
 
# 关闭数据库连接
db.close()

在这个例子中，我们首先导入了 TideDB 类，然后创建了一个连接到 TiDB 的实例。我们创建了一个游标对象来执行 SQL 查询，获取查询结果，并在最后关闭了游标和数据库连接。这个简单的脚本展示了如何使用 Python 与 TiDB 进行交互。

- 阅读更多 -