java面试题整理

1、操作系统中 heap 和 stack 的区别

答案：堆栈的概念：
　　堆栈是两种数据结构。堆栈都是一种数据项按序排列的数据结构，只能在一端(称为栈顶(top))对数据项进行插入和删除。在单片机应用中，堆栈是个特殊的存储区，主要功能是暂时存放数据和地址，通常用来保护断点和现场。要点：堆，队列优先,先进先出（FIFO—first in first out）。栈，先进后出(FILO—First-In/Last-Out)。
堆和栈的区别：
一、堆栈空间分配区别：
　　1、栈（操作系统）：由操作系统自动分配释放 ，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈；
　　2、堆（操作系统）： 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收，分配方式倒是类似于链表。
二、堆栈缓存方式区别：
　　1、栈使用的是一级缓存， 他们通常都是被调用时处于存储空间中，调用完毕立即释放；
　　2、堆是存放在二级缓存中，生命周期由虚拟机的垃圾回收算法来决定（并不是一旦成为孤儿对象就能被回收）。所以调用这些对象的速度要相对来得低一些。
三、堆栈数据结构区别：
　　堆（数据结构）：堆可以被看成是一棵树，如：堆排序；
　　栈（数据结构）：一种先进后出的数据结构。
Java中栈和堆的区别：
　　栈(stack)与堆(heap)都是Java用来在Ram中存放数据的地方。与C++不同，Java自动管理栈和堆，程序员不能直接地设置栈或堆。
　　在函数中定义的一些基本类型的变量和对象的引用变量都在函数的栈内存中分配。当在一段代码块定义一个变量时，Java就在栈中为这个变量分配内存空间，当超过变量的作用域后，Java会自动释放掉为该变量所分配的内存空间，该内存空间可以立即被另作他用。
　　堆内存用来存放由new创建的对象和数组，在堆中分配的内存，由Java虚拟机的自动垃圾回收器来管理。在堆中产生了一个数组或对象后，还可以在栈中定义一个特殊的变量，让栈中这个变量的取值等于数组或对象在堆内存中的首地址，栈中的这个变量就成了数组或对象的引用变量。引用变量就相当于是为数组或对象起的一个名称，以后就可以在程序中使用栈中的引用变量来访问堆中的数组或对象。
Java中变量在内存中的分配：
　　1、类变量（static修饰的变量）：在程序加载时系统就为它在堆中开辟了内存，堆中的内存地址存放于栈以便于高速访问。静态变量的生命周期–一直持续到整个”系统”关闭。
　　2、实例变量：当你使用java关键字new的时候，系统在堆中开辟并不一定是连续的空间分配给变量（比如说类实例），然后根据零散的堆内存地址，通过哈希算法换算为一长串数字以表征这个变量在堆中的”物理位置”。 实例变量的生命周期–当实例变量的引用丢失后，将被GC（垃圾回收器）列入可回收“名单”中，但并不是马上就释放堆中内存。
　　3、局部变量：局部变量，由声明在某方法，或某代码段里（比如for循环），执行到它的时候在栈中开辟内存，当局部变量一但脱离作用域，内存立即释放。
　　
2、什么是基于注解的切面实现

