spring重难点-总结复习

最新推荐文章于 2023-07-06 11:42:15 发布

少说废话多干活

最新推荐文章于 2023-07-06 11:42:15 发布

阅读量1k

点赞数

分类专栏： spring 设计模式

本文链接：https://blog.youkuaiyun.com/qq_24271537/article/details/115419725

版权

本文深入探讨Spring框架的优缺点、模块组成、设计模式应用、核心容器和事件处理。重点讲解了Spring的控制反转(IOC)、BeanFactory与ApplicationContext的区别以及线程安全问题。此外，还讨论了Spring的依赖注入、自动装配、数据访问、面向切面编程(AOP)以及事务管理。通过对Spring的深入理解，有助于提升开发效率和应用性能。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

转https://blog.youkuaiyun.com/ThinkWon/article/details/104397516

优缺点：

优点：

1、简化开发，方便解耦：

将所有对象的创建和依赖关系的维护交给spring来管理（把应用和依赖从应用代码中分离）

2、aop编程

spring提交切面编程，可以动态给目标对象增加功能

3、声明式事务支出

4、方便程序的测试 junit4

5、方便集成各种框架 mybatis，springmvc

6、降低javaee的使用难度

对JDBC，javaMail,远程调用进行了封装

缺点：

1、依赖反射，反射影响性能

spring由哪些模块组成：

1、spring core：

包括控制反转IOC 和依赖注入 DI

2、spring beans：

提供BeanFactory，用于创建对象实例

3、spring context：

提供了对象访问方法

4、spring jdbc：

5、spring aop：

6、spring web：

提供了web开发的集成特性，例如文件上传，邮箱

7、spring test： junit4

spring框架中都用到了哪些设计模式：

1、工厂模式

BeanFactory是简单工厂模式的体现，用于创建对象的实例

2、单例模式

bean默认为单例模式

3、代理模式

spring的aop功能用到jdk动态代理和CGLIB代理

4、模板方法

用来解决代码重复的问题，比如RestTemplate,JpaTemplate

扩展：
模板方法模式：
定义：定义一个模板结构，将具体内容延迟到子类去实现。
主要作用：在不改变模板结构的前提下在子类中重新定义模板中的内容。
解决的问题：
提高代码的复用率  -- 将相同部分的代码放在抽象的父类

转https://blog.youkuaiyun.com/carson_ho/article/details/54910518?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522161745152516780274180984%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=161745152516780274180984&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~sobaiduend~default-1-54910518.first_rank_v2_pc_rank_v29&utm_term=%E6%A8%A1%E6%9D%BF%E6%96%B9%E6%B3%95%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F&spm=1018.2226.3001.4187

实例概况
背景：小成希望学炒菜：手撕包菜 & 蒜蓉炒菜心
冲突：两道菜的炒菜步骤有的重复有的却差异很大，记不住

步骤1： 创建抽象模板结构（Abstract Class）：炒菜的步骤

public  abstract class Abstract Class {  
//模板方法，用来控制炒菜的流程 （炒菜的流程是一样的-复用）
//申明为final，不希望子类覆盖这个方法，防止更改流程的执行顺序 
        final void cookProcess(){  
        //第一步：倒油
        this.pourOil()；
        //第二步：热油
         this.HeatOil();
        //第三步：倒蔬菜
         this.pourVegetable();
        //第四步：倒调味料
         this.pourSauce（）；
        //第五步：翻炒
         this.fry();
    }  

//定义结构里哪些方法是所有过程都是一样的可复用的，哪些是需要子类进行实现的

//第一步：倒油是一样的，所以直接实现
void pourOil(){  
        System.out.println("倒油");  
    }  

//第二步：热油是一样的，所以直接实现
    void  HeatOil(){  
        System.out.println("热油");  
    }  

//第三步：倒蔬菜是不一样的（一个下包菜，一个是下菜心）
//所以声明为抽象方法，具体由子类实现 
    abstract void  pourVegetable()；

//第四步：倒调味料是不一样的（一个下辣椒，一个是下蒜蓉）
//所以声明为抽象方法，具体由子类实现 
    abstract void  pourSauce（）；


//第五步：翻炒是一样的，所以直接实现
    void fry();{  
        System.out.println("炒啊炒啊炒到熟啊");  
    }  
}

步骤2： 创建具体模板（Concrete Class）,即”手撕包菜“和”蒜蓉炒菜心“的具体步骤
//炒手撕包菜的类
  public class ConcreteClass_BaoCai extend  Abstract Class{
    @Override
    public void  pourVegetable(){  
        System.out.println(”下锅的蔬菜是包菜“);  
    }  
    @Override
    public void  pourSauce（）{  
        System.out.println(”下锅的酱料是辣椒“);  
    }  
}
//炒蒜蓉菜心的类
  public class ConcreteClass_CaiXin extend  Abstract Class{
    @Override
    public void  pourVegetable(){  
        System.out.println(”下锅的蔬菜是菜心“);  
    }  
    @Override
    public void  pourSauce（）{  
        System.out.println(”下锅的酱料是蒜蓉“);  
    }  
}


步骤3：客户端调用-炒菜了
public class Template Method{
  public static void main(String[] args){

//炒 - 手撕包菜
    ConcreteClass_BaoCai BaoCai = new ConcreteClass_BaoCai（）；
    BaoCai.cookProcess()；

//炒 - 蒜蓉菜心
  ConcreteClass_ CaiXin = new ConcreteClass_CaiXin（）；
    CaiXin.cookProcess()；
    }
        
}

扩展：
开闭原则：
    开闭原则（Open-Closed Principle, OCP）是指一个软件实体如类、模块和函数应该对扩展开放， 对修改关闭。
所谓的开闭，也正是对扩展和修改两个行为的一个原则。
    强调的是用抽象构建框架，用实 现扩展细节。可以提高软件系统的可复用性及可维护性。
    开闭原则，是面向对象设计中最基础的设计原 则。它指导我们如何建立稳定灵活的系统，
例如：我们版本更新，我尽可能不修改源代码，但是可以增 加新功能。

5、观察者模式（发布-订阅模式）

定义对象键一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知被制动更新，如Spring中listener的实现–ApplicationListener。