发表于 | 更新于 | 分类于
字数统计 | 阅读时长

👌Aop中的相关术语

口语化答案

哈哈，这个就不多说了，面试官问到什么概念，你就直接解释一下就可以了。

题目详细答案

切面（Aspect）

切面是 AOP 的核心概念之一，它是一个模块，包含了横切关注点的逻辑。切面可以看作是对某些功能（如日志记录、事务管理）的封装，这些功能会在特定的连接点上应用。

连接点（Join Point）

连接点是程序执行过程中可以插入切面的一个点。通常，连接点是方法的调用或执行。AOP 框架允许在这些连接点上插入额外的行为。

通知（Advice）

通知是在切面的某个特定的连接点上执行的动作。通知定义了切面在连接点上的具体行为。根据执行时间的不同，通知可以分为以下几种类型：

  • 前置通知（Before）：在目标方法执行之前执行。
  • 后置通知（After）：在目标方法执行之后执行（无论方法是否成功完成）。
  • 返回通知（After Returning）：在目标方法成功返回之后执行。
  • 异常通知（After Throwing）：在目标方法抛出异常时执行。
  • 环绕通知（Around）：包围目标方法的执行，可以在方法执行之前和之后自定义行为。

切入点（Pointcut）

切入点是一个表达式，定义了哪些连接点会被切面所影响。切入点表达式用于匹配连接点，从而决定切面应该应用到哪些方法上。常见的切入点表达式语言包括 AspectJ 的表达式语言。

目标对象（Target Object）

目标对象是被一个或多个切面所通知的对象。目标对象是 AOP 代理的实际对象，即被代理的对象。

AOP 代理（AOP Proxy）

AOP 代理是一个对象，用于实现切面契约（即通知方法）并将调用委托给目标对象。代理对象负责在调用目标方法之前或之后执行切面逻辑。AOP 代理可以是 JDK 动态代理（用于代理接口）或 CGLIB 代理（用于代理类）。

织入（Weaving）

织入是将切面应用到目标对象并创建 AOP 代理对象的过程。织入可以在以下几个时机进行：

  • 编译时（Compile-time Weaving）：在编译阶段将切面织入到目标类中。
  • 类加载时（Load-time Weaving）：在类加载阶段使用类加载器将切面织入到目标类中。
  • 运行时（Runtime Weaving）：在运行时通过动态代理将切面织入到目标对象中。

引入（Introduction）

引入是 AOP 提供的一种机制，允许在不修改现有类的情况下向其添加新的方法或属性。引入可以用于增强现有类的功能。

发表于 | 更新于 | 分类于
字数统计 | 阅读时长

👌ApplicationContext的实现类有哪些？

口语化答案

好的，面试官。常用的只要用 classpathxml 的基于 xml 的方式，annotion 的基于注解的方式，不常见的还有 web 和 groovy。在目前的实际情况下，主要是 annotion，注解形式放入到容器中。像老的 tomcat 那种方式，用的是 web 形式，不过现在都是 boot 注解形式够用。groovy 适用于一些动态加载 bean 的方式，通过脚本的形式处理。以上。

题目解析

经典题，问的还比较多，主要是想借此考察一下，你在项目中，都用过什么样的形式的。其实主要答出注解和 xml 这道题就 ok。

面试得分点

xml，注解，web，groovy

题目详细答案

基于XML配置的实现类

ClassPathXmlApplicationContext：从类路径下加载XML配置文件。

1
ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

FileSystemXmlApplicationContext：从文件系统路径加载XML配置文件。

1
ApplicationContext context = new FileSystemXmlApplicationContext("C:/path/to/applicationContext.xml");

基于注解配置的实现类

AnnotationConfigApplicationContext：从Java配置类（使用@Configuration注解的类）加载配置。

1
2
3
4
5
6
7
8
9
@Configuration
public class AppConfig {
    @Bean
    public MyBean myBean() {
        return new MyBean();
    }
}

ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);

基于Web应用的实现类

XmlWebApplicationContext：专门为Web应用设计的ApplicationContext实现类，从Web应用的上下文中加载XML配置文件。

通常在web.xml中配置：

1
2
3
4
5
6
7
<context-param>
    <param-name>contextConfigLocation</param-name>
    <param-value>/WEB-INF/applicationContext.xml</param-value>
</context-param>
<listener>
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>

AnnotationConfigWebApplicationContext：专门为Web应用设计的ApplicationContext实现类，从Java配置类加载配置

1
2
3
4
5
6
7
8
public class WebAppInitializer implements WebApplicationInitializer {
    @Override
    public void onStartup(ServletContext container) {
        AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
        context.register(AppConfig.class);
        container.addListener(new ContextLoaderListener(context));
    }
}

基于Groovy配置的实现类

GenericGroovyApplicationContext：从Groovy脚本配置文件加载配置。

1
ApplicationContext context = new GenericGroovyApplicationContext("applicationContext.groovy");

发表于 | 更新于 | 分类于
字数统计 | 阅读时长

👌BeanFactory 和 ApplicationContext 的区别？

口语化答案

好的，面试官。BeanFactory和ApplicationContext都是用于管理Bean的容器接口。BeanFactory功能相对简单。提供了Bean的创建、获取和管理功能。默认采用延迟初始化，只有在第一次访问Bean时才会创建该Bean。因为功能较为基础，BeanFactory通常用于资源受限的环境中，比如移动设备或嵌入式设备。ApplicationContext是BeanFactory的子接口，提供了更丰富的功能和更多的企业级特性。默认会在启动时创建并初始化所有单例Bean，支持自动装配Bean，可以根据配置自动注入依赖对象。有多种实现，如ClassPathXmlApplicationContext、FileSystemXmlApplicationContext、AnnotationConfigApplicationContext等。以上

题目解析

经典题，早几年爱考，现在随着时间的发展，问的比较少，不排除古老面试官，应届生可以重点看一下。

面试得分点

初始化时机，延迟，企业级应用场景

题目详细答案

BeanFactory和ApplicationContext都是用于管理Bean的容器接口，它们的功能和用途有所不同。

BeanFactory

BeanFactory是Spring框架的核心接口之一，负责管理和配置应用程序中的Bean。它提供了基本的Bean容器功能，但功能相对简单。BeanFactory提供了Bean的创建、获取和管理功能。它是Spring IoC容器的最基本接口。

BeanFactory默认采用延迟初始化（lazy loading），即只有在第一次访问Bean时才会创建该Bean。这有助于提升启动性能。

因为功能较为基础，BeanFactory通常用于资源受限的环境中，比如移动设备或嵌入式设备。

ApplicationContext

ApplicationContext是BeanFactory的子接口，提供了更丰富的功能和更多的企业级特性。

不仅提供了BeanFactory的所有功能，还提供了更多高级特性，如事件发布、国际化、AOP、自动Bean装配等。

ApplicationContext默认会在启动时创建并初始化所有单例Bean（除非显式配置为延迟初始化）。这有助于在应用启动时尽早发现配置问题。

ApplicationContext支持自动装配Bean，可以根据配置自动注入依赖对象。

ApplicationContext有多种实现，如ClassPathXmlApplicationContext、FileSystemXmlApplicationContext、AnnotationConfigApplicationContext等，适用于不同的配置方式和场景。

具体区别总结

BeanFactory ApplicationContext
初始化时机 延迟初始化，只有在第一次访问Bean时才创建该Bean。 立即初始化，在容器启动时就创建并初始化所有单例Bean。
特性 功能较为基础，只提供Bean的创建、获取和管理功能。 提供更多企业级特性，如事件发布、国际化、AOP、自动装配等。
使用场景 适用于资源受限的环境，或者需要延迟初始化的场景。 适用于大多数企业级应用

代码 Demo

使用 BeanFactory

1
2
3
Resource resource = new ClassPathResource("beans.xml");
BeanFactory beanFactory = new XmlBeanFactory(resource);
MyBean myBean = (MyBean) beanFactory.getBean("myBean");