答案：在程序运行时，动态的将代码切入到类的指定方法、指定位置上的编程思想就是面向切面编程,我们使用切面来非侵入式操作程序方法，常用的场景如日志记录、权限判断等。
（1）、 一般而言，我们管切入到指定类指定方法的代码片段为切面，而切入的哪些类、哪些方法则叫切入点。有了AOP，我们就可以把几个类共有的代码，抽取到一个切片中，等到需要时在切入对象中去，从而改变其原有的行为。
（2）、AOP就是OOP的补充而已。OOP从横向上区分出一个个类来，而AOP则从纵向上向对象加入特定的代码。有了AOP，OOP变得立体了，如果加上时间维度，AOP使OOP从二维变成三维。
（3）、从技术上来说，AOP基本上是通过代理机制实现的。
（4）、经典的Spring AOP是基于动态代理技术的。在实现方式上，最常用的是实现MethodInterceptor接口来提供环绕通知，创建若干代理，然后使用ProxyBeanFactory配置工厂Bean，生成拦截器链，完成拦截。
Spring实现AOP，动态代理技术的两种实现是jdk动态代理、cglib代理，根据被通知的方法是否为接口方法，来选择使用哪种代理生成策略。
dk动态代理：原理是实现接口的实例，拦截定于接口中的目标方法，，性能更优，是spring生成代理的优先选择。
cglib代理：原理是使用cglib库中的字节码动态生成技术，生成被代理类的子类实例，可以拦截代理类中的任一public方法的调用，无论目标方法是否定义与接口中，更通用，但性能相对jdk代理差一些。
下面我实现权限判断的切面。
分析：
要实现基于注解的切面，我们要定义“注解”，定义切面，定义权限验证，定义权限返回。

1.定义注解：PermissionCheck.java

@Target({ElementType.TYPE, ElementType.METHOD}) // 注解类型， 级别 @Retention(RetentionPolicy.RUNTIME) // 运行时注解 
public @interface PermissionCheck { 
		String value() default ""; 
}

2.定义权限校验方法,这里定义 AuthService 和它的实现。

public interface AuthService { 
	boolean checkAccess(); 
} 

@Service 
@Transactional(readOnly = true, rollbackFor = Exception.class) 
public class AuthServiceImpl implements AuthService {
 		@Override
  		public boolean checkAccess() { 
	 		 return true;
	   }
   }

根据需要可改写 checkAccess 方法。
定义一个advice 来处理校验结果:

@ControllerAdvice 
public class PermissionAdvice { 
		@ExceptionHandler(value = PermissionCheckException.class) 
        @ResponseStatus(HttpStatus.OK)
 		@ResponseBody 
		 public String dealWithPermissionCheckException(PermissionCheckException exception) { 			                                System.out.println(exception.getMessage());
		  return exception.getMessage();
		   } 
  		 public String dealWithPermissionCheckException() {
		    return null;
	     }
      }

接下来就是组合进切面了

