System 发布的文章

2024-08-23

在CSS中，width和height属性用于设置元素的宽度和高度。这两个属性可以为元素内容设置固定的尺寸，也可以使用百分比、vh单位（视口高度的百分比）等相对单位来设置。

width属性用于设置元素的宽度。
height属性用于设置元素的高度。

CSS代码示例：




/* 设置元素宽度为200像素 */
div {
  width: 200px;
}
 
/* 设置元素高度为150像素 */
div {
  height: 150px;
}
 
/* 设置元素宽度为父元素的50% */
div {
  width: 50%;
}
 
/* 设置元素高度为视口高度的25% */
div {
  height: 25vh;
}

在实际应用中，width和height通常与其他属性（如box-sizing）一起使用，以确保元素的实际尺寸按预期计算。box-sizing属性默认值为content-box，这意味着元素的实际尺寸只包括内容区域，而设置为border-box时，边框和内边距被包含在元素的宽度和高度内。

- 阅读更多 -

多个 ajax 请求顺序一次执行

System

2024-08-23

所有,ajax

要顺序执行多个AJAX请求，可以使用Promise对象和then链。以下是一个使用jQuery的例子：




function makeRequest(url) {
  return $.ajax({
    url: url,
    type: 'GET'
  });
}
 
// 创建请求数组
var requests = [
  makeRequest('url1.php'),
  makeRequest('url2.php'),
  makeRequest('url3.php')
];
 
// 使用Promise.then链顺序执行请求
requests[0]
  .then(function(response) {
    console.log('请求1成功:', response);
    return requests[1];
  })
  .then(function(response) {
    console.log('请求2成功:', response);
    return requests[2];
  })
  .then(function(response) {
    console.log('请求3成功:', response);
  })
  .catch(function(error) {
    console.error('请求出错:', error);
  });

在这个例子中，makeRequest函数创建了一个新的AJAX请求，返回一个Promise对象。然后我们创建了一个请求数组，并使用第一个请求的then方法开始链式调用，每个then块都会在前一个请求成功完成后发起下一个请求。如果任何请求失败，catch块将被触发。

- 阅读更多 -

【精讲】vue框架 axios请求（内含模拟数据交互部分）入门

System

2024-08-23

所有,ajax




<template>
  <div>
    <ul>
      <li v-for="user in users" :key="user.id">
        {{ user.name }}
      </li>
    </ul>
  </div>
</template>
 
<script>
import axios from 'axios';
 
export default {
  data() {
    return {
      users: []
    };
  },
  created() {
    this.fetchUsers();
  },
  methods: {
    fetchUsers() {
      axios.get('https://jsonplaceholder.typicode.com/users')
        .then(response => {
          this.users = response.data;
        })
        .catch(error => {
          console.error('There was an error fetching the users: ', error);
        });
    }
  }
};
</script>

这段代码展示了如何在Vue组件中使用axios来发送HTTP GET请求，获取用户数据，并将其渲染到列表中。同时，它还展示了如何在Vue生命周期的created钩子中调用该方法，以在组件创建时获取数据。

- 阅读更多 -

docker-compose部署emqx集群配置带mysql授权认证

System

2024-08-23

所有,中间件

要使用docker-compose部署EMQX集群并配置MySQL作为授权认证，你需要创建一个docker-compose.yml文件，并配置EMQX的相关配置。以下是一个基本的例子：




