【韩老师设计模式5】适配器和桥接模式，类，对象，接口适配。自己实现springMvc适配器。JDBC桥接模式。

最新推荐文章于 2024-04-05 14:45:54 发布
最新推荐文章于 2024-04-05 14:45:54 发布
阅读量231 收藏
点赞数
分类专栏： java SE 文章标签： 设计模式 桥接模式 java 适配器模式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq120631157/article/details/125284855
版权

适桥 组装 外 享代

适配器

泰国插座用的是两孔的（欧标） ，可以买个多功能转换插头 (适配器) ，这样就可以
使用了

基本介绍

  1. 适配器模式(Adapter Pattern)将某个类的接口转换成客户端期望的另一个接口表
    示，主的目的是兼容性，让原本因接口不匹配不能一起工作的两个类可以协同
    工作。其别名为包装器(Wrapper)

  2. 适配器模式属于结构型模式

  3. 主要分为三类：类适配器模式、对象适配器模式、接口适配器模式

工作原理

  1. 适配器模式：将一个类的接口转换成另一种接口.让原本接口不兼容的类可以兼
    容

  2. 从用户的角度看不到被适配者，是解耦的

    1. A—> 适配器—>B， A是看不到B的

  3. 用户调用适配器转化出来的目标接口方法， 适配器再调用被适配者的相关接口
    方法

  4. 用户收到反馈结果，感觉只是和目标接口交互， 如图

1. 类适配器

基本介绍： Adapter类，通过继承 src类，实现 dst 类接口，完成src->dst的适配。
类适配器模式应用实例

  1. 应用实例说明
    以生活中充电器的例子来讲解适配器，充电器本身相当于Adapter， 220V交流电
    相当于src (即被适配者)， 我们的目dst(即 目标)是5V直流电

被适配器类

//被适配的类
public class Voltage220V {
	//输出220V的电压
	public int output220V() {
		int src = 220;
		System.out.println("电压=" + src + "伏");
		return src;
	}
}

适配接口

//适配接口
public interface IVoltage5V {
	public int output5V();
}

适配器类

//适配器类
public class VoltageAdapter extends Voltage220V implements IVoltage5V {

	@Override
	public int output5V() {
		int srcV = output220V();
		int dstV = srcV / 44 ; //转成 5v
		return dstV;
	}
}

使用 适配器接口

public class Phone {
	//充电
	public void charging(IVoltage5V iVoltage5V) {
		if(iVoltage5V.output5V() == 5) {
			System.out.println("电压为5V, 可以充电~~");
		}
	}
}

		Phone phone = new Phone();
		phone.charging(new VoltageAdapter());

类适配器模式注意事项和细节

  1. Java是单继承机制，所以类适配器需要继承src类这一点算是一个缺点, 因为这要
    求dst必须是接口，有一定局限性;

  2. src类的方法在Adapter中都会暴露出来，也增加了使用的成本。

  3. 由于其继承了src类，所以它可以根据需求重写src类的方法，使得Adapter的灵
    活性增强了。

2. 对象适配器

  1. 基本思路和类的适配器模式相同，只是将Adapter类作修改，不是继承src类，而
    是持有src类的实例，以解决兼容性的问题。 即：持有 src类，实现 dst 类接口，
    完成src->dst的适配

  2. 根据“合成复用原则”，在系统中尽量使用关联关系来替代继承关系。

  3. 对象适配器模式是适配器模式常用的一种

public class VoltageAdapter  implements IVoltage5V {

	private Voltage220V voltage220V; // 关联关系-聚合
	
	//通过构造器，传入一个 Voltage220V 实例
	public VoltageAdapter(Voltage220V voltage220v) {
		this.voltage220V = voltage220v;
	}

	@Override
	public int output5V() {
		int dst = 0;
		if(null != voltage220V) {
			int src = voltage220V.output220V();//获取220V 电压
			System.out.println("使用对象适配器，进行适配~~");
			dst = src / 44;
			System.out.println("适配完成，输出的电压为=" + dst);
		}
		return dst;
	}

}

		Phone phone = new Phone();
		phone.charging(new VoltageAdapter(new Voltage220V()));

对象适配器模式注意事项和细节

  1. 对象适配器和类适配器其实算是同一种思想，只不过实现方式不同。
    根据合成复用原则， 使用组合替代继承， 所以它解决了类适配器必须继承src的
    局限性问题，也不再要求dst必须是接口。

  2. 使用成本更低，更灵活。