使用 ApplicationContext

1
2
ApplicationContext context = new ClassPathXmlApplicationContext("beans.xml");
MyBean myBean = (MyBean) context.getBean("myBean");

发表于 | 更新于 | 分类于
字数统计 | 阅读时长

👌Bean 标签的属性?

口语化回答

好的，面试官。bean 是最长使用的标签，如果是使用 xml 形式。最常见的基本属性就是 id，name，class。分别标识唯一的 bean，bean 的别名和实际要注入的类。也可以通过一些属性实现，bean 开始时候的操作，比如init-method，配置的方法，可以在 bean 初始化的时候，进行执行。bean 还有常见的构造函数注入标签，注入 bean 中的属性。以上。

题目解析

应届生常问，有工作经验的基本不问，目的其实就是为了，考察一下你到底有没有实际使用过 spring 的 bean 的配置。

面试得分点

id，name，class，一些初始化属性

题目详细答案

常见属性

id：Bean的唯一标识符。

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

name：Bean的别名，可以为Bean定义一个或多个别名。

1
<bean id="myBean" name="alias1,alias2" class="com.example.MyBean"/>

class：Bean的全限定类名。

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

scope：Bean的作用域，常见值包括singleton（默认）、prototype、request、session、globalSession、application。

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

init-method：Bean初始化时调用的方法。

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

destroy-method：Bean销毁时调用的方法。

1
<bean id="myBean" class="com.example.MyBean" destroy-method="cleanup"/>

factory-method：用于创建Bean实例的静态工厂方法。

1
<bean id="myBean" class="com.example.MyBeanFactory" factory-method="createInstance"/>

factory-bean：用于创建Bean实例的工厂Bean的名称。

1
2
<bean id="myFactory" class="com.example.MyFactory"/>
<bean id="myBean" factory-bean="myFactory" factory-method="createInstance"/>

依赖注入相关属性

constructor-arg：用于构造函数注入。

1
2
3
4
<bean id="myBean" class="com.example.MyBean">
    <constructor-arg value="someValue"/>
    <constructor-arg ref="anotherBean"/>
</bean>

property：用于Setter方法注入。

1
2
3
4
<bean id="myBean" class="com.example.MyBean">
    <property name="propertyName" value="someValue"/>
    <property name="anotherProperty" ref="anotherBean"/>
</bean>

其他常用属性

autowire：自动装配模式，常见值包括no（默认）、byName、byType、constructor、autodetect。

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

depends-on：指定Bean的依赖关系，即在初始化当前Bean之前需要先初始化的Bean。

1
<bean id="myBean" class="com.example.MyBean" depends-on="anotherBean"/>

lazy-init：是否延迟初始化，默认值为false。

1
<bean id="myBean" class="com.example.MyBean" lazy-init="true"/>

primary：当自动装配时，如果有多个候选Bean，可以将某个Bean标记为主要候选者。

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

配置 demo

1
2
3
4
5
6
<bean id="myBean" class="com.example.MyBean" scope="singleton" init-method="init" destroy-method="cleanup" lazy-init="true" primary="true" autowire="byType">
    <constructor-arg value="someValue"/>
    <constructor-arg ref="anotherBean"/>
    <property name="propertyName" value="someValue"/>
    <property name="anotherProperty" ref="anotherBean"/>
</bean>

发表于 | 更新于 | 分类于
字数统计 | 阅读时长

👌Cglib的Enhancer实现动态代理？

口语化回答

好的，面试官，cglib 代理相比 jdk 动态代理不同的就是不需要被代理的类实现接口。假设我们现在有一个MyService，其中有一个方法是performTask，我们只需要定义一个新的类，实现MethodInterceptor 接口，然后再里面的 intercept 方法实现需要增强的方法。最终通过 cglib 的enhancer 类，先设置父类，父类就是我们要增强的类，再设置 callback 也就是我们要增强的功能。最后使用 create 就生成了 cglib 的一个代理类。以上

题目解析

和 jdk 的动态代理异曲同工，相比 jdk 反而 cglib 的更常考一点。大家理解一下下面的代码流程就很容易说出其中的过程。

面试得分点

目标类，方法拦截器，创建代理对象

题目详细答案

CGLIB是一种强大的代码生成库，能够在运行时生成代理类。与 JDK 动态代理不同的是，CGLIB 不需要接口，可以直接代理具体类。CGLIB 通过创建目标类的子类并覆盖其中的方法来实现代理。

实现步骤

1、 引入 CGLIB 库：确保在项目中添加 CGLIB 依赖。

2、 创建目标类：定义需要代理的具体类。

3、 创建方法拦截器：实现MethodInterceptor接口，并在intercept方法中定义代理逻辑。

4、 创建代理对象：通过Enhancer类创建代理对象。

代码 Demo

假设我们有一个简单的服务类MyService，通过 CGLIB 动态代理为MyService创建一个代理对象，并在方法调用前后添加日志。

引入 CGLIB 依赖

1
2
3
4
5
<dependency>
    <groupId>cglib</groupId>
    <artifactId>cglib</artifactId>
    <version>3.3.0</version>
</dependency>

创建目标类

1
2
3
4
5
public class MyService {
    public void performTask() {
        System.out.println("Performing task");
    }
}

创建方法拦截器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import net.sf.cglib.proxy.MethodInterceptor;
import net.sf.cglib.proxy.MethodProxy;

import java.lang.reflect.Method;

public class LoggingMethodInterceptor implements MethodInterceptor {
    @Override
    public Object intercept(Object obj, Method method, Object[] args, MethodProxy proxy) throws Throwable {
        System.out.println("Logging before method execution: " + method.getName());
        Object result = proxy.invokeSuper(obj, args);
        System.out.println("Logging after method execution: " + method.getName());
        return result;
    }
}

创建代理对象并使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import net.sf.cglib.proxy.Enhancer;

public class MainApp {
    public static void main(String[] args) {
        // 创建 Enhancer 对象
        Enhancer enhancer = new Enhancer();
        
        // 设置目标类为代理类的父类
        enhancer.setSuperclass(MyService.class);
        
        // 设置方法拦截器
        enhancer.setCallback(new LoggingMethodInterceptor());

        // 创建代理对象
        MyService proxyInstance = (MyService) enhancer.create();
        
        // 调用代理对象的方法
        proxyInstance.performTask();
    }
}

详细解释

引入 CGLIB 库：在项目中添加 CGLIB 依赖，以便使用 CGLIB 提供的类和接口。

目标类：MyService是一个具体类，定义了一个方法performTask。

方法拦截器：LoggingMethodInterceptor实现了MethodInterceptor接口。它的intercept方法在代理对象的方法调用时被调用。

intercept方法接收四个参数：obj：代理对象。method：被调用的方法。args：方法参数。proxy：用于调用父类方法的代理对象。

在intercept方法中，我们在方法调用前后添加了日志打印，并通过proxy.invokeSuper调用父类的方法。

创建代理对象：使用Enhancer类创建代理对象。setSuperclass方法设置目标类为代理类的父类。setCallback方法设置方法拦截器。create方法创建代理对象。

使用代理对象：

通过代理对象调用方法时，实际调用的是LoggingMethodInterceptor的intercept方法。

在intercept方法中，首先打印日志，然后通过proxy.invokeSuper调用目标对象的方法，最后再打印日志。

发表于 | 更新于 | 分类于
字数统计 | 阅读时长

👌Spring事务失效场景？

题目详细答案

Spring事务失效的场景主要有以下几种。

非public方法使用@Transactional

场景描述：Spring事务管理是基于AOP实现的，而AOP对于JDK动态代理或CGLib动态代理只会代理public方法。如果事务方法的访问修饰符为非public，SpringAOP无法正确地代理该方法，从而导致事务失效。

示例代码：事务方法的访问修饰符被设置为private、default或protected。

