参数

抽象类

接口

默认的方法实现

它可以有默认的方法实现

接口完全是抽象的。它根本不存在方法的实现

实现

子类使用extends关键字来继承抽象类。如果子类不是抽象类的话，它需要提供抽象类中所有声明的方法的实现。

子类使用关键字implements来实现接口。它需要提供接口中所有声明的方法的实现

构造器

抽象类可以有构造器

接口不能有构造器

与正常Java类的区别

除了你不能实例化抽象类之外，它和普通Java类没有任何区别

接口是完全不同的类型

访问修饰符

抽象方法可以有public、protected和default这些修饰符

接口方法默认修饰符是public。你不可以使用其它修饰符。

main方法

抽象方法可以有main方法并且我们可以运行它

接口没有main方法，因此我们不能运行它。

多继承

抽象方法可以继承一个类和实现多个接口

接口只可以继承一个或多个其它接口

速度

它比接口速度要快

接口是稍微有点慢的，因为它需要时间去寻找在类中实现的方法。

添加新方法

如果你往抽象类中添加新的方法，你可以给它提供默认的实现。因此你不需要改变你现在的代码。

如果你往接口中添加方法，那么你必须改变实现该接口的类。

在Java中，正则表达式是通过java.util.regex包中的Pattern和Matcher两个类来实现的。一个Pattern对象表示一个正则表达式的编译版本，可以做类似的对比，就好像是java文件和class文件，一个是让程序员看的，一个是让虚拟机执行的，在Java中一个正则表达式要转换为Pattern对象才能最终被使用，Pattern的complie()方法可以实现，同时，我们可以使用matcher()方法和输入字符串从编译过的Pattern对象中产生Matcher对象，在Matcher中可以得到你想要得到的处理完成以后的结果值的信息。

下来介绍Matcher类中的几个重要方法：

1）find()：用户发现应用于CharSequence（即输入的字符串）的多重模式匹配，find()就像是一种迭代器，可以在输入字符串中向前移动迭代，在find()的第二版中，可以指定一个整型参数以告知要开始搜索的字符的位置；

2）groupCount()：在介绍这个方法的之前，现介绍一个概念：“组”

组是由圆括号分开的多个正则表达式，随后可以根据它们的组号进行调用。第0组表示整个匹配表达式，第1组表示第一个用圆括号括起来的组，等等，因此，在表达式A(B(C))D中有三个组：第0组ABCD，第1组BC，第2组C。

groupCount()方法返回该模式中分组的数目。要注意的是第0组不包括在内。

3）group()：返回由以前匹配操作所匹配的输入子序列。

4）group(int i)：返回在以前匹配操作期间由给定组捕获的输入子序列。如果匹配成功，但是指定的组没有匹配输入字符串的任何部分，将返回null。

5）start(int group)：返回在以前的匹配操作期间，由给定组所捕获的子序列的初始索引。

6）end(int group)：返回在以前的匹配操作期间，由给定组所捕获子序列的最后字符之后的偏移量。

7）start()： 返回以前匹配的初始索引。

8）end()： 返回最后匹配字符之后的偏移量。

模式标记：

模式标记是可以影响正则表达式的匹配行为的标记参数，为方便理解，列出这些标记的作用：

Pattern.CANON_EQ ：启用规范等价。

Pattern.CASE_INSENSITIVE ：启用不区分大小写的匹配。

Pattern.COMMENTS ：模式中允许空白和注释。

Pattern.DOTALL ：启用 dotall 模式，在dotall模式中，表达式.匹配多有字符，包括行终结符，缺省情况下，.表达式不匹配行终结符。

Pattern.LITERAL ：启用模式的字面值分析。

Pattern.MULTILINE ：启用多行模式。

Pattern.UNICODE_CASE ：启用 Unicode 感知的大小写折叠。

Pattern.UNIX_LINES ：启用 Unix 行模式。

替换操作：

替换操作在正则表达式中起了尤为重要的作用，能够实现替换操作的几个方法是：

1）replaceFirst(String replacement) ：用replacement替换输入字符串中最先匹配的部分。

2）replaceAll(String replacement) ：用replacement替换输入字符串中所有匹配的部分。

3）appendReplacement(StringBuffer sb, String replacement) ：逐步的在sb中执行替换；而不是像replaceFirst()那样仅替换第一个匹配，或者像replaceAll()那样替换所有的匹配。这是个非常重要的方法，因为它允许我们通过调用某些方法来执行一些其他处理来产生replacement（而不像replaceFirst()和replaceAll()只能输入固定字符串）。有了这个方法，我们就可以通过编程来实现将目标拆分成组以及创建功能强大的替换。

4）appendTail(StringBuffer sb) ：在一个或多个appendReplacement()调用之后被调用，以便复制输入字符串的剩余部分。

reset(String s)方法：可以将Matcher对象应用于一个新的字符序列。

String 类型和StringBuffer的主要性能区别：String是不可变的对象, 因此在每次对String 类型进行改变的时候，都会生成一个新的 String 对象，然后将指针指向新的 String 对象，所以经常改变内容的字符串最好不要用 String ，因为每次生成对象都会对系统性能产生影响，特别当内存中无引用对象多了以后， JVM 的 GC 就会开始工作，性能就会降低。

使用 StringBuffer 类时，每次都会对 StringBuffer 对象本身进行操作，而不是生成新的对象并改变对象引用。所以多数情况下推荐使用 StringBuffer ，特别是字符串对象经常改变的情况下。

在某些特别情况下， String 对象的字符串拼接其实是被 Java Compiler 编译成了 StringBuffer 对象的拼接，所以这些时候 String 对象的速度并不会比 StringBuffer 对象慢.

StringBuilder与StringBuffer有公共父类AbstractStringBuilder(抽象类)。

StringBuilder、StringBuffer的方法都会调用AbstractStringBuilder中的公共方法，如super.append(...)。只是StringBuffer会在方法上加synchronized关键字，进行同步。

最后，如果程序不是多线程的，那么使用StringBuilder效率高于StringBuffer。

访问权限    类    包   子类   其他包

public     ∨   ∨   ∨     ∨

protect    ∨   ∨   ∨      ×

default    ∨   ∨   ×     ×

private    ∨   ×   ×     ×

ArrayList 是一个可改变大小的数组.当更多的元素加入到ArrayList中时,其大小将会动态地增长.内部的元素可以直接通过get与set方法进行访问,因为ArrayList本质上就是一个数组.

LinkedList 是一个双链表,在添加和删除元素时具有比ArrayList更好的性能.但在get与set方面弱于ArrayList.

当然,这些对比都是指数据量很大或者操作很频繁的情况下的对比,如果数据和运算量很小,那么对比将失去意义.

Vector 和ArrayList类似,但属于强同步类。如果你的程序本身是线程安全的(thread-safe,没有在多个线程之间共享同一个集合/对象),那么使用ArrayList是更好的选择。

Vector和ArrayList在更多元素添加进来时会请求更大的空间。Vector每次请求其大小的双倍空间，而ArrayList每次对size增长50%.

而 LinkedList 还实现了 Queue 接口,该接口比List提供了更多的方法,包括 offer(),peek(),poll()等.

注意: 默认情况下ArrayList的初始容量非常小,所以如果可以预估数据量的话,分配一个较大的初始值属于最佳实践,这样可以减少调整大小的开销。

1、List,Set都是继承自Collection接口

2、List特点：元素有放入顺序，元素可重复 ，Set特点：元素无放入顺序，元素不可重复（注意：元素虽然无放入顺序，但是元素在set中的位置是有该元素的HashCode决定的，其位置其实是固定的）

3、List接口有三个实现类：LinkedList，ArrayList，Vector ，Set接口有两个实现类：HashSet(底层由HashMap实现)，LinkedHashSet

1. 编写排序类实现Comparator接口
2. 实现Comparator接口的compare方法
3. Collections.sort(集合, 排序类);

1)      排序(Sort)
使用sort方法可以根据元素的自然顺序
对指定列表按升序进行排序。列表中的所有元素都必须实现 Comparable 接口。此列表内的所有元素都必须是使用指定比较器可相互比较的

2)     
混排（Shuffling）
混排算法所做的正好与 sort 相反: 它打乱在一个 List 中可能有的任何排列的踪迹。也就是说，基于随机源的输入重排该 List,
这样的排列具有相同的可能性（假设随机源是公正的）。这个算法在实现一个碰运气的游戏中是非常有用的。例如，它可被用来混排代表一副牌的 Card
对象的一个 List 。另外，在生成测试案例时，它也是十分有用的。

3)     
反转(Reverse)
       使用Reverse方法可以根据元素的自然顺序
对指定列表按降序进行排序。

4)     
替换所以的元素(Fill)
使用指定元素替换指定列表中的所有元素。

5)     
拷贝(Copy)
用两个参数，一个目标 List 和一个源 List, 将源的元素拷贝到目标，并覆盖它的内容。目标 List 至少与源一样长。如果它更长，则在目标
List 中的剩余元素不受影响。