3. 接口适配器

  1. 一些书籍称为：适配器模式(Default Adapter Pattern)或缺省适配器模式。

  2. 当不需要全部实现接口提供的方法时，可先设计一个抽象类实现接口，并为该接
    口中每个方法提供一个默认实现（空方法），那么该抽象类的子类可有选择地覆
    盖父类的某些方法来实现需求

  3. 适用于一个接口不想使用其所有的方法的情况。

接口 和 抽象类

public interface Interface4 {
	public void m1();
	public void m2();
}

//在AbsAdapter 我们将 Interface4 的方法进行默认实现
public abstract class AbsAdapter implements Interface4 {

	//默认实现
	public void m1() {

	}

	public void m2() {

	}
}

使用抽象类

		AbsAdapter absAdapter = new AbsAdapter() {
			//只需要去覆盖我们 需要使用 接口方法
			@Override
			public void m1() {
				System.out.println("使用了m1的方法");
			}
		};
		
		absAdapter.m1();


= m1()->{
 System.out.println("使用了m1的方法"); 
};

4. spring MVC

自己实现

4.1 controller 和 实现
//多种Controller实现  
public interface Controller {
}

class HttpController implements Controller {
	public void doHttpHandler() {
		System.out.println("http...");
	}
}

/*class SimpleController implements Controller {
	public void doSimplerHandler() {
		System.out.println("simple...");
	}
}

class AnnotationController implements Controller {
	public void doAnnotationHandler() {
		System.out.println("annotation...");
	}
}*/
4.2 适配器接口 和 实现
///定义一个Adapter接口 
public interface HandlerAdapter {
	public boolean supports(Object handler);

	public void handle(Object handler);
}

class HttpHandlerAdapter implements HandlerAdapter {
	//把对象 转为 HttpController，并调用 其接口
	public void handle(Object handler) {
		((HttpController) handler).doHttpHandler();
	}
    //如果是 HttpController ，就返回 true
	public boolean supports(Object handler) {
		return (handler instanceof HttpController);
	}
}

/*
// 多种适配器类
class SimpleHandlerAdapter implements HandlerAdapter {
	public void handle(Object handler) {
		((SimpleController) handler).doSimplerHandler();
	}
	public boolean supports(Object handler) {
		return (handler instanceof SimpleController);
	}
}
class AnnotationHandlerAdapter implements HandlerAdapter {
	public void handle(Object handler) {
		((AnnotationController) handler).doAnnotationHandler();
	}
	public boolean supports(Object handler) {
		return (handler instanceof AnnotationController);
	}
}*/
4.3 整合 适配器 和 Handler
public class DispatchServlet {
	//定义一个 list，放入 所有的 适配器
	public static List<HandlerAdapter> handlerAdapters = new ArrayList<HandlerAdapter>();

	public DispatchServlet() {
		//handlerAdapters.add(new AnnotationHandlerAdapter());
		handlerAdapters.add(new HttpHandlerAdapter());
		//handlerAdapters.add(new SimpleHandlerAdapter());
	}

	public void doDispatch() {

		// 此处模拟SpringMVC从request取handler的对象，
		// 适配器可以获取到希望的Controller
		 HttpController controller = new HttpController();
		//new AnnotationController();
		//new SimpleController();
        
        //1. 先根据请求（mvc里），拿到 controller。
        //mappedHandler = getHandler(processedRequest);
        
        //2. 在根据 controller 获取对象的 adapter
        //HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
        
        //3. 通过 adapter调用控制器里的方法
        //mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
        
        
		// 得到对应适配器
		HandlerAdapter adapter = getHandler(controller);
        
		// 通过适配器执行对应的controller对应方法
		adapter.handle(controller);

	}

	public HandlerAdapter getHandler(Controller controller) {
        
		//遍历：根据得到的controller(handler), 返回对应适配器
		for (HandlerAdapter adapter : this.handlerAdapters) {
            //handler instanceof HttpController 的话，返回 true
			if (adapter.supports(controller)) {
				return adapter;
			}
            
		}
		return null;
	}

	public static void main(String[] args) {
		new DispatchServlet().doDispatch(); // http...
	}

}

源码分析

SpringMvc中的HandlerAdapter, 就使用了适配器模式

处理器的类型不同，有多重实现方式，那么调用方式就不是确定的，

  • 如果需要直接调用Controller方法，需要调用的时候就得不断是使用if else来进行判断是哪一种子类然后执行。
  • 那么如果后面要扩展Controller，就得修改原来的代码，这样违背了OCP原则。

MVC流程

