java面试

模块一：​

试题一

1、 工厂模式和抽象工厂模式之间的区别

工厂方法模式：

一个抽象产品类，可以派生出多个具体产品类。

一个抽象工厂类，可以派生出多个具体工厂类。

每个具体工厂类只能创建一个具体产品类的实例。

抽象工厂模式：

多个抽象产品类，每个抽象产品类可以派生出多个具体产品类。

一个抽象工厂类，可以派生出多个具体工厂类。

每个具体工厂类可以创建多个具体产品类的实例。

区别：

工厂方法模式只有一个抽象产品类，而抽象工厂模式有多个。

工厂方法模式的具体工厂类只能创建一个具体产品类的实例，而抽象工厂模式可以创建多个。

对于java来说，你能见到的大部分抽象工厂模式都是这样的：

---它的里面是一堆工厂方法，每个工厂方法返回某种类型的对象。

比如说工厂可以生产鼠标和键盘。那么抽象工厂的实现类（它的某个具体子类）的对象都可以生产鼠标和键盘，但可能工厂A生产的是罗技的键盘和鼠标，工厂B是微软的。

这样A和B就是工厂，对应于抽象工厂；

每个工厂生产的鼠标和键盘就是产品，对应于工厂方法；

用了工厂方法模式，你替换生成键盘的工厂方法，就可以把键盘从罗技换到微软。但是用了抽象工厂模式，你只要换家工厂，就可以同时替换鼠标和键盘一套。如果你要的产品有几十个，当然用抽象工厂模式一次替换全部最方便（这个工厂会替你用相应的工厂方法）

所以说抽象工厂就像工厂，而工厂方法则像是工厂的一种产品生产线

2、 问题：你读过那些开源框架的源码？那些点给你留下深刻的印 象？

3、 StringBuffer的实现方式，容量如何扩充？

StringBuffer和String刚好不同在内存的空间分配上，

StringBuffer所创建的空间在盛装字串时分配的空间并不是像String那样刚好与字串所占大小相同，而是在盛装字串大小的基础上还要追加16位的空间这就意味着StringBuffer所创建的空间可以向其中再次追加字串，那是不是只能追加剩下的16位大小的字串呢？答案否定，当你在向StringBuffer中追加字串时会触发StringBuffer的reSize()方法，这个方法就会在你追加字串时动态扩展内存空间以保持该空间始终有16位的剩余大小，那StringBuffer 是不是可以无限追加字串呢？答案是肯定的，条件是受到你PC机内存的限制因为对StringBuffer来讲追加字串是在原有的空间中进行，并没有像String 那样产生新的空间，所以返回的内存地址显然是相同的，

4、 了解JVM启动参数—verbose —Xms —Xms的意义是什么？

java -verbose[:class

gc

jni] 在输出设备上显示虚拟机运行信息。

1.) java -verbose:class

在程序运行的时候有多少类被加载！

2.) java –verbose:gc

在虚拟机发生内存回收时在输出设备显示信息

3.) java –verbose:jni

java启动参数共分为三类；

其一是标准参数（-），所有的JVM实现都必须实现这些参数的功能，而且向后兼容；

其二是非标准参数（-X），默认jvm实现这些参数的功能，但是并不保证所有jvm实现都满足，且不保证向后兼容；

其三是非Stable参数（-XX），此类参数各个jvm实现会有所不同，将来可能会随时取消，需要慎重使用；

标准参数中比较有用的：

verbose

-verbose:class

输出jvm载入类的相关信息，当jvm报告说找不到类或者类冲突时可此进行诊断。

-verbose:gc

输出每次GC的相关情况。

-verbose:jni

输出native方法调用的相关情况，一般用于诊断jni调用错误信息。

非标准参数又称为扩展参数

一般用到最多的是

-Xms512m 设置JVM促使内存为512m。此值可以设置与-Xmx相同，以避免每次垃圾回收完成后JVM重新分配内存。

-Xmx512m ，设置JVM最大可用内存为512M。

-Xmn200m：设置年轻代大小为200M。整个堆大小=年轻代大小 + 年老代大小 + 持久代大小。持久代一般固定大小为64m，所以增大年轻代后，将会减小年老代大小。此值对系统性能影响较大，Sun官方推荐配置为整个堆的3/8。

-Xss128k：

设置每个线程的堆栈大小。JDK5.0以后每个线程堆栈大小为1M，以前每个线程堆栈大小为256K。更具应用的线程所需内存大小进行调整。在相同物理内存下，减小这个值能生成更多的线程。但是操作系统对一个进程内的线程数还是有限制的，不能无限生成，经验值在3000~5000左右。

5、 ClassLoader的功能和工作模式什么是ClassLoader？

Java程序并不是一个原生的可执行文件，而是由许多独立的类文件组成，每一个文件对应一个Java类.此外，这些类文件并非立即全部装入内存的，而是根据程序需要装入内存。ClassLoader专门负责类文件装入到内存。

6、 Jvm gc 如何判断对象是否需要回收，有哪几种方式？

比较常被提到的两种垃圾对象判定算法：

1.引用计数（Reference Counting）

概述：给对象添加一个引用计数器，每有一个地方引用这个对象，计数器值加1，每有一个引用失效则减1。

应用实例：Python中使用了这种算法判定死对象。

优点：实现简单、判定效率高

缺点：难以解决对象之间的循环引用问题

2.可达性分析(Reachability Analysis)

概述：从GC Roots（每种具体实现对GC Roots有不同的定义）作为起点，向下搜索它们引用的对象，可以生成一棵引用树，树的节点视为可达对象，反之视为不可达。

应用实例：Java,C#,Lisp都使用这种算法

7、 Error、Exception和RuntimeException的区别，作用有事什么

Error类和Exception类都继承自Throwable类。

二者的不同之处：

Exception：

1．可以是可被控制(checked) 或不可控制的(unchecked)

2．表示一个由程序员导致的错误

3．应该在应用程序级被处理

Error：

1．总是不可控制的(unchecked)

2．经常用来用于表示系统错误或低层资源的错误

Java 中定义了两类异常：

1) Checked exception: 这类异常都是Exception的子类。异常的向上抛出机制进行处理，假如子类可能产生A异常，那么在父类中也必须throws A异常。可能导致的问题：代码效率低，耦合度过高。

2) Unchecked exception: 这类异常都是RuntimeException的子类，虽然RuntimeException同样也是Exception的子类，但是它们是非凡的，它们不能通过client code来试图解决，所以称为Unchecked exception 。

8、 Reader和inputstream区别

java.io下面有两个抽象类：InputStream和Reader

InputStream是表示字节输入流的所有类的超类

Reader是用于读取字符流的抽象类

InputStream提供的是字节流的读取，而非文本读取，这是和Reader类的根本区别。即用Reader读取出来的是char数组或者String ，使用InputStream读取出来的是byte数组。

9、 Object类中有那些方法

1.protected Object clone() 创建并返回此对象的一个副本。

2.boolean equals(Object obj) 指示某个其他对象是否与此对象“相等”。

3.protected void finalize() 当垃圾回收器确定不存在对该对象的更多引用时，由对象的垃圾回收器调用此方法。

4.Class getClass() 返回一个对象的运行时类。

5.int hashCode() 返回该对象的哈希码值。

6.void notify() 唤醒在此对象监视器上等待的单个线程。

7.void notifyAll() 唤醒在此对象监视器上等待的所有线程。

8.String toString() 返回该对象的字符串表示。

9.void wait() 导致当前的线程等待，直到其他线程调用此对象的

notify() 方法或 notifyAll() 方法。

9.void wait(long timeout) 导致当前的线程等待，直到其他线程调用此对象的 notify() 方法或 notifyAll() 方法，或者超过指定的时间量。

9.void wait(long timeout, int nanos) 导致当前的线程等待，直到其他线程调用此对象的 notify()

10、 IO和NIO本质不同在实际项目中使用场景及如何使用

流（Stream）是最早的Java对IO的抽象，而通道（Channel）是NIO对新Java对IO的抽象，通道与流的不同之处在于通道是双向的。而流只是在一个方向上移动(一个流必须是 InputStream 或者 OutputStream 的子类)， 而 通道可以用于读、写或者同时用于读写。流和通道的基本单位都是字节，但是流是以字节数组作为缓冲区中介，而通道是以ByteBuffer来作为缓冲区中介。

NIO允许你使用一个（或多个）线程管理多个通道（network connections or files），解析数据的成功代价比从阻塞的流中读取数据的更大，更复杂。

如果你要管理同时存在的数以千计的的连接，且只发送少量数据，例如：聊天服务，服务端NIO是一个最佳方案。同样，如果你要维持大量与其他计算机的连接，e.g P2P网络，使用单个线程管理外建的连接是个优势。单线程，多连接设计图示如下：

如果你只有少许连接，并且有高带宽，在一个时间端内发送大量数据，或许标准IO是最佳方案。传统的IO设计图如下：

11、 HashMap和Hashtable的区别

Hashtable是基于陈旧的Dictionary类的，HashMap是Java 1.2引进的Map接口的一个实现。

Hashtable的方法是线程安全的，而HashMap的方法不是线程安全。只有HashMap可以让你将空值作为一个表的条目的key或value。HashMap中只有一条记录可以是一个空的key，但任意数量的条目可以是空的value。

12、 多线程有几种实现，同步和并发是如何解决的，什么叫守护线程，用什么方法实现守护线程

实现线程有两种 继承Thread类或者实现Runnable接口... 实现同步也有两种,一种是用同步方法,一种是用同步块.. 同步方法就是在方法返回类型后面加上synchronized,

在Java中比较特殊的线程是被称为守护（Daemon）线程的低级别线程。这个线程具有最低的优先级，用于为系统中的其它对象和线程提供服务。将一个用户线程设置为守护线程的方式是在线程对象创建之前调用线程对象的setDaemon方法。典型的守护线程例子是JVM中的系统资源自动回收线程，它始终在低级别的状态中运行，用于实时监控和管理系统中的可回收资源。

13、 说出数据连接池的工作机制是什么？解决什么问题？

J2EE服务器启动时会建立一定数量的池连接，并一直维持不少于此数目的池连接。客户端程序需要连接时，池驱动程序会返回一个未使用的池连接并将其表记为忙。如果当前没有空闲连接，池驱动程序就新建一定数量的连接，新建连接的数量有配置参数决定。当使用的池连接调用完成后，池驱动程序将此连接表记为空闲，其他调用就可以使用这个连接。