@Aspect // 切面标识 @Component // 交给spring容器管理 public class PermissionAspect { @Autowired private AuthService authService; /**
     * 选取切入点为自定义注解
     */ @Pointcut("@annotation(com.honeywen.credit.annotation.PermissionCheck)") public void permissionCheck(){} @Before(value = "permissionCheck()") public void before(JoinPoint joinPoint) throws NoSuchMethodException { // 获取连接点的方法签名对象 Signature signature = joinPoint.getSignature(); if (!(signature instanceof MethodSignature)) { throw new PermissionCheckException("user permission check failed , stop the request!"); } MethodSignature methodSignature = (MethodSignature) signature; Object target = joinPoint.getTarget(); // 获取到当前执行的方法 Method method = target.getClass().getMethod(methodSignature.getName(), methodSignature.getParameterTypes()); // 获取方法的注解 PermissionCheck annotation = method.getAnnotation(PermissionCheck.class); System.out.println(annotation); System.out.println("我是在执行业务逻辑之前"); // 权限检查 authService.checkAccess(); } @After(value = "permissionCheck()") public void after(JoinPoint joinPoint) { System.out.println("我是在执行业务逻辑之后"); } }

3、 什么是 对象/关系 映射集成模块
答案： 所谓对象关系映射（Object Relational Mapping，简称ORM）是通过使用描述对象和数据库之间映射的元数据，将面向对象语言程序中的对象自动持久化到关系数据库中。本质上就是将数据从一种形式转换到另外一种形式。
详细一点，是 面向对象编程中的 对象(Object)
和关系数据库的 关系(Relation)
的一个映射(Mapping)。

4、什么是 Java 的反射机制
JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为java语言的反射机制。java通常是先有类再有对象，有对象我就可以调用方法或者属性。反射其实是通过Class对象来调用类里面的方法。通过反射可以调用私有方法和私有属性。大部分框架都是运用反射原理，精简总结一下：
1.什么是反射
答：就是可以在程序运行的时候动态装载类，查看类的信息，生成对象，或操作生成对象。类在运行的时候，可以得到该类的信息，并且 可以动态的修改这些信息，自己能看到自己，跟照镜子一样，也就是说Java的反射机制是在编辑的时候并不确定哪个类被加载了，而是在程序运行的时候才加载、探知、自审，使用在编译期并不知道的类，这样的特点就是反射。
2.那么Java反射有什么作用呢？
假如我们有两个程序员，一个程序员在写程序的时候，需要使用第二个程序员所写的类，但第二个程序员并没完成他所写的类。那么第一个程序员的代码能否通过编译呢？这是不能通过编译的。利用Java反射的机制，就可以让第一个程序员在没有得到第二个程序员所写的类的时候，来完成自身代码的编译。Java反射机制主要提供了以下功能： 在运行时判断任意一个对象所属的类；在运行时构造任意一个类的对象；在运行时判断任意一个类所具有的成员变量和方法；在运行时调用任意一个对象的方法；生成动态代理。
Java的反射机制它知道类的基本结构，这种对Java类结构探知的能力，我们称为Java类的“自审”。大家都用过Jcreator和eclipse。 当我们构建出一个对象的时候，去调用该对象的方法和属性的时候。一按点，编译工具就会自动的把该对象能够使用的所有的方法和属性全部都列出来，供用户进行 选择。这就是利用了Java反射的原理，是对我们创建对象的探知、自审。
3.反射技术大量用于Java设计模式和框架技术，最常见的设计模式就是工厂模式和单例模式。

5、工厂模式和单例模式
答案：
单例模式(Singleton)
这个模式主要作用是保证在Java应用程序中，一个类Class只有一个实例存在。在很多操作中，比如建立目录 数据库连接都需要这样的单线程操作。这样做就是为了节省内存空间，保证我们所访问到的都是同一个对象。
单例模式要求保证唯一，那么怎么样才能保证唯一性呢？对了，这就是静态变量。单例模式有以下两种形式：

第一种形式：
package reflect;
public class Singleton {
private Singleton() {
}
private static Singleton instance = new Singleton();
// 这里提供了一个供外部访问本class的静态方法，可以直接访问
public static Singleton getInstance() {
return instance;
}
}
class SingRun{
public static void main(String[] args){
//这样的调用不被允许，因为构造方法是私有的。
//Singleton x=new Singleton();
//得到一个Singleton类实例
Singleton x=Singleton.getInstance();
//得到另一个Singleton类实例
Singleton y=Singleton.getInstance();
//比较x和y的地址，结果为true。说明两次获得的是同一个对象
System.out.println(x==y);
}
}
第二种形式：
public class Singleton {
//先申明该类静态对象
private static Singleton instance = null;
//创建一个静态访问器，获得该类实例。加上同步，表示防止两个线程同时进行对象的创建
public static synchronized Singleton getInstance() {
//如果为空，则生成一个该类实例
if (instance == null){
instance = new Singleton();
}
return instance;
}
}
工厂模式（Factory）
工厂模式是我们最常用的模式了,著名的Jive论坛 ,就大量使用了工厂模式，工厂模式在Java程序系统可以说是随处可见。
为什么工厂模式是如此常用？是因为工厂模式利用Java反射机制和Java多态的特性可以让我们的程序更加具有灵活性。用工厂模式进行大型项目的开发，可以很好的进行项目并行开发。就是一个程序员和另一个程序员可以同时去书写代码，而不是一个程序员等到另一个程序员写完以后再去书写代码。其中的粘合剂就是接口和配置文件。之前说利用接口可以将调用和实现相分离。那么这是怎么样去实现的呢？工厂模式可以为我们解答。
我们先来回顾一下软件的生命周期，分析、设计、编码、调试与测试。其中分析就是指需求分析，就是知道这个软件要做成什么样子，要实现什么样的功能。功能知道了，这时就要设计了。设计的时候要考虑到怎么样高效的实现这个项目，如果让一个项目团队并行开发。这时候，通常先设计接口，把接口给实现接口的程序员和调用接口的程序员，在编码的时候，两个程序员可以互不影响的实现相应的功能，最后通过配置文件进行整合。
代码示例：
interface InterfaceTest{
public void getName();//定义获得名字的方法
}
接口有了，那么得到这个接口，进行实现编码的程序员应该怎么做呢？对了，实现这个接口，重写其中定义的方法
接口实现方法：
class Test1 implements InterfaceTest{
public void getName() {
System.out.println(“test1”);
}
}
class Test2 implements InterfaceTest{
public void getName() {
System.out.println(“test2”);
}

}
大家可以发现，当接口定义好了以后，不但可以规范代码，而且可以让程序员有条不紊的进行功能的实现。实现接口的程序员根本不用去管，这个类要被谁去调用。 那么怎么能获得这些程序员定义的对象呢？在工厂模式里，单独定义一个工厂类来实现对象的生产，注意这里返回的接口对象。
工厂类，生产接口对象：
class Factory{
//创建私有的静态的Properties对象
private static Properties pro=new Properties();
//静态代码块
static{
try {
//加载配置文件
pro.load(new FileInputStream(“file.txt”));
} catch (Exception e) {
e.printStackTrace();
}
}
private static Factory factory=new Factory();
private Factory(){}
public static Factory getFactory(){
return factory;
}
public InterfaceTest getInterface(){
InterfaceTest interfaceTest=null;//定义接口对象
try {
//根据键，获得值，这里的值是类的全路径
String classInfo=pro.getProperty(“test”);
//利用反射，生成Class对象
Class c=Class.forName(classInfo);
//获得该Class对象的实例
Object obj=c.newInstance();
//将Object对象强转为接口对象
interfaceTest=(InterfaceTest)obj;
} catch (Exception e) {
e.printStackTrace();
}
//返回接口对象
return interfaceTest;
}
}
配置文件内容：
test=factory.Test2
通过这个类，大家可以发现，在调用的时候，得到的是个接口对象。而一个接口变量可以指向实现了这个接口的类对象。在利用反射的时候，我们并没有直接把类的 全路径写出来，而是通过键获得值。这样的话，就有很大的灵活性，只要改变配置文件里的内容，就可以改变我们调用的接口实现类，而代码不需做任何改变。在调 用的时候，我们也是通过接口调用，甚至我们可以连这个接口实现类的名字都不知道。
调用方法：
public class FactoryTest {
public static void main(String[] args) {
//获得工厂类的实例
Factory factory=Factory.getFactory();
//调用获得接口对象的方法，获得接口对象
InterfaceTest inter=factory.getInterface();
//调用接口定义的方法
inter.getName();
}
}
上面的代码就是调用方法。大家可以发现，在调用的时候，我们根本没有管这个接口定义的方法要怎么样去实现它，我们只知道这个接口定义这个方法起什么作用就行了。上面代码运行结果要根据配置文件来定。如果配置文件里的内容是test=factory.Test2。那么表示调用factory.Test2这个 类里实现接口的方法，这时候打印“test2”。如果配置文件里的内容是test=factory.Test1。那么表示调用factory.Test1 这个类里实现接口的方法，这时候打印“test1”。

6、什么是 ACID
答案：事务具有四个特征，分别足原子性（Atomicity )、一致性（Consistency )、隔离性（Isolation) 和持久性（Durability),简称为事务的ACID特性。
1、原子性（Atomicity )
事务的原子性是指事务必须是一个原子的操作序列单元。事务中包含的各项操作在一次执行过程中，只允许出现以下两种状态之一。
•全部成功执行。
•全部不执行。

