谈谈你对Spring的理解？

ゞ浴缸里的玫瑰 2022-01-28 05:55 430阅读 0赞

## 认识 Spring 框架 ##

Spring 框架是 Java 应用最广的框架，它的成功来源于理念，而不是技术本身，它的理念包括 IoC (Inversion of Control，控制反转) 和 AOP(Aspect Oriented Programming，面向切面编程)。

**什么是 Spring：**

1.Spring 是一个轻量级的 DI / IoC 和 AOP 容器的开源框架，来源于 Rod Johnson 在其著作《Expert one on one J2EE design and development》中阐述的部分理念和原型衍生而来。  
2.Spring 提倡以“最少侵入”的方式来管理应用中的代码，这意味着我们可以随时安装或者卸载 Spring

适用范围：任何 Java 应用  
Spring 的根本使命：简化 Java 开发

尽管 J2EE 能够赶上 Spring 的步伐，但 Spring 并没有停止前进， Spring 继续在其他领域发展，而 J2EE 则刚刚开始涉及这些领域，或者还没有完全开始在这些领域的创新。移动开发、社交 API 集成、NoSQL 数据库、云计算以及大数据都是 Spring 正在涉足和创新的领域。Spring 的前景依然会很美好。

**Spring 中常用术语：**

框架：是能完成一定功能的半成品。  
框架能够帮助我们完成的是：项目的整体框架、一些基础功能、规定了类和对象如何创建，如何协作等，当我们开发一个项目时，框架帮助我们完成了一部分功能，我们自己再完成一部分，那这个项目就完成了。

非侵入式设计：  
从框架的角度可以理解为：无需继承框架提供的任何类  
这样我们在更换框架时，之前写过的代码几乎可以继续使用。

轻量级和重量级：  
轻量级是相对于重量级而言的，轻量级一般就是非入侵性的、所依赖的东西非常少、资源占用非常少、部署简单等等，其实就是比较容易使用，而重量级正好相反。

JavaBean：  
即符合 JavaBean 规范的 Java 类

POJO：即 Plain Old Java Objects，简单老式 Java 对象  
它可以包含业务逻辑或持久化逻辑，但不担当任何特殊角色且不继承或不实现任何其它Java框架的类或接口。

注意：bean 的各种名称——虽然 Spring 用 bean 或者 JavaBean 来表示应用组件，但并不意味着 Spring 组件必须遵循 JavaBean 规范，一个 Spring 组件可以是任意形式的 POJO。

**容器：**

在日常生活中容器就是一种盛放东西的器具，从程序设计角度看就是装对象的的对象，因为存在放入、拿出等操作，所以容器还要管理对象的生命周期。

**Spring 的优势**

低侵入 / 低耦合 （降低组件之间的耦合度，实现软件各层之间的解耦）  
声明式事务管理（基于切面和惯例）  
方便集成其他框架（如MyBatis、Hibernate）  
降低 Java 开发难度  
Spring 框架中包括了 J2EE 三层的每一层的解决方案（一站式）

**Spring 能帮我们做什么**

①.Spring 能帮我们根据配置文件创建及组装对象之间的依赖关系。  
②.Spring 面向切面编程能帮助我们无耦合的实现日志记录，性能统计，安全控制。  
③.Spring 能非常简单的帮我们管理数据库事务。  
④.Spring 还提供了与第三方数据访问框架（如Hibernate、JPA）无缝集成，而且自己也提供了一套JDBC访问模板来方便数据库访问。  
⑤.Spring 还提供与第三方Web（如Struts1/2、JSF）框架无缝集成，而且自己也提供了一套Spring MVC框架，来方便web层搭建。  
⑥.Spring 能方便的与Java EE（如Java Mail、任务调度）整合，与更多技术整合（比如缓存框架）。

**Spring 的框架结构**

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nMTUwMTE0_size_16_color_FFFFFF_t_70]

Data Access/Integration层包含有JDBC、ORM、OXM、JMS和Transaction模块。  
Web层包含了Web、Web-Servlet、WebSocket、Web-Porlet模块。  
AOP模块提供了一个符合AOP联盟标准的面向切面编程的实现。  
Core Container(核心容器)：包含有Beans、Core、Context和SpEL模块。  
Test模块支持使用JUnit和TestNG对Spring组件进行测试。

————————————————————————————————————

# Spring IoC 和 DI 简介 #

**IoC：Inverse of Control（控制反转）**

读作“反转控制”，更好理解，不是什么技术，而是一种设计思想，就是将原本在程序中手动创建对象的控制权，交由Spring框架来管理。  
正控：若要使用某个对象，需要自己去负责对象的创建  
反控：若要使用某个对象，只需要从 Spring 容器中获取需要使用的对象，不关心对象的创建过程，也就是把创建对象的控制权反转给了Spring框架  
好莱坞法则：Don’t call me ,I’ll call you

一个例子

控制反转显然是一个抽象的概念，我们举一个鲜明的例子来说明。