连接池基本的思想是在系统初始化的时候，将数据库连接作为对象存储在内存中，当用户需要访问数据库时，并非建立一个新的连接，而是从连接池中取出一个已建立的空闲连接对象。使用完毕后，用户也并非将连接关闭，而是将连接放回连接池中，以供下一个请求访问使用。而连接的建立、断开都由连接池自身来管理。同时，还可以通过设置连接池的参数来控制连接池中的初始连接数、连接的上下限数以及每个连接的最大使用次数、最大空闲时间等等。也可以通过其自身的管理机制来监视数据库连接的数量、使用情况等。

数据库连接是一种关键的有限的昂贵的资源，这一点在多用户的网页应用程序中体现得尤为突出。对数据库连接的管理能显著影响到整个应用程序的伸缩性和健壮性，影响到程序的性能指标。数据库连接池正是针对这个问题提出来的。

14、 了解过那些JDK5的新特性，举例描述下相应的特性？

1 循环

5.0 1.4

for (type variable : array){

body

} for (int i = 0; i < array.length; i++){

type variable = array[i];

body

}

for (type variable : arrayList){

body

} for (int i = 0; i < arrayList.size(); i++){

type variable = (type) arrayList.get(i);

body

}

15、 2 泛型

16、 以ArrayList为例，包括创建一个容器对象和取得容器内对象操作：

5.0 1.4

ArrayList arrayList =

new ArrayList() ArrayList arrayList =

new ArrayList();

arrayList.get(i) (Type) arrayList.get(i)

17、 3 自动装箱拆箱

18、在JDK5.0以前，在原始类型与相应的包装类之间的转化是不能自动完成的。要完成这种转化，需要手动调用包装类的构造函数：

5.0 1.4

Integer wrapper = n; Integer wrapper = new Integer(n);

19、 在JDK5.0环境中，可以自动转化，不再需要手工干预：

5.0 1.4

int n = wrapper; int n = wrapper.intValue();

20、 4 可变参数列表

5.0 1.4

method(other params, p1, p2, p3) method(other params, new Type[] { p1, p2, p3 })

21、 5 可变的返回类型

22、在JDK5.0以前，当覆盖父类方法时，返回类型是不能改变的。现在有新的规则用于覆盖方法。如下，一个典型的例子就是clone()方法：

5.0 1.4

public Employee clone() { ... }

...

Employee cloned = e.clone(); public Object clone() { ... }

...

Employee cloned = (Employee) e.clone();

23、 6 静态导入

24、 静态导入功能对于JDK 5.0以前的版本是不支持的。

5.0 1.4

import static java.lang.Math;

import static java.lang.System;

...

out.println(sqrt(PI)); System.out.println(Math.sqrt(Math.PI));

25、 7 控制台输入

26、 JDK 5.0先前的版本没有Scanner类，只能使用JOptionPane.showInputDialog类代替。

5.0 1.4

Scanner in = new Scanner(System.in);System.out.print(prompt);

int n = in.nextInt();

double x = in.nextDouble();

String s = in.nextLine(); String input = JOptionPane.showInputDialog(prompt);

int n = Integer.parseInt(input);

double x = Double.parseDouble(input);

s = input;

27、 8 格式化输出

28、 JDK5.0以前的版本没有print方法，只能使用NumberFormat.getNumberInstance来代替。

5.0 1.4

System.out.printf("%8.2f", x); NumberFormat formatter

= NumberFormat.getNumberInstance();

formatter.setMinimumFractionDigits(2);

formatter.setMaximumFractionDigits(2);

String formatted = formatter.format(x);

for (int i = formatted.length(); i < 8; i++)

System.out.print(" "); System.out.print(formatted);

29、 9 内容面板代理

30、在JDK5.0先前的版本中，JFrame,JDialog,JApplet等类没有代理add和setLayout方法。

5.0 1.4

add(component) getContentPane().add(component)

setLayout(manager) getContentPane().setLayout(manager)

31、 10 StringBuilder类

32、 JDK 5.0引入了StringBuilder类，这个类的方法不具有同步，这使得该类比StringBuffer类更高效。

5.0 1.4

StringBuilder StringBuffer

15、简介常用的集合类，以及对应算法

Collection

├List

│├LinkedList

│├ArrayList

│└Vector

│　└Stack

└Set

Map

├Hashtable

├HashMap

└WeakHashMap

Vector类是java.util包中提供的一个工具类，它类似于可变长的数组，但具有比数组更强大的功能。它很好的解决数组长度不断改变的问题，可以保存一组数据类型不同的元素，不能存储基本数据类型（可以通过存储基本类型对应的包装类来实现）。

Java SDK不提供直接继承自Collection的类，Java SDK提供的类都是继承自Collection的“子接口”如List和Set。

基本操作 增加元素add(Object obj); addAll(Collection c);

删除元素 remove(Object obj); removeAll(Collection c);

求交集 retainAll(Collection c);

删除元素 remove(Object obj); removeAll(Collection c);

求交集 retainAll(Collection c);

Set，即数学中的集合，特点是无重复、无序，即一种不包含重复的元素的Collection，任意的两个元素e1和e2都有e1.equals(e2)=false，Set最多有一个null元素。

List是有序的Collection，次序是List最重要的特点；它确保维护元素特定的顺序。List为Collection添加了许多方法，使得能够向List中间插入与移除元素(只推荐LinkedList使用)。一个List可以生成ListIterator，使用它可以从两个方向遍历 List，也可以从List中间插入和删除元素。和Set不同，List允许有相同的元素。

Map没有继承Collection接口，Map提供key到value的映射。一个Map中不能包含相同的key，每个key只能映射一个value。 Map接口提供3种集合的视图，Map的内容可以被当作一组key集合，一组value集合，或者一组key-value映射。

16、Hibemate/Ibatis,两者的区别，简单的实现

最大的区别在于：

ibatas的sql语句需要自己手动写，而hibernate能够在程序运行时自动生成。但是不要就这样以为hibernate比ibatas方便，其实二者熟悉之后的效率差不多。而hibernate还能够自动建表等等，这样的好处就在于你带着这个程序，无论到什么机器上，你都不需要数据库，应为它能自动为你完成，而ibatas就必须要有相应的数据库表才能进行移植

Hibernate的特点：

Hibernate功能强大，数据库无关性好，O/R（对象/关系）映射能力强，如果你对Hibernate相当精通，而且对Hibernate进行了适当的封装，那么你的项目整个持久层代码会相当简单，需要写的代码很少，开发速度很快，非常爽。Hibernate对数据库结构提供了较为完整的封装，Hibernate的O/R Mapping实现了POJO（实体类） 和数据库表之间的映射，以及SQL 的自动生成和执行。程序员往往只需定义好了POJO 到数据库表的映射关系，即可通过Hibernate 提供的方法完成持久层操作。程序员甚至不需要对SQL 的熟练掌握， Hibernate/OJB 会根据制定的存储逻辑，自动生成对应的SQL 并调用JDBC 接口加以执行。Hibernate的缺点就是学习门槛不低，要精通门槛更高，而且怎么设计O/R映射，在性能和对象模型之间如何权衡取得平衡，以及怎样用好Hibernate方面需要你的经验和能力都很强才行，但是Hibernate现在已经是主流O/R Mapping框架，从文档的丰富性，产品的完善性，版本的开发速度都要强于iBATIS。

iBATIS的特点：

iBATIS入门简单，即学即用，提供了数据库查询的自动对象绑定功能，而且延续了很好的SQL使用经验，对于没有那么高的对象模型要求的项目来说，相当完美。iBATIS的缺点就是框架还是比较简陋，功能尚有缺失，虽然简化了数据绑定代码，但是整个底层数据库查询实际还是要自己写的，工作量也比较大，而且不太容易适应快速数据库修改。当系统属于二次开发,无法对数据库结构做到控制和修改,那iBATIS的灵活性将比Hibernate更适合。系统数据处理量巨大，性能要求极为苛刻，这往往意味着我们必须通过经过高度优化的SQL语句（或存储过程）才能达到系统性能设计指标。在这种情况下iBATIS会有更好的可控性和表现。

现在就市场来说，hibernate的需求要大于ibatas的需求，而hibernate对个人能力的要求更高，即使公司使用ibatas，你在hibernate的基础上也能快速掌握。

在二者之间如果选择学习的话我建议hibernate，上面的理由我想已经足够清楚了。

17、ibatis:sql语句中＞特殊符号 怎么办

1.做过html就知道，其实就是xml的特殊符号，需要做个转义

＆lt； <</P>

＆gt； >

＆lt； <</P>

＆gt； >

＆amp； &

＆apos； '

＆quot； "

2.建议使用符号进行统一说明，将此符号内的任何文本不进行解析

3. 处理Like可以用下面的这两种方法

LIKE #param#

'%' 采用参数传递，或者'$param$%' 采用字符串替换，就是替换参数的值替换param。

其实同理可以处理其它类似的问题。

18、Spring的核心理念是什么？

Spring其主要精髓 就是IOC和AOP。 IOC（英文 Inversion of Control）就是控制反转的意思。就是把新建对象（new Object（））的权利交给Spring容器去管理、程序员用的时候只需到容器中去取就可以、无需自己在去new一个对象。也称其为依赖注入、 AOP（英文 Aspect Oriented Programming ）译为面向切面编程AOP是OOP(面向对象编程)的延续，是Aspect Oriented Programming的缩写，意思是面向方面编程。AOP实际是GoF设计模式的延续，设计模式孜孜不倦追求的是调用者和被调用者之间的解耦，AOP可以说也是这种目标的一种实现。AOP就是在某一个类或方法执行前后形成通知切入点，声明在执行到这里之前要先执行什么，执行完这里之后要接着执行什么。插入了新的执行方法。

1.切面(aspect):要实现的交叉功能，是系统模块化的一个切面或领域。如日志记录。

2.连接点:应用程序执行过程中插入切面的地点，可以是方法调用，异常抛出，或者要修改的

字段。

3.通知:切面的实际实现，他通知系统新的行为。如在日志通知包含了实

现日志功能的代码，如向日志文件写日志。通知在连接点插入到应用系统中。

4.切入点:定义了通知应该应用在哪些连接点，通知可以应用到AOP框架支持的任何连接点。

5.引入:为类添加新方法和属性。

6.目标对象:被通知的对象。既可以是你编写的类也可以是第三方类。