任何一项操作失败都将导致整个事务失败，同时其他已经被执行的操作都将被撤销并回滚，只打所有的操作全部成功，整个事务才算是成功完成。

2、一致性（Consistency )
事务的一致性是指事务的执行不能破坏数据库数据的完整性和一致性，一个事务在执行之前和执行之后，数据库都必须处于一致性状态。也就是说，事务执行的结果必须是使数据库从一个一致性状态转变到另一个一致性状态，因此当数据库只包含成功事务提交 的结果时，就能说数据库处于一致性状态。而如果数据库系统在运行过程中发生故障， 有些事务尚未完成就被迫中断，这些未完成的事务对数据库所做的修改有一部分已写入物理数据库，这时数据库就处于一种不正确的状态，或者说是不一致的状态。

3、隔离性（Isolation)
事务的隔离性是指在并发环境中，并发的事务是相互隔离的，一个事务的执行不能被其他事务干扰。也就是说，不同的事务并发操纵相同的数据时，每个事务都有各自完整的数据空间，即一个事务内部的操作及使用的数据对其他并发事务是隔离的，并发执行的 各个事务之间不能互相干扰。

7、BS与CS的联系与区别
答案：C/S是Client/Server的缩写。服务器通常采用高性能的PC、工作站或小型机，并采用大型数据库系统，如Oracle、Sybase、Informix或 SQL Server。客户端需要安装专用的客户端软件。
B/Ｓ是Brower/Server的缩写，客户机上只要安装一个浏览器（Browser），如Netscape Navigator或Internet Explorer，服务器安装Oracle、Sybase、Informix或 SQL Server等数据库。在这种结构下，用户界面完全通过WWW浏览器实现，一部分事务逻辑在前端实现，但是主要事务逻辑在服务器端实现。浏览器通过Ｗeb Server 同数据库进行数据交互。
C/S 与 B/S 区别：
１．硬件环境不同:
　　C/S 一般建立在专用的网络上, 小范围里的网络环境, 局域网之间再通过专门服务器提供连接和数据交换服务.
　　B/S 建立在广域网之上的, 不必是专门的网络硬件环境,例与电话上网, 租用设备. 信息自己管理. 有比C/S更强的适应范围, 一般只要有操作系统和浏览器就行
２．对安全要求不同
　　C/S 一般面向相对固定的用户群, 对信息安全的控制能力很强. 一般高度机密的信息系统采用C/S 结构适宜. 可以通过B/S发布部分可公开信息.
　　B/S 建立在广域网之上, 对安全的控制能力相对弱, 可能面向不可知的用户。
３．对程序架构不同
　　C/S 程序可以更加注重流程, 可以对权限多层次校验, 对系统运行速度可以较少考虑.
　　B/S 对安全以及访问速度的多重的考虑, 建立在需要更加优化的基础之上. 比C/S有更高的要求 B/S结构的程序架构是发展的趋势, 从MS的.Net系列的BizTalk 2000 Exchange 2000等, 全面支持网络的构件搭建的系统. SUN 和IBM推的JavaBean 构件技术等,使 B/S更加成熟.
４．软件重用不同
　　C/S 程序可以不可避免的整体性考虑, 构件的重用性不如在B/S要求下的构件的重用性好.
　　B/S 对的多重结构,要求构件相对独立的功能. 能够相对较好的重用.就入买来的餐桌可以再利用,而不是做在墙上的石头桌子
５．系统维护不同
　　C/S 程序由于整体性, 必须整体考察, 处理出现的问题以及系统升级. 升级难. 可能是再做一个全新的系统
　　B/S 构件组成,方面构件个别的更换,实现系统的无缝升级. 系统维护开销减到最小.用户从网上自己下载安装就可以实现升级.
６．处理问题不同
　　C/S 程序可以处理用户面固定, 并且在相同区域, 安全要求高需求, 与操作系统相关. 应该都是相同的系统
　　B/S 建立在广域网上, 面向不同的用户群, 分散地域, 这是C/S无法作到的. 与操作系统平台关系最小.
７．用户接口不同
　　C/S 多是建立的Window平台上,表现方法有限,对程序员普遍要求较高
　　B/S 建立在浏览器上, 有更加丰富和生动的表现方式与用户交流. 并且大部分难度减低,减低开发成本.
８．信息流不同
　　C/S 程序一般是典型的中央集权的机械式处理, 交互性相对低
　　B/S 信息流向可变化, B-B B-C B-G等信息、流向的变化, 更像交易中心。