在现实生活中，人们要用到一样东西的时候，第一反应就是去找到这件东西，比如想喝新鲜橙汁，在没有饮品店的日子里，最直观的做法就是：买果汁机、买橙子，然后准备开水。值得注意的是：这些都是你自己“主动”创造的过程，也就是说一杯橙汁需要你自己创造。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nMTUwMTE0_size_16_color_FFFFFF_t_70 1]  
然而到了今时今日，由于饮品店的盛行，当我们想喝橙汁时，第一想法就转换成了找到饮品店的联系方式，通过电话等渠道描述你的需要、地址、联系方式等，下订单等待，过一会儿就会有人送来橙汁了。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nMTUwMTE0_size_16_color_FFFFFF_t_70 2]

请注意你并没有“主动”去创造橙汁，橙汁是由饮品店创造的，而不是你，然而也完全达到了你的要求，甚至比你创造的要好上那么一些。

编写第一个 Spring 程序

新建一个空的 Java 项目，命名为【spring】  
新建一个名为【lib】的目录，并添加进必要的 jar 包，导入项目

![在这里插入图片描述][20190523131916459.png]  
1.在 Packge【pojo】下新建一个【Source】类：

![在这里插入图片描述][20190523131936970.png]  
在 【src】 目录下新建一个 【applicationContext.xml】 文件，通过 xml 文件配置的方式装配我们的 bean

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nMTUwMTE0_size_16_color_FFFFFF_t_70 3]

在 Packge【test】下新建一个【TestSpring】类：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nMTUwMTE0_size_16_color_FFFFFF_t_70 4]

运行测试代码，可以正常拿到 xml 配置的 bean

![在这里插入图片描述][20190523132021333.png]

总结：  
传统的方式：  
通过new 关键字主动创建一个对象  
IOC方式：  
对象的生命周期由Spring来管理，直接从Spring那里去获取一个对象。 IOC是反转控制 (Inversion Of Control)的缩写，就像控制权从本来在自己手里，交给了Spring。

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nMTUwMTE0_size_16_color_FFFFFF_t_70 5]

**DI：Dependency Injection（依赖注入）**

指 Spring 创建对象的过程中，将对象依赖属性（简单值，集合，对象）通过配置设值给该对象 继续上面的例子

在 Packge【pojo】下新建一个【JuiceMaker】类：

package pojo;
     
    public class JuiceMaker {
     
        // 唯一关联了一个 Source 对象
        private Source source = null;
     
        /* setter and getter */
     
        public String makeJuice(){
            String juice = "xxx用户点了一杯" + source.getFruit() + source.getSugar() + source.getSize();
            return juice;
        }
    }

在 xml 文件中配置 JuiceMaker 对象：

注意：这里要使用 ref 来注入另一个对象

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nMTUwMTE0_size_16_color_FFFFFF_t_70 6]  
在 【TestSpring】 中添加如下代码：

package test;
     
    import org.junit.Test;
    import org.springframework.context.ApplicationContext;
    import org.springframework.context.support.ClassPathXmlApplicationContext;
    import pojo.JuiceMaker;
    import pojo.Source;
     
    public class TestSpring {
     
        @Test
        public void test(){
            ApplicationContext context = new ClassPathXmlApplicationContext(
                    new String[]{"applicationContext.xml"}
            );
     
            Source source = (Source) context.getBean("source");
            System.out.println(source.getFruit());
            System.out.println(source.getSugar());
            System.out.println(source.getSize());
     
            JuiceMaker juiceMaker = (JuiceMaker) context.getBean("juickMaker");
            System.out.println(juiceMaker.makeJuice());
        }
    }

运行测试代码：

![在这里插入图片描述][20190523132216133.png]  
总结：IoC 和 DI 其实是同一个概念的不同角度描述，DI 相对 IoC 而言，明确描述了“被注入对象依赖 IoC 容器配置依赖对象”

**IoC 如何实现的**

最后我们简单说说IoC是如何实现的。想象一下如果我们自己来实现这个依赖注入的功能，我们怎么来做？ 无外乎：

读取标注或者配置文件，看看JuiceMaker依赖的是哪个Source，拿到类名  
使用反射的API，基于类名实例化对应的对象实例  
将对象实例，通过构造函数或者 setter，传递给 JuiceMaker  
我们发现其实自己来实现也不是很难，Spring实际也就是这么做的。这么看的话其实IoC就是一个工厂模式的升级版！当然要做一个成熟的IoC框架，还是非常多细致的工作要做，Spring不仅提供了一个已经成为业界标准的Java IoC框架，还提供了更多强大的功能，所以大家就别去造轮子啦！希望了解IoC更多实现细节不妨通过学习Spring的源码来加深理解！

## Spring AOP 简介 ##

如果说 IoC 是 Spring 的核心，那么面向切面编程就是 Spring 最为重要的功能之一了，在数据库事务中切面编程被广泛使用。

**AOP 即 Aspect Oriented Program 面向切面编程**

首先，在面向切面编程的思想里面，把功能分为核心业务功能，和周边功能。

所谓的核心业务，比如登陆，增加数据，删除数据都叫核心业务  
所谓的周边功能，比如性能统计，日志，事务管理等等  
周边功能在 Spring 的面向切面编程AOP思想里，即被定义为切面