7.代理:将通知应用到目标对象后创建的对象，应用系统的其他部分不用为了支持代理对象而

改变。

8.织入:将切面应用到目标对象从而创建一个新代理对象的过程。织入发生在目标

对象生命周期的多个点上：

编译期：切面在目标对象编译时织入.这需要一个特殊的编译器.

类装载期：切面在目标对象被载入JVM时织入.这需要一个特殊的类载入器.

运行期：切面在应用系统运行时织入.

19、Spring属性注入的实现

<:property name="intValue">

123

<:property name="listValue">

list1

list2

<:property name="setValue">

set1

set2

<:property name="arrayValue">

array1

array2

<:property name="mapValue">

20、SpringAOP解决了什么问题，Spring如何实现AOP

AOP是Aspect Oriented Programming的缩写，意思是面向方面编程，一种新兴的编程技术。

AOP实际是GoF设计模式的延续,设计模式孜孜不倦追求的是调用者和被调用者之间的解耦,

AOP可以说也是这种目标的一种实现。它可以解决OOP和过程化方法不能够很好解决的横切

（crosscut）问题,

如：事务、安全、日志等横切关注。当未来系统变得越来越复杂,

横切关注点就成为一个大问题的时候,AOP就可以很轻松的解决横切关注点这个问题。

JDK里面有个类 InvocationHandler 是代理实例的调用处理程序 实现的接口。

必须实现Object invoke(Object proxy, Method method, Object[] args) 在与方法关联的代理实例上调用方法时，将在调用处理程序上调用此方法。

动态代理类（以下简称为代理类）是一个实现在创建类时在运行时指定的接口列表的类，该类具有下面描述的行为。 代理接口是代理类实现的一个接口。 代理实例 是代理类的一个实例。 每个代理实例都有一个关联的调用处理程序 对象，它可以实现接口 InvocationHandler。通过其中一个代理接口的代理实例上的方法调用将被指派到实例的调用处理程序的 Invoke 方法，并传递代理实例、识别调用方法的 java.lang.reflect.Method 对象以及包含参数的 Object 类型的数组。调用处理程序以适当的方式处理编码的方法调用，并且它返回的结果将作为代理实例上方法调用的结果返回。

就是说你要代理的类和你写的类要实现同一接口，为什么SPRING中经常用接口，然后配BEAN确实实现类，就是这个道理

21、Spring , BeanFactory ,FactoryBean的区别

org.springframework.beans及org.springframework.context包是Spring IoC容器的基础。BeanFactory提供的高级配置机制，使得管理任何性质的对象成为可能。ApplicationContext是BeanFactory的扩展，功能得到了进一步增强，比如更易与Spring AOP集成、消息资源处理(国际化处理)、事件传递及各种不同应用层的context实现(如针对web应用的WebApplicationContext)。

简而言之，BeanFactory提供了配制框架及基本功能，而ApplicationContext则增加了更多支持企业核心内容的功能。ApplicationContext完全由BeanFactory扩展而来，因而BeanFactory所具备的能力和行为也适用于ApplicationContext。

org.springframework.beans.factory.BeanFactory是Spring IoC容器的实际代表者，IoC容器负责容纳此前所描述的bean，并对bean进行管理。

在Spring中，BeanFactory是IoC容器的核心接口。它的职责包括：实例化、定位、配置应用程序中的对象及建立这些对象间的依赖。

Spring为我们提供了许多易用的BeanFactory实现，XmlBeanFactory就是最常用的一个。该实现将以XML方式描述组成应用的对象以及对象间的依赖关系。XmlBeanFactory类将持有此XML配置元数据，并用它来构建一个完全可配置的系统或应用。

Beanfactory 和Factory bean，其中BeanFactory指的是IOC容器的编程抽象，比如ApplicationContext， XmlBeanFactory等，这些都是IOC容器的具体表现，需要使用什么样的容器由客户决定但Spring为我们提供了丰富的选择。而 FactoryBean只是一个可以在IOC容器中被管理的一个bean,是对各种处理过程和资源使用的抽象,Factory bean在需要时产生另一个对象，而不返回FactoryBean本省，我们可以把它看成是一个抽象工厂，对它的调用返回的是工厂生产的产品。所有的 Factory bean都实现特殊的org.springframework.beans.factory.FactoryBean接口，当使用容器中factory bean的时候，该容器不会返回factory bean本身，而是返回其生成的对象。Spring包括了大部分的通用资源和服务访问抽象的Factory bean的实现，其中包括：

对JNDI查询的处理，对代理对象的处理，对事务性代理的处理，对RMI代理的处理等，这些我们都可以看成是具体的工厂，看成是SPRING为我们建立好的工厂。也就是说Spring通过使用抽象工厂模式为我们准备了一系列工厂来生产一些特定的对象，免除我们手工重复的工作，我们要使用时只需要在 IOC容器里配置好就能很方便的使用了。

22、Spring 的事务管理， SpringBean注入的几种方式

一.事务的4个特性：

原子性：一个事务中所有对数据库的操作是一个不可分割的操作序列，要么全做，要么全部做。

一致性：数据不会因为事务的执行而遭到破坏。

隔离性：一个事务的执行，不受其他事务（进程）的干扰。既并发执行的个事务之间互不干扰。

持久性：一个事务一旦提交，它对数据库的改变将是永久的。

二.事务的实现方式：

实现方式共有两种：编码方式；声明式事务管理方式。

基于AOP技术实现的声明式事务管理，实质就是：在方法执行前后进行拦截，然后在目标方法开始之前创建并加入事务，执行完目标方法后根据执行情况提交或回滚事务。

声明式事务管理又有两种方式：基于XML配置文件的方式；另一个是在业务方法上进行@Transactional注解，将事务规则应用到业务逻辑中。

依赖注入的意义：让组件依赖于抽象，当组件要与其他实际对象发生依赖关系时，通过抽象来注入依赖的实际对象。

依赖注入的3种实现方式分别是：接口注入（interface injection）、Set注入（setter injection）和构造注入（constructor injection）。

23、aop实现的原理，cglib和动态代理的一些区别

AOP（Aspect-OrientedProgramming，面向方面编程），可以说是OOP（Object-Oriented Programing，面向对象编程）的补充和完善。OOP引入封装、继承和多态性等概念来建立一种对象层次结构，用以模拟公共行为的一个集合。当我们需要为分散的对象引入公共行为的时候，OOP则显得无能为力。也就是说，OOP允许你定义从上到下的关系，但并不适合定义从左到右的关系。例如日志功能。日志代码往往水平地散布在所有对象层次中，而与它所散布到的对象的核心功能毫无关系。对于其他类型的代码，如安全性、异常处理和透明的持续性也是如此。这种散布在各处的无关的代码被称为横切（cross-cutting）代码，在OOP设计中，它导致了大量代码的重复，而不利于各个模块的重用。

而AOP技术则恰恰相反，它利用一种称为“横切”的技术，剖解开封装的对象内部，并将那些影响了多个类的公共行为封装到一个可重用模块，并将其名为 “Aspect”，即方面。所谓“方面”，简单地说，就是将那些与业务无关，却为业务模块所共同调用的逻辑或责任封装起来，便于减少系统的重复代码，降低模块间的耦合度，并有利于未来的可操作性和可维护性。AOP代表的是一个横向的关系，如果说“对象”是一个空心的圆柱体，其中封装的是对象的属性和行为；那么面向方面编程的方法，就仿佛一把利刃，将这些空心圆柱体剖开，以获得其内部的消息。而剖开的切面，也就是所谓的“方面”了。然后它又以巧夺天功的妙手将这些剖开的切面复原，不留痕迹。

使用“横切”技术，AOP把软件系统分为两个部分：核心关注点和横切关注点。业务处理的主要流程是核心关注点，与之关系不大的部分是横切关注点。横切关注点的一个特点是，他们经常发生在核心关注点的多处，而各处都基本相似。比如权限认证、日志、事务处理。Aop 的作用在于分离系统中的各种关注点，将核心关注点和横切关注点分离开来。正如Avanade公司的高级方案构架师Adam Magee所说，AOP的核心思想就是“将应用程序中的商业逻辑同对其提供支持的通用服务进行分离。”

实现AOP的技术，主要分为两大类：一是采用动态代理技术，利用截取消息的方式，对该消息进行装饰，以取代原有对象行为的执行；二是采用静态织入的方式，引入特定的语法创建“方面”，从而使得编译器可以在编译期间织入有关“方面”的代码。

cglib（Code Generation Library）是一个强大的,高性能,高质量的Code生成类库。它可以在运行期扩展Java类与实现Java接口。

cglib封装了asm，可以在运行期动态生成新的class。

cglib用于AOP，jdk中的proxy必须基于接口，cglib却没有这个限制。

原理区别：

java动态代理是利用反射机制生成一个实现代理接口的匿名类，在调用具体方法前调用InvokeHandler来处理。而cglib动态代理是利用asm开源包，对代理对象类的class文件加载进来，通过修改其字节码生成子类来处理。

1、如果目标对象实现了接口，默认情况下会采用JDK的动态代理实现AOP

2、如果目标对象实现了接口，可以强制使用CGLIB实现AOP

3、如果目标对象没有实现了接口，必须采用CGLIB库，spring会自动在JDK动态代理和CGLIB之间转换

24、Oracle中的Varchar , Char数据类型有什么区别

CHAR的长度是固定的，而VARCHAR2的长度是可以变化的， 比如，存储字符串“abc"，对于CHAR (20)，表示你存储的字符将占20个字节(包括17个空字符),在数据库中它是以空格占位的，而同样的VARCHAR2 (20)则只占用3个字节的长度，20只是最大值，当你存储的字符小于20时，按实际长度存储。 CHAR的效率比VARCHAR2的效率稍高。 目前VARCHAR是VARCHAR2的同义词。

25、sql注入原理

SQL注入攻击指的是通过构建特殊的输入作为参数传入Web应用程序，而这些输入大都是SQL语法里的一些组合，通过执行SQL语句进而执行攻击者所要的操作，其主要原因是程序没有细致地过滤用户输入的数据，致使非法数据侵入系统。

根据相关技术原理，SQL注入可以分为平台层注入和代码层注入。前者由不安全的数据库配置或数据库平台的漏洞所致；后者主要是由于程序员对输入未进行细致地过滤，从而执行了非法的数据查询。基于此，SQL注入的产生原因通常表现在以下几方面：①不当的类型处理；②不安全的数据库配置；③不合理的查询集处理；④不当的错误处理；⑤转义字符处理不合适；⑥多个提交处理不当。