6)     
返回Collections中最小元素(min)
根据指定比较器产生的顺序，返回给定 collection 的最小元素。collection 中的所有元素都必须是通过指定比较器可相互比较的

7)     
返回Collections中最小元素(max)
根据指定比较器产生的顺序，返回给定 collection 的最大元素。collection 中的所有元素都必须是通过指定比较器可相互比较的

8)     
lastIndexOfSubList
返回指定源列表中最后一次出现指定目标列表的起始位置

9)     
IndexOfSubList
返回指定源列表中第一次出现指定目标列表的起始位置

10)  
Rotate
根据指定的距离循环移动指定列表中的元素

Java
的堆是一个运行时数据区,类的(对象从中分配空间。这些对象通过new、newarray、anewarray和multianewarray等指令建立，它们不需要程序代码来显式的释放。堆是由垃圾回收来负责的，堆的优势是可以动态地分配内存大小，生存期也不必事先告诉编译器，因为它是在运行时动态分配内存的，Java的垃圾收集器会自动收走这些不再使用的数据。但缺点是，由于要在运行时动态分配内存，存取速度较慢。"

栈的优势是，存取速度比堆要快，仅次于寄存器，栈数据可以共享。但缺点是，存在栈中的数据大小与生存期必须是确定的，缺乏灵活性。栈中主要存放一些基本类型的变量（,int,
short, long, byte, float, double, boolean, char）和对象句柄。

AnnotationTypeMismatchException,

ArithmeticException,

ArrayStoreException,

BufferOverflowException,

BufferUnderflowException,

CannotRedoException,

CannotUndoException,

ClassCastException,

CMMException,

ConcurrentModificationException,

DOMException,

EmptyStackException,

EnumConstantNotPresentException,

EventException,

IllegalArgumentException,

IllegalMonitorStateException,

IllegalPathStateException,

IllegalStateException,

ImagingOpException,

IncompleteAnnotationException,

IndexOutOfBoundsException,

JMRuntimeException,

LSException,

MalformedParameterizedTypeException,

MirroredTypeException,

MirroredTypesException,

MissingResourceException,

NegativeArraySizeException,

NoSuchElementException,

NoSuchMechanismException,

NullPointerException,

ProfileDataException,

ProviderException,

RasterFormatException,

RejectedExecutionException,

SecurityException,

SystemException,

TypeConstraintException,

TypeNotPresentException,

UndeclaredThrowableException,

UnknownAnnotationValueException,

UnknownElementException,

UnknownTypeException,

UnmodifiableSetException,

UnsupportedOperationException,

WebServiceException

常见的5中运行时异常。

例如：ClassCastException(类转换异常)

IndexOutOfBoundsException(数组越界)

NullPointerException(空指针)

ArrayStoreException(数据存储异常，操作数组时类型不一致)

还有IO操作的BufferOverflowException异常

java异常处理机制主要依赖于try，catch，finally，throw，throws五个关键字。

try
关键字后紧跟一个花括号括起来的代码块，简称try块。同理：下面的也被称为相应的块。它里面可置引发异常的代码。catch后对应异常类型和一个代码块，用于表明catch块用于处理这种类型的代码块。后还可以跟一个finally块，finally块用于回收在try块里打开的物理资源，异常机制会保证finally块总被执行。throws关键字主要在方法签名中使用，用于声明该方法可能抛出的异常，而throw则用于抛出一个实际的异常，throw可以单独作为语句使用，抛出一个具体的异常的对象

java异常处理可以让程序具有更好的容错性，程序更加健壮。当程序　出现意外情形时，系统会自动生成一个Exception对象来通知程序，从而实现将“业务功能实现代码”和“错误处理代码”分离，提供更好的可读性。

如果执行try块里的业务逻辑代码时出现异常，系统自动会生成一个异常对象，该异常对象被提交给java运行环境，这个过程被称为抛出（throw）异常。当java运行环境收到异常对象时，会寻找处理该异常对象的catch块，如果找到合适的catch块并把该异常交给它处理，该过程被称为捕获异常；如果java运行环境找不到捕获异常的catch块，则运行环境终止，程序也将退出。

使用finally回收物理资源

当程序在try块里打开了的一些物理资源（数据库连接，网络连接及磁盘文件），这些物理资源必须显示回收。为了保证一定能够回收try块中打开的物理资源，异常处理机制提供了finally块，无论try块中的代码是否出现异常，也不管在哪个catch块中被执行，finally块总会被执行。异常处理结构语法中只有try块是必须的，一旦没有try块，则不能出现catch和finally块，如果存在try块，则catch块和finally块都是可选的。但二者至少要出现其一。也可以同时出现多个catch块。catch块必须位于try块后面，而finally必须位于catch块后面（如果存在的话）；

　　当java程序执行try块，catch块，时遇到了return语句或throw语句，这两个语句都会导致该方法的立即结束，但是系统并不会立即执行这两个语句，而是去寻找该异常处理流程中是否包含finally块，如果没有finally块程序立即执行return语句或throw语句，方法终止。反之，则系统会立即执行finally块——只有当finally块执行完后，系统才会再次跳回来执行try块，catch块里的return或throw语句，如果同时在　finally块中也存在return或throw语句，则finally块已经终止了方法，自然不存在系统再次跳转去执行try或catch块里的return或throw语句。

使用throws声明抛出异常的思路是：当前方法不知道应该如何处理这种异常，该异常应该由上一级调用者处理，如果main方法也不知道如何处理这种异常类型。也可以使用throws声明抛出异常，把该异常交给javaJVM处理。

语法:

Try{

可能出现异常的代码

}catch(Exception
e){

出现异常后的处理

}finally{

不管出现异常与否都要执行的代码

}

Java避免空指针

====

1.空指针引起的原因

----

* 调用空对象的方法

* 访问或更新空对象的变量

* 获取空集合的长度

* 访问或更新空集合中的内容

* 抛出空的Throwable对象

* 同步空对象

2.避免空指针

----

为避免空指针，应当在使用之前确保对其做了适当的初始化。

1. 比较字符串时，模板在前，如：

>
Sting str = null;

>
if("test".equals(str)){

>
//do something

> }

2. 检查方法传进来的参数是否为空，如：

>
public static int getLength(){

> if(s == null){

> throw new IllegalArgumentException("The argument cannot be
null");    >

> }

> return s.length();

> }

3. 使用String.valueOf()而不是toString()

4. 使用三元操作符,如：

>
String message = (str == null) ? "":"message";

5. 方法返回空集合，而不是null，如：

>
private static List<Integer> getList(String jsonData){

> if(jsonData == null){

> return Collections.emptyList();

> }

> //do something

> }

6. 使用Apache
StringUtils类（如果是Android的话，可以使用TextUtils.isEmpty()方法），如：

>
if(TextUtils.isEmpty(str))

7. 合理使用contains(),containsKey,containsValue等方法，如：

*

>
Map<String, String> map = ...

>
...

>
String key = ...

>
if(map.containsKey(key)){

> //do something

> }

*     >
JSONObject jsonObject= new JSONObject() ;

> String key = ...

> if (jsonObject.has(key)) {

> try {

> long result = jsonObject.getLong(key);

> } catch (JSONException e) {

> e.printStackTrace();

> }

> }

8. 检查外部方法的返回值是否为空

9. 使用Assertions(断言)，如：

>
public static int getLength(String str){

> /*确定string不为空*/

> assert(str!=null);

> return str.length();

> }

此时如果str为空，那么则抛出java.lang.AssertionError异常而不是空指针异常

10. 使用单元测试

1. 首先通过Connection对象创建CallableStatement的对象,并传入要执行的存储过程名称如: {call 存储过程名称(参数)}
2. 注册输出参数
3. 执行存储过程
4. 获取输出参数带出的值

1.JDBC的事务是基于Connection对象的,超越Connection事务不是同一个事务

2.启动事务
conn.beginTransaction()

3.提交事务 conn.commit()

4.事务回滚
conn.rollback() [一般异常中]

1采用Statement.addBatch(sql)方式实现批处理：

优点：可以向数据库发送多条不同的ＳＱＬ语句。

缺点：

SQL语句没有预编译。

当向数据库发送多条语句相同，但仅参数不同的SQL语句时，需重复写上很多条SQL语句

2采用PreparedStatement.addBatch()实现批处理

优点：发送的是预编译后的SQL语句，执行效率高。

缺点：只能应用在SQL语句相同，但参数不同的批处理中。因此此种形式的批处理经常用于在同一个表中批量插入数据，或批量更新表的数据

WEB容器（Servlet引擎）接收到以.jsp为扩展名的URL的访问请求时，它将把该访问请求交给JSP引擎去处理。Tomcat中的JSP引擎就是一个Servlet程序，它负责解释和执行JSP页面。

每个JSP 页面在第一次被访问时，JSP引擎将它翻译成一个Servlet源程序，接着再把这个Servlet源程序编译成Servlet的class类文件，然后再由WEB容器（Servlet引擎）像调用普通Servlet程序一样的方式来装载和解释执行这个由JSP页面翻译成的Servlet程序。

Tomcat 5.x把为JSP页面创建的Servlet源文件和class类文件放置在“<TOMCAT_HOME>\work\Catalina\<主机名>\<应用程序名>\”目录中，Tomcat将JSP页面翻译成的Servlet的包名为org.apache.jsp.<JSP页面在WEB应用程序内的目录名> 。

JSP规范也没有明确要求JSP中的脚本程序代码必须采用Java语言，JSP中的脚本程序代码可以采用Java语言之外的其他脚本语言来编写，但是，JSP页面最终必须转换成Java Servlet程序。

可以在WEB应用程序正式发布之前，将其中的所有JSP页面预先编译成Servlet程序。

分析JSP所生成的Servlet代码

JSP页面翻译成的Servlet继承了org.apache.jasper.runtime.HttpJspBase类，HttpJspBase类是HttpServlet的一个子类，因此JSP页面翻译成的Servlet是HttpServlet的一个孙子类。HttpJspBase类实现了javax.servlet.jsp.HttpJspPage接口中的部分方法，因此，HttpJspBase类是抽象的。

SUN公司为JSP的WEB容器开发商和JSP页面开发人员提供了一套专门应用于开发JSP程序的Java类，这套Java类被称为JSP API。HttpJspPage接口和JspPage接口属于JSP API，在HttpJspPage接口中只定义了一个_jspService方法，但它继承了JspPage接口，JspPage接口中定义了两个方法：jspInit()和jspDestroy()。

HttpJspBase的init方法调用了jspInit和_jspInit方法，destroy方法内部调用了jspDestroy和_jspDestroy方法，service方法内部调用了_jspService方法。在HttpJspBase中实现的init、service和destroy方法都被声明成了final类型。

JSP页面中的位于<% %>外面的每行和紧临<%%>两边的每段文本被转换成以这些文本作为参数的一条条out.write语句，JSP脚本片断（位于<%%>内的一段java代码）中的java代码被原封不动地搬移进了_jspService方法中的相应位置处，JSP表达式（位于<%=和%>之中的内容）则是被转换成以其中的变量或表达式作为参数的out.print语句。

cookie 和session 的区别：

1、cookie数据存放在客户的浏览器上，session数据放在服务器上。

2、cookie不是很安全，别人可以分析存放在本地的COOKIE并进行COOKIE欺骗

考虑到安全应当使用session。

3、session会在一定时间内保存在服务器上。当访问增多，会比较占用你服务器的性能

考虑到减轻服务器性能方面，应当使用COOKIE。

4、单个cookie保存的数据不能超过4K，很多浏览器都限制一个站点最多保存20个cookie

jsp:include：在页面被请求的时候引入一个文件。

jsp:useBean：寻找或者实例化一个JavaBean。

jsp:setProperty：设置JavaBean的属性。

jsp:getProperty：输出某个JavaBean的属性。

jsp:forward：把请求转到一个新的页面。

jsp:plugin：根据浏览器类型为Java插件生成OBJECT或EMBED标记

include可以在JSP页面转换成Servlet之前，将JSP代码插入其中。它的主要优点是功能强大，所包含的代码可以含有总体上影响主页面的JSP构造，比如属性、方法的定义和文档类型的设定。它的缺点是难于维护只要被包含的页面发生更改，就得更改主页面，这是因为主页面不会自动地查看被包含的页面是否发生更改。

C/S结构，即Client/Server(客户机/服务器)结构，是大家熟知的软件系统体系结构，通过将任务合理分配到Client端和Server端，降低了系统的通讯开销，可以充分利用两端硬件环境的优势。早期的软件系统多以此作为首选设计标准。。

B/S结构，即Browser/Server(浏览器/服务器)结构，是随着Internet技术的兴起，对C/S结构的一种变化或者改进的结构。在这种

结构下，用户界面完全通过WWW浏览器实现，一部分事务逻辑在前端实现，但是主要事务逻辑在服务器端实现，形成所谓3-tier结构。B/S结构，主要是

利用了不断成熟的WWW浏览器技术，结合浏览器的多种Script语言(VBScript、JavaScript…)和ActiveX技术，用通用浏览器
就实现了原来需要复杂专用软件才能实现的强大功能，并节约了开发成本，是一种全新的软件系统构造技术。随着Windows 98/Windows
2000将浏览器技术植入操作系统内部，这种结构更成为当今应用软件的首选体系结构。

Html: 超文本标记语言，标准通用标记语言下的一个应用。超文本”就是指页面内可以包含图片、链接，甚至音乐、程序等非文字元素。

http: 超文本传输协议（HTTP，HyperText Transfer Protocol)是互联网上应用最为广泛的一种网络协议。所有的WWW文件都必须遵守这个标准。

www: WWW是环球信息网的缩写，（亦作“Web”、“WWW”、“'W3'”，英文全称为“World Wide Web”），中文名字为“万维网”，"环球网"等，常简称为Web。

URL: 统一资源定位符是对可以从互联网上得到的资源的位置和访问方法的一种简洁的表示，是互联网上标准资源的地址。

WEB: web的本意是蜘蛛网和网的意思，在网页设计中我们称为网页的意思。现广泛译作网络、互联网等技术领域。表现为三种形式，即超文本（hypertext）、超媒体（hypermedia）、超文本传输协议（HTTP）等。

WWW:万维网联盟, 万维网联盟创建于1994年，是Web技术领域最具权威和影响力的国际中立性技术标准机构。

BOM(Browser Object Model)
是指浏览器对象模型，是用于描述这种对象与对象之间层次关系的模型，浏览器对象模型提供了独立于内容的、可以与浏览器窗口进行互动的对象结构。BOM由多个对象组成，其中代表浏览器窗口的Window对象是BOM的顶层对象，其他对象都是该对象的子对象。

浏览器对象模型顶层对象是window,window对象包含 location
history document三个属性

document.write() 动态向页面写入内容

document.createElement(Tag) 创建一个html标签对象

document.getElementById(ID) 获得指定ID值的对象

document.getElementsByName(Name) 获得指定Name值的对象

document.body.appendChild(oTag) 向当前BODY标签追加子标签

document.getElementsByTagName(TagName)通过标签名获取当前页面该标签对象

onblur 元素失去焦点。

onchange 域的内容被改变。

onclick 当用户点击某个对象时调用的事件句柄。

ondblclick 当用户双击某个对象时调用的事件句柄。

onfocus 元素获得焦点。

onkeydown 某个键盘按键被按下。

onkeypress 某个键盘按键被按下并松开。

onkeyup 某个键盘按键被松开。

onload 一张页面或一幅图像完成加载。

onmousedown 鼠标按钮被按下。

onmousemove 鼠标被移动。

onmouseout 鼠标从某元素移开。

onmouseover 鼠标移到某元素之上。

onmouseup 鼠标按键被松开。

onselect 文本被选中。

onsubmit 确认按钮被点击。

onunload 用户退出页面。

Struts2是一个优秀的MVC框架,基于WEBWORK,吸收了STRUTS1的优点.

工作原理:

一个请求在Struts2框架中的处理大概分为以下几个步骤

1、客户端初始化一个指向Servlet容器（例如Tomcat）的请求

2、这个请求经过一系列的过滤器（Filter）（这些过滤器中有一个叫做ActionContextCleanUp的可选过滤器，这个过滤器对于Struts2和其他框架的集成很有帮助，例如：SiteMesh Plugin）

3、接着FilterDispatcher被调用，FilterDispatcher询问ActionMapper来决定这个请是否需要调用某个Action

,FilterDispatcher是控制器的核心，就是mvc中c控制层的核心。下面粗略的分析下我理解的FilterDispatcher工作流程和原理：FilterDispatcher进行初始化并启用核心doFilter

4、如果ActionMapper决定需要调用某个Action，FilterDispatcher把请求的处理交给ActionProxy

5、ActionProxy通过ConfigurationManager询问框架的配置文件，找到需要调用的Action类 ,这里，我们一般是从struts.xml配置中读取。

6、ActionProxy创建一个ActionInvocation的实例。

7、ActionInvocation实例使用命名模式来调用，在调用Action的过程前后，涉及到相关拦截器（Intercepter）的调用。

8、一旦Action执行完毕，ActionInvocation负责根据struts.xml中的配置找到对应的返回结果。返回结果通常是（但不总是，也可能是另外的一个Action链）一个需要被表示的JSP或者FreeMarker的模版。在表示的过程中可以使用Struts2
框架中继承的标签。在这个过程中需要涉及到ActionMapper

在上述过程中所有的对象（Action，Results，Interceptors，等）都是通过ObjectFactory来创建的。

拦截器（interceptor）是Struts2最强大的特性之一，也可以说是struts2的核心，拦截器可以让你在Action和result被执行之前或之后进行一些处理。同时，拦截器也可以让你将通用的代码模块化并作为可重用的类。Struts2中的很多特性都是由拦截器来完成的。

工作原理:

当请求到达Struts 2的ServletDispatcher时，Struts
2会查找配置文件，并根据其配置实例化相对的拦截器对象，然后串成一个列表（list），最后一个一个地调用列表中的拦截器。事实上，我们之所以能够如此灵活地使用拦截器，完全归功于“动态代理”的使用。动态代理是代理对象根据客户的需求做出不同的处理。对于客户来说，只要知道一个代理对象就行了。那Struts2中，拦截器是如何通过动态代理被调用的呢？当Action请求到来的时候，会由系统的代理生成一个Action的代理对象，由这个代理对象调用Action的execute()或指定的方法，并在struts.xml中查找与该Action对应的拦截器。如果有对应的拦截器，就在Action的方法执行前（后）调用这些拦截器；如果没有对应的拦截器则执行Action的方法。其中系统对于拦截器的调用，是通过ActionInvocation来实现的。

1.首先，最重要的一点是多个视图能共享一个模型。同一个模型可以被不同的视图重用，大大提高了代码的可重用性。

2.由于MVC的三个模块相互独立，改变其中一个不会影响其他两个，所以依据这种设计思想能构造良好的松耦合的构件。

3.此外，控制器提高了应用程序的灵活性和可配置性。控制器可以用来联接不同的模型和视图去完成用户的需求，这样控制器可以为构造应用程序提供强有力的手段

1. 可以使用Struts2内置的AJAX插件
2. 编写原生的AJAX代码发送异步请求,或者用JQUERY等JS框架发送请求,此时ACTION处理请求的方法的返回值必须为NULL

1. 客户端请求提交到DispatcherServlet

2. 由DispatcherServlet控制器查询一个或多个HandlerMapping，找到处理请求的Controller

3. DispatcherServlet将请求提交到Controller

4. Controller调用业务逻辑处理后，返回ModelAndView

5. DispatcherServlet查询一个或多个ViewResoler视图解析器，找到ModelAndView指定的视图

6. 视图负责将结果显示到客户端

1. 机制：spring mvc的入口是servlet，而struts2是filter。

2. 性能：spring会稍微比struts快。spring mvc是基于方法的设计，而sturts是基于类，每次发一次请求都会实例一个action，每个action都会被注入属性.

而spring基于方法，粒度更细，但要小心把握像在servlet控制数据一样。spring3 mvc是方法级别的拦截，拦截到方法后根据参数上的注解，把request数据注入进去，在spring3 mvc中，一个方法对应一个request上下文。

而struts2框架是类级别的拦截，每次来了请求就创建一个Action，然后调用setter
getter方法把request中的数据注入；struts2实际上是通过setter
getter方法与request打交道的；struts2中，一个Action对象对应一个request上下文。

3. 参数传递：struts是在接受参数的时候，可以用属性来接受参数，这就说明参数是让多个方法共享的。

4. 设计思想上：struts更加符合oop的编程思想， spring就比较谨慎，在servlet上扩展。

5. intercepter的实现机制：struts有以自己的interceptor机制，spring
mvc用的是独立的AOP方式。这样导致struts的配置文件量还是比spring
mvc大，虽然struts的配置能继承，所以我觉得论使用上来讲，spring
mvc使用更加简洁，开发效率Spring MVC确实比struts2高。

Spring配置文件中关于事务配置总是由三个组成部分，分别是DataSource、TransactionManager和代理机制这三部分，无论哪种配置方式，一般变化的只是代理机制这部分。
DataSource、

TransactionManager这两部分只是会根据数据访问方式有所变化，比如使用Hibernate进行数据访问时，DataSource实际为
SessionFactory，TransactionManager的实现为HibernateTransactionManager。

<!-- 配置事务管理器（声明式的事务）
-->

<bean id="transactionManager"
class="org.springframework.orm.hibernate3.HibernateTransactionManager">

<property name="sessionFactory"
ref="sessionFactory"></property>

</bean>

<tx:advice id="txadvice"
transaction-manager="transactionManager">

<tx:attributes>

<tx:method name="add*" propagation="REQUIRED"
rollback-for="Exception" />

<tx:method name="modify*"
propagation="REQUIRED" rollback-for="Exception" />

<tx:method name="del*" propagation="REQUIRED"
rollback-for="Exception"/>

<tx:method name="*" propagation="REQUIRED"
read-only="true"/>

</tx:attributes>

</tx:advice>

<aop:config>

<aop:pointcut id="daoMethod" expression="execution(*
com.dao.*.*(..))"/>

