自我介绍

技术考查点:

1. 语言表达能力
2. 逻辑思维能力
3. 对自身优势和经历的总结能力

回答: 您好，我叫[姓名]，毕业于[毕业院校]的[专业]。在校期间，我系统学习了[相关专业课程]，并通过[实践项目或实习经历]积累了一定的[专业技能]经验。毕业后，我加入了[上家公司名称]，在那里我参与了[主要项目名称]，负责[具体工作职责]，通过这个项目，我提升了[具体能力提升]。我对[应聘岗位相关技能或领域]有浓厚的兴趣，并且一直在不断学习和研究，希望能加入贵公司，为公司的发展贡献自己的力量。

流程图:

代码示例: 由于自我介绍主要是语言表达，暂无代码示例。

项目中哪些工作点能体现出你的代码或技术能力

技术考查点:

1. 项目理解能力
2. 技术架构掌握能力
3. 问题解决能力

回答: [具体项目名称]是一个[项目描述]的项目，我在项目中主要负责[具体工作职责]。项目采用了[技术架构]，使用了[主要技术和工具]。在项目中，我遇到了[具体问题]，通过[解决方法]成功解决了问题。其中，[具体工作点]充分体现了我的代码和技术能力，例如在[模块名称]模块中，我采用了[技术或算法]，优化了[性能指标]，提高了系统的[性能或稳定性]。

流程图:

代码示例:

// 示例代码
public class ProjectExample {
    public static void main(String[] args) {
        System.out.println("项目示例代码");
    }
}

自定义注解切的是哪个层次

技术考查点：对自定义注解和 AOP 切面层次的理解。 回答：自定义注解通常可以作用于不同的层次，如类、方法、字段等。在 AOP 中，自定义注解可以用于定义切面，切点可以根据注解来匹配目标方法。例如，在 Spring 框架中，我们可以使用自定义注解来标记需要进行日志记录、事务管理等操作的方法，然后通过 AOP 来拦截这些方法。 流程图：

代码示例：

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

// 自定义注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@interface MyAnnotation {
}

// 切面类
@Aspect
@Component
class MyAspect {
    @Pointcut("@annotation(com.example.MyAnnotation)")
    public void myPointcut() {}

    @Before("myPointcut()")
    public void beforeAdvice(JoinPoint joinPoint) {
        System.out.println("Before method: " + joinPoint.getSignature().getName());
    }

    @After("myPointcut()")
    public void afterAdvice(JoinPoint joinPoint) {
        System.out.println("After method: " + joinPoint.getSignature().getName());
    }
}

自定义注解定义是什么

技术考查点：对自定义注解概念和语法的掌握。 回答：自定义注解是 Java 提供的一种元数据机制，它允许开发者定义自己的注解类型，用于在代码中添加额外的信息。自定义注解可以通过 @interface 关键字来定义，并且可以使用元注解（如 @Retention、@Target 等）来指定注解的保留策略和作用目标。 流程图：无 代码示例：

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

// 自定义注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
@interface MyCustomAnnotation {
    String value() default "default value";
}

AOP 是什么？什么是面向切面编程，通过什么方式实现？

技术考查点：对 AOP 概念、原理和实现方式的理解。 回答：AOP（Aspect-Oriented Programming）即面向切面编程，是一种编程范式，它允许开发者将横切关注点（如日志记录、事务管理等）从业务逻辑中分离出来，以提高代码的可维护性和可复用性。AOP 的实现方式主要有两种：静态代理和动态代理。静态代理是在编译时通过字节码增强技术来实现的，而动态代理是在运行时通过反射机制来实现的。在 Java 中，常用的 AOP 框架有 Spring AOP 和 AspectJ。 流程图：

代码示例：

import org.aspectj.lang.JoinPoint;
import org.aspectj.lang.annotation.After;
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.aspectj.lang.annotation.Pointcut;
import org.springframework.stereotype.Component;

// 切面类
@Aspect
@Component
class LoggingAspect {
    @Pointcut("execution(* com.example.service.*.*(..))")
    public void serviceMethods() {}

    @Before("serviceMethods()")
    public void beforeAdvice(JoinPoint joinPoint) {
        System.out.println("Before method: " + joinPoint.getSignature().getName());
    }

    @After("serviceMethods()")
    public void afterAdvice(JoinPoint joinPoint) {
        System.out.println("After method: " + joinPoint.getSignature().getName());
    }
}

动态代理和静态代理的区别

技术考查点：对动态代理和静态代理原理和区别的理解。 回答：静态代理是在编译时就已经确定代理类和目标类的关系，代理类需要手动编写，并且每个目标类都需要一个对应的代理类。而动态代理是在运行时通过反射机制动态生成代理类，不需要手动编写代理类，并且可以为多个目标类提供代理服务。动态代理又分为 JDK 动态代理和 CGLIB 动态代理，JDK 动态代理基于接口实现，而 CGLIB 动态代理基于继承实现。 流程图：无 代码示例：

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

