<?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>Java on 极客老墨</title>
    <link>https://blog.hankmo.com/categories/java/</link>
    <description>Recent content in Java 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/java/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反射之AnnotatedType接口</title>
      <link>https://blog.hankmo.com/posts/tech/reflect-annotated-type/</link>
      <pubDate>Thu, 25 Nov 2021 00:00:00 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/tech/reflect-annotated-type/</guid>
      <description>JDK1.8注解可以标注在任何类型上，获取注解的方式也随之扩展了。AnnotatedType 接口的目的在于获取泛型类型上的注解，包括泛型参数、通配符、上下边界等，前提是目标元素声明了泛型类型并且标注了注解，否则其 getType 方法将返回原始类型。</description>
    </item>
    <item>
      <title>Java反射之获取注解的AnnotatedElement接口</title>
      <link>https://blog.hankmo.com/posts/tech/annotated-element/</link>
      <pubDate>Sun, 21 Nov 2021 00:00:00 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/tech/annotated-element/</guid>
      <description>AnnotatedElement接口是用于反射获取注解的顶层接口，其api获取的注解与注解的存在形式息息相关，注解有四中存在形式：直接存在、间接存在、存在和关联。这几种注解存在的形式的出现原因，一方面是由于注解可以通过继承关系传递，另一方面是Java提供了定义可重复注解的功能。</description>
    </item>
    <item>
      <title>Java反射之获取泛型类定义的具体类型</title>
      <link>https://blog.hankmo.com/posts/tech/generic-actualtype/</link>
      <pubDate>Mon, 15 Nov 2021 00:00:00 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/tech/generic-actualtype/</guid>
      <description>很多时候，我们需要获取到泛型类上定义的具体类型，从而完成一些业务逻辑。比如，最常见的情景就是JSON的反序列化，需要将JSON字符串反序列化为泛型的具体类型，比如反序列化为 `List&amp;lt;User&amp;gt;`，这就要求每一个 `List` 中的元素都是 `User` 对象。那么，如何获取到泛型类上定义的具体类型呢？这就是本文要阐述的内容。</description>
    </item>
    <item>
      <title>Java反射之表示所有类型的Type接口</title>
      <link>https://blog.hankmo.com/posts/tech/type-components/</link>
      <pubDate>Sun, 14 Nov 2021 00:00:00 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/tech/type-components/</guid>
      <description>Type接口是JDK1.5新增的表示Java所有类型的接口，它有5个组件，除了Java的类、接口的原始类型可以用Class来描述，其他的几个组件都是用来描述泛型类型的，分别是描述整个泛型的ParameterizedType、描述泛型类型变量的TypeVariable、描述泛型通配符的WildcardType，以及描述泛型数组的GenericArrayType。</description>
    </item>
    <item>
      <title>Java反射之创建泛型数组</title>
      <link>https://blog.hankmo.com/posts/tech/reflect-generic-array/</link>
      <pubDate>Wed, 10 Nov 2021 00:00:00 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/tech/reflect-generic-array/</guid>
      <description>泛型是编译期特性，我们能否创建泛型数组呢？通过 `Array` 类，除了可以动态的获取和设置数组的元素，还可以动态创建类型安全的数组。</description>
    </item>
    <item>
      <title>Java反射的体系结构</title>
      <link>https://blog.hankmo.com/posts/tech/reflect-class/</link>
      <pubDate>Tue, 09 Nov 2021 11:15:48 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/tech/reflect-class/</guid>
      <description>反射是JDK5推出的非常重要的特性，通过反射，开发者可以在运行时动态的创建类实例，获取、更改、调用类的相关信息、方法等。反射也是各大框架使用的主要技术，如知名的Spring framework框架。</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>Spring扩展原理</title>
      <link>https://blog.hankmo.com/posts/tech/spring-extension/</link>
      <pubDate>Wed, 12 Aug 2020 00:00:00 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/tech/spring-extension/</guid>
      <description>Spring Bean后置处理器用于bean创建对象初始化前后进行拦截工作，因此它是spring容器扩展必不可少的组件。</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>给Spring中注册Bean的几种方式</title>
      <link>https://blog.hankmo.com/posts/tech/methods-to-add-beans-to-spring/</link>
      <pubDate>Thu, 07 May 2020 00:00:00 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/tech/methods-to-add-beans-to-spring/</guid>
      <description>给Spring中添加Bean的这些方式，你都弄明白了吗？</description>
    </item>
    <item>
      <title>Spring IoC容器实现原理</title>
      <link>https://blog.hankmo.com/posts/tech/spring-ioc-container/</link>
      <pubDate>Wed, 08 Apr 2020 00:00:00 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/tech/spring-ioc-container/</guid>
      <description>IOC容器两个核心的接口为 BeanFacotry 和 ApplicationContext，前者提供容器管理Bean的基本功能，后者则扩展 BeanFactory，提供了容器级的强大功能，如国际化支持、资源加载、事件、应用上下文环境等。</description>
    </item>
    <item>
      <title>Spring Bean自动扫描原理</title>
      <link>https://blog.hankmo.com/posts/tech/spring-component-auto-scan/</link>
      <pubDate>Tue, 10 Mar 2020 00:00:00 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/tech/spring-component-auto-scan/</guid>
      <description>Spring 基于注解的Bean自动扫描是由后置处理器 `ConfigurationClassPostProcessor` 来实现的，本篇将讨论Spring自动扫描的原理。</description>
    </item>
    <item>
      <title>Spring IoC容器启动过程</title>
      <link>https://blog.hankmo.com/posts/tech/spring-ioc-start/</link>
      <pubDate>Thu, 06 Feb 2020 00:00:00 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/tech/spring-ioc-start/</guid>
      <description>Spring容器启动过程非常复杂，但是其核心流程都离不开 refresh 方法，所以该方法是spring最重要的一个方法，本文讨论spring容器的启动过程。</description>
    </item>
    <item>
      <title>使用Springboot开发websocket程序(四)——使用RabbitMQ作为STOMP消息代理</title>
      <link>https://blog.hankmo.com/posts/tech/springboot-websocket-chatroom-with-rabbitmq/</link>
      <pubDate>Tue, 12 Nov 2019 18:13:24 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/tech/springboot-websocket-chatroom-with-rabbitmq/</guid>
      <description>基于内存的stomp消息代理能够满足单应用需求，引入外部stomp消息代理解决了多应用之间的websocket消息传递需求。不同的消息中间件，都会按照stomp规范定义自身的destination支持。开发者需要明白两个点：订阅者订阅了什么destination，发送者发送到什么destination，这两个地址的匹配规则是什么。</description>
    </item>
    <item>
      <title>使用Springboot开发websocket程序(三)——基于子协议STOMP的web聊天室</title>
      <link>https://blog.hankmo.com/posts/tech/springboot-websocket-chatroom-with-stomp/</link>
      <pubDate>Sat, 02 Nov 2019 14:36:19 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/tech/springboot-websocket-chatroom-with-stomp/</guid>
      <description>WebSocket RFC定义了子协议的使用规范。在握手阶段，客户端和服务端使用Sec-WebSocket-Protocol请求头来通知彼此使用子协议，即更高级的、应用级的协议。当然，也可以不使用子协议，但是客户端和服务端仍然需要定义消息的格式。使用更规范的通用消息协议，更能让应用程序开发和维护变得简单。STOMP就是这样的一个消息协议，Spring框架提供了对其的支持。</description>
    </item>
    <item>
      <title>使用Springboot开发websocket程序(二)——基于原生websocket的web聊天室</title>
      <link>https://blog.hankmo.com/posts/tech/springboot-websocket-chatroom/</link>
      <pubDate>Fri, 01 Nov 2019 16:22:25 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/tech/springboot-websocket-chatroom/</guid>
      <description>websocket是一种由HTML5定义的浏览器和服务器保持长连接的通信协议，可以进行实时数据交换。WebSocket客户端除了支持Html5的浏览器外，还包括各大语言提供的WebSocket实现，比如Java中Spring框架的实现，从而在没有浏览器时也能进行websocket通信。HTML5中WebSocket API请看这里。服务端中，Java定义Java WebSocket API标准 JSR-356，Java主流容器都已经支持websocket。</description>
    </item>
    <item>
      <title>使用Springboot开发websocket程序(一)——什么是websocket</title>
      <link>https://blog.hankmo.com/posts/tech/springboot-websocket-intro/</link>
      <pubDate>Fri, 01 Nov 2019 11:51:49 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/tech/springboot-websocket-intro/</guid>
      <description>在互联网飞速发展的当代，浏览器和服务器之间的实时通信已经越来越重要，传统的HTTP协议难以解决实时通信的需求。因此，由HTML5定义的websocket协议应运而生。WebSocket是HTML5定义的浏览器与服务器实时通信的协议，它基于HTTP协议来完成与服务器的握手。目前，主流浏览器都已经支持websocket，如果浏览器不支持，也可以使用SocketJS来模拟websocket的API。WebSocket已经被广泛应用在网页游戏、视频直播、电商等等场景。</description>
    </item>
    <item>
      <title>SpringBoot自定义日志配置</title>
      <link>https://blog.hankmo.com/posts/tech/springboot-custom-log/</link>
      <pubDate>Fri, 06 Sep 2019 18:41:26 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/tech/springboot-custom-log/</guid>
      <description>当系统出现问题时，先从表现分析问题远远不够，要快速、准确地分析并定位问题原因，日志就是一个非常重要且必不可少的手段。Java而言，日志框架有很多，常用的有Common-logging、Java自带的Logging、Log4J、Logback等。另外，还有一个Slf4J的框架，主要目的是将这些框架进行整合。</description>
    </item>
    <item>
      <title>Spring AMQP消息转换</title>
      <link>https://blog.hankmo.com/posts/tech/spring-amqp-message-convert/</link>
      <pubDate>Mon, 17 Jun 2019 17:35:15 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/tech/spring-amqp-message-convert/</guid>
      <description>们介绍了如果使用Spring AMQP注解来实现消息发送和监听，示例都是使用的默认的消息转换器，即SimpleMessageConverter，它只能处理byte[]、String、java序列化对象(实现了Serializable接口的对象)。通常，不推荐使用Java序列化，因为它存在与Java对象强耦合、依赖java语言等缺点，Spring AMQP也提供了其他的消息转换方式，在本篇，我们将重点来看看如果将消息序列化为JSON格式。</description>
    </item>
    <item>
      <title>Spring AMQP注解的使用</title>
      <link>https://blog.hankmo.com/posts/tech/spring-amqp-guide-by-annotation/</link>
      <pubDate>Thu, 13 Jun 2019 17:15:31 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/tech/spring-amqp-guide-by-annotation/</guid>
      <description>上一篇 Spring AMQP简介和使用，我们介绍了Spring AMQP的一些基本要素和概念，也通过一些示例代码介绍了消息的发送和接收，但是都是使用的原始编码方式来实现，并不依赖Spring环境。其实，Spring AMQP也支持使用注解的方式来进行异步接收消息，极大的简化了编码。要使用注解，首先需要在Spring应用环境中。</description>
    </item>
    <item>
      <title>Spring AMQP简介和使用</title>
      <link>https://blog.hankmo.com/posts/tech/spring-amqp-intro/</link>
      <pubDate>Wed, 05 Jun 2019 09:42:47 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/tech/spring-amqp-intro/</guid>
      <description>Spring AMQP 是 Spring 对 AMQP 协议的封装和扩展，提供了消息发送和接收的模板。Spring AMQP由spring-amqp和spring-rabbit两个模块组成。spring-amqp模块位于org.springframework.amqp.core包，它的目标是提供不依赖于任何特定AMQP代理实现或客户端库的通用抽象；而spring-rabbit是spring-amqp通用抽象的具体实现，目前仅提供了rabbitmq的实现。</description>
    </item>
    <item>
      <title>Spring boot集成quartz并实现任务调度</title>
      <link>https://blog.hankmo.com/posts/tech/spring-boot-quartz-guide/</link>
      <pubDate>Tue, 22 Jan 2019 16:13:13 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/tech/spring-boot-quartz-guide/</guid>
      <description>spring boot与quartz集成，自定义JobFactory实现自动依赖注入，进行数据持久化。</description>
    </item>
    <item>
      <title>Spring boot工程Feign请求时Get请求无法传递body的问题</title>
      <link>https://blog.hankmo.com/posts/tech/spring-boot-feign-get-with-body/</link>
      <pubDate>Tue, 22 Jan 2019 15:54:21 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/tech/spring-boot-feign-get-with-body/</guid>
      <description>同RestTemplate类似，Feign默认情况下也使用的是JDK原生的http请求，同时也支持OkHttp、HttpClient等框架。默认情况下，原生Http请求不允许Get请求传递body，如果传递了body数据，会将当前请求转为Post请求，而实际上我们后台接收的是Get请求，所以抛出上边的异常，所以我们需要换成能够支持的HttpClient。</description>
    </item>
    <item>
      <title>使用Spring的RestTemplate发送GET请求，并支持传递Request body参数</title>
      <link>https://blog.hankmo.com/posts/tech/spring-resttemplate-get-with-body/</link>
      <pubDate>Wed, 31 Oct 2018 18:32:31 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/tech/spring-resttemplate-get-with-body/</guid>
      <description>使用RestTemplate发送GET请求，默认使用的JDK实现，不支持传递body参数，可以改为Apache的httpclient包，只需对HttpComponentsClientHttpRequestFactory进行扩展，让GET扩展自HttpEntityEnclosingRequestBase即可。</description>
    </item>
    <item>
      <title>Spring Boot参数验证（下）——Bean Validation在Web中的应用</title>
      <link>https://blog.hankmo.com/posts/tech/spring-boot-validation-2/</link>
      <pubDate>Fri, 12 Oct 2018 16:52:20 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/tech/spring-boot-validation-2/</guid>
      <description>Spring Boot的Web Starter已经加入了Bean Validation(JSR303)的依赖，可以直接使用。在使用时，只需在需要校验的方法上加上@Valid或者@Validated注解即可，如果需要编码自定义校验结果，则在校验的参数后加上BindingResult参数，注意对应关系；否则，为了模块化需要，也可以屏蔽校验失败业务逻辑，编写全局校验器，校验失败自动返回JSON校验结果即可。</description>
    </item>
    <item>
      <title>Spring boot全局异常处理和自定义异常页面</title>
      <link>https://blog.hankmo.com/posts/tech/spring-boot-global-exception-process/</link>
      <pubDate>Wed, 10 Oct 2018 17:39:20 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/tech/spring-boot-global-exception-process/</guid>
      <description>Spring boot提供了默认的异常处理机制，但是难以满足业务需要，一般需要编码来实现自己的业务处理机制。可以使用ContrllerAdvisor和ExceptionHandler注解来定义异常处理逻辑，要自定义异常页面，只需定义页面并放到error目录下即可。</description>
    </item>
    <item>
      <title>Spring Boot参数验证（上）——Bean Validation及其Hibernate实现</title>
      <link>https://blog.hankmo.com/posts/tech/spring-boot-validation-1/</link>
      <pubDate>Wed, 10 Oct 2018 15:15:34 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/tech/spring-boot-validation-1/</guid>
      <description>Bean Validation，是JCP(Java Community Process)定义的标准化的JavaBean校验API，基于注解，并且具有良好的易用性和扩展性，1.0版本定义为JSR 303，而现在发布了2.0版本，定义为JSR 380。Hibernate Validator是JSR 380的一种标准实现，同时还对其进行了扩展，如增加了部分验证约束。目前，最新的稳定版本为6.0.13.Final。</description>
    </item>
    <item>
      <title>Spring Cloud服务注册中心Eureka高可用</title>
      <link>https://blog.hankmo.com/posts/tech/springcloud-eureka-cluster/</link>
      <pubDate>Thu, 16 Aug 2018 17:03:18 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/tech/springcloud-eureka-cluster/</guid>
      <description>对于Eureka而言，其本身是支持多节点集群的。其原理大致如下：服务注册中心的多个实例彼此互相注册，形成注册中心的集群，同时对外提供服务，即使其中一个挂掉，其他实例仍然可以对外提供服务，从而保证了高可用。</description>
    </item>
    <item>
      <title>Spring Cloud服务注册中心Eureka</title>
      <link>https://blog.hankmo.com/posts/tech/springcloud-eureka-standalone/</link>
      <pubDate>Wed, 15 Aug 2018 16:48:42 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/tech/springcloud-eureka-standalone/</guid>
      <description>Eureka，字面意思即&amp;#34;发现&amp;#34;之意，是Netflix下开源的服务治理（注册、发现等）中间件。Spring Cloud Eureka在其基础上进行了二次封装，添加了自动化配置等功能，使其成为Spring Cloud微服务体系中核心的服务治理方案之一。</description>
    </item>
    <item>
      <title>Spring Cloud Config之配置集成化</title>
      <link>https://blog.hankmo.com/posts/tech/springcloud-config-center-with-git/</link>
      <pubDate>Tue, 14 Aug 2018 17:35:26 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/tech/springcloud-config-center-with-git/</guid>
      <description>Spring Cloud Config是一款配置集中管理的组件，它提供了分布式系统的客户端和服务端外部化配置支持，由git(也支持svn、本地文件系统等)存储库支持的集中式外部配置管理，实现了配置的外部化存储。</description>
    </item>
    <item>
      <title>Spring Cloud简介</title>
      <link>https://blog.hankmo.com/posts/tech/springcloud-intro/</link>
      <pubDate>Fri, 20 Jul 2018 17:13:10 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/tech/springcloud-intro/</guid>
      <description>Spring Cloud是一套构建于Spring boot之上的微服务框架，它整合了大部分微服务实施所需的组件，并提供了默认实现，使得复杂的微服务实施变得简单化。Spring Cloud是一整套微服务解决方案，相比于dubbo等框架而言，不仅出生于Spring大家族，而且更新频繁，发展特别快，社区也很活跃，对于实施微服务的小型公司而言，使用Spring Cloud不仅能够快速实施微服务，而且其已经考虑微服务的各个方面，从而极大的节约了开发成本，提高了生产力。</description>
    </item>
    <item>
      <title>Spring Boot JPA使用详解</title>
      <link>https://blog.hankmo.com/posts/tech/spring-boot-jpa-guide/</link>
      <pubDate>Wed, 27 Jun 2018 18:08:47 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/tech/spring-boot-jpa-guide/</guid>
      <description>JPA是Java Persistence API的简称，中文名Java持久层API，是JDK 5.0注解或XML描述对象－关系表的映射关系，并将运行期的实体对象持久化到数据库中。本文介绍了Spring boot JPA的用法，包括核心接口和类介绍，查询创建，投影、分页查询、条件查询用法等。</description>
    </item>
    <item>
      <title>SpringBoot-工程结构、配置文件以及打包</title>
      <link>https://blog.hankmo.com/posts/tech/springboot-project-overview/</link>
      <pubDate>Thu, 07 Jun 2018 17:43:26 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/tech/springboot-project-overview/</guid>
      <description>Spring Boot默认以jar方式来打包运行程序，与传统war不同的是，Spring Boot规定了web项目的配置文件、静态资源和模板存放位置，同时也提供了可执行jar包的目录规范和打包插件。通常，我们不需要更改Spring Boot的默认配置，如果有特殊需求，同样可以简单的修改application.properties配置项来实现自定义，例如自定义日志、自定义参数、随机参数、自定义WEB文件存放目录等。</description>
    </item>
    <item>
      <title>Spring Boot之基础入门</title>
      <link>https://blog.hankmo.com/posts/tech/spring-boot-intro/</link>
      <pubDate>Tue, 22 May 2018 18:56:09 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/tech/spring-boot-intro/</guid>
      <description>Spring Boot是Spring的开源项目，其目的是让开发者可以简单、快速地使用Spring框架创建生产级的应用，其目的不是为了替换Spring，而是简化Spring的使用。Spring Boot可以看做是对Spring框架的二次封装，不过，在封装的同时也还提供了许多高级功能。</description>
    </item>
    <item>
      <title>使用visualvm监控Java程序性能三——浏览堆dump文件</title>
      <link>https://blog.hankmo.com/posts/tech/visualvm-heap-dump/</link>
      <pubDate>Tue, 24 Apr 2018 19:18:50 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/tech/visualvm-heap-dump/</guid>
      <description>堆dump，即堆转储，其实是一个当前JVM堆内存所有对象在某个时间点上的快照。堆dump用来将当前应用程序的堆内存中的数据信息保存为文件，并可以快速浏览文件中的内容，查询对象分配信息。堆dump是分析程序类和实例对象的关键手段，通过将堆内存信息保存起来，从而为后续分析做好准备工作。分析对dump，找出占用资源较高的对象，找出其引用关系，然后进行代码优化。</description>
    </item>
    <item>
      <title>使用visualvm监控Java程序性能二——主窗口功能详解</title>
      <link>https://blog.hankmo.com/posts/tech/visualvm-overview/</link>
      <pubDate>Sat, 21 Apr 2018 20:11:35 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/tech/visualvm-overview/</guid>
      <description>VisualVM的概述页详细展示了应用程序和运行环境的参数信息；而监视页以图形化的方式直观的展示了当前监控程序的CPU、内存、类和线程的整体情况；线程页用于详细分析程序的线程情况，比如CPU占用情况、是否死锁等；抽样器则可以用来对CPU或者内存一定一段时间的数据抽样检查，并分析抽样结果；Profiler可以用于从整体上分析本地应用程序的性能，功能类似抽样器。</description>
    </item>
    <item>
      <title>使用VisualVM监控Java程序性能一——简介</title>
      <link>https://blog.hankmo.com/posts/tech/visualvm-intro/</link>
      <pubDate>Fri, 20 Apr 2018 17:08:21 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/tech/visualvm-intro/</guid>
      <description>Java应用程序难免遇到性能问题，借助于一些性能分析工具，来监测程序性能，从而找出影响性能的问题所在，以便进行优化。本文的VisualVM就是一款比较强大的性能分析工具。VisualVM组织Java开发工具包(JDK)工具检索的JVM软件的数据，并以一种使您能够快速查看多个Java应用程序的数据的方式提供信息。您可以查看在远程主机上运行的本地应用程序和应用程序的数据。您还可以捕获有关JVM软件实例的数据，并将数据保存到您的本地系统中，以供后期查看或与其他用户共享。</description>
    </item>
    <item>
      <title>Spring事务管理四：声明式事务</title>
      <link>https://blog.hankmo.com/posts/tech/spring-declarative-transaction/</link>
      <pubDate>Thu, 08 Mar 2018 17:34:51 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/tech/spring-declarative-transaction/</guid>
      <description>可以从传播机制、隔离级别、是否只读、事务超时、回滚规则等方面来描述事务。Spring提供了xml和注解两者事务声明方式：采用xml：需要使用tx命名空间，好处是在xml中完成事务定义，代码中不需要做任何事务相关的编码；但是，事务控制的方法名称需要遵循一定的规则，一遍Spring能够匹配到并为其加入事务通知。采用注解：xml仅需一行配置，其他的事务控制都可以通过编码加上注解实现，而且对方法名称没有要求；如果整个应用不需要事务控制，取消xml配置即可。</description>
    </item>
    <item>
      <title>Spring事务管理三：编程式事务</title>
      <link>https://blog.hankmo.com/posts/tech/spring-programming-transaction/</link>
      <pubDate>Thu, 08 Mar 2018 15:50:47 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/tech/spring-programming-transaction/</guid>
      <description>Spring提供了TransactionTemplate工具类，可以方便地让开发人员手动的编程实现事务控制。编程式事务虽然可以精确控制事务，但是事务控制代码必须侵入业务逻辑代码中，耦合度高，后期难以维护。一般而言，不需要精确控制事务，所以采用的更多的是Spring的声明式事务。</description>
    </item>
    <item>
      <title>Spring事务管理二：Spring事务管理器</title>
      <link>https://blog.hankmo.com/posts/tech/spring-transaction-manage/</link>
      <pubDate>Wed, 07 Mar 2018 21:33:52 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/tech/spring-transaction-manage/</guid>
      <description>Spring并不支持管理事务，而是委托给第三方事务管理机制来完成事务控制，Spring顶层提供事务管理核心接口PlatformTransactionManager，事务管理器均是该接口的实现。如果没有合适的事务管理器或者需要支持分布式事务控制，则可以使用全局事务管理器：JTA事务管理器。</description>
    </item>
    <item>
      <title>Spring事务管理一：Spring事务简介</title>
      <link>https://blog.hankmo.com/posts/tech/spring-transaction-intro/</link>
      <pubDate>Wed, 07 Mar 2018 21:20:39 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/tech/spring-transaction-intro/</guid>
      <description>在软件开发领域，全有或全无的操作被称为事务（transaction）。事物允许将几个操作组合成一个要么全部发生要么全部不发生的工作单元。发生和不发生两者只能选择其一，而不可能两者都选择。事务确保了数据和资源免于处在不一致的状态。事务必须具备ACID特性，在Spring中，除了编程来精确控制事务，还可以使用AOP来配置低耦合度的声明式事务控制。</description>
    </item>
    <item>
      <title>高性能Javascript--脚本的无阻塞加载策略</title>
      <link>https://blog.hankmo.com/posts/tech/javascript-non-blocking-load/</link>
      <pubDate>Wed, 05 Apr 2017 22:49:28 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/tech/javascript-non-blocking-load/</guid>
      <description>JavaScript在浏览器中的性能，可以说是前端开发者所要面对的最重要的可用性问题。在Yahoo的Yslow23条规则当中，其中一条是将JS放在底部 。原因是，事实上，大多数浏览器使用单进程处理UI和更新JavaScript运行等多个任务，而同一时间只能有一个任务被执行。JavaScript运行了多长时间，那么在浏览器空闲下来响应用户交互之前的等待时间就有多长。</description>
    </item>
    <item>
      <title>JVM垃圾回收器工作原理及使用实例介绍</title>
      <link>https://blog.hankmo.com/posts/tech/jvm-gc/</link>
      <pubDate>Mon, 03 Apr 2017 01:15:48 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/tech/jvm-gc/</guid>
      <description>Java语言的一大特点就是可以进行自动垃圾回收处理，而无需开发人员过于关注系统资源，例如内存资源的释放情况。自动垃圾收集虽然大大减轻了开发人员的工作量，但是也增加了软件系统的负担。拥有垃圾收集器可以说是Java语言与C&#43;&#43;语言的一项显著区别。在 C&#43;&#43;语言中，程序员必须小心谨慎地处理每一项内存分配，且内存使用完后必须手工释放曾经占用的内存空间。当内存释放不够完全时，即存在分配但永不释放的内存块，就会引起内存泄漏，严重时甚至导致程序瘫痪。</description>
    </item>
    <item>
      <title>maven定义profile无法替换property属性值</title>
      <link>https://blog.hankmo.com/posts/tech/maven-profile-canot-replace-property/</link>
      <pubDate>Mon, 03 Apr 2017 01:04:21 +0000</pubDate>
      <guid>https://blog.hankmo.com/posts/tech/maven-profile-canot-replace-property/</guid>
      <description>最近开发一个web项目，用的maven构建，建立多个profile，对应不同环境，分别包含不同的配置，在打包的时候发现，xml和properties配置文件没有被替换为profile下定义的property属性值。</description>
    </item>
  </channel>
</rss>