<aop:advisor pointcut-ref="daoMethod"
advice-ref="txadvice"/>

</aop:config>

expression="execution(*
com.dao.*.*(..))"

其中第一个*代表返回值，第二*代表dao下子包，第三个*代表方法名，“（..）”代表方法参数。

1：引入包，这个就不说了，官网下载。

spring-core-3.2.3.RELEASE.jar     核心依赖jar包

spring-context-3.2.3.RELEASE.jar   容器包

spring-beans-3.2.3.RELEASE.jar   beans的管理包

spring-expression-3.2.3.RELEASE.jar

另外还需加入commons-logging.jar

2：在web.xml中添加spring配置。一个监听，一个路径（配置bean文件所在目录）

<listener>

　　<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

</listener>

<!-- 默认配置在WEB-INF目录下 -->

<context-param>

<param-name>contextConfigLocation</param-name>

<param-value>classpath:/applicationContext.xml</param-value>

</context-param>

3：bean配置文件applicationContext.xml

<beans>

<!-- 每个bean都对应有一个id和class -->

<bean id="u"
class="dao.UserDaoImpl"></bean>

<!-- 下面代码表示：在id为userService的service中有一个名叫userDao的属性,

更准确的说是在service中有一个setUserDao的方法 ，该方法调用时必须把上面id为u的bean传进来，