解决方案：将需要事务管理的方法设置为public。

在同类中的非事务方法调用事务方法

场景描述：Spring的事务管理是通过动态代理实现的，只有通过代理对象调用的方法才能享受到Spring的事务管理。如果在同一个类中，一个没有标记为@Transactional的方法内部调用了一个标记为@Transactional的方法，那么事务是不会起作用的。

解决方案：尽量将事务方法放在不同的类中，或者使用Spring的AopContext.currentProxy()来获取当前类的代理对象，然后通过代理对象调用事务方法。

事务属性设置不当

场景描述：在Spring的事务管理中，如果在一个支持当前事务的方法（比如，已经被标记为@Transactional的方法）中调用了一个需要新事务的方法，如果后者方法抛出了异常，但异常并未被Spring识别为需要回滚事务的异常，那么后者的事务将不会回滚。

异常类型不匹配

场景描述：默认情况下，Spring只有在方法抛出运行时异常或者错误时才会回滚事务。对于检查性异常，即使你在方法中抛出了，Spring也不会回滚事务，除非你在@Transactional注解中显式地指定需要回滚哪些检查性异常。

解决方案：了解Spring事务管理对异常的处理，必要时在@Transactional注解中指定需要回滚的异常类型。

事务拦截器配置错误

场景描述：如果没有正确地配置事务拦截器，例如没有指定切入点或指定了错误的切入点，就会导致Spring事务失效。

事务超时配置错误

场景描述：如果事务超时时间设置得太短，就有可能在事务执行过程中出现超时，从而导致Spring事务失效。

发表于 | 更新于 | 分类于
字数统计 | 阅读时长

👌Spring使用注解的进行装配的时候，需要什么注解

口语化答案

好的，面试官，其实这个问题的目的就是将 bean 让 spring 扫描到，并识别出要放到容器中。那就涉及到第一个概念，ComponentScan，自动扫描指定的包，配合basePackages 属性。指定包之后能，spring 就会将@Service、@Repository和@Controller 这些带了注解的类，作为 bean 放入到容器中。ComponentScan 也提供了一些比如 excludefilter 想排除某些包，或者加特定包的方式。以上。

题目解析

基础题必看，主要稍微会发散的一个点就是 lazyinit，其他的没有什么东西。正常背一下属性就可以了。

面试得分点

basepackage，includefilter，扫描注解

题目详细答案

@ComponentScan是用于自动扫描指定的包及其子包中的组件类，并将它们注册为 Spring 容器管理的 Bean。这个过程被称为组件扫描（Component Scanning）。

@ComponentScan注解

@ComponentScan注解通常与@Configuration注解一起使用，用于定义 Spring 应用的配置类。在这个配置类中，@ComponentScan指定了要扫描的包路径，Spring 会自动扫描这些包及其子包中的所有类，并将带有特定注解的类（如@Component、@Service、@Repository、@Controller等）注册为 Bean。

1
2
3
4
5
@Configuration
@ComponentScan(basePackages = "com.example")
public class AppConfig {
    // 配置类内容
}

Spring 会扫描com.example包及其子包中的所有类，并将带有@Component、@Service、@Repository和@Controller注解的类注册为 Spring Bean。

详细说明

basePackages属性

basePackages属性用于指定要扫描的包。可以指定一个或多个包路径。

1
@ComponentScan(basePackages = {"com.example", "com.another"})

basePackageClasses属性

basePackageClasses属性用于指定一个或多个类，Spring 会扫描这些类所在的包。

1
@ComponentScan(basePackageClasses = {MyClass1.class, MyClass2.class})

includeFilters和excludeFilters属性

includeFilters和excludeFilters属性用于指定包含或排除的过滤器。可以根据注解、类型、正则表达式等进行过滤。

1
2
3
4
5
@ComponentScan(
    basePackages = "com.example",
    includeFilters = @ComponentScan.Filter(type = FilterType.ANNOTATION, classes = CustomAnnotation.class),
    excludeFilters = @ComponentScan.Filter(type = FilterType.REGEX, pattern = "com\\.example\\.exclude\\..*")
)

lazyInit属性

lazyInit属性用于指定是否延迟初始化扫描到的 Bean。默认值为false，表示立即初始化。

1
@ComponentScan(basePackages = "com.example", lazyInit = true)

示例

假设我们有以下包结构：

1
2
3
4
5
6
7
com.example
    ├── service
    │   └── MyService.java
    ├── repository
    │   └── MyRepository.java
    └── controller
        └── MyController.java

其中，MyService.java、MyRepository.java和MyController.java分别带有@Service、@Repository和@Controller注解。

定义配置类

1
2
3
4
5
@Configuration
@ComponentScan(basePackages = "com.example")
public class AppConfig {
    // 配置类内容
}

启动 Spring 容器

1
2
3
4
5
6
7
8
9
10
11
12
public class Application {
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        
        MyService myService = context.getBean(MyService.class);
        MyRepository myRepository = context.getBean(MyRepository.class);
        MyController myController = context.getBean(MyController.class);
        
        // 使用 Bean
        context.close();
    }
}

Spring 会扫描com.example包及其子包中的所有类，并将带有@Service、@Repository和@Controller注解的类注册为 Spring Bean。

发表于 | 更新于 | 分类于
字数统计 | 阅读时长

👌Spring 的依赖注入是什么？

口语化答案

好的，面试官，依赖注入（Dependency Injection，简称DI）是Spring框架实现控制反转（IoC）的主要手段。DI的核心思想是将对象的依赖关系从对象内部抽离出来，通过外部注入的方式提供给对象。这样，依赖对象的创建和管理由Spring容器负责，而不是由对象自身负责，使得代码更加模块化、松耦合和易于测试。以上。

题目解析

重点题，三大概念之一。di，ioc，aop 之一，大家一定要整明白。

面试得分点

构造函数，setter，注解

详细答案

在传统编程中，一个对象通常会自己创建它所依赖的其他对象。这种方式使得代码紧密耦合，不利于维护和测试。依赖注入通过将依赖关系从代码中移除，转而由外部容器（如Spring容器）来注入，从而实现了对象之间的松耦合。

依赖注入的类型

Spring框架主要提供了三种依赖注入的方式：

构造函数注入：通过构造函数将依赖对象传递给被依赖对象。

1
2
3
4
5
6
7
public class Service {
    private final Repository repository;

    public Service(Repository repository) {
        this.repository = repository;
    }
}

Setter方法注入：通过Setter方法将依赖对象注入到被依赖对象中。

1
2
3
4
5
6
7
public class Service {
    private Repository repository;

    public void setRepository(Repository repository) {
        this.repository = repository;
    }
}

字段注入：直接在字段上使用注解进行注入。

1
2
3
4
public class Service {
    @Autowired
    private Repository repository;
}

依赖注入的配置方式

XML配置：通过XML文件定义Bean及其依赖关系。

1
2
3
4
5
6
<beans>
    <bean id="repository" class="com.example.Repository"/>
    <bean id="service" class="com.example.Service">
        <constructor-arg ref="repository"/>
    </bean>
</beans>

Java配置：通过Java类和注解定义Bean及其依赖关系。

1
2
3
4
5
6
7
8
9
10
11
12
@Configuration
public class AppConfig {
    @Bean
    public Repository repository() {
        return new Repository();
    }

    @Bean
    public Service service() {
        return new Service(repository());
    }
}

注解配置：通过注解（如@Component,@Autowired）自动扫描和注入Bean。

1
2
3
4
5
6
7
8
9
@Component
public class Repository {
}

@Component
public class Service {
    @Autowired
    private Repository repository;
}

发表于 | 更新于 | 分类于
字数统计 | 阅读时长

👌Spring 的属性注入方式有哪几种？

口语化答案

