题目

--java基础（任选2题）

1.Map是否有序？是否存在有顺序的Map的实现类，且是如何保证它的顺序，或者你是否有更好的实现的方式？ 

Map中TreeMap是有序的，通过Comparator来保证有序的，要么是默认的排序规则进行排序，要么是给定一个Comparator进行排序，TreeMap通过其构造方法来初始化其持有的Comparator

（1）这个是用keys自然的排序，而且这些key是实现了Comparable接口的，是可以比较的

public TreeMap() {

        comparator = null;

}

（2）这是给定了一个Comparator进行排序的

public TreeMap(Comparator<? superK> comparator) {

       this.comparator = comparator;

}

（3）同（1），给定的这些keys都是可以比较的

public TreeMap(Map<? extends K, ?extends V> m) {

       comparator = null;

       putAll(m);

}

（4）用给定的SortedMap里的Comparator

public TreeMap(SortedMap<K, ? extendsV> m) {

       comparator = m.comparator();

       try {

            buildFromSorted(m.size(),m.entrySet().iterator(), null, null);

       } catch (java.io.IOException cannotHappen) {

       } catch (ClassNotFoundException cannotHappen) {

       }

}

PS:

红黑树的理解：通过2-3树来理解红黑树

对HashMap的理解：http://www.importnew.com/7099.html

Comparator和Comparable的区别：如果比较的key本身已经实现了Comparable接口，那就表示是可以比较的，可以通过Collections.sort(list)进行一个排序；如果没有实现Comparable接口，可去实现Comparator接口，给定一个比较器XxxComparator，通过Collections.sort(list, new XxxComparator());

 

2.java反射理解，java注解（如何编写一个annation）

（1）反射的基本概念

在Java运行时环境中，对于任意一个类，能否知道这个类有哪些属性和方法？对于任意一个对象，能否调用它的任意一个方法？答案是肯定的。

这种动态获取类的信息以及动态调用对象的方法的功能来自于Java 语言的反射（Reflection）机制。

Java 反射机制主要提供了以下功能：

在运行时判断任意一个对象所属的类。

在运行时构造任意一个类的对象。

在运行时判断任意一个类所具有的成员变量和方法。

在运行时调用任意一个对象的方法

Reflection 是Java被视为动态（或准动态）语言的一个关键性质。这个机制允许程序在运行时透过Reflection API取得任何一个已知名称的class的内部信息，包括其modifiers（诸如public,static 等等）、superclass（例如Object）、实现之interfaces（例如Serializable），也包括fields和methods的所有信息，并可于运行时改变fields内容或调用methods。在JDK中，主要由以下类来实现Java反射机制，这些类都位于java.lang.reflect包中。

Class类：代表一个类。

Field 类：代表类的成员变量（成员变量也称为类的属性）。

Method类：代表类的方法。

Constructor 类：代表类的构造方法。

Array类：提供了动态创建数组，以及访问数组的元素的静态方法

Proxy类以及InvocationHandler接口：提供了动态生成代理类以及实例的方法

其中，Class类是Reflection API 中的核心类，它有以下方法：

·getName()：获得类的完整名字

·getFields()：获得类的public类型的属性

·getDeclaredFields()：获得类的所有属性

·getMethods()：获得类的public类型的方法

·getDeclaredMethods()：获得类的所有方法

·getMethod(String name, Class[] parameterTypes)：获得类的特定方法，name参数指定方法的名字，parameterTypes参数指定方法的参数类型

·getConstructors()：获得类的public类型的构造方法

·getConstructor(Class[] parameterTypes)：获得类的特定构造方法，parameterTypes 参数指定构造方法的参数类型

·newInstance()：通过类的不带参数的构造方法创建这个类的一个对象

（2）Spring AOP底层用的原理是动态代理，动态代理的实质是java的反射机制