此时就把这两个东西装配起来：专业说法是动态装配。

即可以把UserService.java中的private的userDao属性给注入进来【注入】

<!-- 一定要注意：下面代码中的property中的name的值必须和你UserService.java中定义的变量要一致。

也就是和必须和你service中的setDao的方法匹配，有setDao(),则name的值就是dao，即去掉前面的set -->

-->

<bean id="userService"
class="service.UserService">

<property name="dao"
ref="u"></property>

</bean>

</beans>

4：使用（UserService.java）

ApplciationContext ctx=new
ClasspathXmlApplicationContext(“beans.xml”);

UserService service
=(UserService)ctx.getBean("userService");

User u =new User();

service.add(u);

1. 简单工厂

又叫做静态工厂方法（StaticFactory Method）模式，但不属于23种GOF设计模式之一。

简单工厂模式的实质是由一个工厂类根据传入的参数，动态决定应该创建哪一个产品类。

Spring中的BeanFactory就是简单工厂模式的体现，根据传入一个唯一的标识来获得Bean对象，但是否是在传入参数后创建还是传入参数前创建这个要根据具体情况来定。

2. 工厂方法（Factory Method）

定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method使一个类的实例化延迟到其子类。

Spring中的FactoryBean就是典型的工厂方法模式。

3. 单例（Singleton）

保证一个类仅有一个实例，并提供一个访问它的全局访问点。

Spring中的单例模式完成了后半句话，即提供了全局的访问点BeanFactory。但没有从构造器级别去控制单例，这是因为Spring管理的是是任意的Java对象。

4. 适配器（Adapter）

将一个类的接口转换成客户希望的另外一个接口。Adapter模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

5.包装器（Decorator）

动态地给一个对象添加一些额外的职责。就增加功能来说，Decorator模式相比生成子类更为灵活。

Spring中用到的包装器模式在类名上有两种表现：一种是类名中含有Wrapper，另一种是类名中含有Decorator。基本上都是动态地给一个对象添加一些额外的职责。

6. 代理（Proxy）

为其他对象提供一种代理以控制对这个对象的访问。

从结构上来看和Decorator模式类似，但Proxy是控制，更像是一种对功能的限制，而Decorator是增加职责。

Spring的Proxy模式在aop中有体现，比如JdkDynamicAopProxy和Cglib2AopProxy。

7.观察者（Observer）

定义对象间的一种一对多的依赖关系，当一个对象的状态发生改变时，所有依赖于它的对象都得到通知并被自动更新。

Spring中Observer模式常用的地方是listener的实现。如ApplicationListener。

8. 策略（Strategy）

定义一系列的算法，把它们一个个封装起来，并且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。

Spring中在实例化对象的时候用到Strategy模式

9.模板方法（Template
Method）

定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。Template Method 使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

1. request.getSession().getServletContext().getAttribute("org.springframework.web.context.WebApplicationContext.ROOT")
2. WebApplicationContextUtils.getRequiredWebApplicationContext(ServletContext
   sc);