先猜表名

And (Select count(*) from 表名)<>0

猜列名

And (Select count（列名） from 表名）<>0

验证绕过漏洞就是'or'='or'后台绕过漏洞，利用的就是AND和OR的运算规则，从而造成后台脚本逻辑性错误

例如管理员的账号密码都是admin，那么再比如后台的数据库查询语句是

user=request("user")

passwd=request("passwd")

sql='select admin from adminbate where user='&'''&user&'''&' and passwd='&'''&passwd&'''

那么我使用'or 'a'='a来做用户名密码的话，那么查询就变成了

select admin from adminbate where user=''or 'a'='a' and passwd=''or 'a'='a'

这样的话，根据运算规则，这里一共有4个查询语句，那么查询结果就是 假or真and假or真，先算and 再算or，最终结果为真，这样就可以进到后台了

26、AJAX感受，有什么缺点？你使用的是AJAX的那种框架？AJAX如何解决跨域问题？

Ajax一直都是一个很热的话题。其主要就是运用JavaScript在客户端执行的特性，异步的向服务器发起请求。同时服务器接受请求，获取请求过来的参数，同时返回一些数据。数据主要包括string类型和XML类型。

Ajax好在什么地方呢：首先他提交的数据相对较少，或者说他提交的是可控的，不会提交一些无用的数据。而一些像aspx，asp这些请求，他会把控件状态以及页面信息发送到服务器。从而提交了很多的不必要的数据，必然会影响速度。而且提交的数据多了，服务器反映也会慢一些。处理的数据也会多一些。不错 Ajax在这一方面肯定有自己的优势，能够异步提交，不影响客户端的操作，同时提交的数据少，使得服务端能更好的反应。但是不得不考虑的就是。有很多时候，客户端的一些无意思的操作。也会引起数据的提交，从而使得服务端重复的去处理了这样的一些操作。所以，在页面触发提交操作的时候自己一定需要控制好这些流程。判断此提交的少本身是不是因为无意思而引起的。如果是，那么就不触发提交操作。同时服务端，在数据提交上去以后，一定要给出回应。判断是否提交成功。所以这个时候相对于后台语言，需要更多的JavaScript脚本语言。

同时Ajax在安全方面相对直接提交还是有所欠缺的。所以，在使用的时候还是需要注意的。同时JavaScript相对来说，调试并不像后台代码那样方面进行调试。很多错误提示并不是很准确。所以在编写的时候也是很耗费时间的。所以，在选择使用Ajax还是需要考虑一下。

同时我们也应该注重客户的感受。有的时候客户已经习惯于一次性的提交。反而异步提交，有些让人摸不着头脑。

说了这么多，不是说不占成使用Ajax，只是说在使用Ajax的时候。我们需要更多的考虑一些东西。

1.?使用中间层过渡的方式：?中间过渡，很明显，就是在ajax与不同域的服务器进行通讯的中间加一层过渡，这一层过渡可以是php、jsp、c++等任何具备网络通讯功能的语言，由中间层向不同域的服务器进行读取数据的操作。拿php做一个例子，如果需要对不同域的某一个php进行通讯，现在客户端的xmlhttprequest先query本域的一个php，然后由本域的这个php去和不同域的php进行通讯，然后由本域的php输出response；

2. 使用标签

这个方法是利用标签中的src来query一个php获得response，因为标签的src属性不存在跨域的问题。举个例子来让大家看得更清楚一点吧：

1.

2.

3.

4.

19.

20.

21.

22.

23.

其中get.php的代码是

1. < php

2. echo "var param = 'www.achome.cn'";

3. >

最后的运行结果是，当你点击那个button，它会出现一个内容为”www.achome.cn”的对话框。

这个方法又叫做ajaj或者ajax without xmlHttprequest，把x换成了j，是因为使用了标签而没有用到xml和xmlHttprequest的缘故。

27、http get和post的区别

"HTTP请求的GET与POST方式的区别

（1）get是从服务器上获取数据，post是向服务器传送数据。在客户端，Get方式在通过URL提交数据，数据在URL中可以看到；POST方式，数据放置在HTMLHEADER内提交。（2）对于get方式，服务器端用Request.QueryString获取变量的值，对于post方式，服务器端用Request.Form获取提交的数据。（3）GET方式提交的数据最多只能有1024字节，而POST则没有此限制。（4）安全性问题。正如在（1）中提到，使用Get的时候，参数会显示在地址栏上，而Post不会。所以，如果这些数据是中文数据而且是非敏感数据，那么使用get；如果用户输入的数据不是中文字符而且包含敏感数据，那么还是使用post为好"

28、在web开发中，用redirect与forward做跳转有什么区别，web应用服务器对用户请求通常返回一些状态码，请描述一下分别以4和5开头的状态码

1.从地址栏显示来说

forward是服务器请求资源,服务器直接访问目标地址的URL,把那个URL的响应内容读取过来,然后把这些内容再发给浏览器.浏览器根本不知道服务器发送的内容从哪里来的,所以它的地址栏还是原来的地址.

redirect是服务端根据逻辑,发送一个状态码,告诉浏览器重新去请求那个地址.所以地址栏显示的是新的URL.

2.从数据共享来说

forward:转发页面和转发到的页面可以共享request里面的数据.

redirect:不能共享数据.

3.从运用地方来说

forward:一般用于用户登陆的时候,根据角色转发到相应的模块.

redirect:一般用于用户注销登陆时返回主页面和跳转到其它的网站等.

4.从效率来说

forward:高.

redirect:低.

转发是服务器行为，重定向是客户端行为。为什么这样说呢，这就要看两个动作的工作流程：

转发过程：客户浏览器发送http请求----》web服务器接受此请求--》调用内部的一个方法在容器内部完成请求处理和转发动作----》将目标资源发送给客户；在这里，转发的路径必须是同一个web容器下的url，其不能转向到其他的web路径上去，中间传递的是自己的容器内的request。在客户浏览器路径栏显示的仍然是其第一次访问的路径，也就是说客户是感觉不到服务器做了转发的。转发行为是浏览器只做了一次访问请求。

重定向过程：客户浏览器发送http请求----》web服务器接受后发送302状态码响应及对应新的location给客户浏览器--》客户浏览器发现是302响应，则自动再发送一个新的http请求，请求url是新的location地址----》服务器根据此请求寻找资源并发送给客户。在这里 location可以重定向到任意URL，既然是浏览器重新发出了请求，则就没有什么request传递的概念了。在客户浏览器路径栏显示的是其重定向的路径，客户可以观察到地址的变化的。重定向行为是浏览器做了至少两次的访问请求的。

常见的状态代码包括：

200 – 服务器成功返回网页

404 – 请求的网页不存在

503 – 服务器暂时不可用

1xx（临时响应）

表示临时响应并需要请求者继续执行操作的状态代码。

2xx（成功）

表示服务器成功处理了请求的状态代码。

3xx（重定向）

要完成请求，需要进一步操作。 通常，这些状态代码用来重定向。

4xx（请求错误）

这些状态代码表示请求可能出错，妨碍了服务器的处理。

5xx（服务器错误）

这些状态代码表示服务器在尝试处理请求时发生内部错误。 这些错误可能是服务器本身的错误，而不是请求出错。

29、session 和cookie区别

cookie 和session 的区别：

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

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

考虑到安全应当使用session。

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

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

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

5、所以个人建议：

将登陆信息等重要信息存放为SESSION

其他信息如果需要保留，可以放在COOKIE中

cookie的内容主要包括：名字，值，过期时间，路径和域。路径与域一起构成cookie的作用范围。若不设置过期时间，则表示这

个cookie的生命期为浏览器会话期间，关闭浏览器窗口，cookie就消失。这种生命期为浏览器会话期的cookie被称为会话cookie。

会话cookie一般不存储在硬盘上而是保存在内存里，当然这种行为并不是规范规定的。若设置了过期时间，浏览器就会把cookie

保存到硬盘上，关闭后再次打开浏览器，这些cookie仍然有效直到超过设定的过期时间。存储在硬盘上的cookie可以在不同的浏

览器进程间共享，比如两个IE窗口。而对于保存在内存里的cookie，不同的浏览器有不同的处理方式

session机制。session机制是一种服务器端的机制，服务器使用一种类似于散列表的结构（也可能就是使用散列表）来保存信息。

试题二

1.泛型相关问题参考(http://blog.csdn.net/jinuxwu/article/details/6771121)

a) Java为什么要引入泛型?有什么好处?

在引入范型之前，Java类型分为原始类型、复杂类型，其中复杂类型分为数组和类。引入范型后，一个复杂类型就可以在细分成更多的类型。

例如原先的类型List，现在在细分成List

注意，现在List

他们之间没有继承关系，即使String继承了Object。下面的代码是非法的

Listls = new ArrayList();

List

b) 泛型检验类型值的时候是在编译阶段,还是运行阶段?为什么要在编译阶段?

c) 泛型通配符的几个关键字?(? extends super) extends 和 super 有什么区别?

d) 泛型能得到<>里面的类型吗?怎么得到?

2.异常相关问题参考(http://www.cnblogs.com/qinqinmeiren/archive/2010/10/14/2151702.html)

a) Java异常分哪几类?

1.Error

动态链接失败，虚拟机错误等，通常Java程序不应该捕获这类异常，也不会抛弃这种异常

2.Exception

运行时异常：继承于RuntimeException的类都属于运行时异常，例如算术异常（除零错）、数组下标越界异常等等。由于这些异常产生的位置是未知的，Java 编译器允许程序员在程序中不对它们做出处理。

b) 怎么理解RuntimeException和非RuntimeException? 两者有什么区别?

非RuntimeException需要通过try catch语块处理，如果有这个语块在调用这一方法时用throws关键字抛出

c) 解释一下throw 和 throws的区别?

throw是语句抛出一个异常。

语法：throw (异常对象);

throws是方法可能抛出异常的声明。(用在声明方法时，表示该方法可能要抛出异常)

d) 异常的继承结构?基类是什么?

e) Exception体系包括哪两个体系?

RuntimeException 和 其它类型异常

RuntimeException 通常是由于程序逻辑不严谨或用户非法操作导 致的运行异常

算术异常类：ArithmeticExecption