Spring AOP使用动态代理技术在运行期织入增强代码，一种是基于JDK的动态代理，一种是基于CGLib的动态代理，JDK本身只提供接口的代理，而不支持类的代理。

    1）JDK的动态代理里两个重要的：Proxy类和InvocationHandler接口

     InvocationHandler里的invoke方法，一般（如代理类或者性能监控代码）这种代码类会去实现这个接口，通过method.invoke方法通过java的反射机制间接调用目标对象的方法。

      Object invoke(Object proxy, Method method, Object[] args) throwsThrowable

         proxy:　　指代我们所代理的那个真实对象

         method:　　指代的是我们所要调用真实对象的某个方法的Method对象

         args:　　指代的是调用真实对象某个方法时接受的参数

Proxy中的newProxyInstance(ClassLoaderloader, Class<?>[] interfaces, InvocationHandler h)

     loader: 一般是被代理的目标类

     interfaces: 被代理的目标类的一些接口

     h：代理类

2）CGLib填补了JDK动态代理的空缺，采用非常底层的字节码技术，可以为一个类创建子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，并顺势织入横切逻辑。其中比较重要的几个类Enhancer，MethodProxy，MethodInterceptor

   Enhancer可以用来创建一个动态代理对象

   MethodInterceptor里的intercept(Object paramObject, Method paramMethod, Object[]paramArrayOfObject, MethodProxy paramMethodProxy)方法，它拦截所有目标类方法的调用

   MethodProxy里的invokeSuper方法，去动态的调用被代理类的方法。

（3）怎么去写java注解

1）一般会有@Target，@Retention，@Constraint，@Documented

   ·@Target，注解的作用范围，如@Target(ElementType.TYPE)//类，接口（包括注解），枚举

   ·@Retention，表示注解可以保存的时间，如@Retention(RetentionPolicy.RUNTIME)//被虚拟机保存，可用反射机制读取

   ·@Constraint，这个是在validation-api-1.1.0.Final.jar包里面的类，如果你要写自定义的校验类，可以引入这个jar包，并且在自定义的校验类里面写你的相关校验

   ·@Documented，说明该注解将被包含在javadoc中

2）比如要写一个校验金额的注解

@Target({METHOD, FIELD, ANNOTATION_TYPE})

@Retention(RUNTIME)

@Constraint(validatedBy =BigDecimalValidator.class)

@Documented

public @interface BigDecimalRange

{

                       publicClass<?>[] groups() default {};

                       public Class<? extendsPayload>[] payload() default {};

   long minPrecision() default Long.MIN_VALUE;

                        longmaxPrecision() default Long.MAX_VALUE;

                       intscale() default 0;

}

BigDecimalValidator类里去写具体的校验逻辑，具体要用这个注解的时候可以如下：

/**投资金额**/

@BigDecimalRange( minPrecision = 0,maxPrecision = 11, scale =2)

private BigDecimal amount;

3）我们可以通过反射机制去读取一个方法的注解信息，在单元测试中也是有广泛应用的

（4）反射是否真的会让你的程序性能降低?

1.      反射大概比直接调用慢50~100倍，但是需要你在执行100万遍的时候才会有所感觉

2.      判断一个函数的性能，你需要把这个函数执行100万遍甚至1000万遍

3.      如果你只是偶尔调用一下反射，请忘记反射带来的性能影响

4.      如果你需要大量调用反射，请考虑缓存。

5.      你的编程的思想才是限制你程序性能的最主要的因素

3.J.U.C并发包内容知多少，写出1-2个JUC的class实现方式和应用场景

（1）CountDownLatch

CountDownLatch的一个非常典型的应用场景是：有一个任务想要往下执行，但必须要等到其他的任务执行完毕后才可以继续往下执行。假如我们这个想要继续往下执行的任务调用一个CountDownLatch对象的await()方法，其他的任务执行完自己的任务后调用同一个CountDownLatch对象上的countDown()方法，这个调用await()方法的任务将一直阻塞等待，直到这个CountDownLatch对象的计数值减到0为止。

CountDownLatch类有3个基本元素：

·初始值决定CountDownLatch类需要等待的事件的数量。

·await() 方法, 被等待全部事件终结的线程调用。

·countDown() 方法，事件在结束执行后调用。

具体可参见http://blog.csdn.net/chenssy/article/details/49794141

（2）ReentrantLock的使用

