学习笔记-设计模式在java/Spring中的应用（未完待施工

最新推荐文章于 2024-03-23 14:24:54 发布
最新推荐文章于 2024-03-23 14:24:54 发布
阅读量136 收藏
点赞数
分类专栏： 面向面试学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Sindweller5530/article/details/109449591
版权

单例模式

  • 设计思想：内存中只会创建且仅创建一次对象。
  • 使用：所有要调用该对象的地方共享单例对象。
  • 目的：防止频繁创建对象使用内存。
    分为两类：
  1. 懒汉式（非线程安全）：真正需要使用时才去加载对象。
  2. 饿汉式：类加载时已经创建好。

实现饿汉需要：
private static Singleton singleton = new Singleton();
实现单例模式（懒汉）需要：

  1. 限制用户自己创建实例->将构造方法设为private
  2. 使用时判断是否已经存在这个对象->将singleton定义为null，并在使用时判断，==null则创建（注意这里会发生线程安全问题）
    代码：
public class Singleton{
	//	最简单的实现，会有线程安全问题
	private Singleton(){};//private限制用户自己创建该类实例
	private static Singleton singleton = null;//注意线程安全问题的修改点
	//使用时先获取；线程安全问题修改点
	public static Singleton getSingleton(){
		if(singleton==null){
		//如果没有就创建
			singleton = new Singleton();
	    }
	    return singleton;
	}

线程安全问题在于1.指令重排序：
Singleton singleton = new Singleton();的步骤有3步：
Step1:分配内存空间
Step2:初始化对象
Step3:设置instance指向刚分配给它的内存地址
其中2、3步是可以颠倒的。那么就会发生线程A从1直接执行了3，此时instance已经不是null了，但仍没有被初始化。如果线程B此时选择获取实例，那么就会发现不是null，但是获取的时候就会报错NPE。
解决方法：
禁止指令重排序->volatile关键字修饰singleton
2.多个线程同时进入
两种可能：要么是后走完的覆盖前一个的实例，要么是同时走完出现两个实例。总之都要出现两个实例。只有一前一后进入的才可以。
解决方法：（最好的解决方法是静态内部类）
首先考虑加锁 Synchronized 粗略的来看加锁的地方在getSingleton()这个方法上。但是为了确保单例空间共享和方法不被重写、重载，我们已经用了static来修饰方法。如果synchronized加在静态方法上，会把整个类给锁住。因此synchronized要放到方法里面来锁。
双重检测机制：（为什么要双重？）

	if(instance==null){
	//避免全走锁
		syschronized(Singleton.class){
			if(instance==null){
			//确保另一个线程获得锁之后也要判断
				instance = new Singleton():
			}
		}
	}

静态内部类：

public class Singleton{
	//静态内部类
	private static class LazyHolder{
	//通过静态内部类来创建
		private static final Singleton INSTANCE = new Singleton();
	}
	//原构造方法
	public Singleton(){};
	//获取实例方法，static避免重写重载，
	public static final Singleton getInstance(){
		return LazyHolder.INSTANCE;//通过静态内部类来加载
	}
}

如何打破单例模式？——利用“反射”机制

