华为OD面试，技术一面问什么？常用设计模式，自定义的bean，多线程处理共享变量等问题

华为 OD 面试流程

1. 机试：三道算法题，关于机试，橡皮擦已经准备好了各语言专栏，可以直接订阅。
2. 性格测试：机试
3. 技术一面
4. 技术二面
5. 主管面试
6. 定级定薪发 offer
7. 体检入职

本专栏的所有博客，将为大家整理技术一面二面中【面试官问到的真题】，并提供大家答案。

⭐️ 华为 OD 机考 Python https://blog.csdn.net/hihell/category_12199275.html
⭐️ 华为 OD 机考 C++ https://blog.csdn.net/hihell/category_12199283.html
⭐️ 华为 OD 机考 JS https://blog.csdn.net/hihell/category_12201825.html
⭐️ 华为 OD 机考 JAVA https://blog.csdn.net/hihell/category_12201821.html
⭐️ 华为 OD 机考真 C 语言 https://blog.csdn.net/hihell/category_12225286.html
⭐️ 华为 OD 机考 Golang https://blog.csdn.net/hihell/category_12231589.html

所有问题都来自通过华为 OD 机考通过人员反馈信息。
每篇博客会涉及 7 个面试题，题目和答案仅供参考~

一、常用设计模式

• 单例模式 ️
• 工厂模式
• 抽象工厂模式
• 建造者模式 ️
• 原型模式
• 适配器模式
• 桥接模式
• 组合模式
• 装饰器模式
• 外观模式
• 享元模式
• 代理模式 ️
• 观察者模式
• 模板方法模式
• 策略模式
• 命令模式
• 职责链模式
• 状态模式
• 访问者模式
• 中介者模式
• 解释器模式

二、springmvc 的流程

• 客户端发送请求
• DispatcherServlet 接收请求
• HandlerMapping 根据请求 URL 查找对应的处理器（Handler） ️
• HandlerAdapter 调用 Handler 进行处理
• Handler 处理请求并返回 ModelAndView 对象
• ModelAndView 包含视图名称和模型数据，传递给 DispatcherServlet 处理 ‍
• ViewResolver 根据视图名称解析出视图对象（View）
• View 渲染模型数据，生成响应内容并返回给 DispatcherServlet 处理
• DispatcherServlet 将响应内容返回给客户端

三、自定义的 bean 怎么交给 spring 管理

• 在自定义 Bean 类上添加 @Component 或其他注解，以声明该类是一个 Bean
• 在 Spring 的配置文件中声明组件扫描，以使 Spring 能够自动扫描到该 Bean 的注解
• 或者，在 Spring 的配置文件中手动声明该 Bean，以使 Spring 能够将该 Bean 加载到容器中

@Component // 添加注解声明该类是一个 Bean
public class MyBean {
  // 类实现
}

<context:component-scan base-package="com.example" />


<bean id="myBean" class="com.example.MyBean" />

四、bean 的加载过程

1. Spring 启动时读取配置文件
2. Spring 实例化 BeanFactory，准备加载 Bean
3. Spring 根据配置文件中的定义，实例化 Bean（实例化 Bean 并不代表 Bean 已经就绪）
4. Spring 对 Bean 进行依赖注入（DI）：将 Bean 所依赖的其他 Bean 注入到该 Bean 中
5. Spring 调用 Bean 的初始化方法（如果有定义的话）
6. Bean 可以被应用程序使用了 ‍♀️
7. 当应用程序关闭时，Spring 调用 Bean 的销毁方法（如果有定义的话）

<bean id="myBean" class="com.example.MyBean" init-method="init" destroy-method="destroy">
  
bean>

五、spring 容器加载哪些 bean，加载哪些配置文件

1. Spring 容器加载哪些 Bean 取决于配置文件中定义的 Bean 和注解声明的 Bean
2. 加载哪些配置文件也取决于配置文件中定义的 Bean 和注解声明的 Bean，因为这些 Bean 可能需要依赖其他 Bean，而这些依赖关系通常在配置文件中声明
3. Spring 容器默认会加载名为 applicationContext.xml 的配置文件，但也可以通过在 web.xml 文件中配置 ContextLoaderListener 和 ContextLoaderServlet 来加载其他配置文件

