Spring理解,重要概念及图解,2023秋招spring常见八股文

按照自己的需求,找到自己不会的地方去解决

1.Spring的核心

1)Spring的两大核心:IoC和AOP

Spring框架包含众多模块,如Core、Testing、Data Access、Web Servlet等,其中Core是整个Spring框架的核心模块。Core模块提供了IoC容器、AOP功能、数据绑定、类型转换等一系列的基础功能,而这些功能以及其他模块的功能都是建立在IoC和AOP之上的,所以IoC和AOP是Spring框架的核心。

IoC(Inversion of Control)是控制反转的意思,这是一种面向对象编程的设计思想。在不采用这种思想的情况下,我们需要自己维护对象与对象之间的依赖关系,很容易造成对象之间的耦合度过高,在一个大型的项目中这十分的不利于代码的维护。IoC则可以解决这种问题,它可以帮我们维护对象与对象之间的依赖关系,降低对象之间的耦合度。

说到IoC就不得不说DI(Dependency Injection),DI是依赖注入的意思,它是IoC实现的实现方式,就是说IoC是通过DI来实现的。由于IoC这个词汇比较抽象而DI却更直观,所以很多时候我们就用DI来代替它,在很多时候我们简单地将IoC和DI划等号,这是一种习惯。而实现依赖注入的关键是IoC容器,它的本质就是一个工厂。

AOP(Aspect Oriented Programing)是面向切面编程思想,这种思想是对OOP的补充,它可以在OOP的基础上进一步提高编程的效率。简单来说,它可以统一解决一批组件的共性需求(如权限检查、记录日志、事务管理等)。在AOP思想下,我们可以将解决共性需求的代码独立出来,然后通过配置的方式,声明这些代码在什么地方、什么时机调用。当满足调用条件时,AOP会将该业务代码织入到我们指定的位置,从而统一解决了问题,又不需要修改这一批组件的代码。

2)IOC容器:BeanFactory和ApplicationContext

1.两种工厂的创建方式:

Spring理解,重要概念及图解,2023秋招spring常见八股文_第1张图片

2.两种工厂的关系(区别)

底层图解:

Spring理解,重要概念及图解,2023秋招spring常见八股文_第2张图片

总结Spring理解,重要概念及图解,2023秋招spring常见八股文_第3张图片

3)DI依赖注入

依赖注入有三种常见的注入方式:构造函数注入、Setter方法注入和接口注入。下面分别展示这三种注入方式的代码体现。

  1. 构造函数注入:

public class MyApplication {
    private MessageService messageService;
​
    // 通过构造函数注入依赖
    public MyApplication(MessageService messageService) {
        this.messageService = messageService;
    }
​
    public void processMessage(String message) {
        // 使用依赖对象
        messageService.sendMessage(message);
    }
}
  1. Setter方法注入:

public class MyApplication {
    private MessageService messageService;
​
    // 通过Setter方法注入依赖
    public void setMessageService(MessageService messageService) {
        this.messageService = messageService;
    }
​
    public void processMessage(String message) {
        // 使用依赖对象
        messageService.sendMessage(message);
    }
}
  1. 接口注入:

public interface MessageServiceInjector {
    MyApplication getApplication();
}
​
public class EmailServiceInjector implements MessageServiceInjector {
    public MyApplication getApplication() {
        // 创建依赖对象
        MessageService messageService = new EmailService();
​
        // 创建应用程序并注入依赖
        MyApplication application = new MyApplication(messageService);
​
        return application;
    }
}

在接口注入中,我们定义了一个MessageServiceInjector接口,它包含一个getApplication方法,用于获取MyApplication对象。然后,我们创建了一个EmailServiceInjector类,实现了MessageServiceInjector接口,并在getApplication方法中创建了依赖对象messageService,并将其注入到MyApplication对象中。

通过以上三种方式,我们可以将依赖对象注入到目标类中,实现依赖的解耦和灵活替换。具体选择哪种注入方式,取决于具体的需求和设计。