空指针异常类：NullPointerException

类型强制转换异常： ClassCastException

数组负下标异常：NegativeArrayException

数组下标越界异常：ArrayIndexOutOfBoundsException

违背安全原则异常：SecturityException

文件已结束异常： EOFException

文件未找到异常： FileNotFoundException

字符串转换为数字异常： NumberFormatException

操作数据库异常： SQLException

输入输出异常： IOException

方法未找到异常： NoSuchMethodException

java.lang.AbstractMethodError

抽象方法错误。当应用试图调用抽象方法时抛出。

java.lang.AssertionError

断言错。用来指示一个断言失败的情况。

java.lang.ClassCircularityError

类循环依赖错误。在初始化一个类时，若检测到类之间循环依赖则抛出该异常

f) Try-catch-finally中finally有什么作用

3.Java枚举相关问题参考(http://www.cnblogs.com/yuyijq/archive/2010/10/26/1861988.html)

a) 描述一下Java中的枚举特性?

b) 枚举的关键字是什么? (enum)

c) 枚举能有构造函数吗? (可以滴)

4.Java 同步相关问题

a) Java中同步怎么实现?有哪几种方式?

b) ....

5.Http 相关问题参考(http://www.cnblogs.com/hyddd/archive/2009/03/31/1426026.html)

a) Http提交方式有哪几种,分别是什么?(get post put delete)

b) Get 和 Post 提交方式有什么区别? Get和Post方式参数是如何传递的?

c) Http 和 Https 有什么区别? Https加密的方式是什么?(SSL加密)

d) 用过哪些服务器配置Https Server?怎么配置的?

6.加密 相关问题参考(http://zhidao.baidu.com/question/28053955.html?fr=ala0)

a) 了解过对称加密和非对称性加密吗?

b) 对称加密如何进行加密?(采用单钥密码加密方式)

c) 非对称性加密如何进行加密 (采用两个密钥,公钥和私钥加密)

7.数据库方面

a) ACID解释一下什么意思?

b) 数据库的游标如何理解?

c) 触发器如何使用?

d) Java中PreparedStatement和Statement用法和区别?哪个性能好?

8.Java虚拟机参考(http://www.cnblogs.com/zcshan/archive/2011/03/10/jvm.html)

a) 了解过java虚拟机回收机制吗?

9、hibernate的缓存机制?

10、Spring详细介绍一下？

11、Java 虚拟机工作模式，垃圾回收机制？

12、Java异常详细介绍？

 

模块二：

一、String,StringBuffer, StringBuilder 的区别是什么？String为什么是不可变的？

String 不变

StringBuffer 变 线程安全，同步互斥，效率低

StringBuilder 替代StringBuffer，线程不安全，效率高

二、VECTOR,ARRAYLIST, LINKEDLIST的区别是什么？

1)由 Vector 的 iterator 和 listIterator 方法所返回的迭代器是快速失败的：如果在迭代器创建后的任意时间从结构上修改了向量（通过迭代器自身的 remove 或 add 方法之外的任何其他方式），则迭代器将抛出 ConcurrentModificationException。--同步

2）ARRAYLIST 不同步

List list = Collections.synchronizedList(new ArrayList(...)); --同步创建

此类的 iterator 和 listIterator 方法返回的迭代器是快速失败的：在创建迭代器之后，除非通过迭代器自身的 remove 或 add 方法从结构上对列表进行修改，否则在任何时间以任何方式对列表进行修改，迭代器都会抛出 ConcurrentModificationException。因此，面对并发的修改，迭代器很快就会完全失败，而不是冒着在将来某个不确定时间发生任意不确定行为的风险。

3）LINKEDLIST 不同步

List list = Collections.synchronizedList(new LinkedList(...));--同步创建

类实现 Queue 接口，为 add、poll 等提供先进先出队列操作

类的 iterator 和 listIterator 方法返回的迭代器是快速失败的：在迭代器创建之后，如果从结构上对列表进行修改，除非通过迭代器自身的 remove 或 add 方法，其他任何时间任何方式的修改，迭代器都将抛出 ConcurrentModificationException

java的线程同步机制：java的线程同步机制很大程度上都是基于内存模型而设定的

一个线程执行临界区代码过程如下：

1 获得同步锁

2 清空工作内存

3 从主存拷贝变量副本到工作内存

4 对这些变量计算

5 将变量从工作内存写回到主存

6 释放锁

三、HASHTABLE, HASHMAP，TreeMap区别

为了成功地在哈希表中存储和检索对象，用作键的对象必须实现 hashCode 方法和 equals 方法。

1)Hashtable 是同步的

2)HASHMAP 基于哈希表的 Map 接口的实现。此实现提供所有可选的映射操作，并允许使用 null 值和 null 键。（除了不同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。）此类不保证映射的顺序，特别是它不保证该顺序恒久不变。--不同步

Map m = Collections.synchronizedMap(new HashMap(...));--同步创建

3）TreeMap实现SortedMap 接口的基于红黑树的实现。此类保证了映射按照升序顺序排列关键字，根据使用的构造方法不同，可能会按照键的类的自然顺序 进行排序（参见 Comparable），或者按照创建时所提供的比较器进行排序。

--不同步

Map m = Collections.synchronizedMap(new TreeMap(...)); 同步创建

四、ConcurrentMap和HashMap的区别

1）ConcurrentMap 接口 ConcurrentHashMap实现了改接口。此类遵守与 Hashtable 相同的功能规范，并且包括对应于 Hashtable 的每个方法的方法版本。不过，尽管所有操作都是线程安全的，但获取操作不必锁定，并且不 支持以某种防止所有访问的方式锁定整个表。

2）HashMap并允许使用 null 值和 null 键。（除了非同步和允许使用 null 之外，HashMap 类与 Hashtable 大致相同。）

五、apache，Tomcat，jboss，IIS，Weblogic，Websphere的区别

1）Apache只是一个web服务器，解释静态网页Html

Apache是以进程为基础的结构，进程要比线程消耗更多的系统开支，不太适合于多处理器环境，因此，在一个Apache Web站点扩容时，通常是增加服务器或扩充群集节点而不是增加处理器。

2）Tomcat是一个初级的应用服务器，不支持EJB，如需EJB功能须用jboss

3）JBoss含有Jsp和Servlet容器,也就可以做web容器,也包含EJB容器,是完整的J2EE应用服务器

JBoss是一个运行EJB的J2EE应用服务器。它是开放源代码的项目，遵循最新的J2EE规范。从JBoss项目开始至今，它已经从一个EJB容器发展成为一个基于的J2EE的一个web操作系统（operating systemfor web），它体现了J2EE规范中最新的技术，含有Jsp和Servlet容器,也就可以做web容器,也包含EJB容器,是完整的J2EE应用服务器.

4）Weblogic是一个企业级的应用服务器，其中包括j2ee中的各类应用如jsp,servlet,ejb等

Weblogic是BEA公司的产品，是用于开发、集成、部署和管理大型分布式Web应用、网络应用和数据库应用的Java应用服务器，将Java的动态功能和Java Enterprise标准的安全性引入大型网络应用的开发、集成、部署和管理之中

5）Websphere是IBM公司的产品，基于J2EE的，对Jsp，Servlet,ejb的支持非常好！不过挺复杂的！

WebSphere 是随需应变的电子商务时代的最主要的软件平台。它使您的公司可以开发、部署和整合新一代的电子商务应用，如B2B 电子商务，并支持从简单的网页内容发布到企业级事务处理的商业应用,含有Jsp和Servlet容器,也就可以做web容器,也包含EJB容器,是完整的J2EE应用服务器

6）IIS是微软的Internet Information Server的简称！主要是用来提供Web服务的，当然是针对它自己的产品asp的

六、GET POST区别

1、HTTP 只有POST和GET 两种命令模式；

2、 POST 是被设计用来向上放东西的，而GET是被设计用来从服务器取东西的，GET也能够向服务器传送较少的数据，而Get之所以也能传送数据,只是用来设计告诉服务器,你到底需要什么样的数据.POST的信息作为HTTP 请求的内容，而GET是在HTTP 头部传输的；

3、POST与GET在HTTP 中传送的方式不同，GET的参数是在HTTP 的头部传送的，而Post的数据则是在HTTP 请求的内容里传送;

4、POST传输数据时，不需要在URL中显示出来，而GET方法要在URL中显示；

5、 GET方法由于受到URL长度的限制,只能传递大约1024字节；POST传输的数据量大，可以达到2M，而根据微软方面的说法，微软对用 Request.Form() 可接收的最大数据有限制，IIS 4 中为 80 KB 字节，IIS 5 中为 100 KB 字节；

HTTP 协议请求方法GET 与POST 的简单区别：

1.GET 方法

GET 方法提交数据不安全，数据置于请求行，客户端地址栏可见;

GET 方法提交的数据大小限制在255 个字符之内

GET 方法不可以设置书签

2.POST 方法

POST 方法提交数据安全，数据置于消息主体内，客户端不可见

POST 方法提交的数据大小没有限制

POST 方法可以设置书签

七、SESSION, COOKIE区别

1、session保存在服务器，客户端不知道其中的信息；cookie保存在客户端，服务器能够知道其中的信息。

2、session中保存的是对象，cookie中保存的是字符串。

3、session不能区分路径，同一个用户在访问一个网站期间，所有的session在任何一个地方都可以访问到。而cookie中如果设置了路径参数，那么同一个网站中不同路径下的cookie互相是访问不到的。

4.session是以cookie或URL重写为基础的，默认使用cookie来实现，

八、Servlet的生命周期

1，初始化阶段 调用init()方法

2，响应客户请求阶段　　调用service()方法

3，终止阶段　　调用destroy()方法

Servlet工作原理：

首先简单解释一下Servlet接收和响应客户请求的过程，首先客户发送一个请求，Servlet是调用service()方法对请求进行响应的，通过源代码可见，service()方法中对请求的方式进行了匹配，选择调用doGet,doPost等这些方法，然后再进入对应的方法中调用逻辑层的方法，实现对客户的响应。在Servlet接口和GenericServlet中是没有doGet,doPost等等这些方法的，HttpServlet中定义了这些方法，但是都是返回error信息，所以，我们每次定义一个Servlet的时候，都必须实现doGet或doPost等这些方法。

