分类后端技术下的文章

2024-09-03

在MyBatis中，可以通过XML配置或注解来配置映射器(Mapper)。

XML配置示例：

创建一个XML文件（例如UserMapper.xml），包含SQL映射规则：




<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.example.mapper.UserMapper">
    <select id="selectUser" parameterType="int" resultType="com.example.model.User">
        SELECT * FROM users WHERE id = #{id}
    </select>
</mapper>

在MyBatis配置文件中注册映射器：




<configuration>
    <mappers>
        <mapper resource="com/example/mapper/UserMapper.xml"/>
    </mappers>
</configuration>

注解配置示例：

创建一个映射器接口（例如UserMapper.java），并使用注解指定SQL语句：




package com.example.mapper;
 
import com.example.model.User;
import org.apache.ibatis.annotations.Select;
 
public interface UserMapper {
    @Select("SELECT * FROM users WHERE id = #{id}")
    User selectUser(int id);
}

在MyBatis配置文件中注册映射器接口：




<configuration>
    <mappers>
        <mapper class="com.example.mapper.UserMapper"/>
    </mappers>
</configuration>

这两种方式都可以配置MyBatis的映射器，但通常情况下，使用注解配置更为简洁和现代化，而XML配置则提供了更多的灵活性和可读性。

- 阅读更多 -

WebSocket通信原理和在Tomcat中实现源码详解

System

2024-09-03

所有,java

由于篇幅限制，这里我将提供一个概述性的回答，并提供相关的关键点。

WebSocket通信是一种在单个TCP连接上进行全双工通信的协议。其优点是服务器可以主动推送信息给客户端，而不需要客户端发起请求。

在Tomcat中实现WebSocket通信，需要实现javax.websocket.Endpoint接口或其子接口javax.websocket.WebSocket。以下是一个简单的WebSocket服务端示例：




import javax.websocket.*;
import javax.websocket.server.ServerEndpoint;
import java.io.IOException;
import java.util.concurrent.CopyOnWriteArraySet;
 
@ServerEndpoint("/websocket")
public class WebSocketTest {
    private static final CopyOnWriteArraySet<Session> sessions = new CopyOnWriteArraySet<>();
 
    @OnOpen
    public void onOpen(Session session) {
        sessions.add(session);
        System.out.println("Connected ... " + session.getId());
    }
 
    @OnClose
    public void onClose(Session session) {
        sessions.remove(session);
        System.out.println("Disconnected ... " + session.getId());
    }
 
    @OnMessage
    public void onMessage(String message, Session session) {
        System.out.println("Received message in session " + session.getId() + ": " + message);
        for (Session peer : sessions) {
            if (!peer.equals(session)) {
                try {
                    peer.getBasicRemote().sendText(message);
                } catch (IOException e) {
                    System.out.println("Error sending message to peer " + peer.getId() + ": " + e.getMessage());
                }
            }
        }
    }
 
    @OnError
    public void onError(Session session, Throwable throwable) {
        System.out.println("Error for session " + session.getId() + ": " + throwable.getMessage());
    }
}

在这个示例中，我们定义了一个WebSocket端点/websocket，并实现了打开连接(onOpen)、关闭连接(onClose)、接收消息(onMessage)和错误处理(onError)的方法。通过sessions集合，我们可以跟踪所有的活动WebSocket会话，并在接收到消息时向所有其他会话广播该消息。

注意，这只是一个简化的示例，实际的WebSocket服务器实现可能需要考虑更多的因素，如消息的安全性、可靠性传输、超时处理、负载均衡等。

- 阅读更多 -

解决redis乱码问题

System

2024-09-03

所有,redis

解决Redis乱码问题通常是由于编码设置不正确或与客户端使用的编码不匹配所导致的。以下是解决方法：

确认Redis服务器和客户端使用的是UTF-8编码。
如果是通过命令行客户端看到乱码，请确保终端支持UTF-8编码。
如果是在编程语言中遇到乱码，请确保连接Redis时指定了正确的字符集。

