面渣逆袭：Spring三十五问，四万字+五十图详解

Python微信订餐小程序课程视频

https://blog.csdn.net/m0_56069948/article/details/122285951

Python实战量化交易理财系统

https://blog.csdn.net/m0_56069948/article/details/122285941
大家好，我是老三啊，面渣逆袭 继续，这节我们来搞定另一个面试必问知识点——Spring。

有人说，“Java程序员都是Spring程序员”，老三不太赞成这个观点，但是这也可以看出Spring在Java世界里举足轻重的作用。

基础

1.Spring是什么？特性？有哪些模块？

一句话概括：Spring 是一个轻量级、非入侵式的控制反转 (IoC) 和面向切面 (AOP) 的框架。

2003年，一个音乐家Rod Johnson决定发展一个轻量级的Java开发框架，Spring作为Java战场的龙骑兵渐渐崛起，并淘汰了EJB这个传统的重装骑兵。

到了现在，企业级开发的标配基本就是 Spring5 + Spring Boot 2 + JDK 8

Spring有哪些特性呢？

Spring有很多优点：

1. IOC 和 DI 的支持

Spring 的核心就是一个大的工厂容器，可以维护所有对象的创建和依赖关系，Spring 工厂用于生成 Bean，并且管理 Bean 的生命周期，实现高内聚低耦合的设计理念。

2. AOP 编程的支持

Spring 提供了面向切面编程，可以方便的实现对程序进行权限拦截、运行监控等切面功能。

3. 声明式事务的支持

支持通过配置就来完成对事务的管理，而不需要通过硬编码的方式，以前重复的一些事务提交、回滚的JDBC代码，都可以不用自己写了。

4. 快捷测试的支持

Spring 对 Junit 提供支持，可以通过注解快捷地测试 Spring 程序。

5. 快速集成功能

方便集成各种优秀框架，Spring 不排斥各种优秀的开源框架，其内部提供了对各种优秀框架（如：Struts、Hibernate、MyBatis、Quartz 等）的直接支持。

6. 复杂API模板封装

Spring 对 JavaEE 开发中非常难用的一些 API（JDBC、JavaMail、远程调用等）都提供了模板化的封装，这些封装 API 的提供使得应用难度大大降低。

2.Spring有哪些模块呢？

Spring 框架是分模块存在，除了最核心的Spring Core Container是必要模块之外，其他模块都是可选，大约有 20 多个模块。

最主要的七大模块：

1. Spring Core：Spring 核心，它是框架最基础的部分，提供 IOC 和依赖注入 DI 特性。
2. Spring Context：Spring 上下文容器，它是 BeanFactory 功能加强的一个子接口。
3. Spring Web：它提供 Web 应用开发的支持。
4. Spring MVC：它针对 Web 应用中 MVC 思想的实现。
5. Spring DAO：提供对 JDBC 抽象层，简化了 JDBC 编码，同时，编码更具有健壮性。
6. Spring ORM：它支持用于流行的 ORM 框架的整合，比如：Spring + Hibernate、Spring + iBatis、Spring + JDO 的整合等。
7. Spring AOP：即面向切面编程，它提供了与 AOP 联盟兼容的编程实现。

3.Spring有哪些常用注解呢？

Spring有很多模块，甚至广义的SpringBoot、SpringCloud也算是Spring的一部分，我们来分模块，按功能来看一下一些常用的注解：

Web:

• @Controller：组合注解（组合了@Component注解），应用在MVC层（控制层）。
• @RestController：该注解为一个组合注解，相当于@Controller和@ResponseBody的组合，注解在类上，意味着，该Controller的所有方法都默认加上了@ResponseBody。
• @RequestMapping：用于映射Web请求，包括访问路径和参数。如果是Restful风格接口，还可以根据请求类型使用不同的注解：
  • @GetMapping
  • @PostMapping
  • @PutMapping
  • @DeleteMapping
• @ResponseBody：支持将返回值放在response内，而不是一个页面，通常用户返回json数据。
• @RequestBody：允许request的参数在request体中，而不是在直接连接在地址后面。
• @PathVariable：用于接收路径参数，比如@RequestMapping(“/hello/{name}”)申明的路径，将注解放在参数中前，即可获取该值，通常作为Restful的接口实现方法。
• @RestController：该注解为一个组合注解，相当于@Controller和@ResponseBody的组合，注解在类上，意味着，该Controller的所有方法都默认加上了@ResponseBody。

容器:

• @Component：表示一个带注释的类是一个“组件”，成为Spring管理的Bean。当使用基于注解的配置和类路径扫描时，这些类被视为自动检测的候选对象。同时@Component还是一个元注解。
• @Service：组合注解（组合了@Component注解），应用在service层（业务逻辑层）。
• @Repository：组合注解（组合了@Component注解），应用在dao层（数据访问层）。
• @Autowired：Spring提供的工具（由Spring的依赖注入工具（BeanPostProcessor、BeanFactoryPostProcessor）自动注入）。
• @Qualifier：该注解通常跟 @Autowired 一起使用，当想对注入的过程做更多的控制，@Qualifier 可帮助配置，比如两个以上相同类型的 Bean 时 Spring 无法抉择，用到此注解
• @Configuration：声明当前类是一个配置类（相当于一个Spring配置的xml文件）
• @Value：可用在字段，构造器参数跟方法参数，指定一个默认值，支持 #{} 跟 ${} 两个方式。一般将 SpringbBoot 中的 application.properties 配置的属性值赋值给变量。
• @Bean：注解在方法上，声明当前方法的返回值为一个Bean。返回的Bean对应的类中可以定义init()方法和destroy()方法，然后在@Bean(initMethod=”init”,destroyMethod=”destroy”)定义，在构造之后执行init，在销毁之前执行destroy。
• @Scope:定义我们采用什么模式去创建Bean（方法上，得有@Bean） 其设置类型包括：Singleton 、Prototype、Request 、 Session、GlobalSession。

AOP:

• @Aspect:声明一个切面（类上） 使用@After、@Before、@Around定义建言（advice），可直接将拦截规则（切点）作为参数。
  • @After ：在方法执行之后执行（方法上）。
  • @Before： 在方法执行之前执行（方法上）。
  • @Around： 在方法执行之前与之后执行（方法上）。
  • @PointCut： 声明切点 在java配置类中使用@EnableAspectJAutoProxy注解开启Spring对AspectJ代理的支持（类上）。

事务：

• @Transactional：在要开启事务的方法上使用@Transactional注解，即可声明式开启事务。

4.Spring 中应用了哪些设计模式呢？

Spring 框架中广泛使用了不同类型的设计模式，下面我们来看看到底有哪些设计模式?

1. 工厂模式 : Spring 容器本质是一个大工厂，使用工厂模式通过 BeanFactory、ApplicationContext 创建 bean 对象。
2. 代理模式 : Spring AOP 功能功能就是通过代理模式来实现的，分为动态代理和静态代理。
3. 单例模式 : Spring 中的 Bean 默认都是单例的，这样有利于容器对Bean的管理。
4. 模板模式 : Spring 中 JdbcTemplate、RestTemplate 等以 Template结尾的对数据库、网络等等进行操作的模板类，就使用到了模板模式。
5. 观察者模式: Spring 事件驱动模型就是观察者模式很经典的一个应用。
6. 适配器模式 :Spring AOP 的增强或通知 (Advice) 使用到了适配器模式、Spring MVC 中也是用到了适配器模式适配 Controller。
7. 策略模式：Spring中有一个Resource接口，它的不同实现类，会根据不同的策略去访问资源。

IOC

5.说一说什么是IOC？什么是DI?

Java 是面向对象的编程语言，一个个实例对象相互合作组成了业务逻辑，原来，我们都是在代码里创建对象和对象的依赖。

所谓的IOC（控制反转）：就是由容器来负责控制对象的生命周期和对象间的关系。以前是我们想要什么，就自己创建什么，现在是我们需要什么，容器就给我们送来什么。

也就是说，控制对象生命周期的不再是引用它的对象，而是容器。对具体对象，以前是它控制其它对象，现在所有对象都被容器控制，所以这就叫控制反转。

DI（依赖注入）：指的是容器在实例化对象的时候把它依赖的类注入给它。有的说法IOC和DI是一回事，有的说法是IOC是思想，DI是IOC的实现。

为什么要使用IOC呢？

最主要的是两个字解耦，硬编码会造成对象间的过度耦合，使用IOC之后，我们可以不用关心对象间的依赖，专心开发应用就行。

6.能简单说一下Spring IOC的实现机制吗？

PS:这道题老三在面试中被问到过，问法是“你有自己实现过简单的Spring吗？”

Spring的IOC本质就是一个大工厂，我们想想一个工厂是怎么运行的呢？

• 生产产品：一个工厂最核心的功能就是生产产品。在Spring里，不用Bean自己来实例化，而是交给Spring，应该怎么实现呢？——答案毫无疑问，反射。

那么这个厂子的生产管理是怎么做的？你应该也知道——工厂模式。

• 库存产品：工厂一般都是有库房的，用来库存产品，毕竟生产的产品不能立马就拉走。Spring我们都知道是一个容器，这个容器里存的就是对象，不能每次来取对象，都得现场来反射创建对象，得把创建出的对象存起来。
• 订单处理：还有最重要的一点，工厂根据什么来提供产品呢？订单。这些订单可能五花八门，有线上签签的、有到工厂签的、还有工厂销售上门签的……最后经过处理，指导工厂的出货。