好的，面试官，属性注入的方式主要有几种，比如构造器注入，setter 注入，字段注入，value 注入等等。最常见的我们平时用的最多的就是，就是@Resource ，@Autowired 这种，像构造器和 setter 这种，经常在第三方依赖包的一些情况下，会进行使用，比如对接一些阿里云 oss，就体现的很明显。像@Value. 这种就常常用于读取配置文件的属性值，来使用。以上。

题目解析

常考题。也是年限低一点的小伙伴会问到，考察一下你对不同注入的情况，有没有一定的选择，以及了解当想注入一个属性的时候，都可以有什么方式的思路。

面试得分点

构造器，setter，@value。@resource @autowired。

题目详细答案

属性注入（Dependency Injection, DI）是将依赖对象注入到目标对象中的过程。Spring 支持多种属性注入方式，主要包括构造器注入、Setter 方法注入和字段注入。

构造器注入

构造器注入通过类的构造器来注入依赖对象。这种方式在对象创建时就完成了依赖注入，确保了依赖对象的不可变性。

1
2
3
4
5
6
7
public class MyBean {
    private final Dependency dependency;

    public MyBean(Dependency dependency) {
        this.dependency = dependency;
    }
}

XML 配置

1
2
3
4
<bean id="myBean" class="com.example.MyBean">
    <constructor-arg ref="dependency"/>
</bean>
<bean id="dependency" class="com.example.Dependency"/>

注解配置

1
2
3
4
5
6
7
8
9
@Component
public class MyBean {
    private final Dependency dependency;

    @Autowired
    public MyBean(Dependency dependency) {
        this.dependency = dependency;
    }
}

Setter 方法注入

Setter 方法注入通过类的 Setter 方法来注入依赖对象。这种方式允许在对象创建后进行依赖注入，并且可以在运行时更改依赖对象。

1
2
3
4
5
6
7
public class MyBean {
    private Dependency dependency;

    public void setDependency(Dependency dependency) {
        this.dependency = dependency;
    }
}

XML 配置

1
2
3
4
<bean id="myBean" class="com.example.MyBean">
    <property name="dependency" ref="dependency"/>
</bean>
<bean id="dependency" class="com.example.Dependency"/>

注解配置

1
2
3
4
5
6
7
8
9
@Component
public class MyBean {
    private Dependency dependency;

    @Autowired
    public void setDependency(Dependency dependency) {
        this.dependency = dependency;
    }
}

字段注入

字段注入（也称为属性注入）直接通过在类的字段上使用注解来注入依赖对象。这种方式不需要 Setter 方法，但不推荐使用，因为它违反了面向对象设计原则，使得依赖关系不够明确。

1
2
3
4
5
@Component
public class MyBean {
    @Autowired
    private Dependency dependency;
}

通过@Value注解注入基本类型和字符串

除了注入 Bean 对象，Spring 还支持通过@Value注解注入基本类型、字符串和其他值，如从配置文件中读取的值。

1
2
3
4
5
@Component
public class MyBean {
    @Value("${my.property}")
    private String myProperty;
}

通过环境变量或系统属性注入

1
2
3
4
5
@Component
public class MyBean {
    @Value("#{systemProperties['user.name']}")
    private String userName;
}

通过@Resource注解注入

1
2
3
4
5
@Component
public class MyBean {
    @Resource(name = "dependency")
    private Dependency dependency;
}

通过@Inject注解注入

1
2
3
4
5
@Component
public class MyBean {
    @Inject
    private Dependency dependency;
}

发表于 | 更新于 | 分类于
字数统计 | 阅读时长

👌bean 的作用范围和生命周期？

口语化答案

好的，面试官。bean 的作用范围主要用 singleton，prototype，request，session，globalsession，application。常用的就是 singleton，singleton 是单例的，当 bean 是无状态的时候，singleton 是最好的使用方式，如果说 bean 里面涉及共享数据，singleton 就不够安全了，这个时候需要使用 prototype。bean 的生命周期从实例化创建 bean 开始，然后进行属性设置。再之后，调用 bean 的一些初始化方法，如果有则执行，这样处理完之后，bean 就可以被使用了。最终当 bean 要被销毁的时候，就会调用 destroy 方法进行 bean 的后置处理，以上。

题目解析

非常常考，一定要熟悉要 singleton 和 prototype 的区别。这个重点要的是状态问题。bean 的生命周期就比较好答，按照顺序来说就可以了。

面试得分点

singleton，prototype，无状态，实例化，属性设置，初始方法，销毁

题目详细答案

Bean的作用范围（Scope）和生命周期（Lifecycle）决定了Bean的创建、使用和销毁方式。

Bean的作用范围（Scope）

singleton：默认作用范围，整个Spring容器中只有一个实例，所有对该Bean的引用都指向同一个实例。适用于无状态的Bean。

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

prototype：每次请求该Bean时都会创建一个新的实例。适用于有状态的Bean。

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

request：每次HTTP请求都会创建一个新的实例，仅适用于Web应用。

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

session：每个HTTP会话都会创建一个新的实例，仅适用于Web应用。

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

globalSession：每个全局HTTP会话都会创建一个新的实例，仅适用于Portlet应用。

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

application：每个ServletContext会创建一个新的实例，适用于Web应用。

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

Bean的生命周期

1724754790092-94de9a92-f85f-4b0f-851d-62174f065951.png

实例化（Instantiation）

Spring容器根据配置创建Bean实例。

属性设置（Property Population）

Spring容器进行依赖注入，设置Bean的属性。

初始化（Initialization）

如果Bean实现了InitializingBean接口，Spring会调用其afterPropertiesSet()方法。

如果在XML配置中指定了init-method属性，Spring会调用指定的初始化方法。

如果Bean使用了@PostConstruct注解，Spring会调用标注的方法。

使用（Usage）

Bean处于就绪状态，可以被应用程序使用。

销毁（Destruction）

如果Bean实现了DisposableBean接口，Spring会调用其destroy()方法。

如果在XML配置中指定了destroy-method属性，Spring会调用指定的销毁方法。

如果Bean使用了@PreDestroy注解，Spring会调用标注的方法。

生命周期回调接口和注解

InitializingBean接口

方法：afterPropertiesSet()

1
2
3
4
5
6
public class MyBean implements InitializingBean {
    @Override
    public void afterPropertiesSet() throws Exception {
        // 初始化逻辑
    }
}

DisposableBean接口

方法：destroy()

1
2
3
4
5
6
public class MyBean implements DisposableBean {
    @Override
    public void destroy() throws Exception {
        // 销毁逻辑
    }
}

@PostConstruct注解

用于标注初始化方法。

1
2
3
4
5
6
public class MyBean {
    @PostConstruct
    public void init() {
        // 初始化逻辑
    }
}

@PreDestroy注解

用于标注销毁方法。

1
2
3
4
5
6
public class MyBean {
    @PreDestroy
    public void cleanup() {
        // 销毁逻辑
    }
}

代码 Demo

1
<bean id="myBean" class="com.example.MyBean" scope="singleton" init-method="customInit" destroy-method="customDestroy"/>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public class MyBean implements InitializingBean, DisposableBean {
    @Override
    public void afterPropertiesSet() throws Exception {
        // 初始化逻辑
    }

    @Override
    public void destroy() throws Exception {
        // 销毁逻辑
    }

    @PostConstruct
    public void init() {
        // 初始化逻辑
    }

    @PreDestroy
    public void cleanup() {
        // 销毁逻辑
    }

    public void customInit() {
        // 自定义初始化逻辑
    }

    public void customDestroy() {
        // 自定义销毁逻辑
    }
}

发表于 | 更新于 | 分类于
字数统计 | 阅读时长

👌jdk动态代理如何实现

口语化答案

好的，面试官。jdk 的动态代理主要是依赖Proxy 和InvocationHandler 接口。jdk 动态代理要求类必须有接口。在进行实现的时候，首先要定义接口，比如MyService，这个接口就是我们的正常功能的实现。但是希望在不更改MyService 的情况下增加，那么我们需要定义一个实现InvocationHandler 接口的实现类，同时在方法实现上面增加额外的逻辑。最后通过 Proxy 的 newProxyInstance 将二者结合到一起。就实现了动态代理。以上。