3. WebApplicationContext
   webApplicationContext = ContextLoader.getCurrentWebApplicationContext();

1. 
利用ContextLoaderListener

Spring提供一个ContextLoaderListener对象,该类可以作为Web应用的Listener使用,它会在Web应用启动时自动查找WEB-INF/下的applicationContext.xml配置文件(Spring的配置文件),并且根据该文件来创建Spring容器.因此,如果Web应用中只有一个Spring配置文件,并且文件名为"applicationContext.xml",并将该文件放在Web应用的WEB-INF/路径下,则只需在web.xml文件中增加如下一段即可:

<!-- 根据默认配置文件来初始化Spring容器 -->

<listener>

<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>

</listener>

如果有多个配置文件需要载入,或则applicationContext.xml不在WEB-INF目录下，则应该在web.xml中再使用<context-param>元素来确定配置文件的文件名，内容如下:

<!-- 定义spring配置文件 -->

<context-param>

<param-name>contextConfigLocation</param-name>

<param-value>

/WEB-INF/applicationContext.xml,

/WEB-INF/classes/conf/spring/applicationContext-*.xml

</param-value>

</context-param>

如果spring配置文件被命名为applicationContext.xml，并且放在WEB-INF目录下，则不需要配置<context-param>，因为ContextLoaderListener默认在WEB-INF目录下寻找名为applicationContext.xml的文件。若存在多个Spring配置文件，则在<param-value>中依次列出，之间以逗号隔开。

2. 
Spring管理控制器,并利用依赖注入为控制器注入业务逻辑组件

1)       
将Struts的业务逻辑控制器类配置在Spring的配置文件中，业务逻辑控制器中引用的业务类一并注入。注意，必须将业务逻辑控制器类配置为scope=”prototype”！
示例如下：

<bean
id=”LoginAction” class=”yaso.struts.action.LoginAction”>

<property name=”loginDao” ref=”LoginDao”/>

</bean>

2)       
在struts.xml或者等效的Struts2配置文件中配置Action时，指定<action>的class属性为Spring配置文件中相应bean的id或者name值。示例如下：

<action
name=”LoginAction” class=”LoginAction”>

<result
name=”success”>/index.jsp</result>

</action>

在applicationContext.xml加载一个bean

<bean id=”messageSource”
class=”org.springframework.context.support.ResourceBundleMessageSource”>

<property name=”basename”>

<value>message</value>

</property>

</bean>

 在src目录下建多个properties文件

 对于非英文的要用native2ascii
-encoding gb2312 源  目转化文件相关内容

 其命名格式是message_语言_国家。

 页面中的中显示提示信息，键名取键值。

 当给定国家，系统会自动加载对应的国家的properties信息。

 通过applictionContext.getMessage(“键名”,”参数”,”区域”)取出相关的信息。

1. 当调用者通过 getBean（ name ）向  容器寻找Bean  时，如果容器注册了
org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor接口，在实例 bean 之前，将调用该接口的
postProcessBeforeInstantiation （）方法，

2. 根据配置情况调用 Bean构造函数或工厂方法实例化 bean

3. 如果容器注册了
org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor接口，在实例 bean 之后，调用该接口的
postProcessAfterInstantiation （）方法，可以在这里对已经实例化的对象进行一些装饰。

4. 受用依赖注入，Spring 按照 Bean 定义信息配置 Bean 的所有属性  ，在设置每个属性之前将调用 InstantiationAwareBeanPostProcess接口的
postProcessPropertyValues （）方法  。

5 .如果 Bean 实现了 BeanNameAware 接口，工厂调用 Bean 的 setBeanName() 方法传递 Bean 的 ID 。

6 .如果 Bean 实现了 BeanFactoryAware 接口，工厂调用
setBeanFactory() 方法传入工厂自身。

7 .如果
BeanPostProcessor 和 Bean 关联，那么  将调用该接口
的postProcessBeforeInitialzation() 方法  对 bean进行加工操作，这个非常重要， spring 的 AOP 就是用它实现的。

8. 如果bean 实现了 InitializingBean 接口，将调用
afterPropertiesSet （）方法

9. 如果Bean 指定了 init-method 方法，它将被调用。

10. 如果有BeanPsotProcessor
和 Bean 关联，那么它们的
postProcessAfterInitialization() 方法将被调用。 到这个时候， Bean 已经可以被应用系统使用了   。

11. 如果在<bean> 中指定了该 bean 的作用范围为
scope="prototype", 将 bean 的调用者，调用者管理该 bean 的生命周期， spring 不在管理该 bean 。

12. 如果在<bean> 中指定了该 bean 的作用范围为
scope="singleton", 则将该 bean 放入 springIOC 的缓存池中，将触发 spring 对该 bean 的生命周期管理。

13. 有两种方法可以把它从Bean
Factory 中删除掉  ：

1.如果 Bean 实现了 DisposableBean 接口， destory() 方法被调用。

2.如果指定了订制的销毁方法，就调用这个方法。

<!-- 定义DBCP的数据库连接属性，该数据源会被hibernate使用，DBCP是连接池开源包，其中的url,username,password需要替换成你的数据库访问属性 -->

<bean id="dataSource"
class="org.apache.commons.dbcp.BasicDataSource"
destroy-method="close">

<property name="driverClassName">

<value>com.mysql.jdbc.Driver</value>

</property>

<property name="url">

<value>jdbc:mysql://localhost/mysql</value>

</property>

<property name="username">

<value>root</value>

</property>

<property name="password">

<value>doerliu</value>

</property>

</bean>

<!-- 配置sessionFactory,
为Hibernate配置属性 -->

<bean id="sessionFactory"
class="org.springframework.orm.hibernate3.LocalSessionFactoryBean">

<property name="dataSource">

<ref local="dataSource"
/>

</property>

<property name="mappingResources">

<list>

<!—Hibernate的map 文件在这里配置了，注意文件的相对位置。 -->

<value>../Userinfo.hbm.xml</value>

</list>

</property>

<property name="hibernateProperties">

<props>

<prop key="hibernate.dialect">org.hibernate.dialect.MySQLDialect</prop>

<prop key="hibernate.show_sql">true</prop>

</props>

</property>

</bean>

控制反转（IoC/Inverse Of Control）:   调用者不再创建被调用者的实例，由spring框架实现（容器创建）所以称为控制反转。

依赖注入(DI/Dependence injection) :  
容器创建好实例后再注入调用者称为依赖注入。

1.ORM 对象关系映射

2.通过实体类和表之间的映射完成用面向对象的方式操作关系型数据库

实体类映射表

实体类属性映射列

实体类对象映射行

当我们完成对某个实体类的 ,框架会将我们的JAVA实体类的操作转换成SQL语句,具体转换通过映射配置来完成.

3.MYBATIS,HIBERNATE,JPA

工作原理：
就是读取你的hql语句
然后根据数据库方言转变成sql语句然后使用jdbc执行转变后的数据库

加载配置：

1.通过Configuration().configure();读取并解析hibernate.cfg.xml配置文件

2.由hibernate.cfg.xml中的<mapping resource="com/xx/User.hbm.xml"/>读取并解析映射信息

3.通过config.buildSessionFactory();//创建SessionFactory

延迟加载分类级别和关联级别

类级别是在映射文件<Class>节点上添加lazy属性

关联级别是在<set><many-to-one>上添加lazy属性

Hibernate的缓存包括Session的缓存和SessionFactory的缓存，其中SessionFactory的缓存又可以分为两类：内置缓存和外置缓存。Session的缓存是内置的，不能被卸载，也被称为Hibernate的第一级缓存。SessionFactory的内置缓存和Session的缓存在实现方式上比较相似，前者是SessionFactory对象的一些集合属性包含的数据，后者是指Session的一些集合属性包含的数据。SessionFactory的内置缓存中存放了映射元数据和预定义SQL语句，映射元数据是映射文件中数据的拷贝，而预定义SQL语句是在Hibernate初始化阶段根据映射元数据推导出来，SessionFactory的内置缓存是只读的，应用程序不能修改缓存中的映射元数据和预定义SQL语句，因此SessionFactory不需要进行内置缓存与映射文件的同步。SessionFactory的外置缓存是一个可配置的插件。在默认情况下，SessionFactory不会启用这个插件。外置缓存的数据是数据库数据的拷贝，外置缓存的介质可以是内存或者硬盘。SessionFactory的外置缓存也被称为Hibernate的第二级缓存。

Hibernate的这两级缓存都位于持久化层，存放的都是数据库数据的拷贝，为了理解二者的区别，需要深入理解持久化层的缓存的两个特性：缓存的范围和缓存的并发访问策略。

SessionFactory在Hibernate中实际起到了一个缓冲区的作用，它缓冲了Hibernate自动生成的SQL语句和一些其它的映射数据，还缓冲了一些将来有可能重复利用的数据。

SessionFactory是线程安全的，多个并发线程可以同时访问一个

SessionFactory 并从中获取Session实例。