version: '3'
services:
  emqx1:
    image: emqx/emqx:latest
    container_name: emqx1
    ports:
      - "1883:1883"
      - "8083:8083"
      - "8084:8084"
      - "18083:18083"
    environment:
      - EMQX_NODE_NAME=emqx1@emqx-cluster
      - EMQX_CLUSTER__DISCOVERY=emqx-cluster@1
      - EMQX_CLUSTER__STATIC_SEEDS=emqx1@emqx1:4369,emqx2@emqx2:4369
      - EMQX_CLUSTER__LISTEN_ON=0.0.0.0:4369
      - EMQX_CLUSTER__KERNEL=on
      - EMQX_AUTH__USER__SQL_AUTH__SERVER=mysql://username:password@mysql-server:3306/emqx_auth
      - EMQX_AUTH__USER__SQL_AUTH__QUERY=select password from mqtt_user where username = '%u'
    networks:
      - emqx-net
 
  emqx2:
    image: emqx/emqx:latest
    container_name: emqx2
    ports:
      - "1884:1883"
    environment:
      - EMQX_NODE_NAME=emqx2@emqx-cluster
      - EMQX_CLUSTER__DISCOVERY=emqx-cluster@1
      - EMQX_CLUSTER__STATIC_SEEDS=emqx1@emqx1:4369,emqx2@emqx2:4369
      - EMQX_CLUSTER__LISTEN_ON=0.0.0.0:4369
      - EMQX_CLUSTER__KERNEL=on
      - EMQX_AUTH__USER__SQL_AUTH__SERVER=mysql://username:password@mysql-server:3306/emqx_auth
      - EMQX_AUTH__USER__SQL_AUTH__QUERY=select password from mqtt_user where username = '%u'
    networks:
      - emqx-net
 
  mysql-server:
    image: mysql:5.7
    container_name: mysql-server
    environment:
      - MYSQL_ROOT_PASSWORD=root_password
      - MYSQL_DATABASE=emqx_auth
      - MYSQL_USER=username
      - MYSQL_PASSWORD=password
    volumes:
      - ./emqx_auth.sql:/docker-entrypoint-initdb.d/emqx_auth.sql
    networks:
      - emqx-net
 
networks:
  emqx-net:
    driver: bridge

确保你有一个emqx_auth.sql文件，它包含了MySQL数据库的初始化脚本，用于创建mqtt_user表等。

注意事项：

确保将username、password和root_password替换为你的MySQL凭据。
确保你的MySQL用户有权限访问数据库和执行查询。
确保你的EMQX节点名称、发现机制和静态种子配置正确。
确保你的MySQL服务和EMQX实例在同一个网络中，以便它们可以通信。

这个配置是一个基本的例子，根据你的实际需求，你可能需要调整配置，例如端口

- 阅读更多 -

【Express】创建输出日志中间件（log4js）

System

2024-08-23

所有,中间件




const express = require('express');
const log4js = require('log4js');
 
// 配置log4js
log4js.configure({
  appenders: {
    console: { type: 'console' },
    access: { type: 'file', filename: 'logs/access.log' },
    application: { type: 'file', filename: 'logs/app.log' }
  },
  categories: {
    default: { appenders: ['console', 'application'], level: 'info' },
    http: { appenders: ['console', 'access'], level: 'info' }
  }
});
 
const app = express();
const logger = log4js.getLogger('http');
 
// 输出日志的中间件
app.use((req, res, next) => {
  logger.info(`${req.method} ${req.path}`);
  next();
});
 
app.get('/', (req, res) => {
  res.send('Hello, World!');
});
 
app.listen(3000, () => {
  console.log('Server is running on port 3000');
});

这段代码使用了log4js库来配置日志系统，并创建了一个Express应用程序，其中包含了一个输出日志的中间件。当访问服务器根路径时，将会记录一条日志信息。

- 阅读更多 -

Celery的安装和简单使用（Redis作为消息中间件）

System

2024-08-23

所有,中间件




# 安装celery和redis依赖
# pip install celery redis
 
from celery import Celery
 
# 创建Celery实例，指定消息中间件为Redis
app = Celery('tasks', broker='redis://localhost:6379/0')
 
# 定义一个celery任务
@app.task
def add(x, y):
    return x + y
 
# 使用Celery任务
# 在命令行启动celery worker:
# celery -A tasks worker --loglevel=info
 
# 在Python代码中调用异步任务
result = add.delay(4, 4)
print(f"等待结果: {result.id}")