8、Cookie 和 Session的区别
答案：session原理：
1、session是保存在服务器端，理论上是没有是没有限制，只要你的内存够大

2、浏览器第一次访问服务器时会创建一个session对象并返回一个JSESSIONID=ID的值，
创建一个Cookie对象key为JSSIONID，value为ID的值，将这个Cookie写回浏览器

3、浏览器在第二次访问服务器的时候携带Cookie信息JSESSIONID=ID的值，如果该JSESSIONID的session已经销毁，
那么会重新创建一个新的session再返回一个新的JSESSIONID通过Cookie返回到浏览器

4、针对一个web项目，一个浏览器是共享一个session，就算有两个web项目部署在同一个服务器上，针对两个项目的session是不同的
如：你在tomcat上同时部署了两个web项目，分别是web1、web2。当你在一个浏览器上同时访问web1时创建的session是A1，访问web2时创建的session是A2。
后面你再多次访问web1使用的session还是A1,多次访问web2时使用session就是A2

5、session是基于Cookie技术实现，重启浏览器后再次访问原有的连接依然会创建一个新的session，
因为Cookie在关闭浏览器后就会消失，但是原来服务器的Session还在，只有等到了销毁的时间会自动销毁

6、如果浏览器端禁用了Cookie，那么每次访问都会创建一个新的Session，但是我们可以通过服务器端程序重写URL即可，如果页面多连接多，会增加不必要的工作量，
那可以强制让你用户开启接收Cookie后再让其访问即可。