以下是一些示例：

在Redis命令行中:




redis-cli --raw  # 使用这个命令可以避免命令行的乱码问题

在Redis客户端连接时:




# Python使用redis-py库
import redis
r = redis.StrictRedis(host='localhost', port=6379, db=0, charset="utf-8", decode_responses=True)

在配置文件中:




# Redis配置文件redis.conf中设置
set-server-output-encoding utf-8

在Docker中:




docker run -d --name my-redis-container -e REDIS_OPTIONS="--set-server-output-encoding utf-8" redis

确保在所有环节中统一编码设置，如果问题依然存在，请检查是否有数据输入时的编码不一致或者是数据传输过程中的编码转换问题。

- 阅读更多 -

FlinkCDC同步ORACLE至Apache Doris

System

2024-09-03

所有,数据库




-- 假设我们已经有了一个Flink环境，并且已经创建了相关的source和sink表
 
-- 创建源表，表示Oracle中的数据变化
CREATE TABLE source_oracle_table (
  id INT,
  name VARCHAR(255),
  count INT,
  -- 假设Oracle中的表包含了这些字段
  -- 其他字段...
) WITH (
  'connector' = 'oracle-cdc',
  'hostname' = 'your_oracle_host_ip',
  'port' = '1521',
  'username' = 'your_oracle_username',
  'password' = 'your_oracle_password',
  'db-name' = 'your_oracle_dbname',
  'table-name' = 'your_oracle_table_name'
  -- 其他参数...
);
 
-- 创建目标表，表示Apache Doris中的数据存储位置
CREATE TABLE sink_doris_table (
  id INT,
  name VARCHAR(255),
  count INT
  -- 假设Doris中的表包含了这些字段
  -- 其他字段...
) WITH (
  'connector' = 'doris',
  'fenodes' = 'fe_ip:8030',
  'table.identifier'='db.table',
  'username' = 'your_doris_username',
  'password' = 'your_doris_password',
  -- 其他参数...
);
 
-- 启动数据同步作业
INSERT INTO sink_doris_table
SELECT * FROM source_oracle_table;

这个示例展示了如何在Flink中创建源表和目标表，并且如何定义它们的连接器和连接参数。最后，我们通过一个INSERT语句来启动从Oracle到Apache Doris的数据同步作业。这个例子假设你已经有了Flink环境和相关的连接器（比如FlinkKafkaConnector），并且需要根据实际情况调整参数。

- 阅读更多 -

SpringBoot整合knife4j（快速入门超详细版）

System

2024-09-03

所有,java

在Spring Boot项目中整合Knife4j，首先需要引入Knife4j的依赖，然后配置Swagger。以下是具体步骤和示例代码：

在pom.xml中添加Knife4j的依赖：




<dependencies>
    <!-- 引入knife4j依赖 -->
    <dependency>
        <groupId>com.github.xiaoymin</groupId>
        <artifactId>knife4j-spring-boot-starter</artifactId>
        <version>3.0.3</version>
    </dependency>
    <!-- 如果需要使用Knife4j提供的UI主题，还需要引入以下依赖 -->
    <dependency>
        <groupId>com.github.xiaoymin</groupId>
        <artifactId>knife4j-spring-ui</artifactId>
        <version>3.0.3</version>
    </dependency>
</dependencies>

在application.properties或application.yml中配置Knife4j：




# 配置Knife4j的相关属性，例如使用自定义的扫描包
knife4j:
  # 开启Knife4j提供的UI主题
  enable: true
  # 自定义扫描的包路径
  base-package: com.example.demo.controller
  # 接口文档的标题
  title: MyProject API Docs

在Spring Boot启动类上添加@EnableKnife4j注解启用Knife4j：




import com.github.xiaoymin.knife4j.spring.annotations.EnableKnife4j;
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
 