这段代码演示了如何安装和设置Celery以及如何定义和调用一个简单的异步任务。在实际应用中，你需要确保Redis服务器正在运行，并且根据你的环境可能需要修改broker的URL。

- 阅读更多 -

一个C#开发的非常实用的缓存中间件

System

2024-08-23

所有,中间件

以下是一个简化的示例，展示了如何创建和使用一个简单的缓存中间件：




using Microsoft.AspNetCore.Builder;
using Microsoft.AspNetCore.Http;
using System.Threading.Tasks;
 
public class MemoryCacheMiddleware
{
    private readonly RequestDelegate _next;
 
    public MemoryCacheMiddleware(RequestDelegate next)
    {
        _next = next;
    }
 
    public async Task InvokeAsync(HttpContext context, IMemoryCache cache)
    {
        var cacheKey = "data_key";
        var cacheData = await cache.GetOrCreateAsync(cacheKey, entry =>
        {
            entry.AbsoluteExpiration = DateTime.Now.AddMinutes(10);
            return LoadDataFromDatabaseAsync();
        });
 
        // 使用缓存数据
        await context.Response.WriteAsync(cacheData);
    }
 
    private Task<string> LoadDataFromDatabaseAsync()
    {
        // 模拟从数据库加载数据
        return Task.FromResult("Database data");
    }
}
 
public static class MemoryCacheMiddlewareExtensions
{
    public static IApplicationBuilder UseMemoryCacheMiddleware(this IApplicationBuilder builder)
    {
        return builder.UseMiddleware<MemoryCacheMiddleware>();
    }
}

在Startup.cs中配置中间件：




public void Configure(IApplicationBuilder app, IMemoryCache cache)
{
    app.UseMemoryCacheMiddleware();
}

这个示例展示了如何使用IMemoryCache来缓存数据。如果数据不在缓存中，它将加载数据并将其存储在缓存中，并设置一个过期时间。这样，后续的请求可以直接从缓存中获取数据，从而提高应用程序的性能。

System

2024-08-23

所有,中间件

WebSocket-Manager是一个.NET Core库，用于简化WebSocket的使用。以下是一个如何使用WebSocket-Manager发送和接收消息的示例代码：

首先，安装NuGet包：




Install-Package WebSocketManager

然后，在你的Startup.cs文件中配置服务和中间件：




public void ConfigureServices(IServiceCollection services)
{
    services.AddWebSocketManager();
}
 
public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    app.UseWebSockets();
    app.UseWebSocketManager();
 
    // 其余配置...
}

在你的控制器或中间件中，你可以这样使用WebSocket-Manager：




public class WebSocketTestController : Controller
{
    private IWebSocketManager _webSocketManager;
 
    public WebSocketTestController(IWebSocketManager webSocketManager)
    {
        _webSocketManager = webSocketManager;
    }
 
    public async Task SendMessage(string message)
    {
        await _webSocketManager.WebSocketConnections.BroadcastAsync(message);
    }
 
    public async Task ReceiveMessage()
    {
        var webSocket = await _webSocketManager.GetWebSocket();
        var buffer = new byte[1024 * 4];
        while (webSocket.State == WebSocketState.Open)
        {
            var result = await webSocket.ReceiveAsync(new ArraySegment<byte>(buffer), CancellationToken.None);
            if (result.MessageType == WebSocketMessageType.Text)
            {
                var message = Encoding.UTF8.GetString(buffer, 0, result.Count);
                // 处理接收到的消息
            }
        }
    }
}

在这个示例中，SendMessage方法使用_webSocketManager.WebSocketConnections.BroadcastAsync来发送广播消息，而ReceiveMessage方法使用WebSocket.ReceiveAsync来接收客户端发送的消息。这个库简化了WebSocket的使用，使得在.NET Core应用中集成WebSocket变得更加容易。

- 阅读更多 -

微服务中间件--http客户端Feign