在面向切面编程AOP的思想里面，核心业务功能和切面功能分别独立进行开发，然后把切面功能和核心业务功能 “编织” 在一起，这就叫AOP

AOP 的目的

AOP能够将那些与业务无关，却为业务模块所共同调用的逻辑或责任（例如事务处理、日志管理、权限控制等）封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可拓展性和可维护性。

AOP 当中的概念：

切入点（Pointcut）  
在哪些类，哪些方法上切入（where）  
通知（Advice）  
在方法执行的什么实际（when:方法前/方法后/方法前后）做什么（what:增强的功能）  
切面（Aspect）  
切面 = 切入点 + 通知，通俗点就是：在什么时机，什么地方，做什么增强！  
织入（Weaving）  
把切面加入到对象，并创建出代理对象的过程。（由 Spring 来完成）  
AOP 编程

在 Packge【service】下创建 【ProductService】类：

package service;
     
    public class ProductService {
        public void doSomeService(){
            System.out.println("doSomeService");
        }
    }

在 xml 文件中装配该 bean：

在【TestSpring】中编写测试代码，运行：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nMTUwMTE0_size_16_color_FFFFFF_t_70 7]

在 Packge【aspect】下准备日志切面 【LoggerAspect】类：

package aspect;
     
    import org.aspectj.lang.ProceedingJoinPoint;
     
    public class LoggerAspect {
        
        public Object log(ProceedingJoinPoint joinPoint) throws Throwable {
            System.out.println("start log:" + joinPoint.getSignature().getName());
            Object object = joinPoint.proceed();
            System.out.println("end log:" + joinPoint.getSignature().getName());
            return object;
        }
    }

在 xml 文件中声明业务对象和日志切面：

<?xml version="1.0" encoding="UTF-8"?>
    <beans xmlns="http://www.springframework.org/schema/beans"
           xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
           xmlns:aop="http://www.springframework.org/schema/aop"
           xmlns:tx="http://www.springframework.org/schema/tx"
           xmlns:context="http://www.springframework.org/schema/context"
           xsi:schemaLocation="
       http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
       http://www.springframework.org/schema/aop
       http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
       http://www.springframework.org/schema/tx
       http://www.springframework.org/schema/tx/spring-tx-3.0.xsd
       http://www.springframework.org/schema/context
       http://www.springframework.org/schema/context/spring-context-3.0.xsd">
     
        <bean name="productService" class="service.ProductService" />
        <bean id="loggerAspect" class="aspect.LoggerAspect"/>
     
        
        <aop:config>
            
            <aop:pointcut id="loggerCutpoint"
                          expression="execution(* service.ProductService.*(..)) "/>
     
            
            <aop:aspect id="logAspect" ref="loggerAspect">
                
                <aop:around pointcut-ref="loggerCutpoint" method="log"/>
            </aop:aspect>
        </aop:config>
    </beans>

再次运行 TestSpring 中的测试代码，代码并没有改变，但是在业务方法运行之前和运行之后，都分别输出了日志信息：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nMTUwMTE0_size_16_color_FFFFFF_t_70 8]

--------------------

作者：Java程序员-张凯  
来源：CSDN  
原文：[https://blog.csdn.net/qq\_41701956/article/details/90453716][https_blog.csdn.net_qq_41701956_article_details_90453716]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nMTUwMTE0_size_16_color_FFFFFF_t_70]: /images/20220128/39933cea8cf540e8b1bc48765b1de022.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nMTUwMTE0_size_16_color_FFFFFF_t_70 1]: /images/20220128/792c69dfc52d48c7b5b141323fd28f0e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nMTUwMTE0_size_16_color_FFFFFF_t_70 2]: /images/20220128/e6d7c3bcaef6449fa37a1463152c34e4.png
[20190523131916459.png]: /images/20220128/c51623125c6b4fbe8be8111544e8287a.png
[20190523131936970.png]: /images/20220128/a3d0cce22d4f424e951ecdc6f75d2753.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nMTUwMTE0_size_16_color_FFFFFF_t_70 3]: /images/20220128/8aaab9e704784a648aabb0171017de00.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nMTUwMTE0_size_16_color_FFFFFF_t_70 4]: /images/20220128/6b337741b79146dbbf4473cd8680440d.png
[20190523132021333.png]: /images/20220128/5d0a5d4c681749d7a6907b972cb7c3dd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nMTUwMTE0_size_16_color_FFFFFF_t_70 5]: /images/20220128/ce0705b94672458bb146f9f898d27f93.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nMTUwMTE0_size_16_color_FFFFFF_t_70 6]: /images/20220128/b22f8cb45b5b4e53beaa3423d872d398.png
[20190523132216133.png]: /images/20220128/26d419e4cd9c4abeabc7a29970d0b209.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nMTUwMTE0_size_16_color_FFFFFF_t_70 7]: /images/20220128/fb71411fc6cf48869b81b6c78805724e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poYW5nMTUwMTE0_size_16_color_FFFFFF_t_70 8]: /images/20220128/4de9354849f24c72b0f191d031cfa8ac.png
[https_blog.csdn.net_qq_41701956_article_details_90453716]: https://blog.csdn.net/qq_41701956/article/details/90453716