2.AOP和动态代理关系

动态代理于AOP基本逻辑关系:

OOP编程的垂直性造成代码冗余,不方便管理;

解决代码冗余这类问题的思维是AOP面向切面编程思想;

实现这一思想,就要用动态代理技术;代理技术直接使用很麻烦,所以不会直接用,而是使用spring Aop技术框架来解决该类问题,aop框架底层就用到动态代理技术。Spring理解,重要概念及图解,2023秋招spring常见八股文_第4张图片

通过AOP例子理解AOP

下面是一个简单的Java AOP代码示例:

  1. 定义一个切面类,实现切面逻辑:

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 beforeAdvice() {
        System.out.println("Before executing the method");
    }
}
  1. 创建一个服务类,该类中的方法将被切面所拦截:

import org.springframework.stereotype.Service;
​
@Service
public class UserService {
​
    public void addUser(String username) {
        System.out.println("Adding user: " + username);
    }
}
  1. 创建一个配置类,启用AOP并扫描切面和服务类:

import org.springframework.context.annotation.ComponentScan;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.EnableAspectJAutoProxy;
​
@Configuration
@EnableAspectJAutoProxy
@ComponentScan(basePackages = "com.example")
public class AppConfig {
​
}
  1. 创建一个主类,加载配置类并获取服务类的实例:

import org.springframework.context.annotation.AnnotationConfigApplicationContext;
​
public class MainApp {
​
    public static void main(String[] args) {
        AnnotationConfigApplicationContext context = new AnnotationConfigApplicationContext(AppConfig.class);
        UserService userService = context.getBean(UserService.class);
​
        userService.addUser("John");
​
        context.close();
    }
}

在上述示例中,切面类 LoggingAspect 使用 @Aspect 注解标记为切面,并使用 @Before 注解定义了一个前置通知,该通知会在执行 com.example.service 包下的任何方法之前执行。服务类 UserService 中的 addUser 方法会被切面所拦截,在方法执行之前会打印一条日志。配置类 AppConfig 使用 @EnableAspectJAutoProxy 注解启用了AOP,并通过 @ComponentScan 注解扫描了切面和服务类。主类 MainApp 加载配置类,并获取服务类的实例,然后调用 addUser 方法。

运行主类 MainApp,将会输出以下内容:

Before executing the method
Adding user: John

这表明切面逻辑在方法执行之前被调用,成功拦截了服务类的方法。

3.spring中bean的安全问题

补充:成员方法才存在线程安全问题

  • spring中的bean如果是无状态的(一般情况是),则是线程安全的;

  • spring中的bean如果是有状态的,则需要标注@Scope("prototype"),意思是允许多个实例

    相反的@Scope("singleton"),意思是IOC容器中只允许创建一个实例

4.事务(来保证操作的原子性)

补充:事务是数据库中的概念,但spring对事务进行了拓展Spring理解,重要概念及图解,2023秋招spring常见八股文_第5张图片

  • 在Spring框架中,一般需要在以下情况下使用事务

  1. 数据库操作:当需要进行数据库的增删改操作时,可以使用事务来确保操作的一致性和完整性。例如,插入用户信息和同时插入用户订单信息,这两个操作应该放在同一个事务中,要么都成功,要么都失败。

  2. 多个服务方法调用:当一个服务方法中调用了多个其他服务方法,并且这些方法需要保证一致性,可以使用事务来统一管理。例如,用户下单操作需要调用库存服务和支付服务,这些服务操作应该在同一个事务中。

  3. 并发操作:当多个并发请求需要修改同一份数据时,需要使用事务来保证数据的一致性。例如,多个用户同时对同一商品进行抢购,需要使用事务来控制商品库存的减少和订单的生成。

  4. 异常处理:当方法执行过程中发生异常,需要回滚之前的操作,可以使用事务来实现回滚。例如,用户购买商品时,如果支付过程中发生异常,需要回滚订单和库存的操作。

