首页 / 更多教程 / spring重难点-总结复习

spring重难点-总结复习

内容导读

互联网集市收集整理的这篇技术教程文章主要介绍了spring重难点-总结复习，小编现在分享给大家，供广大互联网技能从业者学习和参考。文章包含13854字，纯文字阅读大概需要20分钟。

内容图文

转https://blog.csdn.net/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.csdn.net/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()；
    }
        
}

spring重难点-总结复习 - 文章图片

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

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

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

扩展：
观察者模式：
它定义了一种一对多的依赖关系，让多个观察者对象同时监听某一个主题对象。这个主题对象在状态变化时，
会通知所有的观察者对象，使他们能够自动更新自己。

转
https://blog.csdn.net/itachi85/article/details/50773358?ops_request_misc=%257B%2522request%255Fid%2522%253A%2522161745233616780357298484%2522%252C%2522scm%2522%253A%252220140713.130102334..%2522%257D&request_id=161745233616780357298484&biz_id=0&utm_medium=distribute.pc_search_result.none-task-blog-2~all~top_positive~default-1-50773358.first_rank_v2_pc_rank_v29&utm_term=%E8%A7%82%E5%AF%9F%E8%80%85%E6%A8%A1%E5%BC%8F&spm=1018.2226.3001.4187

在观察者模式中有如下角色：
Subject：抽象主题（抽象被观察者），抽象主题角色把所有观察者对象保存在一个集合里，
每个主题都可以有任意数量的观察者，抽象主题提供一个接口，可以增加和删除观察者对象。
ConcreteSubject：具体主题（具体被观察者），该角色将有关状态存入具体观察者对象，
在具体主题的内部状态发生改变时，给所有注册过的观察者发送通知。
Observer：抽象观察者，是观察者者的抽象类，它定义了一个更新接口，使得在得到主题更改通知时更新自己。
ConcrereObserver：具体观察者，实现抽象观察者定义的更新接口，以便在得到主题更改通知时更新自身的状态。

//抽象观察者
public interface Observer {
    public void update(String message);
}

//具体观察者
public class WeixinUser implements Observer {
    // 微信用户名
    private String name;
    public WeixinUser(String name) {
        this.name = name;
    }
    @Override
    public void update(String message) {
        System.out.println(name + "-" + message);
    }

}

//抽象被观察者
public interface Subject {
    /**
     * 增加订阅者
     * @param observer
     */
    public void attach(Observer observer);
    /**
     * 删除订阅者
     * @param observer
     */
    public void detach(Observer observer);
    /**
     * 通知订阅者更新消息
     */
    public void notify(String message);
}

//具体被观察者
public class SubscriptionSubject implements Subject {
    //储存订阅公众号的微信用户   关联1
    private List<Observer> weixinUserlist = new ArrayList<Observer>();

    //关联观察者
    @Override
    public void attach(Observer observer) {
        weixinUserlist.add(observer);
    }

    @Override
    public void detach(Observer observer) {
        weixinUserlist.remove(observer);
    }

    //通知观察者
    @Override
    public void notify(String message) {
        //关联2
        for (Observer observer : weixinUserlist) {
            observer.update(message);//关联3
        }
    }
}

//客户端调用
public class Client {
    public static void main(String[] args) {
        SubscriptionSubject mSubscriptionSubject=new SubscriptionSubject();
        //创建微信用户
        WeixinUser user1=new WeixinUser("赵云");
        WeixinUser user2=new WeixinUser("关羽");
        WeixinUser user3=new WeixinUser("张飞");
        //订阅公众号
        mSubscriptionSubject.attach(user1);
        mSubscriptionSubject.attach(user2);
        mSubscriptionSubject.attach(user3);
        //公众号更新发出消息给订阅的微信用户
        mSubscriptionSubject.notify("诸葛亮挂了");
    }
}

spring重难点-总结复习 - 文章图片

详细讲解核心容器spring context应用上下文

spring框架中有哪些不同类型的事件

Spring控制反转(IOC)

1、所谓的“控制反转”概念就是对组件对象控制权的转移，从程序代码本身转移到了外部容器。

Spring IOC 负责创建对象，管理对象（通过依赖注入（DI），装配对象，配置对象，并且管理这些对象的整个生命周期）。

2、Spring IoC 的实现机制

Spring 中的 IoC 的实现原理就是工厂模式加反射机制。

interface Fruit {
   public abstract void eat();
 }

class Apple implements Fruit {
    public void eat(){
        System.out.println("Apple");
    }
}

class Orange implements Fruit {
    public void eat(){
        System.out.println("Orange");
    }
}

