Spring入门核心理解（心法篇）用你听得懂的方式告诉你Spring是什么

最新推荐文章于 2024-03-31 15:00:00 发布

Ice吃米线

最新推荐文章于 2024-03-31 15:00:00 发布

阅读量370

点赞数 1

文章标签： spring java java-ee ioc aop

本文链接：https://blog.csdn.net/VB551/article/details/121200139

版权

学习思维：

学新东西！我喜欢从三个方向去处理这个知识:

1.这个东西是用来干什么的？

2.这个东西怎么用？

3.使用前，使用后有什么区别？

善用百度：

首先我们去百度百科看看这个是什么？

百度百科

spring框架

Spring框架是由于软件开发的复杂性而创建的。Spring使用的是基本的JavaBean来完成以前只可能由EJB完成的事情。然而，Spring的用途不仅仅限于服务器端的开发。从简单性、可测试性和松耦合性角度而言，绝大部分Java应用都可以从Spring中受益。（不用纠结其中专业的名词）

思考：

用我们已经学到的东西，当我们开发一个软件时，你是否觉得太慢？那么我们就该多人合作！

可是,有一个问题：我们如何用一个方法保证我们代码互相看懂，且如何分工?

所以我们现在就学习Spring 来规范我们开发时候的问题

Spring

我们没学过Spring之前肯定听说过：

Spring是一个轻量级的控制反转(IoC)和面向切面(AOP)的容器框架。

轻量级代表什么？ IOC是什么？ AOP又是什么？

轻量级：spring给用户提供的服务完全有用户自己决定，spring想用什么服务自己开启使用。但是重量级的都是只要你用就把所有的服务都给你，不能自己定制。

哦！原来是指它提供的服务是否能自己决定！

控制反转(IOC)

IoC不是一种技术，只是一种思想，一个重要的面向对象编程的法则，它能指导我们如何设计出松耦合、更优良的程序。

一个给初学者的tip，不要看它的名字，我们只管干什么的、有什么用！

于是法外狂徒张三直接上图！

图一

图二

如上图：如果按图一：

你可以理解这就是正向控制，程序员控制整个过程，你需要写许许多多冗余的代码。

用户调用add方法时，程序员需要new对象，还要把接收的name数据设置进去，多么繁琐，而且一旦方法复杂起来，非常不好管理。每次都修改controller里的源代码，维护成本高

如图二：

现在我使用一个叫IOC容器的东西（先不管怎么实现），它能自动创建对象，设置属性，并放到controller需要的位置。我们仅仅只需要给IOC提供class模板。代码少写很多，并且当我想多传一个属性（id）给student时，也只需要改动模板，不会改动controller。

控制反转，就是程序员不在管理对象的创建，赋值等....都由这个第三方IOC容器自己搞。

Spring Bean容器和 DI依赖注入：

bean是什么？

Spring Bean是被实例的，组装的及被Spring 容器管理的Java对象。

我说到底，其实也刚刚入门，我以一个小白的角度看：一切我们写的class（student，studentDAO，studentMapper）都是bean（若以后成为大牛一定回来更正）

我们执行所用到的class，都以一个个bean存入缓存中，这样才能调用

Bean容器：就是Spring把一些可能会用到的bean先实例化，方便用户需要时，Spring调用。

当一个Bean长这样，Grilfriend 这个属性也是一个Bean，是不是也该实例化呢？

实例化这个属性Bean（Grilfriend）就是依赖注入DI，Spring会造一个女朋友给你，并且在这里注入进去

整个bean创建到注入的过程被称作自动装配

public class Student {
    String name;
    Grilfriend grilfriend;
}

那么Spring怎么Bean实例化和依赖注入DI的呢？还记得反射吗？哈哈哈哈，Spring通过反射，把对象给搞出来然后放到容器里！！（这里不着重讲解反射，不懂的小伙伴自行学习）

理解IOC和DI：

其实IOC和DI都只是为了解决同一个问题的不同角度。通过依赖注入机制，我们只需要通过简单的配置，而无需任何代码就可指定目标需要的资源，完成自身的业务逻辑，而不需要关心具体的资源来自何处，由谁实现。（这句话如果不理解，那你一定还没写过Spring的代码）

AOP面向切面编程：

AOP我认为是Spring的一个难点，但剖析对比，就很简单了

AOP：当程序运行时，动态地将代码切入到类的指定方法、指定位置上的编程思想就是面向切面的编程。（敲小黑板：AOP是编程思想。 )

public class controller {
    
    @Resource
    Service service；

    public void selectService(){
        service.select();
    }
}
===================================分界线===========================================
public class controller {
    public void selectService(){
        log();
        service.select();
    }
}
===================================分界线===========================================
public class controller {
    public void selectService(){
        log();
        service.select();
        selectCorret();
    }
}

老板：帮我做一个查询张三：好了

一个月后----------

老板：查询上加个日志功能张三：哦（早不告诉我）

六个月后--------

老板：再加一个筛选功能张三：那么久了，代码都忘了，加个锤子！

代码需要重复迭代，如果没有一个很好的机制来规范，每次加功能我们都要改已经写好的代码。

AOP切面就是解决这个问题！再来看这段话

AOP：当程序运行时，动态地将代码切入到类的指定方法、指定位置上的编程思想就是面向切面的编程。（敲小黑板：AOP是编程思想。 )

现在我们大概知道AOP是用来对代码进行加强更新的，但是好像不是用改源代码的方法！

我现在写一个这样的配置：(下面是自己模拟的AOP配置只为简单明确)

试试看一下，log 和selectCorrect我们写成一个类，注入到容器中

用aop:config 配置切入点是哪个方法，切入在前还是在后把二者关系绑定起来，让Spring调用，并且你把log和selectCorrect删了，也不会报错影响到selectService，对原有代码毫无入侵性。真正的AOP配置很灵活，可以配置筛选多个方法切入，需要的条件等....(就是把你原来写的几十行代码，用这样简简单单一句话实现)

再来看这句话：

AOP：当程序运行时，动态地将代码切入到类的指定方法、指定位置上的编程思想就是面向切面的编程。

什么是动态地？

还是以上面controller为例：

public class controller {
    
    @Resource
    Service service；
    public void selectService(){
        service.select();
    }
}

现在我已经设置好了AOP，当用户调用controller时，这时才开始生成Service动态代理对象；

大概长这个样子

public class ServiceProxy implement service {
      //反射
    Service serviceImpl;

    void select(){
       log();  
       serviceImpl.select();
       selectCorrect();       
}
}

controller中的service其实是ServiceProxy实例出来的，由于Spring不知道用户会调用什么方法，所以动态生成这样的代理对象来实现不同需求的方法。

这个过程就被称作：运行时织入