每一个自定义的Servlet都必须实现Servlet的接口，Servlet接口中定义了五个方法，其中比较重要的三个方法涉及到Servlet的生命周期，分别是上文提到的init(),service(),destroy()方法。GenericServlet是一个通用的，不特定于任何协议的Servlet,它实现了Servlet接口。而HttpServlet继承于GenericServlet，因此HttpServlet也实现了Servlet接口。所以我们定义Servlet的时候只需要继承HttpServlet即可。

Servlet接口和GenericServlet是不特定于任何协议的，而HttpServlet是特定于HTTP协议的类，所以HttpServlet中实现了service()方法，并将请求ServletRequest,ServletResponse强转为HttpRequest和HttpResponse。

Servlet响应请求阶段：

对于用户到达Servlet的请求，Servlet容器会创建特定于这个请求的ServletRequest对象和ServletResponse对象，然后调用Servlet的service方法。service方法从ServletRequest对象获得客户请求信息，处理该请求，并通过ServletResponse对象向客户返回响应信息。

对于Tomcat来说，它会将传递过来的参数放在一个Hashtable中，该Hashtable的定义是：

private HashtableparamHashStringArray = new Hashtable();

Servlet终止阶段：

当WEB应用被终止，或Servlet容器终止运行，或Servlet容器重新装载Servlet新实例时，Servlet容器会先调用Servlet的destroy()方法，在destroy()方法中可以释放掉Servlet所占用的资源

九、HTTP 报文包含内容

HTTP消息包括客户机向服务器的请求消息和服务器向客户机的响应消息。这两种类型的消息由：

一个起始行

请求：MethodSPRequest-URISPHTTP-VersionCRLFMethod

响应：HTTP-VersionSPStatus-CodeSPReason-PhraseCRLF

一个或者多个头域，HTTP的头域包括通用头，请求头，响应头和实体头四个部分。每个头域由一个域名，冒号（:）和域值三部分组成。域名是大小写无关的，

通用头域包含

Cache-Control、指定请求和响应遵循的缓存机制

HTTP Keep-Alive 使客户端到服务器端的连接持续有效，当出现对服务器的后继请求时，Keep-Alive功能避免了建立或者重新建立连接。虽然为客户保留打开的连接有一定的好处，但它同样影响了性能，

KeepAliveTime 值控制 TCP/IP 尝试验证空闲连接是否完好的频率

Connection、

Date、Date头域表示消息发送的时间，时间的描述格式由rfc822定义。例如，Date:Mon,31Dec200104:25:57GMT

Pragma、Pragma头域用来包含实现特定的指令，最常用的是Pragma:no-cache

Transfer-Encoding、

Upgrade、

Via

Host头域指定请求资源的Intenet主机和端口号，

Referer头域允许客户端指定请求uri的源资源地址，这可以允许服务器生成回退链表，可用来登陆、优化cache等。

Range头域可以请求实体的一个或者多个子范围

User-Agent头域的内容包含发出请求的用户信息。

一个指示头域结束的空行

可选的消息体组成。

------------------如果存在不支持的请求头域，一般将会作为实体头域处理

十、Statement与PreparedStatement的区别,什么是SQL注入，如何防止SQL注入

1.PreparedStatement是预编译的,对于批量处理可以大大提高效率. 也叫JDBC存储过程

2.使用 Statement 对象。在对数据库只执行一次性存取的时侯，用 Statement 对象进行处理。PreparedStatement 对象的开销比Statement大，对于一次性操作并不会带来额外的好处。

3.statement每次执行sql语句，相关数据库都要执行sql语句的编译，preparedstatement是预编译得, preparedstatement支持批处理

4.安全性。传递给PreparedStatement对象的参数可以被强制进行类型转换，使开发人员可以确保在插入或查询数据时与底层的数据库格式匹配。

SQL注入：

就是通过把SQL命令插入到Web表单递交或输入域名或页面请求的查询字符串，最终达到欺骗服务器执行恶意的SQL命令

避免：

1.永远不要信任用户的输入。对用户的输入进行校验，可以通过正则表达式，或限制长度；对单引号和 　　双"-"进行转换等。

要过滤的关键词，如select ; “”；form

2.永远不要使用动态拼装sql，可以使用参数化的sql或者直接使用存储过程进行数据查询存取。

3.永远不要使用管理员权限的数据库连接，为每个应用使用单独的权限有限的数据库连接。

4.不要把机密信息直接存放，加密或者hash掉密码和敏感的信息。

5.应用的异常信息应该给出尽可能少的提示，最好使用自定义的错误信息对原始错误信息进行包装

6.sql注入的检测方法一般采取辅助软件或网站平台来检测，软件一般采用sql注入检测工具jsky

十一、redirect, foward区别

1）forward是服务器请求资源，服务器直接访问目标地址的URL，把那个URL的响应内容读取过来，然后把这些内容再发给浏览器，浏览器根本不知道服务器发送的内容是从哪儿来的，所以它的地址栏中还是原来的地址。

2）redirect就是服务端根据逻辑,发送一个状态码,告诉浏览器重新去请求那个地址，一般来说浏览器会用刚才请求的所有参数重新请求，所以session,request参数都可以获取。

3）SendRedirect则是完全的跳转，浏览器将会得到跳转的地址，并重新发送请求链接。这样，从浏览器的地址栏中可以看到跳转后的链接地址。

所以，forward更加高效，在前者可以满足需要时，尽量使用forward()方法，并且，这样也有助于隐藏实际的链接。但在有些情况下，比如，需要跳转到一个其它服务器上的资源，则必须使用sendRedirect()方法。

十二、关于JAVA内存模型，一个对象（两个属性，四个方法）实例化100次，现在内存中的存储状态，几个对象，几个属性，几个方法。？？？

十三、谈谈Hibernate的理解，一级和二级缓存的作用，在项目中Hibernate都是怎么使用缓存的

通过可扩展标记语言（XML）实现了类和数据表之间的映射，使程序员在业务逻辑的开发中面向数据库而改为面向对象开发。使整个项目开发分工更加明确，提高了程序开发的效率。

Hibernate缓存分为二级，第一级存放于session中称为一级缓存，默认带有且不能卸载。

第二级是由sessionFactory控制的进程级缓存。是全局共享的缓存，凡是会调用二级缓存的查询方法都会从中受益。只有经正确的配置后二级缓存才会发挥作用。同时在进行条件查询时必须使用相应的方法才能从缓存中获取数据。比如Query.iterate()方法、load、get方法等。必须注意的是session.find方法永远是从数据库中获取数据，不会从二级缓存中获取数据，即便其中有其所需要的数据也是如此

查询时使用缓存的实现过程为：首先查询一级缓存中是否具有需要的数据，如果没有，查询二级缓存，如果二级缓存中也没有，此时再执行查询数据库的工作。要注意的是：此3种方式的查询速度是依次降低的。

因为Session的生命期往往很短，存在于Session内部的第一级最快缓存的生命期当然也很短，所以第一级缓存的命中率是很低的。其对系统性能的改善也是很有限的。当然，这个Session内部缓存的主要作用是保持Session内部数据状态同步。并非是hibernate为了大幅提高系统性能所提供的。

怎么配置使用

true

net.sf.hibernate.cache.HashtableCacheProvider

另外：

。。。。。。。

十四、反射讲一讲，主要是概念,都在哪需要反射机制，反射的性能，如何优化

十五、谈谈Hibernate与Ibatis的区别，哪个性能会更高一些

1)hibernate 是一个ORM框架 sql自动生成

数据库结构提供了较为完整的封装，提供了从POJO 到数据库表的全套映射机制。程序员往往只需定义好了POJO 到数据库表的映射关系，即可通过Hibernate 提供的方法完成持久层操作。程序员甚至不需要对SQL 的熟练掌握，Hibernate 会根据制定的存储逻辑，自动生成对应的SQL 并调用JDBC 接口加以执行。

2)ibatis 是一个sql map框架 sql需要自己写 可以进行细粒度的优化

Ibatis最直接的好处就是不但为程序员提供了对象与关系数据库之间的映射，同时提供操作方法与SQL间的直接影射，设计者可以直接为一个方法指定一条SQL语句，从而取得更加准确的数据，同时为优化查询、连接查询提供了方便。

运行效率在不考虑 cache 的情况下，iBatis 应该会比hibernate 快一些或者很多。

十六、对Spring的理解，项目中都用什么？怎么用的？对IOC、和AOP的理解及实现原理

http://www.ibm.com/developerworks/cn/java/wa-spring1/

Spring 是一个开源框架，是为了解决企业应用程序开发复杂性而创建的。框架的主要优势之一就是其分层架构，分层架构允许您选择使用哪一个组件，同时为 J2EE 应用程序开发提供集成的框架。

核心容器：核心容器提供 Spring 框架的基本功能。核心容器的主要组件是 BeanFactory，它是工厂模式的实现。BeanFactory 使用控制反转 （IOC）模式将应用程序的配置和依赖性规范与实际的应用程序代码分开。

Spring 上下文：Spring 上下文是一个配置文件，向 Spring 框架提供上下文信息。Spring 上下文包括企业服务，例如 JNDI、EJB、电子邮件、国际化、校验和调度功能。

Spring AOP：通过配置管理特性，Spring AOP 模块直接将面向方面的编程功能集成到了 Spring 框架中。所以，可以很容易地使 Spring 框架管理的任何对象支持 AOP。Spring AOP 模块为基于 Spring 的应用程序中的对象提供了事务管理服务。通过使用 Spring AOP，不用依赖 EJB 组件，就可以将声明性事务管理集成到应用程序中。参考SpringAOP笔记

Spring DAO：JDBC DAO 抽象层提供了有意义的异常层次结构，可用该结构来管理异常处理和不同数据库供应商抛出的错误消息。异常层次结构简化了错误处理，并且极大地降低了需要编写的异常代码数量（例如打开和关闭连接）。Spring DAO 的面向 JDBC 的异常遵从通用的 DAO 异常层次结构。

Spring ORM：Spring 框架插入了若干个 ORM 框架，从而提供了 ORM 的对象关系工具，其中包括 JDO、Hibernate 和 iBatis SQL Map。所有这些都遵从 Spring 的通用事务和 DAO 异常层次结构。

Spring Web 模块：Web 上下文模块建立在应用程序上下文模块之上，为基于 Web 的应用程序提供了上下文。所以，Spring 框架支持与 Jakarta Struts 的集成。Web 模块还简化了处理多部分请求以及将请求参数绑定到域对象的工作。