class Factory {
    public static Fruit getInstance(String ClassName) {
        Fruit f=null;
        try {
            f=(Fruit)Class.forName(ClassName).newInstance();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return f;
    }
}

class Client {
    public static void main(String[] a) {
        Fruit f=Factory.getInstance("io.github.dunwu.spring.Apple");
        if(f!=null){
            f.eat();
        }
    }
}

BeanFactory和ApplicationContext有什么区别？

1、BeanFactory和ApplicationContext是Spring的两大核心接口，都可以当做Spring的容器。其中ApplicationContext是BeanFactory的子接口。

2、依赖关系

BeanFactory：是Spring里面最底层的接口，包含了各种Bean的定义，读取bean配置文档，管理bean的加载、实例化，控制bean的生命周期，维护bean之间的依赖关系。

ApplicationContext接口作为BeanFactory的派生，除了提供BeanFactory所具有的功能外，还提供了更完整的框架功能：

继承MessageSource，因此支持国际化。

统一的资源文件访问方式。

提供在监听器中注册bean的事件。

同时加载多个配置文件。

3、加载方式

BeanFactroy采用的是延迟加载形式来注入Bean的，即只有在使用到某个Bean时(调用getBean())，才对该Bean进行加载实例化。这样，我们就不能发现一些存在的Spring的配置问题。如果Bean的某一个属性没有注入，BeanFacotry加载后，直至第一次使用调用getBean方法才会抛出异常。

ApplicationContext，它是在容器启动时，一次性创建了所有的Bean。这样，在容器启动时，我们就可以发现Spring中存在的配置错误，这样有利于检查所依赖属性是否注入。 ApplicationContext启动后预载入所有的单实例Bean，通过预载入单实例bean ,确保当你需要的时候，你就不用等待，因为它们已经创建好了。

相对于基本的BeanFactory，ApplicationContext 唯一的不足是占用内存空间。当应用程序配置Bean较多时，程序启动较慢。
4、创建方式

BeanFactory通常以编程的方式被创建，ApplicationContext还能以声明的方式创建，如使用ContextLoader。

Spring 如何设计容器的，BeanFactory和ApplicationContext的关系详解

1、BeanFactory 简单粗暴，可以理解为就是个 HashMap，Key 是 BeanName，Value 是 Bean 实例。通常只提供注册（put），获取（get）这两个功能。我们可以称之为 “低级容器”。

  • 加载配置文件，解析成 BeanDefinition 放在 Map 里。

  • 调用 getBean 的时候，从 BeanDefinition 所属的 Map 里，拿出 Class 对象进行实例化，同时，如果有依赖关系，将递归调用 getBean 方法 —— 完成依赖注入。

2、ApplicationContext 可以称之为 “高级容器”。因为他比 BeanFactory 多了更多的功能。

spring重难点-总结复习 - 文章图片

ApplicationContext通常的实现是什么？

什么是Spring的依赖注入？

  • 依赖注入：它会把符合依赖关系的对象通过属性（JavaBean中的setter）或者是构造器传递给需要的对象  -- 有set注入和构造注入
  • 依赖查找：容器中的受控对象通过容器的 API 来查找自己所依赖的资源和协作对象
  • 依赖注入的优势？     让容器全权负责依赖查询，受管组件只需要暴露JavaBean的setter方法或者带参数的构造器或者接口，使容器可以在初始化时组装对象的依赖关系

Spring Beans

1、定义：它们被Spring IOC容器初始化，装配，和管理。这些beans通过容器中配置的元数据创建。比如，以XML文件中 的形式定义。

2、一个springbean定义包含什么？？     元数据（如何创建一个bean--类信息，他的生命周期及其依赖）

3、如果给spring容器中提供配置元数据   xml + 注解 + java的配置

4、注入bean的几种方式

  • set方法
  • 构造器注入
  • 静态工厂
  • 实例工厂

5、作用域   scope = singleton 单例  ；  prototype  可有多个实例

request ;  session  ;  

Spring框架中的单例bean是线程安全的吗？

1、Spring框架中的单例bean不是线程安全的。

实际上大部分时候 spring bean 无状态的（比如 dao 类），所有某种程度上来说 bean 也是安全的，

但如果 bean 有状态的话（比如 view model 对象），那就要开发者自己去保证线程安全了

【有状态就是有数据存储功能。无状态就是不会保存数据。】

最简单的就是改变 bean 的作用域，把“singleton”变更为“prototype”，这样请求 bean 相当于 new Bean()了，就可以保证线程安全了

Spring如何处理线程并发问题？

1、例如多线程访问Model对象时进行存储获取时 ， 可有ThreadLocal处理。

同步机制：采用时间换空间，仅提供一份变量，不同线程在访问前需要获取锁，没获得锁的线程需要排队

ThreadLocal ： 采用空间换时间 。为每一个线程提供一个独立的变量副本。

public class SimpleThreadLocal {
	private Map valueMap = Collections.synchronizedMap(new HashMap());

