Posted in Java, 技术

一、大型网站技术架构演化

Writer      :BYSocket(泥沙砖瓦浆木匠)

2016年的书 — A Year Of Books


大型网站系统的特点

  • 1、高并发,大流量
  • 2、高可用:7*24小时不间断服务,不宕机

  • 3、海量数据储存及管理

  • 4、网络复杂

  • 5、安全性

  • 6、易扩展,可伸缩:需求快速变更,发布频繁

  • 7、渐进式发展:脸谱网是宿舍,谷歌是斯坦福大学实验室,淘宝是马云家

一句话,高可用,高性能,易扩展,可伸缩且安全的网站。

大型网站架构演化发展历程

1、初始阶段

    单机服务器:应用程序+数据库+文件都在一台服务器上。

  • 2、应用服务和数据服务分离

    应用服务器,文件服务器和数据库服务器。

中间通过通信的是:HTTP/Socket

  • 3、缓存

    二八定律。核心集中在百分之20

    缓存分两种:应用服务器上的本地缓存 和 缓存在专门分布式缓存服务器的远程缓存

    其中Ehcache 简介:(通过RMIJGroupsJMS进行的异步或同步的缓存复制、支持的通过RMI、JGroups或JMS进行的异步或同步的缓存复制、可靠的分发:使用TCP的内建分发机制、面向资源的RESTful,还有就是SOAP)

  • 4、应用服务器集群

    集群是常用手段,实现系统的可伸缩性。

    通过负载均衡调度服务器,将请求分发任何一台服务器。

  • 5、数据库读写分离

    读部分(缓存不命中或者过期) 和 全部写操作要访问数据库

    主从热备-数据库同步

  • 6、反向代理nginx CDN加速网站响应

    原理:缓存

    CDN:就近的网络提供上机房。反向代理缓存这用户请求的资源。

  • 7、分布式文件系统分布式数据库系统

    单表数据规模很大的情况,常用手段是业务分库。

8、NoSQL搜索引擎

    数据存储及大规模数据的检索

    NoSQL场景: 场景:储存用户信息,比如会话、配置文件、参数、购物车等等。这些信息一般都和ID(键)挂钩,这种情景下键值数据库是个很好的选择。

  • 9、业务拆分

    分而治之,业务分成各个产品线。然后各个应用服务器。

    应用之间通过超链接或者消息队列进行数据分发。

10、分布式服务

    SOA、云服务

小结

云计算服务,可以让一切技术资源:计算,存储,网络按需购买即可。

欢迎点击我的博客及GitHub — 博客提供RSS订阅哦!

———- http://www.bysocket.com/ ————- https://github.com/JeffLi1993 ———-

微         博:BYSocket  豆         瓣:BYSocket  FaceBook:BYSocket  Twitter    :BYSocket

Posted in Spring, 技术

《Spring 3.X 企业应用开发实战》摘记 【IOC】

Writer      :BYSocket(泥沙砖瓦浆木匠)

一、IOC的概念

IOC(Inverse of Control )控制反转,原本自身控制自身的权利转移到了其他身上。IOC是一个“协议”,或者理论。需要涉及到代码解耦设计模式等一些问题考量。

其中包含了两层内容:控制 + 反转。意思明了


后来,IOC由于是种理论需要实战 — 就出现了依赖注入

DI(Dependency Injection)依赖注入即调用类让某一接口的实现类的依赖关系有第三方(容器或者协作类)注入,以移除调用类对某一接口实现类的依赖。这里就是将实战的武功秘籍传授了。实现类与类的依赖关系。

IOC容器还提供了Bean实例缓存、生命周期管理、Bean实例代理、事件发布、资源装载等高级服务。

二、注入的方式

依赖注入有三种注入方式:

1、通过构造函数注入

2、通过属性注入(常用方式)

3、接口注入


三、如何实现其注入呢?

那就涉及到相关的知识点,比如反射类装载器 和 反射机制)、资源访问机制

a. 反射Reflect


b. 资源装载器

资源,考虑资源的来源。可能是本地的File(jar、zip等),网络的URLFTP等)。Spring提供的Resource接口比JDK访问资源API更强大个好用。其实就是一种VFS的特例吧。

1. 读取配置文件时,Ant风格资源地址支持3中匹配符:

?:匹配一个字符

*:任意一个字符

**:匹配多层路径

Resource 与 ResourceLoader UML图:

image

BeanFactory类继承体系:

image

ApplicationContext主要实现类:

a. ClassPathXmlApplicationContext 从类路径加载配置文件

b. FileSystemXmlApplicationContext 从文件系统加载配置文件

Spring用于启动WebApplicationContext的Servlet和Web容器监听器

org.springframework.web.servlet.DispatcherServlet
org.springframework.web.context.ContextLoaderListener

待续。。。

Posted in Java, 技术

初探设计:Java接口和抽象类何时用?怎么用?

今天犯了个错:

接口变动,伤筋动骨,除非你确定只有你一个人在用”。哪怕只是throw了一个新的Exception。哈哈,这是我犯的错误。

 

一、接口和抽象类

类,即一个对象

抽象类,就是抽象出类的基础部分,即抽象基类(抽象类)。官方定义让人费解,但是记忆方法是也不错的 — 包含抽象方法的类叫做抽象类。

接口就是把抽象的深度更深,它就像用简短的非逻辑的一些规则表示类之间的关系。可以比作协议,比如通信使用的UDP/TCP协议等。

小结类与接口是Java语言的基本抽象单元。

 

二、为什么有接口的两大原因

a. 向上转型为多个基类型

如此,会给开发带来相当大的灵活性。比如女神刘亦菲(Class),实现了 明星 和 女人 的接口。这样在复杂的继承结构的某类中使用它,以后在调用seeStar(Star star)或者seeWomen(Women women)方法时,只要传入其实现类(刘亦菲)即可。这也就是常说的接口可以多实现,达到了完全解耦

b. 可复用性

即根据接口定义,让创建类有了遵循的”协议“(规则)。whatever~ 要做的仅仅建立一个接口,为了保证生成对象的非耦合。如此而来,接口的使用让代码更具可复用性通用性灵活性。但并不是那么万能。后面使用守则会讲到。

 

三、怎么用?

前人大牛总结了一些设计模式,也就是接口衍生出的一些设计模式。设计模式就是语法糖的甜蜜吧。接口让我们尝到了甜蜜。和我身边的一杯starBucks的热巧克力一样。有点太甜。比如:

a.策略模式方法中参数使用接口,传入的参数对象(实现类)即包含了执行的代码。如图:

image
调用过程如下,在方法中出入实现而已:

image

 

b. 适配器模式接口适配器(Interface Adapter)类,可以将不同源配到同一个目标。即暴露目标接口和实现源有共同的方法,适配器类怎么适配呢?实现目标接口,并关联了实现源对象,在实现方法中调用关联实现源真正对象,然后在里面进行各种适配操作。比如再关联一个源什么的。如图:

image

这其实有点AOP的味道。比如Spring AOP框架对BeforeAdvice、AfterAdvice、ThrowsAdvice三种通知类型的支持实际上是借助适配器模式来实现的。

 

c. 工厂模式 工厂对象将生成接口某个实现的对象。从而代码将实现和接口的实现分离,比较透明地将某个实现透明地替换成另一个实现。但是这里工厂调用方法是静态的,也就是简单工厂模式(静态工厂模式)。动态工厂模式无非是使用了反射达到了动态调用。

 

四、接口与抽象类的使用守则

第一、尽可能使每一个类或成员不被外界访问

这里的外界有个度,比如包级或者公有的。这样子可以更好地模块化,模块与模块之间通过暴露的api调动。这样如果有个模块改动接口或者类。只要担心该模块,而不会涉及其他模块。

第二、适当的使用类(抽象类)继承,更多的使用复合

继承,实现了代码重用。内部中使用继承非常安全,但是要记住什么时候使用继承。即当子类真正是超类的子类型时,才适用继承。否则尽可能使用复合,即在一个类中引用另一个类的实例。也就是说将另一个类包装了一下,这也就是装饰模式所体现的。

第三、优先考虑使用接口,相比抽象类

首先Java只许单继承,这导致抽象类定义收到极大的限制。二者,接口无法实现方法。但是Java 8提供了函数式接口

但是接口在设计的时候注意,设计公有接口必须谨慎。接口如果被公开发行,则肯定会被广泛实现,那样改接口几乎不可能,会是巨大的工程。(这和我犯的错误一样。)

第四、占时没有第四了…

 

小结:

明白了 Java接口和抽象类何时用?怎么用?待续,有新的点补充吧

欢迎点击我的博客及GitHub — 博客提供RSS订阅哦!

———- http://www.bysocket.com/ ————- https://github.com/JeffLi1993 ———-

微         博:BYSocket  豆         瓣:BYSocket  FaceBook:BYSocket  Twitter    :BYSocket

 