Spring MVC 框架：MVC 框架是一个全功能的构建 Web 应用程序的 MVC 实现。通过策略接口，MVC 框架变成为高度可配置的，MVC 容纳了大量视图技术，其中包括 JSP、Velocity、Tiles、iText 和 POI。

Spring 的核心要点是：支持不绑定到特定 J2EE 服务的可重用业务和数据访问对象

十七、线程同步，并发操作怎么控制

java的线程同步机制：java的线程同步机制很大程度上都是基于内存模型而设定的

一个线程执行临界区代码过程如下：

1 获得同步锁

2 清空工作内存

3 从主存拷贝变量副本到工作内存

4 对这些变量计算

5 将变量从工作内存写回到主存

6 释放锁

可见，synchronized既保证了多线程的并发有序性，又保证了多线程的内存可见性。

内存模型：

java的内存模型

a)可见性：当一个共享变量在多个线程的工作内存中都有副本时，如果一个线程修改了这个共享变量，那么其他线程应该能够看到这个被修改后的值，这就是多线程的可见性问题。

多个线程之间是不能互相传递数据通信的，它们之间的沟通只能通过共享变量来进行。Java内存模型（JMM）规定了jvm有主内存，主内存是多个线程共享的。当new一个对象的时候，也是被分配在主内存中，每个线程都有自己的工作内存，工作内存存储了主存的某些对象的副本，当然线程的工作内存大小是有限制的

(1) 从主存复制变量到当前工作内存 (read and load)

(2) 执行代码，改变共享变量值 (use and assign)

(3) 用工作内存数据刷新主存相关内容 (store and write) JVM规范定义了线程对主存的操作指令：read，load，use，assign，store，write

read-load

read-load-use

assign

store-write

b)有序性（互斥）

线程在引用变量时不能直接从主内存中引用,如果线程工作内存中没有该变量,则会从主内存中拷贝一个副本到工作内存中,这个过程为read-load,完成后线程会引用该副本。当同一线程再度引用该字段时,有可能重新从主存中获取变量副本(read-load-use),也有可能直接引用原来的副本 (use),也就是说 read,load,use顺序可以由JVM实现系统决定。

线程不能直接为主存中中字段赋值，它会将值指定给工作内存中的变量副本(assign),完成后这个变量副本会同步到主存储区(store- write)，至于何时同步过去，根据JVM实现系统决定.有该字段,则会从主内存中将该字段赋值到工作内存中,这个过程为read-load,完成后线程会引用该变量副本，当同一线程多次重复对字段赋值时,比如：

十八、描述struts的工作流程。

Struts的工作流程:

在web应用启动时就会加载初始化ActionServlet,ActionServlet从struts-config.xml文件中读取配置信息,把它们存放到各种配置对象

当ActionServlet接收到一个客户请求时,将执行如下流程.

-(1)检索和用户请求匹配的ActionMapping实例,如果不存在,就返回请求路径无效信息;

-(2)如果ActionForm实例不存在,就创建一个ActionForm对象,把客户提交的表单数据保存到ActionForm对象中;

-(3)根据配置信息决定是否需要表单验证.如果需要验证,就调用ActionForm的validate()方法;

-(4)如果ActionForm的validate()方法返回null或返回一个不包含ActionMessage的ActuibErrors对象, 就表示表单验证成功;

-(5)ActionServlet根据ActionMapping所包含的映射信息决定将请求转发给哪个Action,如果相应的 Action实例不存在,就先创建这个实例,然后调用Action的execute()方法;

-(6)Action的execute()方法返回一个ActionForward对象,ActionServlet在把客户请求转发给 ActionForward对象指向的JSP组件;

-(7)ActionForward对象指向JSP组件生成动态网页,返回给客户;

十九、Tomcat的session处理，如果让你实现一个tomcatserver，如何实现session机制

Session创建的大致过程:

首先判断requestedSessionId是否存在，如果存在，那么根据这个ID去查找Session对象。如果requestedSessionId不存在或者没有取到Session，并且传递给#getSession(boolean)的参数为真，那么要创建一个新的Session，并且给客户端写回去一个Session Cookie。

写一个Session Listener 类

该类要求实现HttpSessionListener接口的两个方法：

public void sessionCreated(HttpSessionEvent event) {

}

public void sessionDestroyed(HttpSessionEvent event) {

}

当session创建的时候，调用 sessionCreated 方法

当session销毁的时候，调用 sessionDestroyed 方法

这样你就可以知道用户什么时候上来，什么时候退出。

二十、关于Cache(Ehcache,Memcached)

Ehcache:ehcache是纯java编写的，通信是通过RMI方式，适用于基于java技术的项目。

一个ehcache缓存系统可以同时定义多个cache，每个cache使用key- value方式存储数据

Memcached:memcached服务器端是c编写的，客户端有多个语言的实现，如c，php（淘宝，sina等各大门户网站），python（豆瓣网），java（Xmemcached，spymemcached)。memcached服务器端是使用文本或者二进制通信的。

memcahced只有key-value，它是一个大的哈希表。因此当我们在Hibernate配置了多个缓存的时候在 memcached就会出现问题，这些问题具体表现出来的异常是ClassCastException，因为不同的对象使用同一个key进行缓存数据的读写。这在ehcache中是没有问题的，因为这就是ehcache的结构。由此，为了让Hibernate使用memcached缓存系统，我们需要在 Provider这个级别上对缓存的key进行包装，我们可以将Hibernate传递过来的缓存名跟key结合起来生成一个新的key，读写缓存数据都是用这个key，这样就不会发生缓存数据冲突导致的异常。 ---------com.*.frame.cache.memcached.MemcachedCacheProvider

二一、sql的优化相关问题

二二、oracle中 rownum与rowid的理解，一千条记录我查200到300的记录怎么查？

1）rownum

select xx from table where rownum < n”(n>1)这样的查询是有正确含义的，

select xx from table where rownum = n”这样的查询只在n=1的时候成立，

select xx from table where rownum > n”(n>1)这样的查询只能得到一个空集。

另外“select xx from table where rownum > 0”这个查询会返回所有的记录

Oracle对rownum的处理上，rownum是在得到结果集的时候产生的，用于标记结果集中结果顺序的一个字段，这个字段被称为“伪数列”，也就是事实上不存在的一个数列。它的特点是按顺序标记，而且是逐次递加的，换句话说就是只有有rownum=1的记录，才可能有rownum=2的记录。

2）rowid与rownum虽都被称为伪列，但它们的存在方式是不一样的，rowid可以说是物理存在的，表示记录在表空间中的唯一位置ID，在DB中唯一。只要记录没被搬动过，rowid是不变的。

SELECT * FROM

(

SELECT A.*, ROWNUM RN

FROM (SELECT * FROM inte_order) A

)

WHERE RN BETWEEN 21 AND 40

二三、如何分析ORACLE的执行计划？

二四、 DB中索引原理，种类，使用索引的好处和问题是什么？

1）所有索引的原形都是树状结构，由根、枝干和叶子组成。根和枝干中存放键值范围的导引指针，叶子中存放的是条目，条目中存放的是索引的键值和该数据行的ROWID。索引的叶子间通过指针横向的联系在一起，前一个叶子指向下一片叶子，这样的目的是数据库在找到一个叶子后就可以查找相临近的叶子，而不必再次去查找根和枝干的数据块。

查看索引的属性。

SQL> select INDEX_NAME,INDEX_TYPE,TABLE_NAME,UNIQUENESS from user_indexes;

查看索引在哪个表和哪个列上。

SQL> select INDEX_NAME,TABLE_NAME,COLUMN_NAME from user_ind_columns

索引的建立有两种模式：隐式建立和显式建立

隐式建立，当我们在表上建立主键和唯一性约束的时候，数据库会自动的建立同名称的索引，如果你删除或者禁用约束，数据库会自动的删除该同名称的索引，因为这两个约束是通过索引来实现的。

2）分类

B树索引和位图索引是按照索引的组织方式来分类的。

B树是指索引的组织方式是以索引块为节点的B+树，位图索引是按照索引值排列的。

函数索引：

顾名思义，这是指对列值做了函数之后存储的一种索引方式；

聚簇索引和非聚簇索引：

这是按照索引与table的关系区分的，如果table中的内容按照索引的顺序存储，则该索引为聚簇索引，否则为非聚簇索引。

联合索引：

多个字段上一起建立索引。

分区本地索引： B树索引和位图索引都可以分区，但是HASH索引不可以被分区。位图索引必须是本地索引

分区索引分为：

本地(local index)索引

前缀(prefix)的索引

无前缀(nonprefix)的索引

全局索引(global index)。

前缀(prefix)的索引

create table test (id number,data varchar2(100))

partition by RANGE (id)

(

partition p1 values less than (1000) tablespace p1,

partition p2 values less than (2000) tablespace p2,

partition p3 values less than (maxvalue) tablespace p3

);

create index i_id on test(id) local; 因为id是分区键，所以这样就创建了一个有前缀的本地索引。

create index i_data on test(data) local;因为data不是分区键，所以这样就创建了一个无前缀的本地索引。

全局与分区：是否按照“区”来见索引。

3）检索速度快，但是需要维护，对数据库性能影响——维护！！！

数据库会自动的维护索引也可自己手工维护：

alter index i_t1_empno coalesce;--合并

alter index i_t1_empno rebuild;

注意：

合并不释放段所拥有的空间，不处理正在变化的行，也就是说有事务的时候也可以合并。合并只是合并枝干内的叶子，如果叶子属于不同的枝干则分别独立合并，记住合并不会改变索引的结构。不会改变改变索引的表空间和索引类型。

重建只能在没有事务的情况下进行，如果有未提交的事务，就会报错。

重建要求所有要索引的行都要就位，所以必须等待事务结束。索引重建会改变索引的结构，释放多余的空间，可以改变索引的表空间和索引类型。

二五、JVM垃圾回收实现原理。垃圾回收的线程优先级。

JVM使用的是分代垃圾回收的方式

在jvm中堆空间划分为三个代：年轻代（Young Generation）、年老代（Old Generation）和永久代（Permanent Generation）。

年轻代和年老代是存储动态产生的对象。

永久代主要是存储的是java的类信息，包括解析得到的方法、属性、字段等等。永久代基本不参与垃圾回收。

这里讨论的垃圾回收主要是针对年轻代和年老代。具体如下图。

当eden区申请不到空间的时候，进行minorGC，把存活的对象拷贝到survior。