	public void set(Object newValue) {
                //①键为线程对象，值为本线程的变量副本
		valueMap.put(Thread.currentThread(), newValue);
	}

	public Object get() {
		Thread currentThread = Thread.currentThread();
 
                //②返回本线程对应的变量
		Object o = valueMap.get(currentThread); 
                
                //③如果在Map中不存在，放到Map中保存起来
               if (o == null && !valueMap.containsKey(currentThread)) {
			o = initialValue();
			valueMap.put(currentThread, o);
		}
		return o;
	}

	public void remove() {
		valueMap.remove(Thread.currentThread());
	}
	public Object initialValue() {
		return null;
	}
}

解释Spring框架中bean的生命周期

1、

spring重难点-总结复习 - 文章图片

2、哪些是重要的bean生命周期方法？ 你能重载它们吗？

有两个重要的bean 生命周期方法，第一个是setup ， 它是在容器加载bean的时候被调用。第二个方法是 teardown 它是在容器卸载类的时候被调用。

bean 标签有两个重要的属性（init-method和destroy-method）。用它们你可以自己定制初始化和注销方法。它们也有相应的注解

自动装配

1、定义：在spring容器中把bean组装在一起 。 由容器负责把需要相互协作的对象引用赋给各个对象。

@Controller xxcontroller { @Autowire xxService ;  //将service对象赋给xxcontroller}

2、自动装配方式：

byName: 通过bean的名称进行自动装配

byType: 通过参数的数据类型进行自动装配

construnctor:

3、@Autowire

在启动spring IoC时，容器自动装载了一个AutowiredAnnotationBeanPostProcessor后置处理器，当容器扫描到@Autowied、@Resource或@Inject时，就会在IoC容器自动查找需要的bean，并装配给该对象的属性。在使用@Autowired时，首先在容器中查询对应类型的bean：

  • 如果查询结果刚好为一个，就将该bean装配给@Autowired指定的数据；

  • 如果查询的结果不止一个，那么@Autowired会根据名称来查找；

  • 如果上述查找的结果为空，那么会抛出异常。解决方法时，使用required=false。

Spring注解

1、@Bean

@Configuration
public class StudentConfig {
    @Bean  //@Bean注解，它表示此方法将要返回一个对象
    public StudentBean myStudent() {
        return new StudentBean();
    }
}

2、@Component

@Component（@Controller、@Service、@Repository）通常是通过类路径扫描来自动侦测以及自动装配到Spring容器中。

@Bean注解通常是我们在标有该注解的方法中定义产生这个bean的逻辑。

3、@Controller

4、@Service

5、@Repository

7、@Required  若@Required注解的bean属性未被设置，容器将抛出BeanInitializationException

@Required   

public void setName(String name){ this.name=name; }

8、@Autowired

它的用法和@Required一样，修饰setter方法、构造器、属性或者具有任意名称和/或多个参数的PN方法

@Autowired

public void setName(String name) { this.name=name; }

9、@Resource

@Autowired可用于：构造函数、成员变量、Setter方法

@Autowired和@Resource之间的区别

@Autowired默认是按照类型装配注入的，默认情况下它要求依赖对象必须存在（可以设置它required属性为false）。

@Resource默认是按照名称来装配注入的，只有当找不到与名称匹配的bean才会按照类型来装配注入。
10、@Qualifier   

当创建多个相同类型的bean时 ，指定bean名称，和@Autowired配合使用

11、@RequestMapping

 

 

 

 

 

内容总结

以上是互联网集市为您收集整理的spring重难点-总结复习全部内容，希望文章能够帮你解决spring重难点-总结复习所遇到的程序开发问题。 如果觉得互联网集市技术教程内容还不错，欢迎将互联网集市网站推荐给程序员好友。

内容备注

版权声明：本文内容由互联网用户自发贡献，该文观点与技术仅代表作者本人。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如发现本站有涉嫌侵权/违法违规的内容， 请发送邮件至 gblab@vip.qq.com 举报，一经查实，本站将立刻删除。

内容手机端

扫描二维码推送至手机访问。

本文链接：https://qyyshop.com/info/1020745.html

来源：【匿名】