总之,一般需要在涉及到数据库操作、多个服务方法调用、并发操作和异常处理的场景下使用事务。事务可以确保操作的一致性和完整性,提供可靠的数据访问和更新机制。

  • 步骤

    1. 开启事务:在执行一组操作之前,通过调用数据库的事务管理器来开启一个事务。

    2. 执行操作:在事务中执行一组相关的操作,如插入、更新、删除等。

    3. 提交事务:如果所有操作都成功执行,通过调用事务管理器的提交方法来提交事务,将操作的结果永久保存到数据库中。

    4. 回滚事务:如果有任何操作失败或发生异常,通过调用事务管理器的回滚方法来回滚事务,撤销已经执行的操作,保持数据库的一致性。

  • .spring支持编程式事务声明式事务是实现事务管理的两种主要方式。(重点)**

    1. 编程式事务:编程式事务是通过编写代码来管理事务的方式。在编程式事务中,开发人员需要手动编写事务的开启、提交和回滚等逻辑。通常,编程式事务使用的是底层的事务管理API,如JDBC的事务管理API。以下是一个使用编程式事务的示例:

    Connection conn = null;
    try {
        conn = dataSource.getConnection();
        conn.setAutoCommit(false); // 开启事务
        // 执行数据库操作
        // ...
        conn.commit(); // 提交事务
    } catch (SQLException e) {
        if (conn != null) {
            try {
                conn.rollback(); // 回滚事务
            } catch (SQLException ex) {
                ex.printStackTrace();
            }
        }
        e.printStackTrace();
    } finally {
        if (conn != null) {
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
    1. 声明式事务:声明式事务是通过配置的方式来管理事务的方式。在声明式事务中,开发人员只需要在配置文件或注解中声明事务的属性,框架会自动根据配置来管理事务。常见的使用声明式事务的框架有Spring的事务管理机制。以下是一个使用声明式事务的示例:

    @Transactional
    public void doTransaction() {
        // 执行数据库操作
        // ...
    }

    在上述示例中,使用了@Transactional注解来声明事务,并将事务逻辑封装在doTransaction方法中。框架会根据注解的配置来管理事务的开启、提交和回滚等操作。

    总的来说,编程式事务需要手动编写事务管理的代码,灵活性较高,但工作量较大;而声明式事务通过配置的方式来管理事务,简化了开发人员的工作,但灵活性相对较低。选择使用哪种方式取决于具体的需求和项目的特点。

5.Spring事务失效的场景(都是代码执行出现异常,事务却没有回滚)

  • 异常捕获处理,自己处理了异常,没有抛出,解决:手动抛出

  • 抛出检查异常,配置rollbackFor属性为Exception

  • 非public方法导致的事务失效,改为public

详细解释:

第一种:异常捕获处理,自己处理了异常,没有抛出,解决:手动抛出(左图改成右图)

                    事务失效的情况                                                                  改正后Spring理解,重要概念及图解,2023秋招spring常见八股文_第6张图片

第二种:抛出检查异常,配置rollbackFor属性为ExceptionSpring理解,重要概念及图解,2023秋招spring常见八股文_第7张图片

第三种:public方法导致的事务失效,改为public

Spring理解,重要概念及图解,2023秋招spring常见八股文_第8张图片

6.spring中bean的生命周期

Spring理解,重要概念及图解,2023秋招spring常见八股文_第9张图片

Spring理解,重要概念及图解,2023秋招spring常见八股文_第10张图片

7.三级缓存 (具体解决流程看视频解析)

可以解决spring中注入引起循环依赖问题

Spring理解,重要概念及图解,2023秋招spring常见八股文_第11张图片

构造方法中的循环依赖问题需要配合@Lazy懒加载注解解决

Spring理解,重要概念及图解,2023秋招spring常见八股文_第12张图片

8.spring中的常用注解

Spring理解,重要概念及图解,2023秋招spring常见八股文_第13张图片

你可能感兴趣的:(spring,底层,秋招八股文,bean,AOP,IOC,DI依赖注入)