<?xml version="1.0" encoding="utf-8" standalone="yes"?>
<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom" xmlns:content="http://purl.org/rss/1.0/modules/content/">
  <channel>
    <title>架构设计 on 极客老墨</title>
    <link>https://blog.hankmo.com/categories/%E6%9E%B6%E6%9E%84%E8%AE%BE%E8%AE%A1/</link>
    <description>Recent content in 架构设计 on 极客老墨</description>
    <generator>Hugo -- 0.138.0</generator>
    <language>zh-cn</language>
    <lastBuildDate>Mon, 17 Jan 2022 00:00:00 +0000</lastBuildDate>
    <atom:link href="https://blog.hankmo.com/categories/%E6%9E%B6%E6%9E%84%E8%AE%BE%E8%AE%A1/index.xml" rel="self" type="application/rss+xml" />
    <item>
      <title>Java设计模式(24)-职责链模式</title>
      <link>https://blog.hankmo.com/posts/architecture/java-chainofresp-pattern/</link>
      <pubDate>Mon, 17 Jan 2022 00:00:00 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/architecture/java-chainofresp-pattern/</guid>
      <description>您有没有遇到各种需要走流程的事情？比如，请假申请，假设公司规定，3天以内的请假申请组长可以直接审批，而4到7天的请假申请必须要让部门经理来审批了，超过7天的请假申请只能由公司总经理来审批。类似的场景还有很多，尤其在工作流中，比如物资审批、报账审批、资金审批等等……</description>
    </item>
    <item>
      <title>Java设计模式(23)-备忘录模式</title>
      <link>https://blog.hankmo.com/posts/architecture/java-memento-pattern/</link>
      <pubDate>Wed, 12 Jan 2022 00:00:00 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/architecture/java-memento-pattern/</guid>
      <description>中国有句古话：&amp;#34;千金难买后悔药&amp;#34;。生活中很多时候，我们做过了的事情，虽然后悔，却无济于事。但是，在软件世界，我们却可以自己制作&amp;#34;后悔药&amp;#34;。比如，以前玩&amp;#34;仙剑&amp;#34;，每每遇到Boss战，那必须要存档的，就算没打过也可以恢复存档再来一次，否则，玩过的人都知道，哭去吧……这里的游戏存档，就会用到今天说的——备忘录模式。</description>
    </item>
    <item>
      <title>Java设计模式(22)-迭代器模式</title>
      <link>https://blog.hankmo.com/posts/architecture/java-iterator-pattern/</link>
      <pubDate>Tue, 11 Jan 2022 00:00:00 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/architecture/java-iterator-pattern/</guid>
      <description>生活中，存在这样的场景：需要逐个遍历一堆对象，然后判断对象是否符合要求，做出相应的处理。例如，乘火车时，检票员站在门口挨个检票，没有买票的人不能乘车。类似的场景还有很多，比如乘地铁、乘公交、从书架上找书、食堂排队打饭等等…… 我们把需要逐个遍历的这一堆对象称为对象集合，把挨个遍历的过程称为迭代。迭代时，如果能将迭代过程从对象集合中抽取出来单独实现，让对象集合只负责管理自身状态，而不用负担迭代的任务，这就减轻了对象集合的职责，这就是今天要说的——迭代器模式。</description>
    </item>
    <item>
      <title>Java设计模式(21)-中介者模式</title>
      <link>https://blog.hankmo.com/posts/architecture/java-mediator-pattern/</link>
      <pubDate>Sat, 08 Jan 2022 00:00:00 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/architecture/java-mediator-pattern/</guid>
      <description>如果您有租房的经历，那么您对中介并不陌生。租房时，我们先去房屋租赁中介登记，告诉它您的租房需求，然后中介会按照您的要求为您筛选适合的房子。房子确定后，您会与中介签订租赁合同，缴纳费用，然后拿到钥匙……整个过程中，所有事项都由中介一手包办，入住以后房屋有任何问题，您都直接去找中介，您甚至可能并不知道房东是谁。这就是我们今天要说的模式——中介者模式。</description>
    </item>
    <item>
      <title>Java设计模式(20)-观察者模式</title>
      <link>https://blog.hankmo.com/posts/architecture/java-observer-pattern/</link>
      <pubDate>Thu, 06 Jan 2022 00:00:00 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/architecture/java-observer-pattern/</guid>
      <description>很快又到年底了，一年一度的春节除了可以享受愉快地享受假期之外，每年的&amp;#34;春节联欢晚会&amp;#34;也是让人倍感期待。然而，大多数人都没能坐在电视机跟前等着它的开始，有的人在厨房忙着准备丰富的食物，有的在一起打麻将、玩牌，还有的可能在玩电脑游戏……大家都想看晚会，于是派出一个小朋友，告诉他：&amp;#34;如果晚会开始了，你要立刻来通知我们哦！&amp;#34;虽然，大家就可以继续做自己的事情，小朋友就坐在电视跟前，当晚会开始的时候，他就立即跑去挨个通知大家……</description>
    </item>
    <item>
      <title>Java设计模式(19)-状态模式</title>
      <link>https://blog.hankmo.com/posts/architecture/java-state-pattern/</link>
      <pubDate>Tue, 22 Jun 2021 00:00:00 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/architecture/java-state-pattern/</guid>
      <description>状态模式建议为对象的所有可能状态新建一个类， 然后将所有状态的对应行为抽取到这些类中。当控制一个对象的状态转换条件过于复杂时，就可以将判断逻辑转移到状态类中，以简化复杂的判断逻辑。</description>
    </item>
    <item>
      <title>Java设计模式(18)-命令模式</title>
      <link>https://blog.hankmo.com/posts/architecture/java-command-pattern/</link>
      <pubDate>Mon, 14 Jun 2021 00:00:00 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/architecture/java-command-pattern/</guid>
      <description>命令模式的定义：将一个请求封装为一个对象，从而可以用不同的请求对客户进行参数化，并且可以对请求排队或记录日志，还支持可以撤销的操作。</description>
    </item>
    <item>
      <title>Java设计模式(17)-策略模式</title>
      <link>https://blog.hankmo.com/posts/architecture/java-strategy-pattern/</link>
      <pubDate>Mon, 07 Jun 2021 00:00:00 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/architecture/java-strategy-pattern/</guid>
      <description>策略模式(Strategy Pattern)，定义了一系列算法，并将他们封装起来，让他们之间可以相互替换，并且不影响使用这些算法的客户。</description>
    </item>
    <item>
      <title>Java设计模式(16)-模板方法模式</title>
      <link>https://blog.hankmo.com/posts/architecture/java-template-method-pattern/</link>
      <pubDate>Thu, 27 May 2021 00:00:00 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/architecture/java-template-method-pattern/</guid>
      <description>模板方法模式，其核心思想是：定义一个操作中的算法骨架，而将算法的一些步骤延迟到子类中，使得子类可以不改变该算法结构的情况下重定义该算法的某些特定步骤。</description>
    </item>
    <item>
      <title>Java设计模式(15)-代理模式</title>
      <link>https://blog.hankmo.com/posts/architecture/java-proxy-pattern/</link>
      <pubDate>Thu, 31 Dec 2020 00:00:00 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/architecture/java-proxy-pattern/</guid>
      <description>什么是代理？代理就是中介，它提供与服务提供方相同或者相似的功能，客户不再直接面对服务提供方，而是先找代理，再由代理去与服务提供方交互完成功能。现实生活中，有很多代理的例子，比如前边提到的外卖订餐，外卖小哥就是一个代理角色；又如，购买火车票，火车票代售点就是一个代理角色，用户直接可以去代售点购买车票；再如，各种中介所，如婚姻中介所、房产中介等等，都是代理。</description>
    </item>
    <item>
      <title>Java设计模式(14)-享元模式</title>
      <link>https://blog.hankmo.com/posts/architecture/java-flyweight-pattern/</link>
      <pubDate>Mon, 21 Dec 2020 00:00:00 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/architecture/java-flyweight-pattern/</guid>
      <description>享元模式，&amp;#34;享&amp;#34;即共享，&amp;#34;元&amp;#34;即元素，软件中则为对象，享元就是共享对象之意。这种设计模式用来共享对象而不是大量创建对象，以节约系统资源。</description>
    </item>
    <item>
      <title>Java设计模式(13)-外观模式</title>
      <link>https://blog.hankmo.com/posts/architecture/java-facade-pattern/</link>
      <pubDate>Tue, 08 Dec 2020 00:00:00 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/architecture/java-facade-pattern/</guid>
      <description>外观模式（Facade Pattern），也叫门面模式，是一种经常被使用的结构性设计模式。DP对其定义如下：通过为多个复杂的子系统提供一个一致的接口，而使这些子系统更加容易被访问。</description>
    </item>
    <item>
      <title>Java设计模式(12)-组合模式</title>
      <link>https://blog.hankmo.com/posts/architecture/java-composite-pattern/</link>
      <pubDate>Mon, 07 Dec 2020 00:00:00 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/architecture/java-composite-pattern/</guid>
      <description>组合模式（Composite Pattern），将对象组合成树形结构以表示**&amp;#34;部分-整体&amp;#34;**的层次结构，使得用户对单个对象和组合对象的使用具有一致性。</description>
    </item>
    <item>
      <title>Java设计模式(11)-装饰模式</title>
      <link>https://blog.hankmo.com/posts/architecture/java-decorator-pattern/</link>
      <pubDate>Thu, 05 Nov 2020 00:00:00 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/architecture/java-decorator-pattern/</guid>
      <description>在不改变现有对象结构的情况下，动态地给该对象增加一些职责（即增加其额外功能）的模式称为装饰模式。装饰模式属于一种结构型模式，它比继承更灵活。</description>
    </item>
    <item>
      <title>Java设计模式(10)-桥接模式</title>
      <link>https://blog.hankmo.com/posts/architecture/java-bridge-pattern/</link>
      <pubDate>Wed, 04 Nov 2020 00:00:00 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/architecture/java-bridge-pattern/</guid>
      <description>桥接模式（Bridge Pattern）的定义如下：将抽象部分与它的实现部分分离，使他们都可以独立变化。抽象化角色、实现化角色将桥接模式结构分为两个部分：抽象部分由抽象化角色作为父类，实现部分由实现化角色为父类。然后抽象化角色依赖了实现化角色，中间的依赖线类似一座桥梁，很形象的说明了桥接模式的命名由来。</description>
    </item>
    <item>
      <title>Java设计模式(9)-适配器模式</title>
      <link>https://blog.hankmo.com/posts/architecture/java-adapter-pattern/</link>
      <pubDate>Mon, 24 Aug 2020 00:00:00 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/architecture/java-adapter-pattern/</guid>
      <description>模式来源于生活，适配器模式最能直观的体现这一点。适配器，就是将多个原本不能共同工作的产品经过一定的处理，使得他们能够彼此协同工作的一种装置。</description>
    </item>
    <item>
      <title>Java设计模式(8)-建造者模式</title>
      <link>https://blog.hankmo.com/posts/architecture/java-builder-pattern/</link>
      <pubDate>Sun, 23 Aug 2020 00:00:00 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/architecture/java-builder-pattern/</guid>
      <description>建造者模式（Builder Pattern），旨在解决复杂对象的创建过程，将对象与其创建过程分离，通过相同的创建过程创建多种不同的对象。</description>
    </item>
    <item>
      <title>Java设计模式(7)-原型模式</title>
      <link>https://blog.hankmo.com/posts/architecture/java-prototype-pattern/</link>
      <pubDate>Wed, 15 Jul 2020 00:00:00 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/architecture/java-prototype-pattern/</guid>
      <description>某些情况下，我们需要重复的创建多个对象，但是这些对象仅仅只有某几个属性不一致，大部分的信息都是相同的，如果使用传统的构造函数来创建对象，我们需要不断的实例化对象，并且反复调用属性的set方法来设置值，而这些值大多都是相同的。有没有一种模式，能够快速而高效的创建这些差别不大的对象呢？这就需要使用到原型模式。</description>
    </item>
    <item>
      <title>Java设计模式(6)-抽象工厂模式</title>
      <link>https://blog.hankmo.com/posts/architecture/java-abstract-factory-pattern/</link>
      <pubDate>Tue, 09 Jun 2020 00:00:00 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/architecture/java-abstract-factory-pattern/</guid>
      <description>如果工厂模式中需要生产多种类型的产品，那么工厂方法模式就适合了，需要用到抽象工厂模式。</description>
    </item>
    <item>
      <title>Java设计模式(5)-工厂方法模式</title>
      <link>https://blog.hankmo.com/posts/architecture/java-factory-method-pattern/</link>
      <pubDate>Sat, 06 Jun 2020 00:00:00 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/architecture/java-factory-method-pattern/</guid>
      <description>工厂方法模式，是工厂模式的一种，它对简单工厂模式进行进一步抽象化。它将工厂和产品进行抽象，抽象出来的工厂负责定义创建产品的规范，而抽象的产品负责定义产品规范，然后通过具体的工厂实现类来创建具体的产品。</description>
    </item>
    <item>
      <title>Java设计模式(4)-简单工厂模式</title>
      <link>https://blog.hankmo.com/posts/architecture/java-simple-factory-pattern/</link>
      <pubDate>Fri, 05 Jun 2020 00:00:00 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/architecture/java-simple-factory-pattern/</guid>
      <description>工厂模式，一般分为三种，包括：简单工厂模式（也叫静态工厂模式）、工厂方法模式、抽象工厂模式。在GOF提及的23中设计模式中，没有简单工厂模式，但对于简单的软件开发中，简单工厂模式使用的还是很普遍的。</description>
    </item>
    <item>
      <title>Java设计模式(3)-单例模式</title>
      <link>https://blog.hankmo.com/posts/architecture/java-singleton-pattern/</link>
      <pubDate>Fri, 29 May 2020 00:00:00 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/architecture/java-singleton-pattern/</guid>
      <description>单例模式，Java中最简单的设计模式之一，它定义了如何在整个系统范围内仅创建只有单个实例的类。单例模式是一种创建型模式，系统中的类只有一个实例，该类负责自己创建自身的唯一单个实例，并提供一个静态方法来获取自身实例。</description>
    </item>
    <item>
      <title>Java设计模式(2)-软件设计遵循的七大原则</title>
      <link>https://blog.hankmo.com/posts/architecture/seven-principles-for-software-design/</link>
      <pubDate>Wed, 27 May 2020 00:00:00 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/architecture/seven-principles-for-software-design/</guid>
      <description>设计模式为面向对象软件设计的前进道路照亮了明灯，而设计模式遵循面向对象软件设计的七大原则，这些原则也是设计模式的基础。</description>
    </item>
    <item>
      <title>Java设计模式(1)-什么是设计模式?</title>
      <link>https://blog.hankmo.com/posts/architecture/what-is-designpattern/</link>
      <pubDate>Tue, 26 May 2020 00:00:00 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/architecture/what-is-designpattern/</guid>
      <description>什么是设计模式？顾名思义，设计模式是一种软件设计所使用的方法，适用于面向对象软件设计。设计模式是一种方法，或者说是一种方法论，它是软件前辈们经历了无数的软件工程设计中的痛点和教训之后，总结出来的经验的结晶。设计模式是一种软件设计方法，不是代码，也不是规范。</description>
    </item>
    <item>
      <title>微服务架构的理论基础 - 康威定律</title>
      <link>https://blog.hankmo.com/posts/architecture/microservice-conways-law/</link>
      <pubDate>Tue, 29 May 2018 20:06:22 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/architecture/microservice-conways-law/</guid>
      <description>可能出乎很多人意料之外的一个事实是，微服务很多核心理念其实在半个世纪前的一篇文章中就被阐述过了，而且这篇文章中的很多论点在软件开发飞速发展的这半个世纪中竟然一再被验证，这就是康威定律。</description>
    </item>
    <item>
      <title>什么是微服务架构</title>
      <link>https://blog.hankmo.com/posts/architecture/what-is-microservice/</link>
      <pubDate>Tue, 29 May 2018 10:18:23 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/architecture/what-is-microservice/</guid>
      <description>微服务架构风格是一种将一个单一应用程序开发为一组小型服务的方法，每个服务运行在自己的进程中，服务间通信采用轻量级通信机制(通常用HTTP资源API)。这些服务围绕业务能力构建并且可通过全自动部署机制独立部署。这些服务共用一个最小型的集中式的管理，服务可用不同的语言开发，使用不同的数据存储技术。</description>
    </item>
  </channel>
</rss>