Session接口对于Hibernate  
开发人员来说是一个最重要的接口。然而在Hibernate中，实例化的Session是一个轻量级的类，创建和销毁它都不会占用很多资源。这在实际项目中确实很重要，因为在客户程序中，可能会不断地创建以及销毁Session对象，如果Session的开销太大，会给系统带来不良影响。但值得注意的是
Session对象是非线程安全的，因此在你的设计中，最好是一个线程只创建一个Session对象。

1. 
在Hibernate中，对象具有三种状态：transient、persistent和detached。

2.

同Hibernate的session有关联的对象是persistent对象。对这种对象进行的所有修改都会按照事先设定的刷新策略，反映到数据库之中，也即，可以在对象的任何一个属性发生改变时自动刷新，也可以通过调用Session.flush()方法显式地进行刷新。

3. 
如果一个对象原来同Session有关联关系，但当下却没有关联关系了，这样的对象就是detached的对象。
可以通过调用任意一个session的update()或者saveOrUpdate()方法，重新将该detached对象同相应的seesion建立关联关系。

4. 
Transient对象指的是新建的持久化类的实例，它还从未同Hibernate的任何Session有过关联关系。
可以调用persist()或者save()方法，将transient对象变成persistent对象。

注意：这里所说的transient指的不是 Java中的transient关键字。

MyBatis应用程序根据XML配置文件创建SqlSessionFactory，SqlSessionFactory在根据配置，配置来源于两个地方，一处是配置文件，一处是Java代码的注解，获取一个SqlSession。SqlSession包含了执行sql所需要的所有方法，可以通过SqlSession实例直接运行映射的sql语句，完成对数据的增删改查和事务提交等，用完之后关闭SqlSession。

使用#{}格式的语法在mybatis中使用Preparement语句来安全的设置值,可以防止SQL注入

$将传入的数据直接显示生成在sql中,不能防止SQL注入

在<INSERT>中顶部添加

<selectKey
resultType="java.lang.Short" order="AFTER"
keyProperty="id">

SELECT LAST_INSERT_ID() AS id

</selectKey>

MyBatis的动态SQL是基于OGNL表达式的，它可以帮助我们方便的在SQL语句中实现某些逻辑。

MyBatis中用于实现动态SQL的元素主要有：

If

if就是简单的条件判断，利用if语句我们可以实现某些简单的条件选择

choose（when，otherwise）

choose元素的作用就相当于JAVA中的switch语句，基本上跟JSTL中的choose的作用和用法是一样的，通常都是与when和otherwise搭配的。

Trim

trim元素的主要功能是可以在自己包含的内容前加上某些前缀，也可以在其后加上某些后缀，与之对应的属性是prefix和suffix；可以把包含内容的首部某些内容覆盖，即忽略，也可以把尾部的某些内容覆盖，对应的属性是prefixOverrides和suffixOverrides；正因为trim有这样的功能，所以我们也可以非常简单的利用trim来代替where元素的功能

where

where语句的作用主要是简化SQL语句中where中的条件判断的

set

set元素主要是用在更新操作的时候，它的主要功能和where元素其实是差不多的，主要是在包含的语句前输出一个set，然后如果包含的语句是以逗号结束的话将会把该逗号忽略，如果set包含的内容为空的话则会出错。有了set元素我们就可以动态的更新那些修改了的字段。

foreach

foreach的主要用在构建in条件中，它可以在SQL语句中进行迭代一个集合。

AJAX全称为“Asynchronous
JavaScript and XML”（异步JavaScript和XML），是一种创建交互式网页应用的网页开发技术。它使用：

使用XHTML+CSS来标准化呈现；

使用XML和XSLT进行数据交换及相关操作；

使用XMLHttpRequest对象与Web服务器进行异步数据通信；

使用Javascript操作Document Object
Model进行动态显示及交互；

使用JavaScript绑定和处理所有数据。

为什么使用

传统的Web应用交互由用户触发一个HTTP请求到服务器,服务器对其进行处理后再返回一个新的HTHL页到客户端,
每当服务器处理客户端提交的请求时,客户都只能空闲等待,并且哪怕只是一次很小的交互、只需从服务器端得到很简单的一个数据,都要返回一个完整的HTML页,而用户每次都要浪费时间和带宽去重新读取整个页面。这个做法浪费了许多带宽，由于每次应用的交互都需要向服务器发送请求，应用的响应时间就依赖于服务器的响应时间。这导致了用户界面的响应比本地应用慢得多。

与此不同，AJAX应用可以仅向服务器发送并取回必需的数据，它使用SOAP或其它一些基于XML的Web
Service接口，并在客户端采用JavaScript处理来自服务器的响应。因为在服务器和浏览器之间交换的数据大量减少，结果我们就能看到响应更快的应用。同时很多的处理工作可以在发出请求的客户端机器上完成，所以Web服务器的处理时间也减少了。

XHTML和CSS

　　使用文档对象模型(Document Object Model)作动态显示和交互

　　使用XML和XSLT做数据交互和操作

　　使用XMLHttpRequest进行异步数据接收

　　使用JavaScript将它们绑定在一起

(1).AJAX的优点

<1>.无刷新更新数据。

<2>.异步与服务器通信。

<3>.前端和后端负载平衡。

<4>.基于标准被广泛支持。

<5>.界面与应用分离。

(2).AJAX的缺点

<1>.AJAX干掉了Back和History功能，即对浏览器机制的破坏。

<2>.AJAX的安全问题。

<3>.对搜索引擎支持较弱。

<4>.破坏程序的异常处理机制。

<5>.违背URL和资源定位的初衷。

<6>.AJAX不能很好支持移动设备。

<7>.客户端过肥，太多客户端代码造成开发上的成本。

1.执行时间

window.onload必须等到页面内包括图片的所有元素加载完毕后才能执行。

$(document).ready()是DOM结构绘制完毕后就执行，不必等到加载完毕。

2.编写个数不同

window.onload不能同时编写多个，如果有多个window.onload方法，只会执行一个

$(document).ready()可以同时编写多个，并且都可以得到执行

3.简化写法

window.onload没有简化写法

$(document).ready(function(){})可以简写成$(function(){});

Js+css:

1.把CSS放到代码页上端

2.避免CSS表达式

3.从页面中剥离JavaScript与CSS

4.精简JavaScript与CSS

5.使用<link>而不是@importChoose<link>over@import

6.避免使用CSSFilter

7.JS尽量放到页面最下端

8.页面展现尽量交给CSS完成

图片:

1. 优化图片,尽量使用PNG

2. 使用 CSS Sprites 对图片优化

3. 不要在 HTML 中缩放图片

4. 用更小的并且可缓存的
favicon.ico

1.创建必要的索引

2.使用预编译查询

3.调整Where子句中的连接顺序

4.Select 语句中避免使用*

5.尽量将多条SQL语句压缩到一句SQL中

6.用Where子句中替换Having子句

7.使用表的别名

8. 用EXISTS 替代IN

9.用表连接替换EXISTS

10.避免在索引列上使用计算

11.用UNION ALL替换UNION

12.避免隐式类型转换造成全表扫描

13.防止检索范围过宽

1、生成对象时，合理分配空间和大小

2、优化for循环 将集合或数组长度做成变量,循环判断只判断长度变量,不用SIZE().LENGTH()之类方法

3、new一个实例对象，new在什么位置(尽量在使用时再创建该对象)。

4、异常处理技巧

5、尽量使用局部变量和静态变量

6、尽量不适用多线程同步

7、尽可能的使用Java自身提供的API

8、尽量减少I/O操作(控制台、日志)

9、尽量使用缓存流(尽可能使用带有Buffer的类代替没有Buffer的类，BufferedReader、BufferedWriter、BufferedInputStream)

10、sql优化、存储过程、视图、连接池(C3P0 、DBCP)

11、数据库数据分级存储

12、缓存策略

13、html静态化

14、不用保存太多的信息在HttpSession中

15、在使用大数据对象时，因此建议在对象使用完毕后，手动设置成null(避免内存溢出)。

方法 1：在servlet的init()方法中缓存数据　

方法 2:禁止servlet和JSP 自动重载(auto-reloading)　

方法 3: 不要滥用HttpSession

方法 4: 将页面输出进行压缩　

方法 5: 使用线程池　　

方法 6: 选择正确的页面包含机制

方法 7:正确地确定javabean的生命周期

a.允许/限制对表的修改

b.自动派生列，如自增字段

c.强制数据的一致性

d.提供审计和日志记录

e.防止无效的事务处理

f.启动复杂的业务逻辑

存储过程是:

将常用的或很复杂的工作，预先用SQL语句写好并用一个指定的名称存储起来, 那么以后要叫数据库提供与已定义好的存储过程的功能相同的服务时,只需调用execute,即可自动完成命令。

调用:

调用:

1.创建CallableStatement对象

callStmt = conn.prepareCall("{call 存储过程名(参数占位符?)}");