中央调度（DispatcherServlet） 控制器 是一个 servlet，

  • 所有的 请求都需要 经过它，在 web.xml
    • springMVC配置文件，这个文件 从形式 和 工作原理上 和 Spring 的 ioc容器文件类似
    • applicationContext-mvc.xml [类 struts.xml]

UserTest 普通类，加入 注解 @controller，就成为一个 控制器，

  • 在springmvc中 叫 Handler
  1. 浏览器组装好 参数（用户名 密码），请求 login
  2. 通过 HandlerMapping的处理，找到 用户希望请求的 Handler
    1. 即：DispatcherServlet 中的 doDispatch
  3. 执行 目标方法。适配器
  4. 访问一个结果，该 结果是 一个对象 ModelAndView
  5. 调用 Internal Resource View Resolver 来对 返回 ModelAndView进行解析，
    1. 就到指定的资源，该 对象 需要在 applicationContext-mvc.xml 配置
    2. 当然现在 肯定用 GetMapp这样注解
  6. Jsp 去执行 响应的代码
  7. 将 这个 字符串结果，给 tomcat，然后 tomcat对这个 字符串进行 包装
    1. 成 一个 静态的 html页面（字符串），返回给 浏览器。
  8. 浏览器 本身解析 返回 的 静态页面，并显示
整合流程类
  • 大体的流程
public class DispatcherServlet extends FrameworkServlet {
    
    //doDispatch方法
    
	// 通过HandlerMapping来映射Controller
	mappedHandler = getHandler(processedRequest);
    
	//获取适配器
	HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
    
	// 通过适配器调用controller的方法并返回ModelAndView
	mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
}
  • 详细的方法调用
public class DispatcherServlet extends FrameworkServlet {

	protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
		HttpServletRequest processedRequest = request;
		HandlerExecutionChain mappedHandler = null;
		boolean multipartRequestParsed = false;

		WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

			ModelAndView mv = null;
			Exception dispatchException = null;

				processedRequest = checkMultipart(request);
				multipartRequestParsed = (processedRequest != request);

				// Determine handler for the current request.
        		//根据请求，得到 一个 handler (控制器)
				mappedHandler = getHandler(processedRequest);
				if (mappedHandler == null) {
					noHandlerFound(processedRequest, response);
					return;
				}

				// Determine handler adapter for the current request.
        		//通过控制器，返回一个 适配器。不同的 hander 用不同的适配器
				HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());

				// Process last-modified header, if supported by the handler.
				String method = request.getMethod();
				boolean isGet = HttpMethod.GET.matches(method);
				if (isGet || HttpMethod.HEAD.matches(method)) {
					long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
					if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
						return;
					}
				}

        		// Actually invoke the handler.
       			//通过 适配器，调用 controller 的响应方法
				mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
	}
    
    //返回的 就是顶层适配器的 接口。如下，现在有有6个实现
    protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
		if (this.handlerAdapters != null) {
			for (HandlerAdapter adapter : this.handlerAdapters) {
                //调用的 是AbstractHandlerMethodAdapter
				if (adapter.supports(handler)) {
					return adapter;
				}
			}
		}
		throw new ServletException("No adapter for handler");
	}
}


public abstract class AbstractHandlerMethodAdapter extends WebContentGenerator implements HandlerAdapter, Ordered {
    
    	@Override
	public final boolean supports(Object handler) {
		return (handler instanceof HandlerMethod && supportsInternal((HandlerMethod) handler));
	}
    
}   


Abstract Handler Method Adapter

Annotation Method Handler Adapter
Http Request xx xx		有
Simple Controller xx xx	有
Simple Servlet xx xx	
    
Request Mapping xx xx 有 。自：3.1，现在都是用这个

this.handlerAdapters现在有 4个值

1. RequestMapping Handler Adapter
2. Handler Function Adapter		未知
3. Http Request Handler Adapter
4. Simple Controller Handler Adapter

RequestMappingHandlerMapping
顶层适配器接口
public interface HandlerAdapter {
    boolean supports(Object handler);

    @Nullable
    ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception;

}
各种适配器实现

HandlerAdapter 的实现子类 有多种

  • 使得每一种Controller有一种对应的适配器 实现类，
  • 每种 handler 有不同的实现方式
public class HttpRequestHandlerAdapter implements HandlerAdapter {
    public HttpRequestHandlerAdapter() {
    }

    public boolean supports(Object handler) {
        return handler instanceof HttpRequestHandler;
    }