在Spring里，也有这样的订单，它就是我们bean的定义和依赖关系，可以是xml形式，也可以是我们最熟悉的注解形式。

我们简单地实现一个mini版的Spring IOC：

Bean定义：

Bean通过一个配置文件定义，把它解析成一个类型。

• beans.properties

偷懒，这里直接用了最方便解析的properties，这里直接用一个类型的配置来代表Bean的定义，其中key是beanName，value是class

userDao:cn.fighter3.bean.UserDao

• BeanDefinition.java

bean定义类，配置文件中bean定义对应的实体

public class BeanDefinition {

    private String beanName;

    private Class beanClass;
     //省略getter、setter 
 }   

• ResourceLoader.java

资源加载器，用来完成配置文件中配置的加载

public class ResourceLoader {

    public static Map getResource() {
 Map beanDefinitionMap = new HashMap<>(16);
 Properties properties = new Properties();
 try {
 InputStream inputStream = ResourceLoader.class.getResourceAsStream("/beans.properties");
 properties.load(inputStream);
 Iterator it = properties.stringPropertyNames().iterator();
 while (it.hasNext()) {
 String key = it.next();
 String className = properties.getProperty(key);
 BeanDefinition beanDefinition = new BeanDefinition();
 beanDefinition.setBeanName(key);
 Class clazz = Class.forName(className);
 beanDefinition.setBeanClass(clazz);
 beanDefinitionMap.put(key, beanDefinition);
 }
 inputStream.close();
 } catch (IOException | ClassNotFoundException e) {
 e.printStackTrace();
 }
 return beanDefinitionMap;
 }

}

• BeanRegister.java

对象注册器，这里用于单例bean的缓存，我们大幅简化，默认所有bean都是单例的。可以看到所谓单例注册，也很简单，不过是往HashMap里存对象。

public class BeanRegister {

    //单例Bean缓存
    private Map singletonMap = new HashMap<>(32);

 /**
 * 获取单例Bean
 *
 * @param beanName bean名称
 * @return
 */
 public Object getSingletonBean(String beanName) {
 return singletonMap.get(beanName);
 }

 /**
 * 注册单例bean
 *
 * @param beanName
 * @param bean
 */
 public void registerSingletonBean(String beanName, Object bean) {
 if (singletonMap.containsKey(beanName)) {
 return;
 }
 singletonMap.put(beanName, bean);
 }

}

• BeanFactory.java

+ 对象工厂，我们最**核心**的一个类，在它初始化的时候，创建了bean注册器，完成了资源的加载。
+ 获取bean的时候，先从单例缓存中取，如果没有取到，就创建并注册一个bean



```
public class BeanFactory {

    private Map beanDefinitionMap = new HashMap<>();

 private BeanRegister beanRegister;

 public BeanFactory() {
 //创建bean注册器
 beanRegister = new BeanRegister();
 //加载资源
 this.beanDefinitionMap = new ResourceLoader().getResource();
 }

 /**
 * 获取bean
 *
 * @param beanName bean名称
 * @return
 */
 public Object getBean(String beanName) {
 //从bean缓存中取
 Object bean = beanRegister.getSingletonBean(beanName);
 if (bean != null) {
 return bean;
 }
 //根据bean定义，创建bean
 return createBean(beanDefinitionMap.get(beanName));
 }

 /**
 * 创建Bean
 *
 * @param beanDefinition bean定义
 * @return
 */
 private Object createBean(BeanDefinition beanDefinition) {
 try {
 Object bean = beanDefinition.getBeanClass().newInstance();
 //缓存bean
 beanRegister.registerSingletonBean(beanDefinition.getBeanName(), bean);
 return bean;
 } catch (InstantiationException | IllegalAccessException e) {
 e.printStackTrace();
 }
 return null;
 }
}

```

• 测试

  • UserDao.java

  我们的Bean类，很简单

  public class UserDao {
  
      public void queryUserInfo(){
          System.out.println("A good man.");
      }
  }
  
  

  • 单元测试

  public class ApiTest {
      @Test
      public void test\_BeanFactory() {
          //1.创建bean工厂(同时完成了加载资源、创建注册单例bean注册器的操作)
          BeanFactory beanFactory = new BeanFactory();
  
          //2.第一次获取bean（通过反射创建bean，缓存bean）
          UserDao userDao1 = (UserDao) beanFactory.getBean("userDao");
          userDao1.queryUserInfo();
  
          //3.第二次获取bean（从缓存中获取bean）
          UserDao userDao2 = (UserDao) beanFactory.getBean("userDao");
          userDao2.queryUserInfo();
      }
  }
  
  

  • 运行结果

  A good man.
  A good man.
  
  

至此，我们一个乞丐+破船版的Spring就完成了，代码也比较完整，有条件的可以跑一下。

PS:因为时间+篇幅的限制，这个de