c260f7abjw1eynwbrcghnj20qo0k00w0

Posted in Spring, 技术

《Spring 3.X 企业应用开发实战》摘记 【持续更新】

Writer      :BYSocket(泥沙砖瓦浆木匠)

一、实战中的经验

注解相关

@Repository

标示一种作为单独在Model中使用的操作接口,没有封装的状态。

很常见的定义注解通过Spring定义Dao Bean。DAO(Data Access Object),项目中经常应用的数据库访问层可以使用该注释。但要注意和DDD(领域驱动设计)的区别。


@Service

表示一种作为服务类,也是一种特殊的@Component。


@Controller

标注一种是Controller层的类。也就是形象的Action层,我觉得Action更贴近生活点。因为我比较爱生活。和@Service一样一种特殊的@Component。


@Autowired

标注构造函数,字段,setter方法或配置方法,让其通过Spring依赖注入自动填充。

是否看过很常见的如下定义:在Action层自动注入service层Bean,可以字段也可以set方法,也就是说字段可以省了段代码(何乐而不为)。

那个配置方法,就是Java Config方法,比如说获取些主机名,端口号之类。


@RequestMapping

作用于类或者方法,用于映射Web请求。也就是一种在Servlet与Web组件之间的一种中庸之道吧。


二、配置

<context:component-scan base-package=”packagename.xxx”/>

扫描base-package下的包,将标注Spring注解(@Service、@Autowired、@Repository)的类自动转化为Bean,完成Bean的注入。比如DAO层,Service层的依赖注入。


事务配置及AOP配置提供事务增强:

<!-- ①配置事务管理器:负责声明式事务管理,引用了dataSource Bean -->
<bean id="transactionManager" class="org.springframework.jdbc.datasource.DataSourceTransactionManager">
<property name="dataSource" ref="dataSource"/>
</bean>

<!-- ②通过AOP配置提供事务增强,让Service包下所有Bean的所有方法拥有事务 -->
<aop:config proxy-target-class="true">
<!-- ③AOP切入点 -->
<aop:pointcut id="serviceMethod" expression="execution(*projectpackage.service..*(..))"/>
<!-- ④Spring Advisor类似拦截器 -->
<aop:advisor advice-ref="txAdvice" pointcut-ref="serviceMethod"/>
</aop:config>
<!-- ⑤AOP通知 -->
<tx:advice id="txAdvice" transaction-manager="transactionManager">
<tx:attributes>
<tx:method name="*"/>
</tx:attributes>
</tx:advice>

①处配置了transaction事务管理器,引用了dataSource 。其内在应该是把数据库事务用Spring(代码)级别声明式管理

②配了事务管理器,哪里用到了?当然要用的地方,比如Service层。利用AOP切面提供事务,使得事务得到打了鸡血式的使用。里面配置了③切入点(哪里用事务)及④利用Spring Advisor(类似拦截器)拦截至切入点,并引用⑤通知来正则匹配其Service方法来AOP,可以看出细粒度达到方法级别

三、持续更新。。。

欢迎点击我的博客及GitHub — 博客提供RSS订阅哦!

———- http://www.bysocket.com/ ————- https://github.com/JeffLi1993 ———-

微         博:BYSocket  豆         瓣:BYSocket  FaceBook:BYSocket  Twitter    :BYSocket

c260f7abjw1ey2ostokgbj20hs0c876d

Posted in Java, 技术

初探设计:Java继承何时用?怎么用?

Writer      :BYSocket(泥沙砖瓦浆木匠)

一、回顾继承

常见的如下:

1、依赖(”uses-a“)

2、聚合(”has-a“)

3、继承(”is-a“)类之间关系

也就是UML类图中常见的三种关系,另外常见的还有实现(接口与实现类的关系),组合等。

 

继承,即“is-a”关系,是一种表示特殊与一般的关系。比如,女人(特殊)是一个人(一般)。关键字extends表明正在构造的新类派生于一个存在的类。

1、已经存在的类称为 超类父类或者基类

2、新类被称为 子类或者派生类

 

有时候看着人家源码的设计。比如常见的接口,紧接着抽象类实现接口,然后继承该抽象类的各种实现:

image

一般都是这样的,行为总则都写着顶层接口抽象类实现了下面各个实现类公用的方法和字段实现类各自实现功能

但里面这些究竟怎么用呢?比如继承在什么前提下使用,什么场景前提下,下面就是思考后的小结:(Think , Write & Do)

 