    @Nullable
    public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        ((HttpRequestHandler)handler).handleRequest(request, response);
        return null;
    }   
}

注意事项和细节

  1. 三种命名方式，是根据 src是以怎样的形式给到Adapter（在Adapter里的形式）来
    命名的。

  2. 类适配器：以类给到，在Adapter里，就是将src当做类，继承
    对象适配器：以对象给到，在Adapter里，将src作为一个对象，持有
    接口适配器：以接口给到，在Adapter里，将src作为一个接口，实现

  3. Adapter模式最大的作用还是将原本不兼容的接口融合在一起工作。

  4. 实际开发中，实现起来不拘泥于我们讲解的三种经典形式

桥接模式

现在对不同手机类型的
不同品牌实现操作编程(比如:
开机、关机、上网，打电话等)，

手机

  • 折叠式
  • 直立式
  • 旋转式

华为 小米 Vivo 都有这三个款式

传统解决：

  • phone
    • 折叠
      • 华为 小米
    • 直立
      • 又有 华为 小米

在这里插入图片描述

传统方案解决手机操作问题分析

  1. 扩展性问题(类爆炸)， 如果我们再增加手机的样式(旋转式)，就需要增加各个品
    牌手机的类，同样如果我们增加一个手机品牌，也要在各个手机样式类下增加。

  2. 违反了单一职责原则，当我们增加手机样式时，要同时增加所有品牌的手机，这
    样增加了代码维护成本.

  3. 解决方案-使用桥接模式

基本介绍

  1. 桥接模式(Bridge模式)是指：将实现与抽象放在两个不同的类层次中，使两个层
    次可以独立改变。

  2. 是一种结构型设计模式

  3. Bridge模式基于类的最小设计原则，通过使用封装、聚合及继承等行为让不同
    的类承担不同的职责。它的主要特点是把抽象(Abstraction)与行为实现
    (Implementation)分离开来，从而可以保持各部分的独立性以及应对他们的功能
    扩展

  • client 调用抽象类 Abstraction (桥接类 和 下面接口 聚合关系，抽象类是调用者，接口是 被调用者)
    • 抽象类 聚合 接口 Implementtor （行为实现的接口）
      • 接口有 A ，B 两个实现 （行为的具体实现）
    • 抽象类 有子类的实现，RefinedAbstraction

接口 和 多个实现

//接口
public interface Brand {
	void open();
}

public class XiaoMi implements Brand {
	@Override
	public void open() {
		System.out.println(" 小米手机开机 ");
}

抽象类 和 多个实现

  • 桥
public abstract class Phone {
	
	//组合品牌
	private Brand brand;

	//构造器
	public Phone(Brand brand) {
		super();
		this.brand = brand;
	}
	
	protected void open() {
		this.brand.open();
	}
}
  • open找的 父类的 open，
    • 父类open是接口，
      • 最终的 实现是 接口的实现类
//折叠式手机类，继承 抽象类 Phone
public class FoldedPhone extends Phone {
	//构造器
	public FoldedPhone(Brand brand) {
		super(brand);
	}
	
	public void open() {
		super.open();
		System.out.println(" 折叠样式手机 ");
	}
}

		//获取折叠式手机 (样式 + 品牌 )
		Phone phone1 = new FoldedPhone(new XiaoMi());
		phone1.open();
  • 增加一个 样式写一个类
  • 增加一个 品牌写一个类

JDBC

桥接模式在JDBC的源码剖析

  1. Jdbc 的 Driver接口，如果从桥接模式来看， Driver就是一个接口，下面可以有
    MySQL的Driver， Oracle的Driver，这些就可以当做实现接口类
public class Driver extends NonRegisteringDriver implements
java.sql.Driver {
    
static {
    
    try {
        //1.注册驱动
        //2. 调用DriverManager中的getConnection
        DriverManager.registerDriver(new Driver());
    } catch (SQLException var1) {
    	throw new RuntimeException("Can't register driver!");
    }

	}//静态
}//类

public Driver() throws SQLException {
}

public class ConnectionImpl extends ConnectionPropertiesImpl 
    implements MySQLConnetion {
}
  • java.sql.Connection
    • com.mysql.jdbc.Connection 新接口废弃
      • MySQLConnection 新接口变成了 顶层
        • ConnectionImpl 具体的类，实现上面

现在是：把原来的4层关系，改为了3层。连接：Connection 和 MysqlConnection，增加了过渡层：JdbcConnection