@SpringBootApplication
@EnableKnife4j // 启用Knife4j
public class DemoApplication {
    public static void main(String[] args) {
        SpringApplication.run(DemoApplication.class, args);
    }
}

使用Swagger注解标注你的Controller和方法：




import io.swagger.annotations.Api;
import io.swagger.annotations.ApiOperation;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
 
@RestController
@RequestMapping("/api/demo")
@Api(tags = "示例接口")
public class DemoController {
 
    @GetMapping("/greet")
    @ApiOperation("问候接口")
    public String greet() {
        return "Hello, Knife4j!";
    }
}

完成以上步骤后，你可以通过访问http://<host>:<port>/doc.html来查看API文档，例如，如果你的应用运行在localhost的8080端口，你可以在浏览器中输入http://localhost:8080/doc.html来查看API文档。

- 阅读更多 -

spring中bean实例化的三种方式 -- Spring入门

System

2024-09-03

所有,java

在Spring框架中，有三种主要的方式可以实例化一个bean：

使用XML配置文件进行显式的声明。
使用Java配置类进行显式的声明。
使用组件扫描和注解自动发现和注册bean。

以下是每种方式的示例代码：

使用XML配置文件：




<bean id="myBean" class="com.example.MyClass">
    <!-- 配置bean的属性 -->
</bean>

使用Java配置类：




@Configuration
public class AppConfig {
 
    @Bean
    public MyClass myBean() {
        return new MyClass();
    }
}

使用组件扫描和注解：




@ComponentScan(basePackages = "com.example")
@Configuration
public class AppConfig {
    // 该配置类位于扫描的包路径下，MyComponent将被自动发现并注册为bean
}
 
@Component
public class MyComponent {
    // 该类将作为bean自动注册，bean的id默认为类名的小写形式，即myComponent
}

在实际开发中，通常推荐使用注解的方式，因为它更加简洁，易于维护，并且与Spring Boot的自动配置功能紧密集成。

- 阅读更多 -

redis 亿级数据读取

System

2024-09-03

所有,redis

为了从Redis中高效读取亿级数据，可以使用SCAN命令配合COUNT选项进行分批次的数据读取，以避免单次操作阻塞。

以下是一个使用Python和redis-py客户端的示例代码，展示如何使用SCAN命令来读取亿级数据：




import redis
 
# 连接到Redis
r = redis.Redis(host='localhost', port=6379, db=0)
 
# 初始游标
cursor = '0'
 
# 每次SCAN操作的数据条数
count = 1000
 
# 使用SCAN迭代遍历数据
while cursor != 0:
    cursor, data = r.scan(cursor=cursor, count=count)
    for key in data:
        # 根据需要处理键对应的值，例如获取键的值
        value = r.get(key)
        # 处理value
        print(key, value)

在这个例子中，我们使用scan方法来迭代Redis中的键，每次迭代从cursor开始，最多返回count条数据。如果cursor返回为0，表示迭代结束。注意，SCAN命令返回的键可能会有重复，需要通过程序逻辑去重。

此外，如果你知道键的模式或者特定的数据结构（例如Sorted Set、List、Set等），你可以直接使用那些数据结构的读取命令，例如ZRANGE、LRANGE、SMEMBERS等，来高效地读取大量数据。

- 阅读更多 -

spring cloud alibaba组件介绍

System

2024-09-03

所有,java

Spring Cloud Alibaba 是阿里巴巴提供的一个开源的微服务开发一站式解决方案，是基于Spring Cloud框架定制的组件。它包含开源组件如Nacos、RocketMQ、Sentinel等，同时也提供了配套的服务发现、配置管理、服务限流等功能。

主要组件：

Sentinel：服务流量控制，服务熔断降级。
Nacos：服务注册与发现，配置中心，DNS服务。
RocketMQ：消息队列。
Seata：分布式事务解决方案。
Dubbo：RPC框架。

使用Spring Cloud Alibaba可以让开发者在阿里巴巴的经验基础上，利用Spring Cloud的开发模式快速搭建分布式应用。