面试：

说说Cookie和Session的区别？

1、Cookie和Session都是会话技术，Cookie是运行在客户端，Session是运行在服务器端。

2、Cookie有大小限制以及浏览器在存cookie的个数也有限制，Session是没有大小限制和服务器的内存大小有关。

3、Cookie有安全隐患，通过拦截或本地文件找得到你的cookie后可以进行攻击。

4、Session是保存在服务器端上会存在一段时间才会消失，如果session过多会增加服务器的压力。

9、fail-fast 与 fail-safe 机制有什么区别
答案：
一：快速失败（fail—fast）
在用迭代器遍历一个集合对象时，如果遍历过程中对集合对象的内容进行了修改（增加、删除、修改），则会抛出Concurrent Modification Exception。
原理：迭代器在遍历时直接访问集合中的内容，并且在遍历过程中使用一个 modCount 变量。集合在被遍历期间如果内容发生变化，就会改变modCount的值。每当迭代器使用hashNext()/next()遍历下一个元素之前，都会检测modCount变量是否为expectedmodCount值，是的话就返回遍历；否则抛出异常，终止遍历。
注意：这里异常的抛出条件是检测到 modCount！=expectedmodCount 这个条件。如果集合发生变化时修改modCount值刚好又设置为了expectedmodCount值，则异常不会抛出。因此，不能依赖于这个异常是否抛出而进行并发操作的编程，这个异常只建议用于检测并发修改的bug。
场景：java.util包下的集合类都是快速失败的，不能在多线程下发生并发修改（迭代过程中被修改）。
二：安全失败（fail—safe）
采用安全失败机制的集合容器，在遍历时不是直接在集合内容上访问的，而是先复制原有集合内容，在拷贝的集合上进行遍历。
原理：由于迭代时是对原集合的拷贝进行遍历，所以在遍历过程中对原集合所作的修改并不能被迭代器检测到，所以不会触发Concurrent Modification Exception。
缺点：基于拷贝内容的优点是避免了Concurrent Modification Exception，但同样地，迭代器并不能访问到修改后的内容，即：迭代器遍历的是开始遍历那一刻拿到的集合拷贝，在遍历期间原集合发生的修改迭代器是不知道的。
场景：java.util.concurrent包下的容器都是安全失败，可以在多线程下并发使用，并发修改。