二、继承何时用?怎么用

也就是说,继承设计使用的时候,有哪些技巧,有哪些需要注意的地方。

1、公共的方法和字段才放在基类(也就是父类)

这句话可能有争议,太过于吹毛求兹或者是严格。拿女人和人的问题来说,比如名字字段、age都可以放在基类人上面,但女人的那些第二特征就是独有了。

但有些时候的例子总是很疑惑:比如Java工程师实习生和Java工程师,看样子可以“实习生”extends “Java工程师”,然后很多Java工程师上的字段都是不属于Java实习生的。顾两者并没有上面太大关系,可能都是从属于一个父类—工程师。下面类关系图才是正确的:

image

子类对父类的继承是包括了父类的公有和受保护的方法和字段。但子类只需要继承父类的一部分,就没辙了。这时候记住一句话:“多用组合,少用继承”。

 

2、protect并不能保护父类

其实protect机制在父类并不能起到好的保护。子类可以在需要的的时候访问父类。但是继承无限制,即子类的子类… 无止境的。如果想侵入父类protect方法,只需要写个类,继承任意子类就可访问。二者,同一个包下能访问。

 

从上面也可以总结出:

3、在继承父类的方法与字段都有意义的时候,选择继承。否则,不要使用继承。

 

4、在覆盖父类中的行为(方法)时,不要偏离最初的设计内涵。

父类的方法实现或者定义都是指定了一种行为的内涵。所以继承父类的时候,有个重写override)方法可以改变子类的行为。但请不要改变其定义的内涵。源码中常见的有:比如 IO 中的 read write方法和Servlet中 的 get post。

 

5、继承与组合、多态

继承,子类与父类在编译期就能确定其对象。而组合或者是多态,在运行期就才能确定其对象,相比之下,组合多态达到了更多的灵活性。但,运行期未知的错误是要注意处理的。

顾,“多用组合,少用继承”。

 

三、本文小结

继承的一点一滴。泥瓦匠,这软文小结,难免有错误。欢迎指正讨论。

欢迎点击我的博客及GitHub — 博客提供RSS订阅哦!

———- http://www.bysocket.com/ ————- https://github.com/JeffLi1993 ———-

微         博:BYSocket  豆         瓣:BYSocket  FaceBook:BYSocket  Twitter    :BYSocket

7066956_21002167761444703497_thumb

Posted in Java, 技术

【Java模板语言】TinyTemplate 实战 <一>:Serlvet集成

Writer      :BYSocket(泥沙砖瓦浆木匠)

一、什么是TinyTemplate

什么是模板语言?

模板语言是为了使用户界面与业务数据(内容)分离而产生的,并能生成特定格式的文档。