<bean id="myBean" class="com.example.MyBean">
  
bean>

@Component // 添加注解声明该类是一个 Bean，这个 Bean 将被 Spring 加载到容器中
public class MyBean {
  // 类实现
}

<context-param>
  <param-name>contextConfigLocationparam-name>
  <param-value>/WEB-INF/spring/applicationContext.xmlparam-value>
context-param>

<listener>
  <listener-class>org.springframework.web.context.ContextLoaderListenerlistener-class>
listener>

<servlet>
  <servlet-name>MyServletservlet-name>
  <servlet-class>com.example.MyServletservlet-class>
  <init-param>
    <param-name>contextConfigLocationparam-name>
    <param-value>/WEB-INF/spring/myServlet-context.xmlparam-value>
  init-param>
servlet>

六、非 spring 管理的 bean 怎么使用 spring 管理的 bean

1. 将非 Spring 管理的 Bean 实例化
2. 将非 Spring 管理的 Bean 注入到 Spring 管理的 Bean 中
3. 使用 Spring 管理的 Bean 来操作非 Spring 管理的 Bean，或者让非 Spring 管理的 Bean 来操作 Spring 管理的 Bean

public class NonSpringBean {
  // 类实现
}

@Component
public class MySpringBean {
  private NonSpringBean nonSpringBean;

  @Autowired
  public MySpringBean(NonSpringBean nonSpringBean) {
    this.nonSpringBean = nonSpringBean;
  }

  public void doSomething() {
    // 使用非 Spring 管理的 Bean
    nonSpringBean.doSomethingElse();

    // 让非 Spring 管理的 Bean 来操作 Spring 管理的 Bean
    nonSpringBean.setSomeProperty(this.someProperty);
  }
}

@Configuration
public class AppConfig {
  @Bean
  public NonSpringBean nonSpringBean() {
    return new NonSpringBean();
  }
}

七、多线程处理共享变量的几种方式

1. 加锁（synchronized）：通过加锁来保证同时只有一个线程访问共享变量，避免并发问题 ️
2. 使用 volatile 关键字：使用 volatile 关键字修饰共享变量，强制所有线程从主内存中读取该变量，避免线程间的变量不一致问题
3. 使用 Atomic 类型：使用 Atomic 类型（如 AtomicInteger、AtomicBoolean 等）来保证共享变量的原子性，避免并发问题 ⚛️
4. 使用 synchronized 容器：使用 synchronized 容器（如 Collections.synchronizedList、Collections.synchronizedMap 等）来保证对容器中元素的操作是线程安全的
5. 使用并发容器：使用并发容器（如 ConcurrentHashMap、CopyOnWriteArrayList 等）来保证对容器中元素的操作是线程安全的，避免并发问题

public class MyRunnable implements Runnable {
  // 共享变量
  private volatile int count = 0;
  private AtomicInteger atomicCount = new AtomicInteger(0);

  // synchronized 方式
  public synchronized void incrementCount() {
    count++;
  }

  // Atomic 方式
  public void incrementAtomicCount() {
    atomicCount.incrementAndGet();
  }

  @Override
  public void run() {
    // 加锁方式
    synchronized (this) {
      incrementCount();
    }

    // 使用 volatile 关键字
    incrementCount();

    // 使用 Atomic 类型
    incrementAtomicCount();
  }
}

// 使用 synchronized 容器
List<Integer> synchronizedList = Collections.synchronizedList(new ArrayList<>());
Map<String, Integer> synchronizedMap = Collections.synchronizedMap(new HashMap<>());

// 使用并发容器
ConcurrentMap<String, Integer> concurrentMap = new ConcurrentHashMap<>();
CopyOnWriteArrayList<Integer> copyOnWriteArrayList = new CopyOnWriteArrayList<>();