题目解析

大家不要觉得动态代理很难理解，按照这个步骤其实你发现很简单。记忆的过程和 cglib 对比着看，就很轻松，面试也是属于常考一点的题目。

面试得分点

InvocationHandler 增强，Proxy 创建代理

题目详细答案

JDK 动态代理主要依赖于java.lang.reflect.Proxy类和java.lang.reflect.InvocationHandler接口来实现。

实现步骤

定义接口：定义需要代理的接口。

实现接口：创建接口的实现类。

创建调用处理器：实现InvocationHandler接口，并在invoke方法中定义代理逻辑。

创建代理对象：通过Proxy.newProxyInstance方法创建代理对象。

代码 Demo

假设我们有一个简单的服务接口MyService和它的实现类MyServiceImpl，我们将通过 JDK 动态代理为MyService创建一个代理对象，并在方法调用前后添加日志。

1. 定义接口

1
2
3
public interface MyService {
    void performTask();
}

2. 实现接口

1
2
3
4
5
6
public class MyServiceImpl implements MyService {
    @Override
    public void performTask() {
        System.out.println("Performing task");
    }
}

3. 创建调用处理器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;

public class LoggingInvocationHandler implements InvocationHandler {
    private final Object target;

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

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.println("Logging before method execution: " + method.getName());
        Object result = method.invoke(target, args);
        System.out.println("Logging after method execution: " + method.getName());
        return result;
    }
}

4. 创建代理对象并使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
import java.lang.reflect.Proxy;

public class MainApp {
    public static void main(String[] args) {
        // 创建目标对象
        MyService myService = new MyServiceImpl();

        // 创建调用处理器
        LoggingInvocationHandler handler = new LoggingInvocationHandler(myService);

        // 创建代理对象
        MyService proxyInstance = (MyService) Proxy.newProxyInstance(
                myService.getClass().getClassLoader(),
                myService.getClass().getInterfaces(),
                handler
        );

        // 调用代理对象的方法
        proxyInstance.performTask();
    }
}

详细解释

1、 接口定义和实现：

MyService是一个简单的接口，定义了一个方法performTask。

MyServiceImpl是MyService的实现类，实现了performTask方法。

2、 调用处理器：

LoggingInvocationHandler实现了InvocationHandler接口。它的invoke方法在代理对象的方法调用时被调用。invoke方法接收三个参数：proxy：代理对象。method：被调用的方法。args：方法参数。在invoke方法中，我们在方法调用前后添加了日志打印。

3、 创建代理对象：

使用Proxy.newProxyInstance方法创建代理对象。

newProxyInstance方法接收三个参数：类加载器：通常使用目标对象的类加载器。接口数组：目标对象实现的所有接口。调用处理器：实现了InvocationHandler接口的实例。

4、 使用代理对象：

通过代理对象调用方法时，实际调用的是LoggingInvocationHandler的invoke方法。

在invoke方法中，首先打印日志，然后通过反射调用目标对象的方法，最后再打印日志。

发表于 | 更新于 | 分类于
字数统计 | 阅读时长

👌什么是aop，aop的作用和优势？

口语化回答

好的，面试官。aop 是 spring 框架的一个核心。常见的可以做日志记录，事务管理等公共性的处理。当我们想要统一做一些水平统一的操作的时候，就常用 aop。aop 的核心概念就是面向切面变成。通过 aop 可以在范围内的类方法执行之前，执行之后，或者异常的时候，做统一的操作。aop 可以提高代码的可维护性，任何修改只需要在切面中进行，而不需要修改业务逻辑代码。基于动态代理机制，还可以在不修改源代码的情况下为现有代码添加功能。在 boot 应用使用中，只需要配合Aspect 注解，即可实现功能，以上。

题目解析

aop 是核心问题，spring 里面的比较好的一个特性，因为实际工作中非常常用，面试官就会问你，是否有用过这一块的东西。

面试得分点

面向切面，模块化，减少重复代码

题目详细答案

AOP（面向切面编程）是一种编程范式，它旨在通过分离横切关注点来提高代码的模块化。AOP 在传统的面向对象编程（OOP）基础上，提供了一种处理系统级关注点（如日志记录、事务管理、安全性等）的机制，而这些关注点通常会散布在多个模块中。

AOP 的基本概念

Aspect（切面）：切面是模块化的横切关注点。它可以包含多个 advice（通知）和 pointcut（切入点）。

Advice（通知）：通知是切面在特定的切入点执行的动作。通知有几种类型：

  • Before：在方法执行之前执行。
  • After：在方法执行之后执行。
  • AfterReturning：在方法成功执行之后执行。
  • AfterThrowing：在方法抛出异常后执行。
  • Around：包围一个方法的执行，能够控制方法的执行前后。

Pointcut（切入点）：切入点定义了通知应该应用到哪些连接点上。连接点是程序执行的特定点，如方法调用或异常抛出。

Join Point（连接点）：程序执行的特定点，例如方法调用或异常抛出。

Weaving（织入）：将切面应用到目标对象创建代理对象的过程。织入可以在编译时、类加载时、运行时进行。

AOP 的作用和优势

模块化横切关注点：AOP 允许将横切关注点（如日志记录、事务管理、安全性等）从业务逻辑中分离出来，从而提高代码的模块化和可维护性。

减少重复代码：通过将通用功能提取到切面中，可以减少代码的重复，提高代码的可读性和可维护性。

提高代码的可维护性：由于横切关注点被模块化为切面，任何修改只需要在切面中进行，而不需要修改业务逻辑代码，从而提高了代码的可维护性。

动态代理：AOP 使用动态代理机制，可以在不修改源代码的情况下为现有代码添加功能。

增强代码的可测试性：由于横切关注点被分离成切面，业务逻辑代码变得更加简洁和专注，从而提高了代码的可测试性。

AOP 的应用场景

日志记录：在方法调用前后记录日志。

事务管理：在方法执行前开启事务，在方法执行后提交事务，在方法抛出异常时回滚事务。

安全性检查：在方法执行前进行权限检查。

性能监控：在方法执行前后记录执行时间。

缓存：在方法调用前检查缓存，在方法调用后更新缓存。

示例代码

定义切面

1
2
3
4
5
6
7
8
9
10
11
12
import org.aspectj.lang.annotation.Aspect;
import org.aspectj.lang.annotation.Before;
import org.springframework.stereotype.Component;

@Aspect
@Component
public class LoggingAspect {
    @Before("execution(* com.example.service.*.*(..))")
    public void logBefore() {
        System.out.println("Logging before method execution");
    }
}

配置 Spring 应用

1
2
3
4
5
6
7
8
9
import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;

@Configuration
@ComponentScan(basePackages = "com.example")
@EnableAspectJAutoProxy
public class AppConfig {
}

使用 AOP 的服务类

1
2
3
4
5
6
7
8
import org.springframework.stereotype.Service;

@Service
public class MyService {
    public void performTask() {
        System.out.println("Performing task");
    }
}

主应用

1
2
3
4
5
6
7
8
9
10
import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;

public class MainApp {
    public static void main(String[] args) {
        ApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        MyService myService = context.getBean(MyService.class);
        myService.performTask();
    }
}

LoggingAspect切面会在每次调用MyService中的方法时记录日志，而无需修改MyService的源代码。 AOP 通过分离横切关注点来提高代码的模块化和可维护性。

发表于 | 更新于 | 分类于
字数统计 | 阅读时长

👌说说Spring常用的注解

口语化回答

好的，面试官，比较常用的就是Component，将类放到容器管理，autowired，resource，来装配 bean。还有就是 configuration 和 bean 进行配合，装载 bean 进入容器。以及一些扩展的注解比如 aop 的 aspect 切面，事务相关的 transsactional。以上。

