笔记111
What,Why,How,When;
Struts2 中获取request,response,session,application 的方式1,2,
1:(1)使用帮助类ActionContext的静态方法 ActionContext.getContext()
(2)使用ServletActionContext帮助类的静态方法,ServletActionContext.getRequest();
ServletActionContext.getResponse();
2:IOC方式与EJB的方式相同,实现特定接口享受特定服务.
实现一定的回调接口.
org.apache.struts2.interceptor.ServletRequestAware;
org.apache.struts2.interceptor.ServletResponseAware;
org.apache.struts2.interceptor.ServletSessionAware;
系统的伸缩性:
1；响应时间
2：响应性
3：等待时间
4：吞吐率 对于一般企业通常用"每秒事务数"来度量.
5：负载
6：负载敏感度
7：效率
8；系统的容量. 指最大有效负载或吞吐率的指标
垂直可伸缩性和水平可伸缩性
死锁:两个事务出现相互等待对方释放的资源.
检测死锁，牺牲掉一个事务.
必免死锁：1短事务.
2合理安排表的访问顺序
3设置超时，但这有可能使并未死锁的事务出现不必要的牺牲,因为有的事务并未出现死锁，只是用的时间长一些.
4在事务开始就获得所有锁，事务进行期间不得再获取锁.
死锁:发生之前的检测，发生之后的处理.
业务事务,
系统事务.
乐观锁检测冲突，悲观锁避免冲突.
乐观锁在提交的最后才检测,这有可能要付出很大的重作代价.如果能够提前检测到并发冲突，会更有效.
Web层视图:模板视图(asp,php,jsp)，转换视图(xml+xslt)，两步视图.
架构上:MVC， 重要的两个分离:1.将表现逻辑和领域逻辑相分离
2.将表现逻辑和控制逻辑相分离
输入控制器的两个责任:1.处理HTTP的请求消息.
2.根据请求的消息来决定下一步做什么.
(1,2会表示成两个Map<String,String>)
FrontController
会话状态的处理:
1.客户端会话保持(1)Cookie (2)URL传参 (3)Hidden 隐藏表单域
2.服务器端会话保持.HttpSession, 有状态SessionBean.
3.数据库会话保持
系统:Linux
数据库:Oracle
面向对象,Java语言
应用服务器WebLogic
设计的臭味:
1,僵化性 Rigidity
2,脆弱性 Fragility
3,牢固性 Immobility
4,粘滞性 Viscosity
5,不必要的复杂性 Needless Complexity
6,不必要的重复 Needless Repetition
7,晦涩性 Opacity
找到一种方法，使得设计对于这种变化具有弹性，并应用一些
实践来防止这种腐化.
XP TDD,重构.
软件编程的基本:一是抽象,
二是封装,封装重复的代码，封装变化的代码.
GOF的第一条是编程(设计)到接口,不要编程(设计)到类或技术.
第二条是组合复合.
设计原则:
1,单一职责(SRP ),发散式的变仳(多个变化引起一个类的改动),
防止霰弹式的变化(一个变化引起多个类的改动),
一个类只有一个变化原因，一个变化只引起一个类的改变.
2,开闭原则(OCP Open-Closed Principle),1988年Meyer提出的.
3,Liskov里氏代换原则(LSP Liskov Substituation Principle), 子类型的可替换性,替换后行为不改变.
契约式编程:前提条件,后置条件,子类型只能弱化前提条件,只能强化后置条件(Meyer提出).
4,依赖倒置原则(DIP Dependency Iversion Prinicple), 的启发式规则:依赖抽象. 变量声明，方法参数，返回值都应使用超类型.
1>针对接口编程,不要设计到类，也不要设计到技术.
2>对变化的封装.每一个子类代表每一种变化的情况.
5,接口隔离原则(ISP Interface Segregation Prinicple) , 接口定义类型,客户消费类型，应当给客户最准确的类型以使用.
6,迪米特法则(LoD Law of Demeter) 关于类的内聚性和类之间的耦合性.
7,组合复合法则(CARP).
-----------------------------------------------------------------------------
包的六个设计原则:
一.包的内聚性(如何把类划分到包中)
1.重用发布等价原则.
2.共同重用原则(使用包中的一个类，则要重用包中的所有类).
3.共同封闭原则,(与类的单一职责遵守相同的原则).
二.包的耦合性(用来处理包之间的关系)
1.无环依赖原则.
2.稳定依赖原则(朝向稳定的方向进行依赖).
3.稳定抽象原则(包的抽象程度应和它的稳定程度相一致)
类的内聚性和类之间的耦合性.
///////////////////////////////////////////////////////////////////////////////////////////////////////////
重构: 名词:对软件内部结构的一种调整,目的是在不改变软件外部行为的前提下,提高其可理解性，降低其修改成本.
动词:使用一系列重构准则(手法),在不改变软件外部行为的前提下,调整其结构.
重构与性能的关系:
重构时机:1>系统增加功能时
2>修补错误时.
3>理解代码时,看是否可以用代码替代注释.
4>复审代码时.
5>开发时，时时重构,使重构成为一种习惯，而不是一种负担.
代码的坏味道:
1.重复的代码.(1)提炼出private方法,让其它方法调用它，在同一个类内.如果另外一个类也需要调用此方法，则应决定是否是其中一个类调用另一个类的方法，还是应将此方 法抽取到第三个类中，让另两个类都调用第三个类.
(2)互为兄弟的两个子类,提炼方法，并放置到超类中.
(3)提炼出方法,让其它方法调用它,需要确定方法的位置，Foreign Method(抽取到第三个类中),WrappedMethod(抽取到继承体系中).
2.过长方法.
3.过大类.
4.过长参数列.使用parameter object
5.发散式变化.(多个变化引起一个类发生变化)
6.霰弹式变化.(一个变化引起多个类发生变化)
7.依赖情结.方法,类的职责.
原则: 将总是一起变化的东西放在一起,Visitor,Strategy模式.
public class FirstCls {
public void process(Entity entity) {
int id = entity.getId();
String name = entity.getName();
.....//操作
}
}
public class Entity {
public void process() {
int id = this.getId();
String name = this.getName();
.....//操作.
}
}
//重构后的FirstCls
public class FirstCls {
Entity entity = ...;
public void process() {
entity.process();
}
}
8.数据泥团.将散乱的数据封装到一个值对象中,然后再添加操作以成为一个真正的对象.
9.基本型别偏执(Primitive Obsession)
10.switch惊悚现身(if then else).将条件语句转化为多态调用.
11.平行继承体系.
12.冗余类.(Lazy Class)
13.夸夸其谈未来性.
14.令人迷惑的临时变量.
15.过度耦合的消息链.
16.
17.
18.
19.不完美的程序类库.(Imcomplete Library Class):Foreign Method,Wrapped Method/SubClass Method
20.纯数据类.(Value Object)
21.将不正确的继承关系重构为两个兄弟类，并提取这两个类的超类.
22.过多的注释.当需要写注释的时候，试着是否可以用提炼代码代替注释.
////////////////////////////////////////////////////////////////////////////////////////////////////////////
临时变量只应赋值一次不应再次赋值.
临时变量只在它所处的方法中有意义.
而提炼到方法(Extract Method)中,则可以在整个类中被调用.
方法头表达“做什么”
方法体表达"怎么做",是对方法头的实现.
解释性变量.
Split Temporary Variable
在Java中不要对参数赋值.
Feature特性
Foreign Method(工具类),继承和Wrapper
类以名词命名
方法以动词命名.
消除方法的副作用(Modifier与Query分离开来).
Parameter Object
程序的健壮性:(1)优雅的失败.(2)设置默认值.(3)纠错能力,写一段恢复代码,重新回到正常的程序流中.
异常对程序的健壮性是有帮助的,编译期或运行期.
断言:程序执行的一种必要条件.
梳理并分解体系:建立两个继承体系，并通过委托关系，让其中一调用另一个,
(形式上很像Bridge Pattern,但与实质上所要表达的意义与Bridge Pattern有着根本的不同,
Bridge Pattern只是将一个继承体系分解开来，外观上是两个继承体系一个调用另一个，但
在概念上这两个继承体系所表达的仍只是一个继承体系，但经过这样的分解，使得继承强耦合的关系
变得可以在运行时动态组合，以带来灵活性，但代价是增加了复杂性.)
首先提炼类(Extract Class),将不同的责任进行分离.
再进行Move Method 和 Move Field.
/////////////////////////////////////////////////////////////////////////////////////////////////////
DI (Dependency Injection)依赖注入.
容器:指应用代码的运行框架. EJB容器,Web容器(管理Servlet),第三方的轻量级容(Spring).
任何容器都应提供的服务:
1.生命周期的管理
2.查找服务
3.配置管理
4.依赖决议.
一个轻量级容器应该有的特性:
1.管理应用代码.
2.可以快速启动
3。不需要任何特殊的部署步骤。
3。最小限度地依赖API,可以确保运行在不同环境中.
4。将对象交给轻量级容器管理时,不管工作量，还是性能都是最小.
Strategy 和 Template Method 组合和继承之间的选择.
提供服务,一种方式是使用回调接口,一种方式使用AOP方式将服务提供给容器中的对象.
编程性和声明性，如果能以声明性则优先选择声明性方式.
对象池: 积极Cache,时间和空间的折中.
依赖查找(提供一个工厂类)和回调接口(加入容器，以提供服务)
依赖注入的原则:应用对象不应该负责查询资源或其它依赖的组件，配置对象的工作应该由IOC容器完成,查找资源的代码
应该从应用代码中抽离出来，交由容器负责.!
OOP是一种层级关系的，继承性使得不同类型的对象共用相同的代码，多态性让我们用同样的方式处理不同类型的对象.
尽量少的重复代码，但无法避免代码的重复.
AOP的目的将分散的横切性逻辑进行模块化.
框架设计:IOC + AOP.
/////////////////////////////////////////////////////////////////////////////////////////////
XML 与 Java
解析XML DOM,SAX
DOM API:1,导航类方法 用于从一个节点转换到另一个节点.
2,信息类方法 用于获取给定节点的相关信息(查询).
3,管理类方法. 用于修改或设置一个节点的值或父子关系(增删改)
Node是所有节点的的超接口.
Document接口表示整个文档,并且它是创建各节点的工厂。
////////////////////////////////////////////////////////////////////////////////////////////////////////////
面向对象的基本概念:
对象:对象标识符,状态,操作. 它是类的实例化.
类:具有相同或相似性质的对象的抽象就是类.
面向对象的编程-1.重复代码的处理.
2.依赖倒转,如果编码是依赖倒转的,则是面向对象的,否则编码是过程性的.!
类的结构:通常有两种主要的结构关系. 1,is a 关系, 2, has a 关系.
类之间的关系完整描述(由弱至强):依赖,关联,聚合,复合,继承. 五种关系.前四种是运行时动态链接,继承是编译期链接.
类之间的耦合性:1.无耦合
2.具体耦合
3.抽象耦合(努力的方向)
通常，面对一个典型的面向对象程序，[Budd 2002]将其分成五个抽象层，分别覆盖了OOP中的分析，设计与编程的各个阶段:
1， 最高级别的抽象层上，程序被看成是由很多相互作用并且遵守契约的对象所组成的对象集合。对象之间相互合作完成程序的计算任务。这个抽象级别上的典型代表就是设计模式思想（Design Pattern）。
2， 第二个抽象层就是一个对象集单元，也就是一群定义之间有相互联系的对象，在程序设计语言级别来看Java中是packages,C++中是name space。这个抽象级别上的典型代表就是模块化思想(Modularity)。
3， 第三个抽象层所代表的是典型的OOP模式：客户/服务器模型，这主要是用来抽象两个对象之间的互交过程。在这个抽象级别上的典型代表就是对象之间的消息机制(Message Passing)。
如果能建模成"客户/服务器"模型就要使用这个模型，这样可以将对象建模成服务提供者和服务消费者.有利于建模.
4， 第四个抽象层就是针对一组相似对象定义一个类作为生成对象的模板，类定义了对象的对外使用接口以及继承对象所需的内部继承接口，而这个抽象层次的典型代表就是接口编程(Interface Programming)。
5， 第五个抽象层就是实现一个类所需要的方法和成员变量的实现(Implementation)。在这里OOP最终和POP（Procedure-Oriented Programming）相融合。
Introspector --> BeanInfo --> BeanDescriptor
--> PropertyDescriptor
--> MethodDescriptor
--> EventSetDescriptor
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
HTTP协议
HTTP消息:请求消息和响应消息.
格式:开始行(请求行或状态行),消息报头(可选的),空行(只有CRLF的行),消息正文(可选的)
请求消息:请求行,消息报头,.......
GET /form.html HTTP/1.1(CRLF)
....(消息报头)
CRLF
....(消息正文)
响应消息:状态行,消息报头,.......
HTTP/1.1 200 OK(CRLF)
....(消息报头)
CRLF
....(消息正文)
消息报头:(1)普通报头
(2)请求报头
(3)响应报头
(4)实体报头.
每一个报头域都是由 (名字 + ":" + 空格 + 值) 组成.
请求消息
HEAD /index.shtml HTTP/1.1
Host: www.sina.com.cn
响应消息
HTTP/1.0 200 OK
Date: Mon, 27 Jul 2009 08:56:27 GMT
Server: Apache/2.0.63 (Unix)
Last-Modified: Mon, 27 Jul 2009 08:50:05 GMT
Accept-Ranges: bytes
X-Powered-By: mod_xlayout_jh/0.0.1vhs.markII.remix
Cache-Control: max-age=60
Expires: Mon, 27 Jul 2009 08:57:27 GMT
Vary: Accept-Encoding
X-UA-Compatible: IE=EmulateIE7
Content-Type: text/html
X-Cache: MISS from xd33-91.HP08040030.sina.com.cn
Connection: close
/////////////////////////////////////////////////////////////////////////////////////////////////////////
复合视图组成方式.
include指令(转译包含)
jsp:include(runtime包含)
自定义标签(不要做超出视图角色之外的事情,事实上自定义标签是页面组成的一部分).
Web层与复合视图.
首先我们先明确Web层的设计目标"细而薄",
Web层的Controller用来控制流程和启动业务逻辑,
将控制逻辑与显示逻辑相分离.
Controller截获请求并分发到处理器，处理器处理完毕选取视图返回到Controller,Controller转发特定视图.
观察者模式:
1.推模型(适合复杂数据)和2.拉模型(适合小数据量).
MVC模型.
1.推(PUSH)模型(C/S)和2.拉(PULL)模型(B/S).
视图与控制代码的分离.
视图与模型代码的分离.
Web层应该含有尽可能少的业务处理代码,这可提高可测试性和可重用性,这样就可以保证整个Web层的替换,可以使用WebService
做为服务消费者.即使不是整个Web层的替换,JSP的替换仍然是可以的.JSP只用来做为数据采集入口和数据显示(可能会包含显示逻辑).
Wap页面和Html页面可以共用相同的Web层的控制代码.
显示逻辑
控制逻辑
业务逻辑
数据访问逻辑
JSP充当视图之外角色引起的问题:
1.这个JSP页有两个角色(显示一个输入表单和显示该表单的结果),使它阅读起来混淆不清.
2.模板数据与JSP之间的参数转义是混淆不清的,虽然JSP创作工具将帮助防止不匹配的<%和%>,但没有任何办法使本页面中的Java控制结构(if,try/catch)与标签生成的组合变得更易读。理解视图需要Java知识，但页面人员不懂Java.
3.重复代码收引起的问题,JSP页面和一些业务对象的EJB实现结合在一起,如果我们弃用EJB，将需要修改所有 这样的页面.
4.JSP页的结构没有体现它将生成的内容，在它的每个角色中，输出结果将是不同的。异常处理是原始的，当我们正在生成动态内容的时候，我们可能会遇到错误，而处理它们太迟了，错误将会导致产生错误页面，由于处理不及时，以致不能对特定类型的错误执行适当的控制流程.
5.增加诸如用户输入是数值之类的检查并相应地警告用户将是困难的，页面将会变得更难读懂.
6.服务器小程序中有太多的JAVA代码，以致观察将被生成的标签是很困难的。
7.由于使用了像这样的JSP页面，所以修改表示层代码可能会破坏业务逻辑.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
<!--hibernate-mapping DTD文档 -->
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!--hibernate-configuration DTD文档-->
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
时间和空间的折中:
每一种数据结构与算法都有其时间、空间的开销和收益。当面临一个新的设计问题时，设计者要彻底地掌握怎样权衡时空开销和算法有效性的方法。这就需要懂得算法分析的原理，而且还需要了解所使用的物理介质的特性（例如，数据存储在磁盘上与存储在内存中，就有不同的考虑）。
与开销和收益有关的是时间——空间的权衡。通常可以用更大的时间开销来换取空间的收益，反之亦然。时间——空间的权衡普遍地存在于软件开发的各个阶段中。
例如:ArrayList 和 LinkedList
Struts2 中获取request,response,session,application 的方式1,2,
1:(1)使用帮助类ActionContext的静态方法 ActionContext.getContext()
(2)使用ServletActionContext帮助类的静态方法,ServletActionContext.getRequest();
ServletActionContext.getResponse();
2:IOC方式与EJB的方式相同,实现特定接口享受特定服务.
实现一定的回调接口.
org.apache.struts2.interceptor.ServletRequestAware;
org.apache.struts2.interceptor.ServletResponseAware;
org.apache.struts2.interceptor.ServletSessionAware;
系统的伸缩性:
1；响应时间
2：响应性
3：等待时间
4：吞吐率 对于一般企业通常用"每秒事务数"来度量.
5：负载
6：负载敏感度
7：效率
8；系统的容量. 指最大有效负载或吞吐率的指标
垂直可伸缩性和水平可伸缩性
死锁:两个事务出现相互等待对方释放的资源.
检测死锁，牺牲掉一个事务.
必免死锁：1短事务.
2合理安排表的访问顺序
3设置超时，但这有可能使并未死锁的事务出现不必要的牺牲,因为有的事务并未出现死锁，只是用的时间长一些.
4在事务开始就获得所有锁，事务进行期间不得再获取锁.
死锁:发生之前的检测，发生之后的处理.
业务事务,
系统事务.
乐观锁检测冲突，悲观锁避免冲突.
乐观锁在提交的最后才检测,这有可能要付出很大的重作代价.如果能够提前检测到并发冲突，会更有效.
Web层视图:模板视图(asp,php,jsp)，转换视图(xml+xslt)，两步视图.
架构上:MVC， 重要的两个分离:1.将表现逻辑和领域逻辑相分离
2.将表现逻辑和控制逻辑相分离
输入控制器的两个责任:1.处理HTTP的请求消息.
2.根据请求的消息来决定下一步做什么.
(1,2会表示成两个Map<String,String>)
FrontController
会话状态的处理:
1.客户端会话保持(1)Cookie (2)URL传参 (3)Hidden 隐藏表单域
2.服务器端会话保持.HttpSession, 有状态SessionBean.
3.数据库会话保持
系统:Linux
数据库:Oracle
面向对象,Java语言
应用服务器WebLogic
设计的臭味:
1,僵化性 Rigidity
2,脆弱性 Fragility
3,牢固性 Immobility
4,粘滞性 Viscosity
5,不必要的复杂性 Needless Complexity
6,不必要的重复 Needless Repetition
7,晦涩性 Opacity
找到一种方法，使得设计对于这种变化具有弹性，并应用一些
实践来防止这种腐化.
XP TDD,重构.
软件编程的基本:一是抽象,
二是封装,封装重复的代码，封装变化的代码.
GOF的第一条是编程(设计)到接口,不要编程(设计)到类或技术.
第二条是组合复合.
设计原则:
1,单一职责(SRP ),发散式的变仳(多个变化引起一个类的改动),
防止霰弹式的变化(一个变化引起多个类的改动),
一个类只有一个变化原因，一个变化只引起一个类的改变.
2,开闭原则(OCP Open-Closed Principle),1988年Meyer提出的.
3,Liskov里氏代换原则(LSP Liskov Substituation Principle), 子类型的可替换性,替换后行为不改变.
契约式编程:前提条件,后置条件,子类型只能弱化前提条件,只能强化后置条件(Meyer提出).
4,依赖倒置原则(DIP Dependency Iversion Prinicple), 的启发式规则:依赖抽象. 变量声明，方法参数，返回值都应使用超类型.
1>针对接口编程,不要设计到类，也不要设计到技术.
2>对变化的封装.每一个子类代表每一种变化的情况.
5,接口隔离原则(ISP Interface Segregation Prinicple) , 接口定义类型,客户消费类型，应当给客户最准确的类型以使用.
6,迪米特法则(LoD Law of Demeter) 关于类的内聚性和类之间的耦合性.
7,组合复合法则(CARP).
-----------------------------------------------------------------------------
包的六个设计原则:
一.包的内聚性(如何把类划分到包中)
1.重用发布等价原则.
2.共同重用原则(使用包中的一个类，则要重用包中的所有类).
3.共同封闭原则,(与类的单一职责遵守相同的原则).
二.包的耦合性(用来处理包之间的关系)
1.无环依赖原则.
2.稳定依赖原则(朝向稳定的方向进行依赖).
3.稳定抽象原则(包的抽象程度应和它的稳定程度相一致)
类的内聚性和类之间的耦合性.
///////////////////////////////////////////////////////////////////////////////////////////////////////////
重构: 名词:对软件内部结构的一种调整,目的是在不改变软件外部行为的前提下,提高其可理解性，降低其修改成本.
动词:使用一系列重构准则(手法),在不改变软件外部行为的前提下,调整其结构.
重构与性能的关系:
重构时机:1>系统增加功能时
2>修补错误时.
3>理解代码时,看是否可以用代码替代注释.
4>复审代码时.
5>开发时，时时重构,使重构成为一种习惯，而不是一种负担.
代码的坏味道:
1.重复的代码.(1)提炼出private方法,让其它方法调用它，在同一个类内.如果另外一个类也需要调用此方法，则应决定是否是其中一个类调用另一个类的方法，还是应将此方 法抽取到第三个类中，让另两个类都调用第三个类.
(2)互为兄弟的两个子类,提炼方法，并放置到超类中.
(3)提炼出方法,让其它方法调用它,需要确定方法的位置，Foreign Method(抽取到第三个类中),WrappedMethod(抽取到继承体系中).
2.过长方法.
3.过大类.
4.过长参数列.使用parameter object
5.发散式变化.(多个变化引起一个类发生变化)
6.霰弹式变化.(一个变化引起多个类发生变化)
7.依赖情结.方法,类的职责.
原则: 将总是一起变化的东西放在一起,Visitor,Strategy模式.
public class FirstCls {
public void process(Entity entity) {
int id = entity.getId();
String name = entity.getName();
.....//操作
}
}
public class Entity {
public void process() {
int id = this.getId();
String name = this.getName();
.....//操作.
}
}
//重构后的FirstCls
public class FirstCls {
Entity entity = ...;
public void process() {
entity.process();
}
}
8.数据泥团.将散乱的数据封装到一个值对象中,然后再添加操作以成为一个真正的对象.
9.基本型别偏执(Primitive Obsession)
10.switch惊悚现身(if then else).将条件语句转化为多态调用.
11.平行继承体系.
12.冗余类.(Lazy Class)
13.夸夸其谈未来性.
14.令人迷惑的临时变量.
15.过度耦合的消息链.
16.
17.
18.
19.不完美的程序类库.(Imcomplete Library Class):Foreign Method,Wrapped Method/SubClass Method
20.纯数据类.(Value Object)
21.将不正确的继承关系重构为两个兄弟类，并提取这两个类的超类.
22.过多的注释.当需要写注释的时候，试着是否可以用提炼代码代替注释.
////////////////////////////////////////////////////////////////////////////////////////////////////////////
临时变量只应赋值一次不应再次赋值.
临时变量只在它所处的方法中有意义.
而提炼到方法(Extract Method)中,则可以在整个类中被调用.
方法头表达“做什么”
方法体表达"怎么做",是对方法头的实现.
解释性变量.
Split Temporary Variable
在Java中不要对参数赋值.
Feature特性
Foreign Method(工具类),继承和Wrapper
类以名词命名
方法以动词命名.
消除方法的副作用(Modifier与Query分离开来).
Parameter Object
程序的健壮性:(1)优雅的失败.(2)设置默认值.(3)纠错能力,写一段恢复代码,重新回到正常的程序流中.
异常对程序的健壮性是有帮助的,编译期或运行期.
断言:程序执行的一种必要条件.
梳理并分解体系:建立两个继承体系，并通过委托关系，让其中一调用另一个,
(形式上很像Bridge Pattern,但与实质上所要表达的意义与Bridge Pattern有着根本的不同,
Bridge Pattern只是将一个继承体系分解开来，外观上是两个继承体系一个调用另一个，但
在概念上这两个继承体系所表达的仍只是一个继承体系，但经过这样的分解，使得继承强耦合的关系
变得可以在运行时动态组合，以带来灵活性，但代价是增加了复杂性.)
首先提炼类(Extract Class),将不同的责任进行分离.
再进行Move Method 和 Move Field.
/////////////////////////////////////////////////////////////////////////////////////////////////////
DI (Dependency Injection)依赖注入.
容器:指应用代码的运行框架. EJB容器,Web容器(管理Servlet),第三方的轻量级容(Spring).
任何容器都应提供的服务:
1.生命周期的管理
2.查找服务
3.配置管理
4.依赖决议.
一个轻量级容器应该有的特性:
1.管理应用代码.
2.可以快速启动
3。不需要任何特殊的部署步骤。
3。最小限度地依赖API,可以确保运行在不同环境中.
4。将对象交给轻量级容器管理时,不管工作量，还是性能都是最小.
Strategy 和 Template Method 组合和继承之间的选择.
提供服务,一种方式是使用回调接口,一种方式使用AOP方式将服务提供给容器中的对象.
编程性和声明性，如果能以声明性则优先选择声明性方式.
对象池: 积极Cache,时间和空间的折中.
依赖查找(提供一个工厂类)和回调接口(加入容器，以提供服务)
依赖注入的原则:应用对象不应该负责查询资源或其它依赖的组件，配置对象的工作应该由IOC容器完成,查找资源的代码
应该从应用代码中抽离出来，交由容器负责.!
OOP是一种层级关系的，继承性使得不同类型的对象共用相同的代码，多态性让我们用同样的方式处理不同类型的对象.
尽量少的重复代码，但无法避免代码的重复.
AOP的目的将分散的横切性逻辑进行模块化.
框架设计:IOC + AOP.
/////////////////////////////////////////////////////////////////////////////////////////////
XML 与 Java
解析XML DOM,SAX
DOM API:1,导航类方法 用于从一个节点转换到另一个节点.
2,信息类方法 用于获取给定节点的相关信息(查询).
3,管理类方法. 用于修改或设置一个节点的值或父子关系(增删改)
Node是所有节点的的超接口.
Document接口表示整个文档,并且它是创建各节点的工厂。
////////////////////////////////////////////////////////////////////////////////////////////////////////////
面向对象的基本概念:
对象:对象标识符,状态,操作. 它是类的实例化.
类:具有相同或相似性质的对象的抽象就是类.
面向对象的编程-1.重复代码的处理.
2.依赖倒转,如果编码是依赖倒转的,则是面向对象的,否则编码是过程性的.!
类的结构:通常有两种主要的结构关系. 1,is a 关系, 2, has a 关系.
类之间的关系完整描述(由弱至强):依赖,关联,聚合,复合,继承. 五种关系.前四种是运行时动态链接,继承是编译期链接.
类之间的耦合性:1.无耦合
2.具体耦合
3.抽象耦合(努力的方向)
通常，面对一个典型的面向对象程序，[Budd 2002]将其分成五个抽象层，分别覆盖了OOP中的分析，设计与编程的各个阶段:
1， 最高级别的抽象层上，程序被看成是由很多相互作用并且遵守契约的对象所组成的对象集合。对象之间相互合作完成程序的计算任务。这个抽象级别上的典型代表就是设计模式思想（Design Pattern）。
2， 第二个抽象层就是一个对象集单元，也就是一群定义之间有相互联系的对象，在程序设计语言级别来看Java中是packages,C++中是name space。这个抽象级别上的典型代表就是模块化思想(Modularity)。
3， 第三个抽象层所代表的是典型的OOP模式：客户/服务器模型，这主要是用来抽象两个对象之间的互交过程。在这个抽象级别上的典型代表就是对象之间的消息机制(Message Passing)。
如果能建模成"客户/服务器"模型就要使用这个模型，这样可以将对象建模成服务提供者和服务消费者.有利于建模.
4， 第四个抽象层就是针对一组相似对象定义一个类作为生成对象的模板，类定义了对象的对外使用接口以及继承对象所需的内部继承接口，而这个抽象层次的典型代表就是接口编程(Interface Programming)。
5， 第五个抽象层就是实现一个类所需要的方法和成员变量的实现(Implementation)。在这里OOP最终和POP（Procedure-Oriented Programming）相融合。
Introspector --> BeanInfo --> BeanDescriptor
--> PropertyDescriptor
--> MethodDescriptor
--> EventSetDescriptor
/////////////////////////////////////////////////////////////////////////////////////////////////////////////
HTTP协议
HTTP消息:请求消息和响应消息.
格式:开始行(请求行或状态行),消息报头(可选的),空行(只有CRLF的行),消息正文(可选的)
请求消息:请求行,消息报头,.......
GET /form.html HTTP/1.1(CRLF)
....(消息报头)
CRLF
....(消息正文)
响应消息:状态行,消息报头,.......
HTTP/1.1 200 OK(CRLF)
....(消息报头)
CRLF
....(消息正文)
消息报头:(1)普通报头
(2)请求报头
(3)响应报头
(4)实体报头.
每一个报头域都是由 (名字 + ":" + 空格 + 值) 组成.
请求消息
HEAD /index.shtml HTTP/1.1
Host: www.sina.com.cn
响应消息
HTTP/1.0 200 OK
Date: Mon, 27 Jul 2009 08:56:27 GMT
Server: Apache/2.0.63 (Unix)
Last-Modified: Mon, 27 Jul 2009 08:50:05 GMT
Accept-Ranges: bytes
X-Powered-By: mod_xlayout_jh/0.0.1vhs.markII.remix
Cache-Control: max-age=60
Expires: Mon, 27 Jul 2009 08:57:27 GMT
Vary: Accept-Encoding
X-UA-Compatible: IE=EmulateIE7
Content-Type: text/html
X-Cache: MISS from xd33-91.HP08040030.sina.com.cn
Connection: close
/////////////////////////////////////////////////////////////////////////////////////////////////////////
复合视图组成方式.
include指令(转译包含)
jsp:include(runtime包含)
自定义标签(不要做超出视图角色之外的事情,事实上自定义标签是页面组成的一部分).
Web层与复合视图.
首先我们先明确Web层的设计目标"细而薄",
Web层的Controller用来控制流程和启动业务逻辑,
将控制逻辑与显示逻辑相分离.
Controller截获请求并分发到处理器，处理器处理完毕选取视图返回到Controller,Controller转发特定视图.
观察者模式:
1.推模型(适合复杂数据)和2.拉模型(适合小数据量).
MVC模型.
1.推(PUSH)模型(C/S)和2.拉(PULL)模型(B/S).
视图与控制代码的分离.
视图与模型代码的分离.
Web层应该含有尽可能少的业务处理代码,这可提高可测试性和可重用性,这样就可以保证整个Web层的替换,可以使用WebService
做为服务消费者.即使不是整个Web层的替换,JSP的替换仍然是可以的.JSP只用来做为数据采集入口和数据显示(可能会包含显示逻辑).
Wap页面和Html页面可以共用相同的Web层的控制代码.
显示逻辑
控制逻辑
业务逻辑
数据访问逻辑
JSP充当视图之外角色引起的问题:
1.这个JSP页有两个角色(显示一个输入表单和显示该表单的结果),使它阅读起来混淆不清.
2.模板数据与JSP之间的参数转义是混淆不清的,虽然JSP创作工具将帮助防止不匹配的<%和%>,但没有任何办法使本页面中的Java控制结构(if,try/catch)与标签生成的组合变得更易读。理解视图需要Java知识，但页面人员不懂Java.
3.重复代码收引起的问题,JSP页面和一些业务对象的EJB实现结合在一起,如果我们弃用EJB，将需要修改所有 这样的页面.
4.JSP页的结构没有体现它将生成的内容，在它的每个角色中，输出结果将是不同的。异常处理是原始的，当我们正在生成动态内容的时候，我们可能会遇到错误，而处理它们太迟了，错误将会导致产生错误页面，由于处理不及时，以致不能对特定类型的错误执行适当的控制流程.
5.增加诸如用户输入是数值之类的检查并相应地警告用户将是困难的，页面将会变得更难读懂.
6.服务器小程序中有太多的JAVA代码，以致观察将被生成的标签是很困难的。
7.由于使用了像这样的JSP页面，所以修改表示层代码可能会破坏业务逻辑.
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////
<!--hibernate-mapping DTD文档 -->
<!DOCTYPE hibernate-mapping PUBLIC
"-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<!--hibernate-configuration DTD文档-->
<!DOCTYPE hibernate-configuration PUBLIC
"-//Hibernate/Hibernate Configuration DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
时间和空间的折中:
每一种数据结构与算法都有其时间、空间的开销和收益。当面临一个新的设计问题时，设计者要彻底地掌握怎样权衡时空开销和算法有效性的方法。这就需要懂得算法分析的原理，而且还需要了解所使用的物理介质的特性（例如，数据存储在磁盘上与存储在内存中，就有不同的考虑）。
与开销和收益有关的是时间——空间的权衡。通常可以用更大的时间开销来换取空间的收益，反之亦然。时间——空间的权衡普遍地存在于软件开发的各个阶段中。
例如:ArrayList 和 LinkedList