可重入概念 
若一个程序或子程序可以“安全的被并行执行(Parallel computing)”，则称其为可重入（reentrant或re-entrant）的。即当该子程序正在运行时，可以再次进入并执行它（并行执行时，个别的执行结果，都符合设计时的预期）。可重入概念是在单线程操作系统的时代提出的。

场景1：如果发现该操作已经在执行中则不再执行（有状态执行）

a、用在定时任务时，如果任务执行时间可能超过下次计划执行时间，确保该有状态任务只有一个正在执行，忽略重复触发。 
b、用在界面交互时点击执行较长时间请求操作时，防止多次点击导致后台重复执行（忽略重复触发）。

以上两种情况多用于进行非重要任务防止重复执行，（如：清除无用临时文件，检查某些资源的可用性，数据备份操作等）

场景2：如果发现该操作已经在执行，等待一个一个执行（同步执行，类似synchronized）

这种比较常见大家也都在用，主要是防止资源使用冲突，保证同一时间内只有一个操作可以使用该资源。 
但与synchronized的明显区别是性能优势（伴随jvm的优化这个差距在减小）。同时Lock有更灵活的锁定方式，公平锁与不公平锁，而synchronized永远是公平的。

这种情况主要用于对资源的争抢（如：文件操作，同步消息发送，有状态的操作等）

ReentrantLock默认情况下为不公平锁

不公平锁与公平锁的区别： 
公平情况下，操作会排一个队按顺序执行，来保证执行顺序。（会消耗更多的时间来排队） 
不公平情况下，是无序状态允许插队，jvm会自动计算如何处理更快速来调度插队。（如果不关心顺序，这个速度会更快）

场景3：如果发现该操作已经在执行，则尝试等待一段时间，等待超时则不执行（尝试等待执行）

这种其实属于场景2的改进，等待获得锁的操作有一个时间的限制，如果超时则放弃执行。 
用来防止由于资源处理不当长时间占用导致死锁情况（大家都在等待资源，导致线程队列溢出）。

场景4：如果发现该操作已经在执行，等待执行。这时可中断正在进行的操作立刻释放锁继续下一操作

synchronized与Lock在默认情况下是不会响应中断(interrupt)操作，会继续执行完。lockInterruptibly()提供了可中断锁来解决此问题。（场景2的另一种改进，没有超时，只能等待中断或执行完毕）

这种情况主要用于取消某些操作对资源的占用。如：（取消正在同步运行的操作，来防止不正常操作长时间占用造成的阻塞）

 

--设计模式

1.假设一个A类变到B类，那么你用适配器怎么完成    （内）

 

--DB

1.数据库内、外网如何交互的，如果交互给你做，你怎么做？（内）

网闸技术，详见http://zhaisj.blog.51cto.com/219066/40887/

2.数据库通常的优化方案，使用过什么优化工具（外），具体如何优化，index的数据结构怎样 （内、外）

（1）优化方案：http://www.cnblogs.com/bicabo/archive/2012/09/05/2672669.html

（2）优化工具：http://blog.itpub.net/35489/viewspace-764856/

（3）index的数据结构：见（1）

--WebService

1.webService介绍，是怎么编写的，rest的几种method，区别是什么，http的几种状态（内、外）

（1）webservice简介

Web Service也叫XML Web Service WebService是一种可以接收从Internet或者Intranet上的其它系统中传递过来的请求，轻量级的独立的通讯技术。是:通过SOAP在Web上提供的软件服务，使用WSDL文件进行说明，并通过UDDI进行注册。

XML：(Extensible Markup Language)扩展型可标记语言。面向短期的临时数据处理、面向万维网络，是Soap的基础。

Soap：(Simple Object Access Protocol)简单对象存取协议。是XML Web Service 的通信协议。当用户通过UDDI找到你的WSDL描述文档后，他可以通过SOAP调用你建立的Web服务中的一个或多个操作。SOAP是XML文档形式的调用方法的规范，它可以支持不同的底层接口，像HTTP(S)或者SMTP。

WSDL：(Web Services Description Language) WSDL 文件是一个 XML 文档，用于说明一组 SOAP 消息以及如何交换这些消息。大多数情况下由软件自动生成和使用。