题目解析

基本不会考，这个没啥意义，不排除小公司或应届会问到这个问题。

面试得分点

随便搞下面的 3～4 个注解说出来即可。

题目详细答案

核心注解

@Component：将一个类标记为 Spring 组件类，表示这个类的实例将由 Spring 容器管理。

@Autowired：自动注入依赖对象。可以用于构造器、字段、Setter 方法或其他任意方法。

@Qualifier：在有多个候选 Bean 时，指定要注入的 Bean。通常与@Autowired一起使用。

1
2
3
4
5
6
@Component
public class MyComponent {
    @Autowired
    @Qualifier("specificBean")
    private Dependency dependency;
}

@Value：注入外部化的值，例如配置文件中的属性值、系统属性或环境变量。

1
2
3
4
5
@Component
public class MyComponent {
    @Value("${my.property}")
    private String myProperty;
}

@Configuration：标记一个类为 Spring 配置类，该类可以包含一个或多个@Bean方法。

1
2
3
4
5
6
7
@Configuration
public class AppConfig {
    @Bean
    public MyComponent myComponent() {
        return new MyComponent();
    }
}

@Bean：定义一个方法，返回一个要注册为 Spring 容器管理的 Bean。

1
2
3
4
@Bean
public MyComponent myComponent() {
    return new MyComponent();
}

@ComponentScan：指定要扫描的包，以查找带有@Component、@Service、@Repository和@Controller注解的类，并将它们注册为 Spring Bean。

1
2
3
4
5
@Configuration
@ComponentScan(basePackages = "com.example")
public class AppConfig {
    // 配置类内容
}

@Primary：标记一个 Bean 为首选 Bean，当有多个候选 Bean 时，Spring 会优先注入带有@Primary注解的 Bean。

1
2
3
4
5
@Component
@Primary
public class PrimaryBean implements Dependency {
    // 实现
}

@Scope：指定 Bean 的作用域，例如单例（singleton）、原型（prototype）等。

1
2
3
4
5
@Component
@Scope("prototype")
public class PrototypeBean {
    // 实现
}

特定用途注解

@Service：标记一个类为服务层组件，实际上是@Component的特殊化。

1
2
3
4
@Service
public class MyService {
    // 服务逻辑
}

@Repository：标记一个类为数据访问层组件，实际上是@Component的特殊化，并且支持持久化异常转换。

1
2
3
4
@Repository
public class MyRepository {
    // 数据访问逻辑
}

@Controller：标记一个类为 Spring MVC 控制器，实际上是@Component的特殊化

1
2
3
4
@Controller
public class MyController {
    // 控制器逻辑
}

@RestController：标记一个类为 RESTful Web 服务的控制器，等同于@Controller和@ResponseBody的组合。

1
2
3
4
5
6
7
@RestController
public class MyRestController {
    @GetMapping("/hello")
    public String hello() {
        return "Hello, World!";
    }
}

AOP（面向切面编程）相关注解

@Aspect：标记一个类为切面类。

1
2
3
4
5
@Aspect
@Component
public class MyAspect {
    // 切面逻辑
}

@Before：定义一个方法，在目标方法执行之前执行。

1
2
3
4
5
6
7
8
@Aspect
@Component
public class MyAspect {
    @Before("execution(* com.example.service.*.*(..))")
    public void beforeMethod(JoinPoint joinPoint) {
        // 前置逻辑
    }
}

@After：定义一个方法，在目标方法执行之后执行。

1
2
3
4
5
6
7
8
@Aspect
@Component
public class MyAspect {
    @After("execution(* com.example.service.*.*(..))")
    public void afterMethod(JoinPoint joinPoint) {
        // 后置逻辑
    }
}

@Around：定义一个方法，包围目标方法的执行

1
2
3
4
5
6
7
8
9
@Aspect
@Component
public class MyAspect {
    @Around("execution(* com.example.service.*.*(..))")
    public Object aroundMethod(ProceedingJoinPoint joinPoint) throws Throwable {
        // 环绕逻辑
        return joinPoint.proceed();
    }
}

事务管理相关注解

@Transactional：标记一个方法或类，表示该方法或类中的所有方法都需要事务管理。

1
2
3
4
5
6
7
@Service
public class MyService {
    @Transactional
    public void performTransaction() {
        // 事务逻辑
    }
}

发表于 | 更新于 | 分类于
字数统计 | 阅读时长

👌MyBatis拦截器实现分表

背景

所负责的业务中有一个 xx 系统，其中的 xx 核心表增长速度非常快，每日增长 200W 的数据量，业务特性主要是查询最近一周的数据，那么随着数据量越来越多，查询性能疯狂下降。这是典型的冷热数据场景，于是要开始进行冷热分离的操作。

常见的两种方案，一种是删除/归档旧数据，一种是数据分表。

方案选择

归档/删除旧数据

这种方式最常见的发难就是将冷数据移动到归档表或者直接进行删除，从而减少表的大小。

实现思路非常简单，一般写一个定时任务不断的跑就可以了。

缺点：

1、数据删除会影响数据库性能，引发慢sql，多张表并行删除，数据库压力会更大。

2、频繁删除数据，会产生数据库碎片，影响数据库性能，引发慢SQL。

有一定的风险，选择另一种分表的方案。

分表

业务特性是查最近的一周的数据，按日期的水平拆分是合理的。每周生成一张新表，同时此表只放本周的数据，这样表内数据量得到了控制，不会很大。

分表方案选型

分别常见的主要考虑2种分表方案：Sharding-JDBC、利用Mybatis自带的拦截器特性。

经过对比后，决定采用Mybatis拦截器来实现分表。

1、JAVA生态中很常用的分表框架是Sharding-JDBC，虽然功能强大，但需要一定的接入成本，并且很多功能暂时用不上。

2、系统本身已经在使用Mybatis了，只需要添加一个mybaits拦截器，把SQL表名替换为新的周期表就可以了，没有接入新框架的成本，开发成本也不高。

分表具体实现思路

1、通过拦截器获取表名

String tableName = TemplateMatchService.matchTableName(boundSql.getSql().trim());

2、根据数据日期进行计算后缀

3、替换原有 sql，最终执行。

String rebuildSql = boundSql.getSql().replace(shardingProperty.getTableName(), shardingTable);

metaStatementHandler.setValue(ORIGIN_BOUND_SQL, rebuildSql);

发表于 | 更新于 | 分类于
字数统计 | 阅读时长

👌Linux中断机制是什么？

Linux中断机制是操作系统处理硬件和软件事件的一种重要方式。中断可以使操作系统及时响应各种事件，如硬件设备的输入输出操作、定时器事件等。

中断的基本概念

1.中断类型

  • 硬件中断：由硬件设备（如键盘、网卡、硬盘等）发出的信号，引起CPU中断当前执行的程序，转而执行中断处理程序。
  • 软件中断：由软件指令（如系统调用、异常等）引发的中断。

2.中断向量表

中断向量表（Interrupt Vector Table, IVT）是一个包含中断服务程序地址的表。当中断发生时，CPU通过中断向量表找到相应的中断服务程序并执行。

中断处理流程

  1. 中断发生：硬件设备或软件事件发出中断信号。
  2. 中断响应：CPU停止当前执行的程序，保存当前的上下文（如程序计数器、寄存器等），并根据中断向量表找到对应的中断服务程序。
  3. 中断处理：执行中断服务程序，处理中断事件。
  4. 中断返回：中断处理完成后，恢复保存的上下文，继续执行被中断的程序。

中断处理的关键组件

1.中断控制器

中断控制器（如PIC、APIC）负责管理和分配中断请求。它可以屏蔽不需要的中断，并确定中断的优先级。

2.中断处理程序

中断处理程序（Interrupt Service Routine, ISR）是处理特定中断事件的函数。它通常分为顶半部（Top Half）和底半部（Bottom Half）：

  • 顶半部：快速响应中断，执行紧急的处理任务。
  • 底半部：延迟执行较长时间的任务，以减少顶半部的执行时间，避免阻塞其他中断。