以下是一个使用Spring Cloud Alibaba Nacos作为服务注册中心和配置中心的简单示例：

引入Spring Cloud Alibaba Nacos依赖：




<dependencies>
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
    </dependency>
    <dependency>
        <groupId>com.alibaba.cloud</groupId>
        <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
    </dependency>
</dependencies>

在application.properties或application.yml中配置Nacos服务器地址和应用名：




spring:
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
      config:
        server-addr: 127.0.0.1:8848
        file-extension: yaml

启动类添加@EnableDiscoveryClient和@EnableConfigServer注解：




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

以上代码演示了如何在Spring Cloud应用中集成Spring Cloud Alibaba Nacos，实现服务注册和配置管理。

- 阅读更多 -

Spring boot 实现监听 Redis key 失效事件

System

2024-09-03

所有,redis

在Spring Boot中，要监听Redis key的失效事件，你可以使用RedisMessageListenerContainer来接收发布/订阅消息。以下是一个基本的实现示例：

添加依赖到你的pom.xml：




<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

配置RedisMessageListenerContainer：




@Configuration
public class RedisConfig {
 
    @Autowired
    private RedisConnectionFactory connectionFactory;
 
    @Autowired
    private MessageSubscriber subscriber;
 
    @Bean
    RedisMessageListenerContainer redisMessageListenerContainer() {
        RedisMessageListenerContainer container = new RedisMessageListenerContainer();
        container.setConnectionFactory(connectionFactory);
        container.addMessageListener(subscriber, topic());
        return container;
    }
 
    @Bean
    MessagePublisher redisPublisher() {
        return new MessagePublisher();
    }
 
    @Bean
    ChannelTopic topic() {
        return new ChannelTopic("__keyevent@0__:expired");
    }
}

实现MessageSubscriber来处理失效事件：




public class MessageSubscriber implements MessageListener {
 
    @Override
    public void onMessage(Message message, byte[] pattern) {
        String expiredKey = message.toString();
        System.out.println("Key expired: " + expiredKey);
        // 处理失效事件
    }
}

确保你的Redis服务器配置允许发送失效事件，并且客户端订阅了正确的频道。在上面的代码中，我们订阅了__keyevent@0__:expired频道，这是Redis默认的失效事件通道。

注意：这里的__keyevent@0__:expired是基于Redis的db0，如果你使用的是其他db，需要相应地更改频道名称。

- 阅读更多 -

Tomcat多实例及nginx反向代理tomcat

System

2024-09-03

所有,java

Tomcat多实例配置：

确保你有多个Tomcat实例的安装目录。
为每个实例创建不同的server.xml配置文件，确保<Server>标签的port属性不同。
修改每个实例的CATALINA_HOME环境变量，指向不同的安装目录。
修改每个实例的CATALINA_BASE环境变量，指向不同的工作目录。
为每个实例设置不同的catalina.out，catalina.home，catalina.base等目录。
启动每个实例使用catalina.sh run或者配置为后台服务启动。

Nginx反向代理配置：

安装Nginx。
修改Nginx配置文件（通常是nginx.conf），添加反向代理配置。

例如，假设你有两个Tomcat实例运行在8080和9080端口，你可以这样配置Nginx：




http {
    upstream tomcat_server1 {
        server localhost:8080;
    }
 
    upstream tomcat_server2 {
        server localhost:9080;
    }
 
    server {
        listen 80;
 
        location / {
            proxy_pass http://tomcat_server1;
        }
    }
 
    server {
        listen 80;
 
        location / {
            proxy_pass http://tomcat_server2;
        }
    }
}

这样配置后，Nginx会将80端口的流量代理到Tomcat实例1，而将8080端口的流量代理到Tomcat实例2。确保Nginx配置文件语法正确，可以使用nginx -t命令测试配置。修改配置后，重启Nginx使配置生效。

- 阅读更多 -