UDDI (Universal Description, Discovery, andIntegration) 是一个主要针对Web服务供应商和使用者的新项目。在用户能够调用Web服务之前，必须确定这个服务内包含哪些商务方法，找到被调用的接口定义，还要在服务端来编制软件，UDDI是一种根据描述文档来引导系统查找相应服务的机制。UDDI利用SOAP消息机制（标准的XML/HTTP）来发布，编辑，浏览以及查找注册信息。它采用XML格式来封装各种不同类型的数据，并且发送到注册中心或者由注册中心来返回需要的数据。

调用原理：

Web服务有两层含义：1、是指封装成单个实体并发布到网络上的功能集合体；2、是指功能集合体被调用后所提供的服务。简单地讲，Web服务是一个URL资源，客户端可以通过编程方式请求得到它的服务，而不需要知道所请求的服务是怎样实现的，这一点与传统的分布式组件对象模型不同。

Web服务的体系结构是基于Web服务提供者、Web服务请求者、Web服务中介者三个角色和发布、发现、绑定三个动作构建的。简单地说，Web服务提供者就是Web服务的拥有者，它耐心等待为其他服务和用户提供自己已有的功能；Web服务请求者就是Web服务功能的使用者，它利用SOAP消息向Web服务提供者发送请求以获得服务;Web服务中介者的作用是把一个Web服务请求者与合适的Web服务提供者联系在一起，它充当管理者的角色，一般是UDDI。这三个角色是根据逻辑关系划分的，在实际应用中，角色之间很可能有交叉：一个Web服务既可以是Web服务提供者，也可以是Web服务请求者，或者二者兼而有之。显示了Web服务角色之间的关系:其中，“发布”是为了让用户或其他服务知道某个Web服务的存在和相关信息;“查找（发现）”是为了找到合适的Web服务;“绑定”则是在提供者与请求者之间建立某种联系。

 

图2-1 Web service的体系结构

实现一个完整的Web服务包括以下步骤：

◆ Web服务提供者设计实现Web服务，并将调试正确后的Web服务通过Web服务中介者发布，并在UDDI注册中心注册； （发布）

◆ Web服务请求者向Web服务中介者请求特定的服务，中介者根据请求查询UDDI注册中心，为请求者寻找满足请求的服务； （发现）

◆ Web服务中介者向Web服务请求者返回满足条件的Web服务描述信息，该描述信息用WSDL写成，各种支持Web服务的机器都能阅读；（发现）

◆ 利用从Web服务中介者返回的描述信息生成相应的SOAP消息，发送给Web服务提供者，以实现Web服务的调用；（绑定）

◆ Web服务提供者按SOAP消息执行相应的Web服务，并将服务结果返回给Web服务请求者。（绑定）

（2）在rest风格中，使用标准的 HTTP 方法 (GET/PUT/POST/DELETE) 来抽象所有 Web 系统的服务

GET: 对于到数据库操作的查询，安全的

PUT: 对于到数据库操作的更新，幂等的

POST: 对于到数据库操作的插入，不安全不幂等

DELETE：对于到数据库操作的删除，幂等的

安全性是指访问资源的时候资源本身不会发生改变，也就是资源是安全的

幂等性是一个数学概念，数学上的解释为f(x) = f(f(x))，对同一个资源进行一次或者多次操作，最终资源的状态都是一样的

（3）http的状态是指状态码吗？

1xx(临时响应)：表示临时响应并需要请求者继续执行操作的状态码。

2xx (成功)：表示成功处理了请求的状态码。如200，服务器已成功处理了请求

3xx (重定向)：要完成请求，需要进一步操作。

4xx(请求错误)：这些状态码表示请求可能出错，妨碍了服务器的处理。如404(未找到)服务器找不到请求的网页

2.dubbo等SOA使用

详见http://dubbo.io

架构