3.中断上下文

中断上下文是指中断发生时CPU的状态，包括程序计数器、寄存器等。保存和恢复中断上下文是中断处理的关键步骤。

中断处理的实现

1.注册中断处理程序

在Linux内核中，可以使用request_irq函数注册中断处理程序：

1
2
3
#include <linux/interrupt.h>

int request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags, const char *name, void *dev);

2.中断处理程序示例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/interrupt.h>

static irqreturn_t my_interrupt_handler(int irq, void *dev_id) {
    printk(KERN_INFO "Interrupt occurred!\n");
    // 中断处理逻辑
    return IRQ_HANDLED;
}

static int __init my_module_init(void) {
    int irq = 1; // 假设中断号为1
    int result = request_irq(irq, my_interrupt_handler, IRQF_SHARED, "my_interrupt", NULL);
    if (result) {
        printk(KERN_ERR "Failed to request IRQ\n");
        return result;
    }
    return 0;
}

static void __exit my_module_exit(void) {
    int irq = 1; // 假设中断号为1
    free_irq(irq, NULL);
}

module_init(my_module_init);
module_exit(my_module_exit);

MODULE_LICENSE("GPL");
MODULE_DESCRIPTION("A simple interrupt handler module");
MODULE_AUTHOR("Your Name");

3.顶半部和底半部

  • 顶半部：快速处理中断的关键部分。
  • 底半部：使用任务队列、工作队列或软中断机制延迟处理较长时间的任务。

中断的优先级和屏蔽

中断控制器可以设置中断的优先级和屏蔽某些中断，以确保重要的中断优先得到处理。APIC（Advanced Programmable Interrupt Controller）提供了更高级的中断管理功能，如多级中断优先级和分布式中断处理。

中断的嵌套和重入

中断处理程序应尽量短小精悍，以减少中断嵌套的层数。中断处理程序应避免使用可能导致阻塞的操作，如长时间的I/O操作和锁定操作。

原文: https://www.yuque.com/jsyun/vwxwc6

发表于 | 更新于 | 分类于
字数统计 | 阅读时长

👌Linux查看文件磁盘占用情况？

1.du命令

du（disk usage）命令用于估算文件和目录的磁盘使用情况。

基本用法

1
du [选项] [文件或目录]

常用选项

  • -h：以人类可读的格式显示（例如，K、M、G）。
  • -s：显示总计（不显示子目录的详细信息）。
  • -a：包括所有文件和目录。
  • -c：显示总计。
  • --max-depth=N：限制显示的目录层级深度。

示例

  • 查看当前目录下每个文件和子目录的磁盘使用情况：
1
du -h
  • 查看指定目录的总磁盘使用情况：
1
du -sh /path/to/directory
  • 查看指定目录及其子目录的磁盘使用情况，限制深度为1：
1
du -h --max-depth=1 /path/to/directory

2.df命令

df（disk free）命令用于查看文件系统的磁盘使用情况。

基本用法

1
df [选项] [文件或目录]

常用选项

  • -h：以人类可读的格式显示（例如，K、M、G）。
  • -T：显示文件系统类型。
  • -i：显示inode使用情况。

示例

  • 查看所有挂载的文件系统的磁盘使用情况：
1
df -h
  • 查看特定目录所在的文件系统的磁盘使用情况：
1
df -h /path/to/directory

3.ncdu工具

ncdu（NCurses Disk Usage）是一个基于ncurses的磁盘使用分析工具，提供了交互式界面。

安装

在Debian/Ubuntu系统上：

1
sudo apt-get install ncdu

在CentOS/RHEL系统上：

1
sudo yum install ncdu

使用

1
ncdu /path/to/directory

4.ls命令

ls命令也可以显示文件的大小，但不如du详细。

示例

  • 以人类可读的格式显示文件大小：
1
ls -lh
  • 显示目录的总大小：
1
ls -lhS

5.find命令结合du

可以使用find命令查找特定条件的文件，然后结合du命令查看它们的磁盘使用情况。

示例

  • 查找大于100MB的文件并显示其磁盘使用情况：
1
find /path/to/directory -type f -size +100M -execdu -h {} +

发表于 | 更新于 | 分类于
字数统计 | 阅读时长

👌Linux死锁是什么？

在Linux操作系统中，死锁（Deadlock）是指两个或多个进程在等待彼此释放资源，从而导致它们都无法继续执行的情况。这是一种常见的并发问题，尤其在多线程或多进程环境中。

死锁的四个必要条件

死锁的发生需要满足以下四个条件（也称为Coffman条件）：

  1. 互斥条件（Mutual Exclusion）：至少有一个资源是非共享的，即一次只能被一个进程使用。
  2. 占有并等待条件（Hold and Wait）：一个进程已经持有了至少一个资源，并且正在等待获取其他被其他进程持有的资源。
  3. 不剥夺条件（No Preemption）：资源不能被强制从进程中剥夺，只有持有资源的进程可以主动释放资源。
  4. 环路等待条件（Circular Wait）：存在一个进程链，使得每个进程都在等待链中下一个进程所持有的资源。

死锁的检测和预防

为了处理死锁问题，可以采取以下几种策略：

1.预防死锁

预防死锁的方法包括破坏上述四个条件之一：

  • 破坏互斥条件：尽可能减少对非共享资源的使用。
  • 破坏占有并等待条件：在进程开始时一次性分配所有需要的资源，或者要求进程在请求资源前释放所有持有的资源。
  • 破坏不剥夺条件：允许操作系统强制剥夺某些资源。
  • 破坏环路等待条件：对资源进行排序，并要求进程按顺序请求资源。

2.避免死锁

避免死锁的方法主要是通过资源分配策略来确保系统永远不会进入死锁状态。常用的方法包括银行家算法（Banker’s Algorithm），它通过模拟资源分配情况来判断是否会导致死锁。

3.检测和恢复

如果无法预防或避免死锁，可以通过检测和恢复来处理死锁：

  • 死锁检测：定期检查系统中是否存在死锁。可以使用资源分配图（Resource Allocation Graph）来检测环路，从而识别死锁。
  • 死锁恢复：一旦检测到死锁，可以通过以下方式恢复：
    • 终止进程：强制终止一个或多个进程以打破死锁。
    • 资源剥夺：强制从某些进程中剥夺资源并重新分配。

发表于 | 更新于 | 分类于
字数统计 | 阅读时长

👌linux 内存有问题怎么查看？

如果怀疑内存有问题，可以通过以下步骤进行检查和诊断：

1. 使用free命令查看内存使用情况

free命令可以显示系统的内存使用情况，包括总内存、已使用内存、空闲内存和缓存等信息。

1
free -h

输出示例：

1
2
3
total        used        free      shared  buff/cache   available
Mem:           7.8G        3.2G        1.5G        200M        3.1G        4.1G
Swap:          2.0G        0.0K        2.0G

2. 使用top或htop命令查看内存使用情况

top和htop命令可以实时显示系统的资源使用情况，包括内存使用情况。

  • top命令：
1
top
  • htop命令（需要安装）：
1
2
sudo apt-get install htop
htop

3. 使用vmstat命令查看内存和系统性能

vmstat命令可以报告虚拟内存、进程、CPU 活动等信息。

1
vmstat 1 5

输出示例：

1
2
3
4
procs -----------memory---------- ---swap-- -----io---- -system-- ------cpu-----
 r  b   swpd   free   buff  cache   si   so    bi    bo   in   cs us sy id wa st
 1  0      0 1576828  72464 2192160    0    0     8    11   64  150  1  0 99  0  0
 0  0      0 1576820  72464 2192160    0    0     0     0   59  144  0  0 100  0  0

4. 检查内存使用情况的日志