2.为参数占位符赋值

callStmt.setString(1, "jdbc");

3.如果是输出参数则需要注册

callStmt.registerOutParameter(问号下标, Types.数据类型);

4.执行

callStmt.execute();

5.如果有输出参数则获取带出的值

callStmt.getString(下标)

优点:

1.存储过程只在创造时进行编译，以后每次执行存储过程都不需再重新编译，而一般SQL语句每执行一次就编译一次,所以使用存储过程可提高数据库执行速度。

2.当对数据库进行复杂操作时(如对多个表进行Update,Insert,Query,Delete时），可将此复杂操作用存储过程封装起来与数据库提供的事务处理结合一起使用。

3.存储过程可以重复使用,可减少数据库开发人员的工作量

4.安全性高,可设定只有某此用户才具有对指定存储过程的使用权

索引:

数据库索引是为了增加查询速度而对表字段附加的一种标识

优点:

1.通过创建唯一性索引，可以保证数据库表中每一行数据的唯一性。

2.可以大大加快数据的检索速度，这也是创建索引的最主要的原因。

3.可以加速表和表之间的连接，特别是在实现数据的参考完整性方面特别有意义。

4.在使用分组和排序子句进行数据检索时，同样可以显著减少查询中分组和排序的时间。

5.通过使用索引，可以在查询的过程中，使用优化隐藏器，提高系统的性能。

缺点:

1.创建索引和维护索引要耗费时间，这种时间随着数据量的增加而增加。

2.索引需要占物理空间，除了数据表占数据空间之外，每一个索引还要占一定的物理空间，如果要建立聚簇索引，那么需要的空间就会更大。

3.当对表中的数据进行增加、删除和修改的时候，索引也要动态的维护，这样就降低了数据的维护速度。

1.直接创建索引和间接创建索引

直接创建索引： CREATE INDEX mycolumn_index ON mytable (myclumn)

间接创建索引：定义主键约束或者唯一性键约束，可以间接创建索引

2.普通索引和唯一性索引

普通索引：CREATE INDEX mycolumn_index ON mytable (myclumn)

唯一性索引：保证在索引列中的全部数据是唯一的，对聚簇索引和非聚簇索引都可以使用

CREATE UNIQUE COUSTERED INDEX myclumn_cindex ON mytable(mycolumn)

3.单个索引和复合索引

单个索引：即非复合索引

复合索引：又叫组合索引，在索引建立语句中同时包含多个字段名，最多16个字段

CREATE INDEX name_index ON username(firstname,lastname)

4.聚簇索引和非聚簇索引(聚集索引，群集索引)

聚簇索引：物理索引，与基表的物理顺序相同，数据值的顺序总是按照顺序排列

CREATE CLUSTERED INDEX mycolumn_cindex ON mytable(mycolumn) WITH

ALLOW_DUP_ROW(允许有重复记录的聚簇索引)

非聚簇索引：CREATE UNCLUSTERED INDEX mycolumn_cindex ON mytable(mycolumn)

事务(Transaction)是访问并可能更新数据库中各种数据项的一个程序执行单元(unit)。事务通常由高级数据库操纵语言或编程语言（如SQL，C++或Java）书写的用户程序的执行所引起，并用形如begin
transaction和end transaction语句（或函数调用）来界定。事务由事务开始(begin
transaction)和事务结束(end
transaction)之间执行的全体操作组成。

事务应该具有4个属性：原子性、一致性、隔离性、持续性。这四个属性通常称为ACID特性。

1.原子性（atomicity）。一个事务是一个不可分割的工作单位，事务中包括的操作要么都做，要么都不做。

2.一致性（consistency）。事务必须是使数据库从一个一致性状态变到另一个一致性状态。一致性与原子性是密切相关的。

3.隔离性（isolation）。一个事务的执行不能被其他事务干扰。即一个事务内部的操作及使用的数据对并发的其他事务是隔离的，并发执行的各个事务之间不能互相干扰。

4.持久性（durability）。持续性也称永久性（permanence），指一个事务一旦提交，它对数据库中数据的改变就应该是永久性的。接下来的其他操作或故障不应该对其有任何影响。

Read Uncommitted（未提交读）

在该隔离级别，所有事务都可以看到其他未提交事务的执行结果。本隔离级别很少用于实际应用，因为它的性能也不比其他级别好多少。读取未提交的数据，也被称之为脏读（Dirty Read）

Read Committed（已提交读）

这是大多数数据库系统的默认隔离级别（但不是MySQL默认的）。它满足了隔离的简单定义：一个事务只能看见已经提交事务所做的改变。这种隔离级别也支持所谓的不可重复读（Nonrepeatable Read），

Repeatable Read（可重读）

是MySQL的默认事务隔离级别，它确保同一事务的多个实例在并发(指一个时间段中有几个程序都处于已启动运行到运行完毕之间，且这几个程序都是在同一个处理机上运行，但任一个时刻点上只有一个程序在处理机上运行。)读取数据时，会看到同样的数据行。

Serializable（可串行化）

是最高的隔离级别，它通过强制事务排序，使之不可能相互冲突，从而解决幻读问题。简言之，它是在每个读的数据行上加上共享锁。在这个级别，可能导致大量的超时现象和锁竞争。

sqlserver默认级别是已提交读

SQLSERVER:

1. Begin tran 2.commit tran
   3.rollback tran

MYSQL

1. Start transaction 2.commit
   3.rollback

视图:

在 SQL 中，视图是基于 SQL 语句的结果集的可视化的表。

视图包含行和列，就像一个真实的表。视图中的字段就是来自一个或多个数据库中的真实的表中的字段。我们可以向视图添加 SQL 函数、WHERE 以及 JOIN 语句，我们也可以提交数据，就像这些来自于某个单一的表。

游标:

游标（cursor）是系统为用户开设的一个数据缓冲区，存放SQL语句的执行结果。每个游标区都有一个名字,用户可以用SQL语句逐一从游标中获取记录，并赋给主变量，交由主语言进一步处理。

设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。
毫无疑问，设计模式于己于他人于系统都是多赢的；设计模式使代码编制真正工程化；设计模式是软件工程的基石脉络，如同大厦的结构一样。

设计模式分为三种类型，共23种。

创建型模式：单例模式、抽象工厂模式、建造者模式、工厂模式、原型模式。

结构型模式：适配器模式、桥接模式、装饰模式、组合模式、外观模式、享元模式、代理模式。

行为型模式：模版方法模式、命令模式、迭代器模式、观察者模式、中介者模式、备忘录模式、解释器模式（Interpreter模式）、状态模式、策略模式、职责链模式(责任链模式)、访问者模式。

1. 简单工厂

简单工厂模式（Simple
Factory Pattern）属于类的创新型模式，又叫静态工厂方法模式（Static FactoryMethod Pattern）,是通过专门定义一个类来负责创建其他类的实例，被创建的实例通常都具有共同的父类。

1. 工厂方法

工厂方法模式（FACTORY
METHOD）是一种常用的对象创建型设计模式,此模式的核心精神是封装类中不变的部分，提取其中个性化善变的部分为独立类，通过依赖注入以达到解耦、复用和方便后期维护拓展的目的。它的核心结构有四个角色，分别是抽象工厂；具体工厂；抽象产品；具体产品

1. 抽象工厂

抽象工厂是一种常见的设计模式。此模式为一个产品家族提供了统一的创建接口。当需要这个产品家族的某一系列的时候，可以从抽象工厂中选出相对系的系列来创建一个具体的工厂类别。

单例模式是一种常用的软件设计模式。在它的核心结构中只包含一个被称为单例的特殊类。通过单例模式可以保证系统中一个类只有一个实例

Code:

public class SingletonClass{

private static SingletonClass instance=null;

public static SingletonClass getInstance(){

if(instance==null){

synchronized(SingletonClass.class){

if(instance==null){

instance=new
SingletonClass();

}

}

}

return instance;

}

private SingletonClass(){}

}

表示层,业务层,持久层

1、开发人员可以只关注整个结构中的其中某一层；

　　2、可以很容易的用新的实现来替换原有层次的实现；

　　3、可以降低层与层之间的依赖；

　　4、有利于标准化；

　　5、利于各层逻辑的复用。

　　6、结构更加的明确

　　7、在后期维护的时候，极大地降低了维护成本和维护时间

三层,表示层,业务层,持久层

为每个层次抽象出统一的接口，供上层引用，同时我们必须提供相应的注入方式，为调用层引用的接口实例赋值实例化。

a)     顺序存储结构

逻辑相邻，物理相邻，数据元素之间的关系存储单元的领接关系唯一确定，例如数组就是这种存储结构

b)     链式存储结构

a)      
存储数据结构的内存空间可以不连续，数据元素之间的由指针来确定

b)      
结点由两个域组成：数据域和指针域

c)       
插入和删除操作方便灵活
hashtable就是这种存储结构

a)     顺序查找