  1. 获得构造器 Constructor con = Singleton.class.getDeclaredConstructer();
  2. 设为可访问的构造器 con.setAccessible(true)
  3. 构造两个不同对象

如何防止利用反射来多次创建？——枚举类
枚举类在类加载的时候初始化，JVM会组织反射获取枚举类的私有构造方法。

public enum SingletonEnum{
	INSTANCE;
}

单例模式在Spring中的应用——依赖注入（A类依赖B类，A不再创建B类对象而是写好配置xml文件，控制反转让Spring容器去按配置信息创建管理bean）
Spring依赖注入Bean对象默认为单例。使用的是双重检测加锁的方式。
依赖注入发生在AbstractBeanFactory的getBean里，doGetBean()->getSingleton()->singletonFactories()->创建单例实例

工厂模式

简单工厂模式

工厂类专门负责创建对象，所以将XX类的初始化方法迁到工厂类的创建方法（createXX）里。

public class XXFactory{
	public XX createXX(){
		XX  xx = new XX();
		//初始化代码
		return xx;
	}
}

如果XX存在子类，则加判断。
比如，抽象接口XX，实现子类A，实现子类B。以参数type传入创建方法，让其判断并选择new A还是B。
在客户端的实现：

XXFactory factory = new XXFactory();
XX a = factory.createXX(type);//依靠传参让工厂类判断new哪个子类。

这种依靠传参给工厂类创建方法来创建不同类别对象的是简单工厂模式。

工厂方法模式

去掉对type的if-else判断，对每个XX的子类创建对应的工厂子类，这些工厂子类实现抽象工厂接口。
即，实例化不同的工厂子类，调用创建方法，然后得到对应的对象。（子类继承父类重写方法，多态的体现）

//用接口来代替工厂类
public interface XXFactory{
	XX createXX();
}

实现接口的子类：

public class AF implements XXFactory{
	@Override
	public XX createXX(){
		XX xx = new AF();//实例化不同的工厂子类
	}
}

客户端：

XXFactory af = new AF();
XXFactory bf = new BF();
//利用多态，调用名称相同的创建方法，无需像简单工厂模式一样传参。
XX a = af.createXX();
XX b = bf.createXX();

每个XX子类对应一个实现了XXFactory接口的工厂子类。

抽象工厂模式

如果待创建的子类还是多，可以放弃创建子类，转而寻找子类之间的共性。比如1234四类产品，但是他们本身又都有AB两种分类。那么可以将其分为AB两组，组中的不同产品，由同一工厂类里的不同方法创建：

  • 产品->抽象接口
  • 分组->实现类
public interface IFactory{
//产品1
XX createXX();
//产品2
YY createiYY();
}

A组的工厂

public class AFactory implements IFactory{
	@Override
	public XX createXX(){
		XX xx = new A();
	}
	...
	//YY ZZ
}

客户端的代码：

IFactory fa = new AFactory();
IFactory fb = new BFactory();
//生产A类XX
XX ax = fa.createXX();//调用A工厂的createXX方法
//生产A类YY
YY ay = fa.createYY();
//生产B类XX
XX bx = fb.createXX();
//生产B类YY
YY by = fb.createYY();

设计思想总结：多个产品按类分组，组内的不同产品对应同一工厂子类的不同方法。

工厂模式总结

  1. 简单工厂模式：一个工厂类，创建方法根据传入参数判断。
  2. 工厂方法模式：工厂是抽象接口，多个工厂子类实现接口，并且对应产品调用接口中的创建方法，利用多态——覆写来创建不同的产品对象。
  3. 抽象工厂模式，产品子类再次分组，而不再创建多个子类。按不同产品中的某些共性分组，对组创建子类实现抽象工厂接口，子类中由不同的create方法创建不同产品，减少子类的数量。

工厂模式应用

在上述工厂模式应用中，客户端必须指定工厂子类。但是在Spring中，可以依靠控制反转让Spring创建和管理各种Bean对象。用户需要做的只是在XML（或注解）中配置好bean的各种属性，如实现类class，这样可以创建对象并创建其所依赖的对象。
通过Spring的依赖注入不需要在业务代码中手动实例化对象。（详见BeanFactory源码及其实现类）

依赖注入：A类依赖B类，A类中不实例化B类的实例，而是通过外部将B类传参（注入A中）进A的构造函数里。A把这种依赖关系配置在外部文件里，Spring可以根据配置信息创建、管理bean对象。

  • Spring如何根据xml配置创建、管理bean？——反射，运行时创建对象，使用class元信息（如完整类名）

工厂模式终于结束啦，继续施工。。

策略模式——解决if-else、switch的困境

基本上都是知乎@程序员小灰写的那篇文章里的。。
根据用户选择而使用不同的处理方法。
策略模式的角色分配：