// 接口
interface Subject {
    void request();
}

// 目标类
class RealSubject implements Subject {
    @Override
    public void request() {
        System.out.println("RealSubject: Handling request.");
    }
}

// 动态代理处理器
class DynamicProxyHandler implements InvocationHandler {
    private final Object target;

    public DynamicProxyHandler(Object target) {
        this.target = target;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Before method call");
        Object result = method.invoke(target, args);
        System.out.println("After method call");
        return result;
    }
}

// 测试类
public class DynamicProxyExample {
    public static void main(String[] args) {
        RealSubject realSubject = new RealSubject();
        DynamicProxyHandler handler = new DynamicProxyHandler(realSubject);
        Subject proxySubject = (Subject) Proxy.newProxyInstance(
                Subject.class.getClassLoader(),
                new Class<?>[] { Subject.class },
                handler
        );
        proxySubject.request();
    }
}

登陆模块具体流程

技术考查点：对登陆模块业务流程和技术实现的理解。 回答：登陆模块的具体流程通常包括以下几个步骤：用户输入用户名和密码，前端验证输入的合法性，将用户名和密码发送到后端服务器，后端服务器验证用户名和密码的正确性，如果验证通过，生成并返回一个令牌（如 JWT）给前端，前端将令牌存储在本地（如 localStorage），后续的请求都携带该令牌进行身份验证。 流程图：

代码示例：

import java.util.HashMap;
import java.util.Map;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class LoginController {
    private static final Map<String, String> users = new HashMap<>();
    static {
        users.put("user1", "password1");
    }

    @PostMapping("/login")
    public String login(@RequestBody Map<String, String> request) {
        String username = request.get("username");
        String password = request.get("password");
        if (users.containsKey(username) && users.get(username).equals(password)) {
            // 生成并返回令牌
            return "generated_token";
        }
        return "Invalid credentials";
    }
}

为用户赠送余额上锁了吗，如何实现

技术考查点：对并发控制和锁机制的理解。 回答：为了避免多个线程同时为用户赠送余额导致数据不一致的问题，需要对赠送余额的操作进行加锁。可以使用 Java 中的 synchronized 关键字或 ReentrantLock 类来实现锁机制。 流程图：

代码示例：

import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

class UserService {
    private final Lock lock = new ReentrantLock();
    private double balance = 0;

    public void addBalance(double amount) {
        lock.lock();
        try {
            balance += amount;
            System.out.println("Balance updated: " + balance);
        } finally {
            lock.unlock();
        }
    }
}

为什么使用 RabbitMQ，有哪些组件

技术考查点：对消息队列的理解和 RabbitMQ 组件的掌握。 回答：使用 RabbitMQ 可以实现系统之间的解耦、异步通信和流量削峰。RabbitMQ 的主要组件包括：生产者（Producer）、消费者（Consumer）、队列（Queue）、交换机（Exchange）和绑定（Binding）。生产者负责发送消息到交换机，交换机根据绑定规则将消息路由到对应的队列，消费者从队列中获取消息进行处理。 流程图：

代码示例：

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;
import java.io.IOException;
import java.util.concurrent.TimeoutException;

// 生产者
public class Producer {
    private static final String QUEUE_NAME = "hello";

    public static void main(String[] args) throws IOException, TimeoutException {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            channel.queueDeclare(QUEUE_NAME, false, false, false, null);
            String message = "Hello, World!";
            channel.basicPublish("", QUEUE_NAME, null, message.getBytes("UTF-8"));
            System.out.println(" [x] Sent '" + message + "'");
        }
    }
}

// 消费者
public class Consumer {
    private static final String QUEUE_NAME = "hello";

    public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        System.out.println(" [*] Waiting for messages. To exit press CTRL+C");

        com.rabbitmq.client.Consumer consumer = new com.rabbitmq.client.DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, com.rabbitmq.client.Envelope envelope,
                                       com.rabbitmq.client.AMQP.BasicProperties properties, byte[] body)
                    throws IOException {
                String message = new String(body, "UTF-8");
                System.out.println(" [x] Received '" + message + "'");
            }
        };
        channel.basicConsume(QUEUE_NAME, true, consumer);
    }
}

为什么使用 MQ 而不用线程池

技术考查点：对消息队列和线程池适用场景的理解。 回答：消息队列（MQ）和线程池都可以用于实现异步处理，但它们的适用场景不同。消息队列适用于系统之间的解耦、异步通信和流量削峰，它可以将任务异步处理，并且可以保证任务的顺序性和可靠性。而线程池适用于处理大量的短时间任务，它可以提高系统的并发性能。因此，当需要实现系统之间的解耦和异步通信时，应该使用消息队列；当需要提高系统的并发性能时，应该使用线程池。 流程图：无 代码示例：无