(#)

节点角色说明：

Provider: 暴露服务的服务提供方。

Consumer: 调用远程服务的服务消费方。

Registry: 服务注册与发现的注册中心。

Monitor: 统计服务的调用次调和调用时间的监控中心。

Container: 服务运行容器。

调用关系说明：

0. 服务容器负责启动，加载，运行服务提供者。

1. 服务提供者在启动时，向注册中心注册自己提供的服务。

2. 服务消费者在启动时，向注册中心订阅自己所需的服务。

3. 注册中心返回服务提供者地址列表给消费者，如果有变更，注册中心将基于长连接推送变更数据给消费者。

4. 服务消费者，从提供者地址列表中，基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用。

5. 服务消费者和提供者，在内存中累计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心。

(1)连通性：

注册中心负责服务地址的注册与查找，相当于目录服务，服务提供者和消费者只在启动时与注册中心交互，注册中心不转发请求，压力较小

监控中心负责统计各服务调用次数，调用时间等，统计先在内存汇总后每分钟一次发送到监控中心服务器，并以报表展示

服务提供者向注册中心注册其提供的服务，并汇报调用时间到监控中心，此时间不包含网络开销

服务消费者向注册中心获取服务提供者地址列表，并根据负载算法直接调用提供者，同时汇报调用时间到监控中心，此时间包含网络开销

注册中心，服务提供者，服务消费者三者之间均为长连接，监控中心除外

注册中心通过长连接感知服务提供者的存在，服务提供者宕机，注册中心将立即推送事件通知消费者

注册中心和监控中心全部宕机，不影响已运行的提供者和消费者，消费者在本地缓存了提供者列表

注册中心和监控中心都是可选的，服务消费者可以直连服务提供者

(2)健状性：

监控中心宕掉不影响使用，只是丢失部分采样数据

数据库宕掉后，注册中心仍能通过缓存提供服务列表查询，但不能注册新服务

注册中心对等集群，任意一台宕掉后，将自动切换到另一台

注册中心全部宕掉后，服务提供者和服务消费者仍能通过本地缓存通讯

服务提供者无状态，任意一台宕掉后，不影响使用

服务提供者全部宕掉后，服务消费者应用将无法使用，并无限次重连等待服务提供者恢复

(3)伸缩性：

注册中心为对等集群，可动态增加机器部署实例，所有客户端将自动发现新的注册中心

服务提供者无状态，可动态增加机器部署实例，注册中心将推送新的服务提供者信息给消费者

(4)升级性：

当服务集群规模进一步扩大，带动IT治理结构进一步升级，需要实现动态部署，进行流动计算，现有分布式服务架构不会带来阻力：

Deployer: 自动部署服务的本地代理。

Repository: 仓库用于存储服务应用发布包。

Scheduler: 调度中心基于访问压力自动增减服务提供者。

Admin: 统一管理控制台。

 

--Spring & SpringMVC

1.Spring AOP的实现原理，主要从Proxy和Cglib分析，以及应用场景  （内、外）

Spring AOP底层用的原理是动态代理，动态代理的实质是java的反射机制

Spring AOP使用动态代理技术在运行期织入增强代码，一种是基于JDK的动态代理，一种是基于CGLib的动态代理，JDK本身只提供接口的代理，而不支持类的代理。

    1）JDK的动态代理里两个重要的：Proxy类和InvocationHandler接口

     InvocationHandler里的invoke方法，一般（如代理类或者性能监控代码）这种代码类会去实现这个接口，通过method.invoke方法通过java的反射机制间接调用目标对象的方法。

      Object invoke(Object proxy, Method method, Object[] args) throwsThrowable

         proxy:　　指代我们所代理的那个真实对象

         method:　　指代的是我们所要调用真实对象的某个方法的Method对象

         args:　　指代的是调用真实对象某个方法时接受的参数

Proxy中的newProxyInstance(ClassLoaderloader, Class<?>[] interfaces, InvocationHandler h)

     loader: 一般是被代理的目标类

     interfaces: 被代理的目标类的一些接口

     h：代理类

2）CGLib填补了JDK动态代理的空缺，采用非常底层的字节码技术，可以为一个类创建子类，并在子类中采用方法拦截的技术拦截所有父类方法的调用，并顺势织入横切逻辑。其中比较重要的几个类Enhancer，MethodProxy，MethodInterceptor

   Enhancer可以用来创建一个动态代理对象

   MethodInterceptor里的intercept(Object paramObject, Method paramMethod, Object[]paramArrayOfObject, MethodProxy paramMethodProxy)方法，它拦截所有目标类方法的调用

   MethodProxy里的invokeSuper方法，去动态的调用被代理类的方法。

 

3.FactoryBean和BeanFactory区别，服务器中间件启动时如何通过Spring管理进行方法初始化加载 （内）

 （1）BeanFactory

      BeanFactory是IOC最基本的容器，负责生产和管理bean，它为其他具体的IOC容器提供了最基本的规范，例如DefaultListableBeanFactory,XmlBeanFactory,ApplicationContext 等具体的容器都是实现了BeanFactory，再在其基础之上附加了其他的功能。

（2）FactoryBean

     FactoryBean是一个接口，当在IOC容器中的Bean实现了FactoryBean后，通过getBean(StringBeanName)获取到的Bean对象并不是FactoryBean的实现类对象，而是这个实现类中的getObject()方法返回的对象。要想获取FactoryBean的实现类，就要getBean(&BeanName)，在BeanName之前加上&。

 BeanFactory和FactoryBean其实没有什么比较性的，只是两者的名称特别接近，所以有时候会拿出来比较一番，BeanFactory是提供了IOC容器最基本的形式，给具体的IOC容器的实现提供了规范，FactoryBean可以说为IOC容器中Bean的实现提供了更加灵活的方式，FactoryBean在IOC容器的基础上给Bean的实现加上了一个简单工厂模式和装饰模式，我们可以在getObject()方法中灵活配置。

（3）spring承载的web应用 IOC容器初始化过程

1）web容器初始化的过程 
·Instantiate an instance of each eventlistener identified by a element in the deployment descriptor.

·For instantiated listener instances that implementServletContextListener, call the contextInitialized() method.

·Instantiate an instance of each filter identified by a element inthe deployment descriptor and call each filter instance’s init() method.

·Instantiate an instance of each servlet identified by a element thatincludes a element in the order defined by the load-on-startup element values,and call each servlet instance’s init() method. 
通俗一点讲就是： listener—>filter—>servlet

         2）IOC容器的初始化过程 

对于spring承载的Web应用而言，可以指定在Web应用程序启动时载入IOC容器，即WebApplicationContext，这个功能是有ContextLoaderListener来实现的，它是Web容器配置的监听器。

• ContextLoaderListener实际上是代理ContextLoader的，这里用到了代理模式，所以真正启动载入IOC容器的工作是由ContextLoader来完成的
• ContextLoaderListener是实现了ServletContextListener接口的
• ServletContextListener接口是ServletContext的监听者，如果ServletContext发生变化，就会触发相应的事件，ServletContextListener是一直在对这些事件进行监听的，如果接收到了监听的事件，就会做出预先设计好的响应动作，如： 
  • 服务器启动的时候，ServletContext被创建，ServletContextListener接口的contextInitialized()会被调用
  • 服务器关闭时，ServletContext被销毁，ServletContextListener接口的contextDestroyed()会被调用

·        ContextLoaderListener它是实现了ServletContextListener接口的，当服务启动的时候，默认执行contextInitialized()方法，初始化WebApplicationContext

·        在初始化WebApplicationContext过程中，配置并且实例化整个Spring Application Context中的Bean，见initWebApplicationContext()方法中的configureAndRefreshWebApplicationContext()

• • 先是通过读取context-param中的contextConfigLocation配置，然后读取相应的配置文件
  • 通过refresh方法，实例化配置文件中的Bean

详见：http://www.cnblogs.com/RunForLove/p/5688731.html

--事务

1.事务的传播级别和隔离级别（内、外）

事务的几种传播特性
1. PROPAGATION_REQUIRED: 如果存在一个事务，则支持当前事务。如果没有事务则开启
2. PROPAGATION_SUPPORTS: 如果存在一个事务，支持当前事务。如果没有事务，则非事务的执行
3. PROPAGATION_MANDATORY: 如果已经存在一个事务，支持当前事务。如果没有一个活动的事务，则抛出异常。
4. PROPAGATION_REQUIRES_NEW: 总是开启一个新的事务。如果一个事务已经存在，则将这个存在的事务挂起。
5. PROPAGATION_NOT_SUPPORTED: 总是非事务地执行，并挂起任何存在的事务。
6. PROPAGATION_NEVER: 总是非事务地执行，如果存在一个活动事务，则抛出异常
7. PROPAGATION_NESTED：如果一个活动的事务存在，则运行在一个嵌套的事务中. 如果没有活动事务, 则按TransactionDefinition.PROPAGATION_REQUIRED属性执行

 

Spring事务的隔离级别
1. ISOLATION_DEFAULT： 这是一个PlatfromTransactionManager默认的隔离级别，使用数据库默认的事务隔离级别.另外四个与JDBC的隔离级别相对应
2. ISOLATION_READ_UNCOMMITTED： 这是事务最低的隔离级别，它充许令外一个事务可以看到这个事务未提交的数据。这种隔离级别会产生脏读，不可重复读和幻像读。
3. ISOLATION_READ_COMMITTED： 保证一个事务修改的数据提交后才能被另外一个事务读取。另外一个事务不能读取该事务未提交的数据避免脏读、会产生不重复读、会产生幻读

4. ISOLATION_REPEATABLE_READ： 这种事务隔离级别可以防止脏读，不可重复读。但是可能出现幻像读。它除了保证一个事务不能读取另一个事务未提交的数据外，还保证了避免下面的情况产生(不可重复读)。避免脏读、避免不重复读、会产生幻读

5. ISOLATION_SERIALIZABLE 这是花费最高代价但是最可靠的事务隔离级别。事务被处理为顺序执行。除了防止脏读，不可重复读外，还避免了幻像读。 

脏读: 指当一个事务正在访问数据，并且对数据进行了修改，而这种修改还没有提交到数据库中，这时，另外一个事务也访问这个数据，然后使用了这个数据。因为这个数据是还没有提交的数据，那么另外一 个事务读到的这个数据是脏数据，依据脏数据所做的操作可能是不正确的。

不可重复读: 指在一个事务内，多次读同一数据。在这个事务还没有结束时，另外一个事务也访问该同一数据。那么，在第一个事务中的两次读数据之间，由于第二个事务的修改，那么第一个事务两次读到的数据可能是不一样的。这样就发生了在一个事务内两次读到的数据是不一样的，因此称为是不可重复读。

幻觉读: 指当事务不是独立执行时发生的一种现象，例如第一个事务对一个表中的数据进行了修改，这种修改涉及到表中的全部数据行。同时，第二个事务也修改这个表中的数据，这种修改是向表中插入一行新数据。那么，以后就会发生操作第一个事务的用户发现表中还有没有修改的数据行，就好象发生了幻觉一样。

 

--web

1.统一的全局的字符编码如何设置 （内、外）

在web.xml里面使用spring的过滤器，处理中文乱码问题

<filter>

                   <filter-name>encodingFilter</filter-name>

                   <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>

                   <init-param>

                            <param-name>encoding</param-name>

                            <param-value>UTF-8</param-value>

                   </init-param>

                   <init-param>

                            <param-name>forceEncoding</param-name>

                            <param-value>true</param-value>

                   </init-param>

         </filter>

        

         <filter-mapping>

                   <filter-name>encodingFilter</filter-name>

                   <url-pattern>/*</url-pattern>

         </filter-mapping>

--JVM

1.Java虚拟机运行时内存分配和内存释放 （内）

一个很大的话题，具体可以看一下这个http://hllvm.group.iteye.com/group/wiki/2859-JVM  

 

--整体例外 任选1

1.百度查询框中，假设打一个“中”字，那么输入框中会出现一系列提示字符串，从你角度看这是如何实现的

2.现在要求设计一个类似的word一样的工具，但要求可以远程多人对同一个文档进行操作（编辑、删除）等，同时要求一个人修改，其他人能立刻看到

，并且可以动态添加人员进入，需要保证数据的唯一性、一致性和高效性，不要出现锁住的情况，请问你如何设计