查看系统日志，如/var/log/syslog或/var/log/messages，看看是否有与内存相关的错误或警告。

1
2
sudo grep -i memory /var/log/syslog
sudo grep -i memory /var/log/messages

发表于 | 更新于 | 分类于
字数统计 | 阅读时长

👌linux的中断机制用来干什么？

Linux的中断机制用于处理各种硬件和软件事件，使操作系统能够及时响应并处理这些事件。中断机制在操作系统中起着至关重要的作用。

1.硬件设备的事件处理

硬件设备通过中断机制通知操作系统它们的状态变化或需要处理的事件。例如：

  • 键盘输入：当键盘按键被按下时，键盘控制器会发出中断信号，通知CPU读取按键值。
  • 网络数据接收：网卡接收到数据包时，会触发中断，通知操作系统处理接收到的数据。
  • 硬盘I/O完成：硬盘完成读写操作后，会发出中断信号，通知操作系统该操作已完成，可以继续处理数据。

2.定时器和时钟管理

操作系统使用定时器中断来管理系统时钟和时间片轮转。例如：

  • 系统时钟更新：定时器会定期触发中断，操作系统通过这些中断更新系统时钟。
  • 时间片轮转：在多任务操作系统中，定时器中断用于实现时间片轮转调度，确保各个进程能够公平地获得CPU时间。

3.系统调用和异常处理

软件中断（如系统调用和异常）允许用户空间程序与内核进行交互，并处理异常情况。例如：

  • 系统调用：用户程序通过触发软件中断进入内核态，执行系统调用以请求操作系统服务（如文件操作、进程管理等）。
  • 异常处理：当程序发生异常（如除零错误、非法内存访问等）时，CPU会触发异常中断，操作系统捕获并处理这些异常。

4.中断驱动的I/O操作

中断机制使得设备驱动程序可以实现高效的I/O操作。例如：

  • 非阻塞I/O：通过中断通知，设备驱动程序可以在设备准备好时处理I/O操作，而无需进程持续轮询设备状态，从而提高系统效率。

5.电源管理

中断机制在电源管理中也扮演重要角色。例如：

  • 电池状态变化：当电池电量低或充电完成时，电源管理芯片会触发中断，通知操作系统采取相应的措施（如节能模式或提示用户）。

6.多核处理器的中断分配

在多核处理器系统中，中断控制器（如APIC）可以将中断分配到不同的CPU核，以实现负载均衡和提高并行处理能力。

原文: https://www.yuque.com/jsyun/vwxwc6

发表于 | 更新于 | 分类于
字数统计 | 阅读时长

👌如果不让你用看门狗，你会用什么方案来解决重复支付问题？

1. 幂等性令牌（Idempotency Token）

原理：在每次支付请求中，客户端生成一个唯一的幂等性令牌，并将其发送给服务器。服务器在处理支付请求时，会检查这个令牌是否已经被使用过。如果令牌已经被使用，服务器会拒绝重复的支付请求。

实现步骤：

  1. 客户端生成一个唯一的幂等性令牌（如 UUID）。
  2. 客户端将令牌和支付请求一起发送给服务器。
  3. 服务器检查令牌是否已经存在于数据库中。
  4. 如果令牌不存在，服务器处理支付请求并将令牌存储在数据库中。
  5. 如果令牌已经存在，服务器拒绝支付请求或者返回之前的处理结果。

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public class PaymentService {

    private PaymentRepository paymentRepository;

    public PaymentService(PaymentRepository paymentRepository) {
        this.paymentRepository = paymentRepository;
    }

    public void processPayment(PaymentRequest request) throws DuplicatePaymentException {
        String antiReplayToken = request.getAntiReplayToken();

        if (paymentRepository.existsByAntiReplayToken(antiReplayToken)) {
            throw new DuplicatePaymentException("Duplicate payment detected for anti-replay token: " + antiReplayToken);
        }

        // 处理支付逻辑
        Payment payment = new Payment();
        payment.setAntiReplayToken(antiReplayToken);
        payment.setAmount(request.getAmount());
        payment.setStatus("processing");

        paymentRepository.save(payment);

        // 完成支付后更新状态
        payment.setStatus("completed");
        paymentRepository.save(payment);
    }
}

2. 数据库唯一约束（不推荐）

原理：在数据库中为每个支付请求生成一个唯一的交易 ID，并在数据库中设置唯一约束（Unique Constraint）来防止重复记录。

实现步骤：

  1. 在支付请求中生成一个唯一的交易 ID。
  2. 在数据库中保存支付记录时，使用交易 ID 作为唯一键。
  3. 如果尝试插入重复的交易 ID，数据库会抛出唯一约束异常，从而防止重复支付。

示例代码（伪代码）：

1
2
3
4
5
6
7
8
9
CREATE TABLE payments (
    id SERIAL PRIMARY KEY,
    transaction_id VARCHAR(255) UNIQUE NOT NULL,
    amount DECIMAL(10, 2),
    status VARCHAR(50)
);

-- 插入支付记录时
INSERT INTO payments (transaction_id, amount, status) VALUES ('unique_transaction_id', 100.00, 'pending');

3. 分布式锁

原理：使用分布式锁来确保同一时间只有一个支付请求能够被处理。可以使用 Redis、ZooKeeper 等工具实现分布式锁。

实现步骤：

  1. 在处理支付请求前，尝试获取分布式锁。
  2. 如果获取锁成功，处理支付请求。
  3. 如果获取锁失败，拒绝支付请求或等待重试。
  4. 支付处理完成后，释放分布式锁。

示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
import org.redisson.api.RLock;
import org.redisson.api.RedissonClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.util.concurrent.TimeUnit;

@Service
public class PaymentService {

    @Autowired
    private RedissonClient redissonClient;

    @Autowired
    private PaymentRepository paymentRepository;

    public void processPayment(PaymentRequest request) throws DuplicatePaymentException {
        String transactionId = request.getTransactionId();
        RLock lock = redissonClient.getLock("payment_lock_" + transactionId);

        try {
            if (lock.tryLock(10, 10, TimeUnit.SECONDS)) {
                if (paymentRepository.existsByTransactionId(transactionId)) {
                    throw new DuplicatePaymentException("Duplicate payment detected for transaction ID: " + transactionId);
                }

                // 处理支付逻辑
                Payment payment = new Payment();
                payment.setTransactionId(transactionId);
                payment.setAmount(request.getAmount());
                payment.setStatus("processing");

                paymentRepository.save(payment);

                // 完成支付后更新状态
                payment.setStatus("completed");
                paymentRepository.save(payment);
            } else {
                throw new RuntimeException("Could not acquire lock for transaction ID: " + transactionId);
            }
        } catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new RuntimeException("Lock acquisition interrupted", e);
        } finally {
            lock.unlock();
        }
    }
}

4. 事务和锁机制

原理：使用数据库事务和锁机制来确保支付操作的原子性和一致性。

实现步骤：

  1. 在数据库中为支付操作创建一个事务。
  2. 在事务中获取支付记录的锁，防止其他事务同时修改相同的记录。
  3. 执行支付操作并提交事务。
  4. 如果在支付操作中发生冲突，回滚事务并重试。

5. 状态机

原理：使用状态机来管理支付请求的状态，确保每个支付请求只能从一个状态转移到另一个状态，避免重复处理。

实现步骤：

  1. 定义支付请求的状态（如pending、processing、completed、failed）。
  2. 在处理支付请求时，根据当前状态进行状态转移。
  3. 使用数据库事务确保状态转移的原子性。

总结

以上方法都可以有效地防止重复支付，具体选择哪种方案取决于系统的架构和需求。幂等性令牌和数据库唯一约束是比较常见且易于实现的方法，而分布式锁和状态机适用于更复杂的分布式系统。无论选择哪种方案，都需要确保支付操作的幂等性和一致性。

原文: https://www.yuque.com/jingdianjichi/xyxdsi/cf41s0446a6gokgr