什么是TinyTemplate?(开源项目地址入口

Tiny模板引擎是一个基于Java技术构建的模板引擎,它具有体量小、性能高和扩展易的特点。 适合于所有通过文本模板生成文本类型内容的场景,如:XML、源文件、HTML等等,可以说,它的出现就是为了替换Velocity模板引擎而来,因此在指令集上在尽量与Velocity接近的同时,又扩展了一些Velocity不能很好解决问题的指令与功能,在表达多方面则尽量与Java保持一致,所以非常地易学易用。

1. 体量小表现在总共不到5000多行的代码,去掉解析器近1000行,核心引擎只有4000多行代码。

2. 性能高表现在与现在国内几款高性能模板引擎如:Jetbrick、Webit等引擎的性能相比,近乎伯仲之间,但是比Velocity、Freemarker等则有长足的进步,效率大致是Velocity四倍。

3. 扩展性表现在Tiny框架引擎的所有环境都可以自行扩展,并与原有体系进行良好统一。

4. 易学习表现在Tiny框架概念清晰、模块划分科学、具有非常高的高内聚及低耦合。

5. 使用方式灵活表现在,可以多例方式、单例方式,并可以与Spring等有良好集成。

6. 友好的错误提示信息。


简要特点介绍:

1. 类似于 Velocity 的指令方式,相同或相似指令达90%左右

2. 支持可变参数方法调用

3. 支持类成员方法重载

4. 支持函数扩展

5. 采用弱类型方式,对于模板层的代码编写约束更小,模型层怎样变化,模板层的代码调整都非常容易

6. 支持宏定义#macro

7. 支持布局#layout

二、与Servlet集成,运行Hello,World

1. 新建一个quickstart.servlettemplate maven项目

在Eclipse中,new — Maven Project — “maven-archetype-quickstart“ …

在pom.xml添加对tinyTemplate的依赖:

    	<!-- 模板引擎对servlet的扩展依赖 -->
    	<dependency>
  			<groupId>org.tinygroup</groupId>
  			<artifactId>org.tinygroup.templateservletext</artifactId>
  			<version>2.0.26</version>
		</dependency>
如上代码,重写TinyServlet的handleRequest方法即可,然后在里面进行逻辑处理,return返回index.page。
4. 添加default.layout和index.page
default.layout:
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN"
        "http://www.w3.org/TR/html4/strict.dtd">
<!--[if IE 7 ]>		 <html class="no-js ie ie7 lte7 lte8 lte9" lang="en-US"> <![endif]-->
<!--[if IE 8 ]>		 <html class="no-js ie ie8 lte8 lte9" lang="en-US"> <![endif]-->
<!--[if IE 9 ]>		 <html class="no-js ie ie9 lte9" lang="en-US"> <![endif]-->
<!--[if (gt IE 9)|!(IE)]><!-->
<html class="no-js" lang="en-US"> <!--<![endif]-->
<html lang="en">
<head>
    <meta charset="utf-8"/>
    <title>${pageTitle}</title>

    <script>
        var contextPath = "${TINY_CONTEXT_PATH}";
        var CKEDITOR_BASEPATH = contextPath+'/ckeditor/';

        /*
        jQuery.fn.outerHTML = function(s) {
            return (s) ? this.before(s).remove() : jQuery("p").append(this.eq(0).clone()).html();
        }
        */
    </script>


    <link rel="shortcut icon" href="${TINY_CONTEXT_PATH}/icon/logo.png">
    
 #if(DEBUG_MODE && DEBUG_MODE=="true")
	#foreach(component in uiengine.getHealthUiComponents())
	<!--UI component $component.name start -->
	#if(component.cssResource)
	#set(resources=component.cssResource.split(","))
	#foreach(path in resources)
	#set(path=path.trim())
	#set(newPath=path.replaceAll("[$][{]TINY_THEME[}]","${TINY_THEME}"))
	<link href="${TINY_CONTEXT_PATH}${newPath}" rel="stylesheet" />
	#end
	#end
	#if(component.jsResource)
	#set(resources=component.jsResource.split(","))
	#foreach(path in resources)
	#set(path=path.trim())
	<script src="${TINY_CONTEXT_PATH}${path}"></script>
	#end
	#end
	#if(component.jsCodelet)
	<script>
	$!{component.jsCodelet}
	</script>
	#end
	#if(component.cssCodelet)
	<style>
	$!{component.cssCodelet}
	</style>
	#end
	#end
 #else
  <link href="${TINY_CONTEXT_PATH}/uiengine.uicss" rel="stylesheet" />
  <script src="${TINY_CONTEXT_PATH}/uiengine.uijs"></script>
 #end
</head>
<body>
      #pageContent
</body>
</html>
index.page:
${name},欢迎来到Tiny的世界! 时间:${date}
5. 运行项目,右键项目 run as — maven build — “jetty:run”。访问 localhost:8080/项目名/index
image

三、小结

1、TinyTemplate的简介与特点

2、TinyTemplate与Servlet的配置(下一讲与SpringMVC的配置)

3、TinyTemplate最简单的也是最常用的取值语法${}

欢迎点击我的博客及GitHub — 博客提供RSS订阅哦!

———- http://www.bysocket.com/ ————- https://github.com/JeffLi1993 ———-

微         博:BYSocket  豆         瓣:BYSocket  FaceBook:BYSocket  Twitter    :BYSocket

Posted in 清文

《赌客信条》小摘

全文有理有据,全文小例子,小情节,情节中得出结论。让人回味,让人学到一些所谓的行为经济学。

1、见好就收

2、让“试行办法”成为正式策略

    计划赶不上变化,不如先做着试试。试试十天半个月不妨。

3、大钱小花,小钱大花

    小事做起,要节约。

4、大数法则

    学会一些平均法则

5、小数法则

    心理误区,用于告诫自己

Posted in Java, 技术

深入浅出: Java回调机制(异步)

Writer      :BYSocket(泥沙砖瓦浆木匠)

什么是回调?今天傻傻地截了张图问了下,然后被陈大牛回答道“就一个回调…”。此时千万个草泥马飞奔而过(逃

哈哈,看着源码,享受着这种回调在代码上的作用,真是美哉。不妨总结总结。

一、什么是回调

回调,回调。要先有调用,才有调用者和被调用者之间的回调。所以在百度百科中是这样的:

软件模块之间总是存在着一定的接口,从调用方式上,可以把他们分为三类:同步调用、回调和异步调用

回调是一种特殊的调用,至于三种方式也有点不同。

1、同步回调,即阻塞,单向

2、回调,即双向(类似自行车的两个齿轮)。

3、异步调用,即通过异步消息进行通知。

 

二、CS中的异步回调(java案例)

比如这里模拟个场景:客户端发送msg给服务端,服务端处理后(5秒),回调给客户端,告知处理成功。代码如下:

回调接口类:

/**
 * @author Jeff Lee
 * @since 2015-10-21 21:34:21
 * 回调模式-回调接口类
 */
public interface CSCallBack {
    public void process(String status);
}

模拟客户端:

/**
 * @author Jeff Lee
 * @since 2015-10-21 21:25:14
 * 回调模式-模拟客户端类
 */
public class Client implements CSCallBack {

    private Server server;

    public Client(Server server) {
        this.server = server;
    }

    public void sendMsg(final String msg){
        System.out.println("客户端:发送的消息为:" + msg);
        new Thread(new Runnable() {
            @Override
            public void run() {
                server.getClientMsg(Client.this,msg);
            }
        }).start();
        System.out.println("客户端:异步发送成功");
    }

    @Override
    public void process(String status) {
        System.out.println("客户端:服务端回调状态为:" + status);
    }
}

模拟服务端:

/**
 * @author Jeff Lee
 * @since 2015-10-21 21:24:15
 * 回调模式-模拟服务端类
 */
public class Server {

    public void getClientMsg(CSCallBack csCallBack , String msg) {
        System.out.println("服务端:服务端接收到客户端发送的消息为:" + msg);

        // 模拟服务端需要对数据处理
        try {
            Thread.sleep(5 * 1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("服务端:数据处理成功,返回成功状态 200");
        String status = "200";
        csCallBack.process(status);
    }
}

测试类:

/**
 * @author Jeff Lee
 * @since 2015-10-21 21:24:15
 * 回调模式-测试类
 */
public class CallBackTest {
    public static void main(String[] args) {
        Server server = new Server();
        Client client = new Client(server);

        client.sendMsg("Server,Hello~");
    }
}

 

运行下测试类 — 打印结果如下:

客户端:发送的消息为:Server,Hello~
客户端:异步发送成功
服务端:服务端接收到客户端发送的消息为:Server,Hello~

(这里模拟服务端对数据处理时间,等待5秒)
服务端:数据处理成功,返回成功状态 200
客户端:服务端回调状态为:200

一步一步分析下代码,核心总结如下

1、接口作为方法参数,其实际传入引用指向的是实现类

2、Client的sendMsg方法中,参数final,因为要被内部类一个新的线程可以使用。这里就体现了异步

3、调用server的getClientMsg(),参数传入了Client本身(对应第一点)。

 

还有值得一提的是(逃

— 开源代码都在我的gitHub哦~

 

三、回调的应用场景

回调目前运用在什么场景比较多呢?从操作系统开发者调用

1、Windows平台的消息机制

2、异步调用微信接口,根据微信返回状态对出业务逻辑响应。

3、Servlet中的Filter(过滤器)是基于回调函数,需容器支持。

补充:其中 Filter(过滤器)和Interceptor(拦截器)的区别,拦截器基于是Java的反射机制,和容器无关。但与回调机制有异曲同工之妙。

总之,这设计让底层代码调用高层定义(实现层)的子程序,增强了程序的灵活性。

 

四、模式对比

上面讲了Filter和Intercepter有着异曲同工之妙。其实接口回调机制和一种设计模式—观察者模式也有相似之处:

观察者模式

GOF说道 — “定义对象的一种一对多的依赖关系,当一个对象的状态发送改变的时候,所有对他依赖的对象都被通知到并更新。”它是一种模式,是通过接口回调的方法实现的,即它是一种回调的体现。

接口回调

与观察者模式的区别是,它是种原理,而非具体实现。


五、心得

总结四步走:

机制,即是原理。

模式,即是体现。

记住具体场景,常见模式。

然后深入理解原理。

欢迎点击我的博客及GitHub — 博客提供RSS订阅哦!

———- http://www.bysocket.com/ ————- https://github.com/JeffLi1993 ———-

微         博:BYSocket  豆         瓣:BYSocket  FaceBook:BYSocket  Twitter    :BYSocket