10、get 和 post请求的区别
答案：
● get参数通过url传递，post放在request body中。
● get请求在url中传递的参数是有长度限制的，而post没有，则POST的数据则可以非常大。
● post比get安全，因为数据在地址栏上不可见。get比post更不安全，因为参数直接暴露在url中，所以不能用来传递敏感信息。
○ get请求只能进行url编码，而post支持多种编码方式
○ get请求会浏览器主动cache，而post支持多种编码方式。
○ get请求参数会被完整保留在浏览历史记录里，而post中的参数不会被保留。

● GET和POST本质上就是TCP链接，并无差别。但是由于HTTP的规定和浏览器/服务器的限制，导致他们在应用过程中体现出一些不同。
● GET产生一个TCP数据包；POST产生两个TCP数据包。
长的说：
对于GET方式的请求，浏览器会把http header和data一并发送出去，服务器响应200（返回数据）；
而对于POST，浏览器先发送header，服务器响应100 continue，浏览器再发送data，服务器响应200 ok（返回数据）。

（据研究，在网络环境好的情况下，发一次包的时间和发两次包的时间差别基本可以无视。而在网络环境差的情况下，两次包的TCP在验证数据包完整性上，有非常大的优点。）

但是在有一些解释中说get和post的区别不在参数传递和参数的长度限制上。

GET和POST与数据如何传递没有关系
　　GET和POST是由HTTP协议定义的。在HTTP协议中，Method和Data(URL, Body, Header)是正交的两个概念，也就是说，使用哪个Method与应用层的数据如何传输是没有相互关系的。
　　HTTP没有要求，如果Method是POST数据就要放在BODY中。也没有要求，如果Method是GET，数据（参数）就一定要放在URL中而不能放在BODY中。
　　那么，网上流传甚广的这个说法是从何而来的呢？我在HTML标准中，找到了相似的描述。这和网上流传的说法一致。但是这只是HTML标准对HTTP协议的用法的约定。怎么能当成GET和POST的区别呢？
　　而且，现代的Web Server都是支持GET中包含BODY这样的请求。虽然这种请求不可能从浏览器发出，但是现在的Web Server又不是只给浏览器用，已经完全地超出了HTML服务器的范畴了。
　　知道这个有什么用？我不想解释了，有时候就得自己痛一次才记得住。

HTTP协议对GET和POST都没有对长度的限制
　　HTTP协议明确地指出了，HTTP头和Body都没有长度的要求。而对于URL长度上的限制，有两方面的原因造成：
　　1. 浏览器。据说早期的浏览器会对URL长度做限制。据说IE对URL长度会限制在2048个字符内（流传很广，而且无数同事都表示认同）。但我自己试了一 下，我构造了90K的URL通过IE9访问live.com，是正常的。网上的东西，哪怕是Wikipedia上的，也不能信。
　　2. 服务器。URL长了，对服务器处理也是一种负担。原本一个会话就没有多少数据，现在如果有人恶意地构造几个几M大小的URL，并不停地访问你的服务器。服 务器的最大并发数显然会下降。另一种攻击方式是，把告诉服务器Content-Length是一个很大的数，然后只给服务器发一点儿数据，嘿嘿，服务器你 就傻等着去吧。哪怕你有超时设置，这种故意的次次访问超时也能让服务器吃不了兜着走。有鉴于此，多数服务器出于安全啦、稳定啦方面的考虑，会给URL长度 加限制。但是这个限制是针对所有HTTP请求的，与GET、POST没有关系。
　　（待续）