从表的一端开始，顺序扫描线性表，一次奖扫描到的结点的关键字和给定值K想比较

b)     二分查找

折半查找 要求线性表是有序表，即表中结点按关键字有序，并且用顺序表作为表的存储结构。

c)      哈希表查询技术

查找和检索与唯一标识键相关信息的最好方法之一

a)     插入排序

i.       1.从第一个元素开始，该元素可以认为已经被排序

2.取出下一个元素，在已经排序的元素序列中从后向前扫描

3.如果该元素（已排序）大于新元素，将该元素移到下一位置

4.重复步骤3，直到找到已排序的元素小于或者等于新元素的位置

5.将新元素插入到该位置后

6.重复步骤2~5

b)     希尔排序

将数组列在一个表中并对列排序（用插入排序）。重复这过程，不过每次用更长的列来进行。最后整个表就只有一列了

c)      选择排序

首先在未排序序列中找到最小（大）元素，存放到排序序列的起始位置，然后，再从剩余未排序元素中继续寻找最小（大）元素，然后放到已排序序列的末尾。以此类推，直到所有元素均排序完毕

d)     冒泡排序

它重复地走访过要排序的数列，一次比较两个元素，如果他们的顺序错误就把他们交换过来。走访数列的工作是重复地进行直到没有再需要交换，也就是说该数列已经排序完成

1、构建一个继承自javax.mail.Authenticator的具体类，并重写里面的getPasswordAuthentication()方法。此类是用作登录校验的，以确保你对该邮箱有发送邮件的权利。

2、构建一个properties文件，该文件中存放SMTP服务器地址等参数。

3、通过构建的properties文件和javax.mail.Authenticator具体类来创建一个javax.mail.Session。Session的创建，就相当于登录邮箱一样。剩下的自然就是新建邮件。

4、构建邮件内容，一般是javax.mail.internet.MimeMessage对象，并指定发送人，收信人，主题，内容等等。

5、使用javax.mail.Transport工具类发送邮件。

以百度地图为例:

1. 导入JS <script
   type="text/javascript"
   src="http://api.map.baidu.com/api?v=2.0&ak=您的密钥">
2. 设置移动端兼容性 <meta
   name="viewport" content="initial-scale=1.0,
   user-scalable=no" />
3. 创建地图对象 var map =
   new BMap.Map("地图要呈现的DIV");
4. 创建定位点 var point =
   new BMap.Point(116.404, 39.915);
5. 让地图对象定位在刚刚的坐标map.centerAndZoom(point,
   15);

Apache POI 是创建和维护操作各种符合Office
Open XML（OOXML）标准和微软的OLE 2复合文档格式（OLE2）的Java API。用它可以使用Java读取和创建,修改MS
Excel文件.而且,还可以使用Java读取和创建MS Word和MSPowerPoint文件。Apache POI
提供Java操作Excel解决方案（适用于Excel97-2008）。

HSSF － 提供读写Microsoft Excel
XLS格式档案的功能。

XSSF － 提供读写Microsoft Excel
OOXML XLSX格式档案的功能。

HWPF － 提供读写Microsoft Word
DOC格式档案的功能。

HSLF － 提供读写Microsoft
PowerPoint格式档案的功能。

HDGF － 提供读Microsoft Visio格式档案的功能。

HPBF － 提供读Microsoft
Publisher格式档案的功能。

HSMF － 提供读Microsoft
Outlook格式档案的功能。

// 声明一个工作薄

HSSFWorkbook wb = new HSSFWorkbook();

//声明一个单子并命名

HSSFSheet sheet = wb.createSheet(学生表);

//给单子名称一个长度

sheet.setDefaultColumnWidth((short)15);

// 生成一个样式

HSSFCellStyle style = wb.createCellStyle();

//创建第一行（也可以称为表头）

HSSFRow row = sheet.createRow(0);

//样式字体居中

style.setAlignment(HSSFCellStyle.ALIGN_CENTER);

//给表头第一行一次创建单元格

HSSFCell cell = row.createCell((short) 0);

cell.setCellValue(学生编号);

cell.setCellStyle(style);

cell = row.createCell( (short) 1);

cell.setCellValue(学生姓名);

cell.setCellStyle(style);

cell = row.createCell((short)
2);

cell.setCellValue(学生性别);

cell.setCellStyle(style);

//添加一些数据集合数据

List<student> list = new
ArrayList<student>();

list.add(new Student(111,张三,男));

list.add(new Student(111,李四,男));

list.add(new Student(111,王五,女));

//向单元格里填充数据

for (short i = 0; i <
list.size(); i++) {

row = sheet.createRow(i + 1);

row.createCell(0).setCellValue(list.get(i).getId());

row.createCell(1).setCellValue(list.get(i).getName());

row.createCell(2).setCellValue(list.get(i).getSex());

}

1.创建一个新Excel表格

var XLObj = new ActiveXObject("Excel.Application");

var xlBook = XLObj.Workbooks.Add;                         //新增工作簿

var ExcelSheet = xlBook.Worksheets(1);                   //创建工作表

2.保存表格

ExcelSheet.SaveAs("C:\\TEST.XLS");

3.使 Excel 通过Application 对象可见

ExcelSheet.Application.Visible = true;

4.打印

xlBook.PrintOut;

或者:

ExcelSheet.PrintOut;

5.关闭

xlBook.Close(savechanges=false);

或者:

ExcelSheet.Close(savechanges=false);

6.结束进程

ExcelSheet.Application.Quit();

a)     Web
Service使用的是 SOAP协议

b)     优点

i.       （1）可以跨防火墙进行通信

ii.      （2）应用程序集成。
即把在不同平台编写的应用程序统一集成起来

iii.     （3）软件和数据重用

WebLogic是美商Oracle的主要产品之一，系并购BEA得来。是商业市场上主要的Java（J2EE）应用服务器软件（application
server）之一，是世界上第一个成功商业化的J2EE应用服务器, 已推出到12c(12.1.3) 版。而此产品也延伸出WebLogic
Portal，WebLogic Integration等企业用的中间件（但当下Oracle主要以Fusion
Middleware融合中间件来取代这些WebLogic
Server之外的企业包），以及OEPE(Oracle Enterprise Pack for Eclipse)开发工具。

MySQL是一个关系型数据库管理系统，由瑞典MySQL
AB 公司开发，目前属于 Oracle 旗下公司。MySQL 最流行的关系型数据库管理系统，在 WEB 应用方面MySQL是最好的
RDBMS (Relational Database Management System，关系数据库管理系统) 应用软件之一。

Oracle Database，又名Oracle
RDBMS，或简称Oracle。是甲骨文公司的一款关系数据库管理系统。它是在数据库领域一直处于领先地位的产品。可以说Oracle数据库系统是目前世界上流行的关系数据库管理系统，系统可移植性好、使用方便、功能强，适用于各类大、中、小、微机环境。

它是一种高效率、可靠性好的
适应高吞吐量的数据库解决方案。

SQL Server是由Microsoft开发和推广的关系数据库管理系统（DBMS），它最初是由Microsoft、Sybase和Ashton-Tate三家公司共同开发的，并于1988年推出了第一个OS/2版本。

PowerDesiger是“一站式”建模与设计的解决方案。企业级用户可以借此创建新应用或对现有商业应用软件进行反向工程，而整个流程会十分迅速、流畅、经济。那些困扰项目开发的难题--------使用不同的技术、跨平台运行，以及在大部分企业中常见的混合多种开发语言的问题都可迎刃而解了。这样用户可以在开发流程的各个阶段（从系统分析和设计到自动生成编码）将精力集中在实现商业需求上。

Microsoft Project (或 MSP)是一个国际上享有盛誉的通用的项目管理工具软件，凝集了许多成熟的项目管理现代理论和方法，可以帮助项目管理者实现时间、资源、成本的计划、控制。

LoadRunner，是一种预测系统行为和性能的负载测试工具。通过以模拟上千万用户实施并发负载及实时性能监测的方式来确认和查找问题，LoadRunner能够对整个企业架构进行测试。企业使用LoadRunner能最大限度地缩短测试时间，优化性能和加速应用系统的发布周期。
LoadRunner可适用于各种体系架构的自动负载测试，能预测系统行为并评估系统性能。

QTP是quicktest
Professional的简称，是一种自动测试工具。使用QTP的目的是想用它来执行重复的自动化测试，主要是用于回归测试和测试同一软件的新版本。因此你在测试前要考虑好如何对应用程序进行测试，例如要测试哪些功能、操作步骤、输入数据和期望的输出数据等

StarUML是一款开放源码的UML开发工具，是由韩国公司主导开发出来的产品

SVN是Subversion的简称，是一个开放源代码的版本控制系统，相较于RCS、CVS，它采用了分支管理系统，它的设计目标就是取代CVS。互联网上很多版本控制服务已从CVS迁移到Subversion。说得简单一点SVN就是用于多个人共同开发同一个项目，共用资源的目的。