  • java.sql.Connection
  • com.mysql.cj.MysqlConnection
    • interface JdbcConnection extends Connection, MysqlConnection
      • com.mysql.cj.jdbc.ConnectionImpl implements JdbcConnection

没有抽象类，直接用 DriverManager 桥接，拿到了 连接

  • getConnection ，根据注册的驱动 不一样，返回 不同的驱动
  • 依赖了 java.sql.Connection
  • client 使用 DriverManager

注意事项和细节

  1. 实现了抽象和实现部分的分离，从而极大的提供了系统的灵活性，让抽象部分和实
    现部分独立开来， 这有助于系统进行分层设计，从而产生更好的结构化系统。

  2. 对于系统的高层部分，只需要知道抽象部分和实现部分的接口就可以了，其它的部
    分由具体业务来完成。

  3. 桥接模式替代多层继承方案，可以减少子类的个数，降低系统的管理和维护成本。

  4. 桥接模式的引入增加了系统的理解和设计难度，由于聚合关联关系建立在抽象层，
    要求开发者针对抽象进行设计和编程

  5. 桥接模式要求正确识别出系统中两个独立变化的维度（抽象 和 实现），因此其使用范围有一定的局
    限性，即需要有这样的应用场景。

桥接模式其它应用场景

  1. 对于那些不希望使用继承或因为多层次继承导致系统类的个数急剧增加的系统，桥
    接模式尤为适用.

  2. 常见的应用场景:
    -JDBC驱动程序

  3. -银行转账系统
    转账分类: 网上转账，柜台转账， AMT转账
    转账用户类型：普通用户，银卡用户，金卡用户…