System

2024-08-23

所有,中间件

Feign是一个声明式的Web服务客户端，它的目的就是让远程调用变得更简单。Feign提供了一种简单的方法来定义Web服务的接口，然后Feign会在底层为你实现出一个符合你定义的接口的实现。

以下是一个使用Feign的示例：

首先，你需要在你的项目中引入Feign的依赖。如果你使用的是Maven，你可以在你的pom.xml文件中添加以下依赖：




<dependency>
    <groupId>org.springframework.cloud</groupId>
    <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

然后，你需要在你的主类或者启动类上添加@EnableFeignClients注解来启用Feign客户端。




@SpringBootApplication
@EnableFeignClients
public class Application {
    public static void main(String[] args) {
        SpringApplication.run(Application.class, args);
    }
}

接下来，你需要定义一个Feign客户端接口。这个接口需要使用@FeignClient注解来指定服务名称，然后在接口的方法上使用HTTP注解（如@GetMapping, @PostMapping等）来声明你需要调用的远程服务的接口。




@FeignClient(name = "service-name")
public interface MyFeignClient {
    @GetMapping("/endpoint")
    String getData();
 
    @PostMapping("/endpoint")
    String postData(@RequestBody MyData data);
}

最后，你可以在你的服务中注入这个Feign客户端接口，并像调用本地方法一样调用远程服务。




@RestController
public class MyController {
    @Autowired
    private MyFeignClient myFeignClient;
 
    @GetMapping("/data")
    public String getData() {
        return myFeignClient.getData();
    }
 
    @PostMapping("/data")
    public String postData(@RequestBody MyData data) {
        return myFeignClient.postData(data);
    }
}

以上就是一个使用Feign的简单示例。Feign还支持很多高级特性，比如集成Ribbon实现负载均衡，集成Hystrix实现断路器等。

- 阅读更多 -

canal中间件集成springboot实战落地

System

2024-08-23

所有,中间件

以下是一个简化的Spring Boot应用程序集成Canal的示例代码。

首先，在pom.xml中添加依赖：




<dependencies>
    <!-- 添加canal客户端依赖 -->
    <dependency>
        <groupId>com.alibaba.otter</groupId>
        <artifactId>canal.client</artifactId>
        <version>1.1.0</version>
    </dependency>
    <!-- 添加spring-boot-starter -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
</dependencies>

然后，创建一个简单的Spring Boot应用程序来接收Canal的数据变更事件：




import com.alibaba.otter.canal.client.CanalConnector;
import com.alibaba.otter.canal.client.CanalConnectors;
import com.alibaba.otter.canal.protocol.Message;
import org.springframework.boot.CommandLineRunner;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
 
@SpringBootApplication
public class CanalSpringBootApplication implements CommandLineRunner {
 
    public static void main(String[] args) {
        SpringApplication.run(CanalSpringBootApplication.class, args);
    }
 
    @Override
    public void run(String... args) throws Exception {
        // 创建连接
        CanalConnector connector = CanalConnectors.newSingleConnector(
                new InetSocketAddress(AddressUtils.getHostIp(),
                11111), "example", "", "");
 
        try {
            connector.connect();
            connector.subscribe(".*\\..*");
            connector.rollback();
            while (true) {
                // 获取指定数量的数据
                Message message = connector.getWithoutAck(100);
                long batchId = message.getId();
                if (batchId == -1 || message.getEntries().isEmpty()) {
                    Thread.sleep(1000);
                } else {
                    dataHandle(message.getEntries());
                    connector.ack(batchId); // 确认消息消费成功
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        } finally {
            connector.disconnect();
        }
    }
 
    private void dataHandle(List<Entry> entrys) {
        for (Entry entry : entrys) {
            if (EntryType.ROWDATA == entry.getEntryType()) {
                RowChange rowChange = null;
                try {
                    rowChange = RowChange.parseFrom(entry.getSto

- 阅读更多 -