  • Strategy：决定实现策略所必需的接口
  • ConcreteStrategy：具体的实现Strategy的API
  • Context： 使用Strategy，保存ConcreteStrategy的实例，并调用Strategy的API来实现需求
  1. 定义策略接口：
public interface IStrategy{
	void dealMethod(String option);
}
  1. 具体策略DealX实现策略接口
public class DealX implements IStrategy{
	@Override
	public void dealMethod(String option){...}
}
  1. 定义上下文
public static class DealContext{
	private String type;//type=X
	private Strategy deal;//策略实例
	//构造函数
	public DealContext(String type, Strategy deal){
		this.type = type;
		this.deal = deal;
	}
	//获取Strategy的实例
	public Strategy getDeal(){
		return deal;
	}
	//判断是否与type相等
	public boolean options(String type){
		return this.type.equals(type);
	}
}
  1. 最终功能的实现(new 很多个上下文，在里面传参type和新建对应具体策略实例
public class Share{
	private static List<DealContext> algs = new ArrayList<>();
	//静态代码块，加载所有策略（algs表里）
	static{
		algs.add(new DealContext("X", new DealX());//具体策略
		//...其他策略
	}
	public void shareOptions(String type){
		Strategy deal = null;
		for(DealContext d:algs){
				if(d.options(type)){
					//找到哪个具体策略对应了此处type
					deal = d.getDeal();
					//获取具体策略
					breal;//跳出循环，不必再找了
				}
			}
			deal.dealMethod(type);//调用具体策略里的方法
	}
}

如果要添加新的策略：
6. public class DealNew implements Strategy继续继承Strategy
7. Share中的静态代码块也加入`(new DealContext(“new”,new DealNew());

Java中策略模式的应用

Comparator
如果某类没有实现Comparable接口，则建立一个实现Comparator接口的比较器。
按照上述4步进行

  1. 策略接口：
public interface Comparator<T>{
	int Compare(T o1, T o2);
}
  1. 定义具体策略：
public class Sorter implements Comparator{
//具体策略排序，实现Comparator接口
	@Override
	public int compare(String s1,String s2){
		return Integer.compare(s1.length,s2.length);//此处设计为比较字符串长度
	}
}
  1. 策略上下文
  2. 实现
    可以通过配置文件或者注解来标注定义的策略类。读取配置文件/搜索被标注的策略类，通过反射来加载策略类、创建策略对象。
    与状态模式的区分：待施工。。。还没看

装饰者模式

套娃。。详见java io
new BufferedReader(new InputStreamReader(System.in));
装饰者模式由三部分组成（跟策略模式很像，都是抽象->具体，不同的是策略有个上下文，装饰器分为两组，组件和装饰器， 装饰器是用来扩展的）：

  1. 抽象组件类
abstract class Component{
	public abstract void operation();
}
  1. 具体组件类
class ConcreteComponent extends Component{
	public void operation(){...}//提供具体实现
}
  1. 抽象装饰器类继承抽象组件类
abstract class Decorator extends Component{
	protected Component component;
	public Decorator (Component component){
		//依赖注入？
		this.component = component;
	}
	public void operation(){
		component.operation();
	}
}
  1. 具体装饰器类（有多个）
class ConcreteDecoratorA extends Decorator{
	public ConcreteDecoratorA(Component component){
		//调用父类构造方法
		super(component);
	}
	//具体操作
	private void operation1(){...}
	private void operation2(){...}
	...
	public void operation(){
		operation1();
		super.operation();
		operation2();
	}
	//新功能
	public void anotherOperation(){
		...
	}
}
  1. 客户端实现
public class Client{
	public static void main(String[] args){
		Component c1 = new ConcreteComponent();
		//套娃开始⬇️
		Decorator decoratorA = new ConcreteDecoratorA(c1);
		//实例化具体装饰器并将具体组件实例作为参数传进去
		decoratorA.operation();//上边定义的三个操作
		//新功能
		Decorator decoratorBandA = new ConcreteDecoratorBandA(decoratorA);
		//⬆️扩展装饰器
		decoratorBandA.operation();
	}
}

新功能：新建类继承抽象装饰器类。不修改原有的代码，符合开闭原则。

观察者模式

游戏开发和窗体应用程序中多见，Spring的ApplicationListener和ApplicationContext也有运用。非常简单，待施工。。。

信德维拉5530
关注
专栏目录
千锋重庆JAVA知识点：设计模式在Spring中的应用
qf2019的博客
03-12 115
设计模式(design pattern)是对面向对象设计中反复出现的问题的解决方案。这个术语是在1990年代由Erich Gamma等人从建筑设计领域引入到计算机科学中来的。这个术语的含义还存有争议。算法不是设计模式，因为算法致力于解决问题而非设计问题。设计模式通常描述了一组相互紧密作用的类与对象。设计模式提供一种讨论软件设计的公共语言，使得熟练设计者的设计经验可以被初学者和其他设计者掌握。设计模式还为软件重构提供了目标。 目前出版了许多关于设计模式的书籍,我最喜欢的一本就是《大话设计模式》，该书形象生动的
设计模式学习笔记--设计模式在Java I/O中的应用(装饰模式和适配器模式)
Java之旅
04-06 7484
在Java 语言I/O库的设计中，使用了两个结构模式，即装饰模式和适配器模式。本篇围绕这两个模式讨论Java I/O库的设计。
深入解析spring中用到的九种设计模式
weixin_30740295的博客
06-01 7775
转载请注明出处，文章首发于：http://itxxz.com/a/javashili/tuozhan/2014/0601/7.html 设计模式作为工作学习中的枕边书，却时常处于勤说不用的尴尬境地，也不是我们时常忘记，只是一直没有记忆。 今天，螃蟹在IT学习者网站就设计模式的内在价值做一番探讨，并以spring为例进行讲解，只有领略了其设计的思想理念，才能在工作学习中运用到“无形”...
浅谈java设计模式在Spring中的应用（一）
老徐的天上人间
08-04 541
  很多初级程序员学了设计模式之后，根本不知道怎么应用。很多人甚至还认为使用设计模式那是架构师该干的活，程序员的工作就是专心写代码，完成该完成的工作。其实这种观点非常的错误，架构师关注的是架构设计，设计了前段 后台 数据库以及其他一切的东西，架构师还关注什么地方该使用哪种语言，甚至还关注设计思想。 程序员所关心根本就不是这些问题，程序员应该关注的是写出优秀的代码，而不是那种很垃圾的代码。一段垃...
java中设计模式在springmvc框架中的应用理解
weixin_37582804的博客
09-20 577
1简单.工厂模式 又叫做静态工厂方法（StaticFactory Method）模式，但不属于23种GOF设计模式之一。 简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类。 spring中的BeanFactory就是简单工厂模式的体现，根据传入一个唯一的标识来获得bean对象，但是否是在传入参数后创建还是传入参数前创建这个要根据具体情况来定。如下配置 ...
java Spring中使用到的设计模式
weixin_49131718的博客
07-11 2598
这种方式同样使用了classLoader机制来保证初始化instace时只有一个线程，它跟第三种方式不同的是：第3种方式只要Singleton类被装载了，那么instance就会被实例化，而这种方式是Singleton类被撞在了，instance不一定被初始化。有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要通过new就可以完成创建的对象，无需使用工厂模式。在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式地指定它们的类，每个生成的工厂都能按照工厂模式提供对象。
Java JDK7学习笔记-光盘
08-20
《Java JDK7学习笔记》是作者多年来教学实践经验的总结，汇集了教学过程中学生在学习java时遇到的概念、操作、应用或认证考试等问题及解决方案。《Java JDK7学习笔记》针对java se 7新功能全面改版，无论是章节架构...
微波射频学习笔记12-------单节/多节定向耦合器的设计
Sil_sprout
05-20 7848
平行线耦合器 一、基本原理 两根紧挨着的微带线，一根通信号，因为电磁场的相互作用，另一根会有功率耦合。 当电磁波通过主线时，本身是携带电场和磁场的，由于两根传输线距离很近，类似电容，所以主线上的交变电流通过电容，将两股方向相反的电流耦合到耦合线上；同时根据电磁感应定律，磁场中的导线会产生方向相反的感应电流，故上图②端口和下图4端口会产生叠加的功率，而③口，因为电场和磁场产生电流的方向相反而抵消。正因此，③口称为隔离端，另一个口称为耦合端。 二、单节平行线耦合器结构 1.① 为信号输入；② 为耦合端口；③
java学习笔记总结
04-02
这份“java学习笔记总结”涵盖了作者在深入学习Java过程中积累的知识点和实践经验，旨在帮助读者理解和掌握Java的核心概念。 首先，Java的基础部分包括语法、变量、数据类型、运算符和流程控制。Java支持八种基本...
Spring Boot学习笔记（超详细）
uuuyy_的博客
12-12 8007
一，spring boot 入门 1、Spring Boot 简介 简化Spring应用开发的一个框架； 整个Spring技术栈的一个大整合； J2EE开发的一站式解决方案； 2、微服务 2014，martin fowler 微服务：架构风格（服务微化） 一个应用应该是一组小型服务；可以通过HTTP的方式进行互通； 单体应用：ALL IN ONE 微服务：每一个功能元素最终都是一个可独立替换和独立升级的软件单元； 3、环境准备 环境约束 –jdk1.8：Spring Boot 推荐
设计模式在spring中的应用
远行的博客
09-13 191
@FunctionalInterface public interface ApplicationListener<E extends ApplicationEvent> extends EventListener { /** *处理事件的 */ void onApplicationEvent(E event); }
设计模式在Spring中的应用
意亦逸的博客
03-01 926
设计模式在Spring中的应用 设计模式的分类 总体来说设计模式分为三大类： 创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。 结构型模式，共七种：适配器模式、装饰器模式、代理模式、外观模式、桥接模式、组合模式、享元模式。 行为型模式，共十一种：策略模式、模板方法模式、观察者模式、迭代子模式、责任链模式、命令模式、备忘录模式、状态模式、访问者模式、中介者模式、解释器...
【设计模式】详解设计模式在Spring中的应用
keeper42的博客
01-28 255
spring中常用的设计模式达到九种，一一举例：第一种：简单工厂 又叫做静态工厂方法（StaticFactory Method）模式，但不属于23种GOF设计模式之一。 简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类。 spring中的BeanFactory就是简单工厂模式的体现，根据传入一个唯一的标识来获得bean对象，但是否是在传入参数后创建还是传入参数前创建这个要根据具体情况来定。如下配置，就是在 HelloItxxz 类中创建一个 itxxzBean。 <b..
Java经典面试题：Spring中用到了哪些设计模式？
Tom弹架构
09-21 1076
因为Bean的实例化包含原生对象的实例化，和代理对象的实例化，不同对象实例化的逻辑也不一样，所以实例化策略也不一样，比如SimpleInstantiationStrategy就是Spring中默认的实例化策略。当然，Spring是一个非常经典的框架，它用的的设计模式也非常多。主要用于当一个对象的状态发生改变时，所有依赖于它的对象都会得到通知，在Spring中一般以Listener结尾，比如ApplicationListener等等。在Spring，只要是以Adapter命名的类基本都是适配器模式的应用。
Spring框架中使用的设计模式及应用场景
最新发布
怀揣梦想，一颗执着于技术的心从未磨灭，内心住着一颗顽强的小强时刻提醒自己层层突破自我，同时也成就他人
03-23 333
加载资源文件的方式，使用了不同的方法，比如：ClassPathResource,FileSystemResource,ServletContextResource,UrlResource 但他们都有共同的接口Resource;在AOP的实现中，采用了两种不同的方式，JDK动态代理和CGLIB代理。Spring AOP 利用了Aspectj AOP实现的AspectJ AOP 的底层用了动态代理。在各种BeanFactory以及ApplicationContext实现中也都用到了。比如在创建bean到时候。
九种设计模式在Spring中的应用
拈花的专栏
02-27 1018
Spring中涉及的设计模式总结 1.简单工厂(非23种设计模式中的一种) 实现方式： BeanFactory。Spring中的BeanFactory就是简单工厂模式的体现，根据传入一个唯一的标识来获得Bean对象，但是否是在传入参数后创建还是传入参数前创建这个要根据具体情况来定。 实质： 由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类。 实现原理： bean容器的启动阶段...
惊呆面试官的回答：HashMap和TreeMap的区别
java1527的博客
09-13 2162
最后，我把HashMap和TreeMap的更多详细区别，都整理在这张表中了，需要的小伙伴可以在我的个人主页中获取。基础哈希图树状图DefinitionHashMap是基于哈希表的Map接口实现。TreeMap是Map接口的基于Tree结构的实现。HashMap实现Map, Cloneable和Serializable接口。TreeMap实现NavigableMap, Cloneable和Serializable接口。空键/值HashMap允许单个null键和多个null值。
设计模式及其在spring中的应用（含代码）
weixin_34293059的博客
11-02 227
  前一阶段我把spring的一些知识点回顾了一下，突然有个想法，把spring中用到的设计模式整理下，就有了这篇分享。   目前，整理了spring中应用到的8种设计模式（范围限定spring ioc和aop），分别是：单例、工厂方法、简单工厂方法、适配器、代理、观察者、策略、模板方法。   另外，对于设计模式，我之前也整理过一些，目前已经完成了简单工厂模式和23个gof设计模式中的15个，剩下...
韩顺平Java设计模式实战笔记：从面试题到应用解析
韩顺平的Java设计模式笔记是一份系统的学习资料，针对那些希望通过深度理解和实践掌握设计模式的人群。该笔记以韩顺平老师的23种设计模式讲解视频为引导，帮助读者巩固记忆，避免了初次学习后的遗忘。笔记内容丰富，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值