  4. -消息管理
    消息类型：即时消息，延时消息
    消息分类： 手机短信，邮件消息， QQ消息…

天海华兮
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SpringMVC适配器模式代码示例
08-28
SpringMVC适配器模式代码示例是一个非常重要的知识点，它可以帮助我们更好地理解 SpringMVC 框架的实现原理和设计模式。同时，这个示例也可以作为我们在实际项目中的参考，帮助我们更好地实现自己的 Controller 和...
MVC+DAO设计模式下的设计流程详解
08-28
我们需要设计DAO接口和实现类，例如，NewTableDAO接口和NewTableDAOImpl实现类。DAO层的设计首先是设计DAO的接口，然后在Spring的配置文件中定义此接口的实现类，然后就可以在模块中调用此接口来进行数据业务的处理...
桥接模式
一小步一大步的博客
01-18 1057
桥接（Bridge）是用于把抽象化与实现化解耦，使得二者可以独立变化。它是用组合关系代替继承关系来实现，从而降低了抽象和实现这两个可变维度的耦合度。 意图：将抽象部分与实现部分分离，使它们都可以独立的变化。 主要解决：在有多种可能会变化的情况下，用继承会造成类爆炸问题，扩展起来不灵活。 何时使用：实现系统可能有多个角度分类，每一种角度都可能变化。 如何解决：把这种多角度分类分离出来，让它们...
设计模式—（适配器模式）（桥接模式）
qq_45688193的博客
07-27 254
例子手机里面很多样式，有开机关机方法，为了方便，创建一个Brand接口写入手机的方法，创建手机品牌类继承Brand接口实现开机关机等方法，后创建一个Phone手机抽象类在里面创建一个Brand品牌对象创建构造器传入，调用Brand开机关机等方法，创建Phone类的子类（折叠屏，翻转屏）继承Phone实现父类的有参构造调用方法实际上是调用父类Phone的方法，Phone里面的方法是调用的Brand的方法。Phone就是那个桥。写一个适配器，因为java是单继承所以它需要继承V220类，并实现IV5的接口。..
解锁Spring Boot中的设计模式—04.桥接模式：探索【桥接模式】的奥秘与应用实践！
q1372302825的博客
02-17 1330
桥接模式也称为桥梁模式、接口模式或者柄体（Handle and Body）模式，是将与他的，使它们都可以独立地变化，通过的方式两个类之间的，而不是继承。桥接模式是一种结构型设计模式，旨在将抽象部分与实现部分分离，使它们可以独立地变化。这种模式通过使用组合而不是继承的方式，可以更灵活地组织和管理代码。
设计模式 —— 桥接模式
Woo_home的博客
03-13 1377
文章目录桥接模式基本介绍代码实现桥接模式的注意事项和细节 桥接模式 基本介绍 桥接模式是指：将实现与抽象放在两个不同的类层次中，使得两个层次可以独立改变 是一种结构型设计模式 Bridge 模式基于 类的最小设计原则，通过使用封装、聚合以及继承等行为让不同的类承担不同的职责。它的主要特点是把抽象（Abstraction）与行为实现（Implementation）分离开来，从而可以保持各个部分的独...
SpringMVC体系分层模式原理图解
08-19
SpringMVC体系分层模式原理图解 标题：SpringMVC体系分层...本文主要介绍了SpringMVC体系分层模式原理图解，通过示例代码详细介绍了MVC模式和SpringMVC的实现原理，为大家的学习或者工作提供了一定的参考学习价值。
spring MVC设计模式理念讲解
04-27
针对spring mvc设计模式中的概念性知识点进行简单易懂的讲解
用户信息管理系统，采用servlet+mysql+jdbc技术和借助springMVC开发模式.zip
07-24
用户信息管理系统是一个典型的Java Web应用，它利用了Servlet、MySQL数据库和JDBC技术，并结合SpringMVC框架进行开发。这个项目对于学习者来说，尤其适用于毕业设计或课程设计作业，因为它涵盖了Web开发中的核心概念...
springboot中的桥接模式+装饰器模式
qq_21277357的博客
08-10 419
springboot中的桥接模式
SpringBoot中的桥接模式
econg的博客
11-11 2050
桥接模式是一种结构型设计模式，它的主要目的是通过将抽象部分与实现部分分离，提高系统的灵活性和可扩展性。在桥接模式中，有四个主要参与者：抽象类、具体抽象类、桥接类和具体类。
设计模式之Bridge模式(桥接模式)
qq_44964202的博客
05-16 707
这几天重新去看spring系列的框架了（也又次体会到了理解设计模式在学习框架时的好处），没有接着写，发生了一些事，又少了些许束缚，但结果对向往自由的我来说总是好的，虎入山林，龙归沧海，听听音乐，整理整理博客。 书上的介绍比较简单，抽象，又看了一些其他东西才理解了一些。首先来介绍一下类的两个层次结构：功能层次结构和实现层次结构。 所谓功能层次结构，我们现在有一个类ActionSomething，想在它上面拓展新的功能，直接的方法就是继承他，添加一个派生类ActionSomethingGood，如果再想拓展功能
桥接模式简单使用
Must_Do的博客
01-22 743
前言 桥接模式也称为桥梁模式，属于结构型设计模式。名如其名，桥梁模式就是连接没有关系的两个地，起到连接两边的作用，换点技术性语言，桥接模式就是将抽象部分和实现部分分离，使它们都可以独立进行变化，这个桥梁也就是连接抽象和实现部分了。 适用 任何多维变化类，亦或是多个树状类之间的耦合都可以用桥接模式来解耦。 UML角色 ABStraction：抽象部分，该类保持一个对实现部分的引用，
重读Java设计模式: 桥接模式详解
最新发布
MarkusZhang的博客
04-05 1158
在软件开发中，经常会遇到需要在抽象与实现之间建立连接的情况。当系统需要支持多个维度的变化时，使用传统的继承方式往往会导致类爆炸和耦合度增加的问题。为了解决这一问题，我们可以使用桥接模式。桥接模式是一种结构型设计模式，它将抽象部分与其实现部分分离，使它们可以独立地变化。本文将深入探讨桥接模式的概念、应用场景以及在实际项目中的实现方式。
SpringMVC模式
Tz1039的博客
09-21 106
SpringMVC 配置文件web.xml <?xml version="1.0" encoding="UTF-8"?> <web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://java.sun.com/xml/ns/javaee" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://ja
设计模式-----适配器&&桥接模式
LCYOKO的博客
06-21 168
1适配器模式 1将目标类和适配者类解耦，通过引入一个适配器类来重用现有的适配者类，无须修改原有结构。 2增加了类的透明性和复用性，将具体的业务实现过程封装在适配者类中，对于客户端类而言是透明的，而且提高了适配者的复用性，同一个适配者类可以在多个不同的系统中复用。 3灵活性和扩展性都非常好，通过使用配置文件，可以很方便地更换适配器，也可以在不修改原有代码的基础上增加新的适配器类，完全符合“开闭原则”。 在SpringMVC中可以是进行解耦 获取适配器 处理请求 ...
springMVC适配器设计模式
08-17
适配器模式旨在将不同接口的类进行适配，使其能够协同工作。 在 Spring MVC 中，适配器模式的设计思想是将不同类型的处理器（Handler）适配成统一的处理接口，以便框架能够统一处理它们。适配器模式的角色如下： 1...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值