为什么使用 redis，redis 的多路复用是什么

技术考查点：对 Redis 特点和多路复用机制的理解。 回答：使用 Redis 可以提高系统的性能和并发能力，因为 Redis 是一个内存数据库，读写速度非常快。Redis 还支持多种数据结构，如字符串、哈希表、列表、集合和有序集合等，可以满足不同的业务需求。Redis 的多路复用是指在一个线程中处理多个 I/O 事件，通过使用 select、poll、epoll 等系统调用，Redis 可以同时监听多个套接字的读写事件，从而提高系统的并发性能。 流程图：无 代码示例：无

canal 的机制，如何使用

技术考查点：对 Canal 原理和使用方法的掌握。 回答：Canal 是一个开源的 MySQL 数据库增量日志订阅和消费组件，它可以模拟 MySQL 主从复制的过程，从 MySQL 的二进制日志（binlog）中获取增量数据，并将其发送到下游系统进行处理。Canal 的使用步骤包括：配置 MySQL 开启 binlog 功能，启动 Canal 服务器，创建 Canal 客户端并连接到 Canal 服务器，订阅指定的 MySQL 数据库和表，处理 Canal 客户端接收到的增量数据。 流程图：

代码示例：

import com.alibaba.otter.canal.client.CanalConnector;
import com.alibaba.otter.canal.client.CanalConnectors;
import com.alibaba.otter.canal.protocol.CanalEntry;
import com.alibaba.otter.canal.protocol.Message;
import java.net.InetSocketAddress;
import java.util.List;

public class CanalExample {
    public static void main(String[] args) {
        // 创建连接
        CanalConnector connector = CanalConnectors.newSingleConnector(new InetSocketAddress("127.0.0.1", 11111), "example", "canal", "canal");
        try {
            // 连接到 Canal 服务器
            connector.connect();
            // 订阅指定的数据库和表
            connector.subscribe("test.*");
            // 回滚到未进行 ack 的地方，下次 fetch 时，可以从最后一个没有 ack 的地方开始拿
            connector.rollback();
            while (true) {
                // 获取指定数量的消息
                Message message = connector.get(100);
                List<CanalEntry.Entry> entries = message.getEntries();
                if (entries != null && !entries.isEmpty()) {
                    for (CanalEntry.Entry entry : entries) {
                        if (entry.getEntryType() == CanalEntry.EntryType.ROWDATA) {
                            // 处理增量数据
                            System.out.println("Received data: " + entry.toString());
                        }
                    }
                }
                // 提交确认
                connector.ack(message.getId());
            }
        } finally {
            // 关闭连接
            connector.disconnect();
        }
    }
}

布隆过滤器如何进行分布式部署？

技术考查点：对布隆过滤器原理和分布式系统的理解，以及如何将布隆过滤器应用于分布式环境。 回答：布隆过滤器是一种空间效率极高的概率型数据结构，用于判断一个元素是否存在于一个集合中。在分布式系统中部署布隆过滤器可以采用以下几种常见的方法：

1. Redis 集群：可以将布隆过滤器存储在 Redis 集群中，利用 Redis 的分布式特性来实现布隆过滤器的分布式部署。不同的节点可以负责不同的布隆过滤器实例，客户端可以根据需要选择合适的节点进行操作。
2. 分布式文件系统：将布隆过滤器的数据存储在分布式文件系统（如 HDFS）中，多个节点可以同时访问和更新布隆过滤器。这种方法适用于对布隆过滤器数据的持久化存储和共享。
3. 自定义分布式协议：可以设计自定义的分布式协议，通过网络通信在多个节点之间同步布隆过滤器的状态。这种方法需要自己实现分布式一致性和容错机制。 流程图：

代码示例：

import redis.clients.jedis.Jedis;
import orestes.bloomfilter.FilterBuilder;
import orestes.bloomfilter.redis.BloomFilterRedis;

public class DistributedBloomFilterExample {
    public static void main(String[] args) {
        // 连接 Redis
        Jedis jedis = new Jedis("localhost", 6379);

        // 创建布隆过滤器
        BloomFilterRedis<String> bloomFilter = new FilterBuilder(10000, 0.01)
               .name("distributedBloomFilter")
               .redisBacked(true)
               .redisHost("localhost")
               .redisPort(6379)
               .buildForStrings();

        // 添加元素
        bloomFilter.add("element1");

        // 检查元素是否存在
        boolean exists = bloomFilter.contains("element1");
        System.out.println("Element exists: " + exists);

        // 关闭连接
        jedis.close();
    }
}