年老代主要存放生命周期比较长的对象，比如缓存对象。

具体jvm内存回收过程描述如下（可以结合上图）：

1、对象在Eden区完成内存分配

2、当Eden区满了，再创建对象，会因为申请不到空间，触发minorGC，进行young(eden+1survivor)区的垃圾回收

3、minorGC时，Eden不能被回收的对象被放入到空的survivor（Eden肯定会被清空），另一个survivor里不能被GC回收的对象也会被放入这个survivor，始终保证一个survivor是空的

4、当做第3步的时候，如果发现survivor满了，则这些对象被copy到old区，或者survivor并没有满，但是有些对象已经足够Old，也被放入Old区 XX:MaxTenuringThreshold

5、当Old区被放满的之后，进行fullGC

二六、jvm 最大内存设置。设置的原理。结合垃圾回收讲讲。

JVM的Heap分配可以使用-X参数设定，

-Xms

初始Heap大小

-Xmx

java heap最大值

一般-Xms 与 -Xmx 相同较好

-Xmn 一般1/3 -Xmx Java Heap Young区大小，不熟悉最好保留默认值；

young generation的heap大小

JVM有2个GC线程

第一个线程负责回收Heap的Young区

第二个线程在Heap不足时，遍历Heap，将Young 区升级为Older区

Older区的大小等于-Xmx减去-Xmn，不能将-Xms的值设的过大，因为第二个线程被迫运行会降低JVM的性能。

为什么一些程序频繁发生GC？有如下原因：

1.程序内调用了System.gc()或Runtime.gc()。

2.一些中间件软件调用自己的GC方法，此时需要设置参数禁止这些GC。

3.Java的Heap太小，一般默认的Heap值都很小。

4.频繁实例化对象，Release对象 此时尽量保存并重用对象，例如使用StringBuffer()和String()。

如果你发现每次GC后，Heap的剩余空间会是总空间的50%，这表示你的Heap处于健康状态,许多Server端的Java程序每次GC后最好能有65%的剩余空间

Stack的设定

每个线程都有他自己的Stack。

-Xss 每个线程的Stack大小

Stack的大小限制着线程的数量。如果Stack过大就好导致内存溢漏。-Xss参数决定Stack大小，例如-Xss1024K。如果Stack太小，也会导致Stack溢漏。

4种GC:

1、第一种为单线程GC，也是默认的GC，该GC适用于单CPU机器。

2、第二种为Throughput GC，是多线程的GC，适用于多CPU，使用大量线程的程序。第二种GC与第一种GC相似，不同在于GC在收集Young区是多线程的，但在Old区和第一种一样，仍然采用单线程。-XX:+UseParallelGC参数启动该GC。

3、第三种为Concurrent Low Pause GC，类似于第一种，适用于多CPU，并要求缩短因GC造成程序停滞的时间。这种GC可以在Old区的回收同时，运行应用程序。-XX:+UseConcMarkSweepGC参数启动该GC。

4、第四种为Incremental Low Pause GC，适用于要求缩短因GC造成程序停滞的时间。这种GC可以在Young区回收的同时，回收一部分Old区对象。-Xincgc参数启动该GC。

二七、http协议，tcp协议，socket

1)http

HTTP是一个属于应用层的面向对象的协议，由于其简捷、快速的方式，适用于分布式超媒体信息系统。

请求与响应模式的、无状态的、应用层的协议，常基于TCP的连接方式，HTTP1.1版本中给出一种持续连接的机制，绝大多数的Web开发，都是构建在HTTP协议之上的Web应用。

HTTP协议的主要特点可概括如下：

1.支持客户/服务器模式。

2.简单快速：客户向服务器请求服务时，只需传送请求方法和路径。请求方法常用的有GET、HEAD、POST。每种方法规定了客户与服务器联系的类型不同。由于HTTP协议简单，使得HTTP服务器的程序规模小，因而通信速度很快。

3.灵活：HTTP允许传输任意类型的数据对象。正在传输的类型由Content-Type加以标记。

4.无连接：无连接的含义是限制每次连接只处理一个请求。服务器处理完客户的请求，并收到客户的应答后，即断开连接。采用这种方式可以节省传输时间。

5.无状态：HTTP协议是无状态协议。无状态是指协议对于事务处理没有记忆能力。缺少状态意味着如果后续处理需要前面的信息，则它必须重传，这样可能导致每次连接传送的数据量增大。另一方面，在服务器不需要先前信息时它的应答就较快。

http请求由三部分组成，分别是：请求行、消息报头、请求正文

请求行以一个方法符号开头，以空格分开，后面跟着请求的URI和协议的版本，格式如下：Method Request-URI HTTP-Version CRLF

HTTP响应也是由三个部分组成，分别是：状态行、消息报头、响应正文

HTTP消息由客户端到服务器的请求和服务器到客户端的响应组成。请求消息和响应消息都是由开始行（对于请求消息，开始行就是请求行，对于响应消息，开始行就是状态行），消息报头（可选），空行（只有CRLF的行），消息正文（可选）组成。

运行-->cmd-->telnet

open www.sina.com.cn 80

高层协议有：文件传输协议FTP、电子邮件传输协议SMTP、域名系统服务DNS、网络新闻传输协议NNTP和HTTP协议等

中介由三种：

代理(Proxy):代理根据URI的绝对格式来接受请求，重写全部或部分消息，通过 URI的标识把已格式化过的请求发送到服务器

网关(Gateway):一个作为其它服务器中间媒介的服务器。与代理不同的是，网关接受请求就好象对被请求的资源来说它就是源服务器；发出请求的客户机并没有意识到它在同网关打交道。

网关经常作为通过防火墙的服务器端的门户，网关还可以作为一个协议翻译器以便存取那些存储在非HTTP系统中的资源。

通道(Tunnel):是作为两个连接中继的中介程序。一旦激活，通道便被认为不属于HTTP通讯，尽管通道可能是被一个HTTP请求初始化的。当被中继的连接两端关闭时，通道便消失。当一个门户(Portal)必须存在或中介(Intermediary)不能解释中继的通讯时通道被经常使用。

2)tcp协议

TCP协议提供的是可靠的、面向连接的传输控制协议，即在传输数据前要先建立逻辑连接，然后再传输数据，最后释放连接3个过程。TCP提供端到端、全双工通信；采用字节流方式，如果字节流太长，将其分段；提供紧急数据传送功能。

连接传送：3次握手

断开传送：4次握手

3)socket协议

连接->传输数据->关闭连接

socket通常也称作"套接字"，应用程序通常通过"套接字"向网络发出请求或者应答网络请求。

Socket和ServerSocket类库位于java .net包中。ServerSocket用于服务器端，Socket是建立网络连接时使用的。在连接成功时，应用程序两端都会产生一个Socket实例，操作这个实例，完成所需的会话。对于一个网络连接来说，套接字是平等的，并没有差别，不因为在服务器端或在客户端而产生不同级别。不管是Socket还是ServerSocket它们的工作都是通过SocketImpl类及其子类完成的。

Accept方法用于产生"阻塞"，直到接受到一个连接，并且返回一个客户端的Socket对象实例。"阻塞"是一个术语，它使程序运行暂时"停留"在这个地方，直到一个会话产生，然后程序继续；通常"阻塞"是由循环产生的。

getInputStream方法获得网络连接输入，同时返回一个InputStream对象实例。

getOutputStream方法连接的另一端将得到输入，同时返回一个OutputStream对象实例。注意：其中getInputStream和getOutputStream方法均可能会产生一个IOException，它必须被捕获，因为它们返回的流对象，通常都会被另一个流对象使用。

SOCKET连接过程

根据连接启动的方式以及本地套接字要连接的目标，套接字之间的连接过程可以分为三个步骤：服务器监听，客户端请求，连接确认。

服务器监听：是服务器端套接字并不定位具体的客户端套接字，而是处于等待连接的状态，实时监控网络状态。

客户端请求：是指由客户端的套接字提出连接请求，要连接的目标是服务器端的套接字。为此，客户端的套接字必须首先描述它要连接的服务器的套接字，指出服务器端套接字的地址和端口号，然后就向服务器端套接字提出连接请求。

连接确认：是指当服务器端套接字监听到或者说接收到客户端套接字的连接请求，它就响应客户端套接字的请求，建立一个新的线程，把服务器端套接字的描述发给客户端，一旦客户端确认了此描述，连接就建立好了。而服务器端套接字继续处于监听状态，继续接收其他客户端套接字的连接请求。

OSI 7层 协议

1.物理层：主要定义物理设备标准，如网线的接口类型、光纤的接口类型、各种传输介质的传输速率等。它的主要作用是传输比特流（就是由1、0转化为电流强弱来进行传输,到达目的地后在转化为1、0，也就是我们常说的数模转换与模数转换）。这一层的数据叫做比特。

2.数据链路层：定义了如何让格式化数据以进行传输，以及如何让控制对物理介质的访问。这一层通常还提供错误检测和纠正，以确保数据的可靠传输。

3.网络层：在位于不同地理位置的网络中的两个主机系统之间提供连接和路径选择。Internet的发展使得从世界各站点访问信息的用户数大大增加，而网络层正是管理这种连接的层。

4.传输层：定义了一些传输数据的协议和端口号（WWW端口80等），如：TCP（传输控制协议，传输效率低，可靠性强，用于传输可靠性要求高，数据量大的数据），UDP（用户数据报协议，与TCP特性恰恰相反，用于传输可靠性要求不高，数据量小的数据，如QQ聊天数据就是通过这种方式传输的）。主要是将从下层接收的数据进行分段和传输，到达目的地址后再进行重组。常常把这一层数据叫做段。 　　 tcp/ip udp

5.会话层：通过传输层（端口号：传输端口与接收端口）建立数据传输的通路。主要在你的系统之间发起会话或者接受会话请求（设备之间需要互相认识可以是IP也可以是MAC或者是主机名）

6.表示层：可确保一个系统的应用层所发送的信息可以被另一个系统的应用层读取。例如，PC程序与另一台计算机进行通信，其中一台计算机使用扩展二一十进制交换码（EBCDIC），而另一台则使用美国信息交换标准码（ASCII）来表示相同的字符。如有必要，表示层会通过使用一种通格式来实现多种数据格式之间的转换。

7.应用层： 是最靠近用户的OSI层。这一层为用户的应用程序（例如电子邮件、文件传输和终端仿真）提供网络服务