Java面试题集（71-85）

曾经终败给现在 2021-09-22 03:32 366阅读 0赞

**Java程序员面试题集（71-85）**

**摘要：这一部分主要包括了UML（统一建模语言）、面向对象的设计原则（六原则一法则）、GoF设计模式、企业级设计模式、JDBC（Java数据库连接）、XML（可扩展标记语言）等知识。**

**71、UML是什么？UML中有哪些图？**

答：UML是统一建模语言（Unified Modeling Language）的缩写，它发表于1997年，综合了当时已经存在的面向对象的建模语言、方法和过程，是一个支持模型化和软件系统开发的图形化语言，为软件开发的所有阶段提供模型化和可视化支持。使用UML可以帮助沟通与交流，辅助应用设计和文档的生成，还能够阐释系统的结构和行为。UML定义了多种图形化的符号来描述软件系统部分或全部的静态结构和动态结构，包括：用例图（use case diagram）、类图（class diagram）、时序图（sequence diagram）、协作图（collaboration diagram）、状态图（statechart diagram）、活动图（activity diagram）、构件图（component diagram）、部署图（deployment diagram）等。在这些图形化符号中，有三种图最为重要，分别是：用例图（用来捕获需求，描述系统的功能，通过该图可以迅速的了解系统的功能模块及其关系）、类图（描述类以及类与类之间的关系，通过该图可以快速了解系统）、时序图（描述执行特定任务时对象之间的交互关系以及执行顺序，通过该图可以了解对象能接收的消息也就是说对象能够向外界提供的服务）。

用例图：

![20141009173424301][]

类图：

![20141009173429652][]

时序图：

![20141009173433411][]

**72、写一个单例类。**

答：单例模式主要作用是保证在Java应用程序中，一个类只有一个实例存在。下面给出两种不同形式的单例：

第一种形式：饿汉式单例

public class Singleton {
        private Singleton(){}
        private static Singleton instance = new Singleton();
        public static Singleton getInstance(){
            return instance;
        }
    }

第二种形式：懒汉式单例

public class Singleton {
        private static Singleton instance = null;
        private Singleton() {}
        public static synchronized Singleton getInstance(){
            if (instance==null) instance＝newSingleton();
            return instance;
        }
    }

单例的特点：外界无法通过构造器来创建对象，该类必须提供一个静态方法向外界提供该类的唯一实例。

【补充】用Java进行服务器端编程时，使用单例模式的机会还是很多的，服务器上的资源都是很宝贵的，对于那些无状态的对象其实都可以单例化或者静态化（在内存中仅有唯一拷贝），如果使用了Spring这样的框架来进行对象托管，Spring的IoC容器在默认情况下对所有托管对象都是进行了单例化处理的。

**73、说说你所熟悉或听说过的设计模式以及你对设计模式的看法。**

### 答：在GoF的《Design Patterns: Elements of Reusable Object-Oriented Software》中给出了三类（创建型\[对类的实例化过程的抽象化\]、结构型\[描述如何将类或对象结合在一起形成更大的结构\]、行为型\[对在不同的对象之间划分责任和算法的抽象化\]）共23种设计模式，包括：Abstract Factory（抽象工厂模式），Builder（建造者模式），Factory Method（工厂方法模式），Prototype（原始模型模式），Singleton（单例模式）；Facade（门面模式），Adapter（适配器模式），Bridge（桥梁模式），Composite（合成模式），Decorator（装饰模式），Flyweight（享元模式），Proxy（代理模式）；Command（命令模式），Interpreter（解释器模式），Visitor（访问者模式），Iterator（迭代子模式），Mediator（调停者模式），Memento（备忘录模式），Observer（观察者模式），State（状态模式），Strategy（策略模式），Template Method（模板方法模式）， Chain Of Responsibility（责任链模式）。 ###

所谓设计模式，就是一套被反复使用的代码设计经验的总结（情境中一个问题经过证实的一个解决方案）。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。设计模式使人们可以更加简单方便的复用成功的设计和体系结构。将已证实的技术表述成设计模式也会使新系统开发者更加容易理解其设计思路。

【补充】设计模式并不是像某些地方吹嘘的那样是遥不可及的编程理念，说白了设计模式就是对面向对象的编程原则的实践，面向对象的编程原则包括：

*  单一职责原则：一个类只做它该做的事情。（单一职责原则想表达的就是“高内聚”，写代码最终极的原则只有六个字“高内聚、低耦合”，就如同葵花宝典或辟邪剑谱的中心思想就八个字“欲练此功必先自宫”，所谓的高内聚就是一个代码模块只完成一项功能，在面向对象中，如果只让一个类完成它该做的事，而不涉及与它无关的领域就是践行了高内聚的原则，这个类就只有单一职责。我们都知道一句话叫“因为专注，所以专业”，一个对象如果承担太多的职责，那么注定它什么都做不好。这个世界上任何好的东西都有两个特征，一个是功能单一，好的相机绝对不是电视购物里面卖的那种一个机器有一百多种功能的，它基本上只能照相；另一个是模块化，好的自行车是组装车，从减震叉、刹车到变速器，所有的部件都是可以拆卸和重新组装的，好的乒乓球拍也不是成品拍，一定是底板和胶皮可以拆分和自行组装的，一个好的软件系统，它里面的每个功能模块也应该是可以轻易的拿到其他系统中使用的，这样才能实现软件复用的目标。）

*  开闭原则：软件实体应当对扩展开放，对修改关闭。（在理想的状态下，当我们需要为一个软件系统增加新功能时，只需要从原来的系统派生出一些新类就可以，不需要修改原来的任何一行代码。要做到开闭有两个要点：①抽象是关键，一个系统中如果没有抽象类或接口系统就没有扩展点；②封装可变性，将系统中的各种可变因素封装到一个继承结构中，如果多个可变因素混杂在一起，系统将变得复杂而换乱，如果不清楚如何封装可变性，可以参考[《设计模式精解》][Link 1]一书中对桥梁模式的讲解的章节。）

*  依赖倒转原则：面向接口编程。（该原则说得直白和具体一些就是声明方法的参数类型、方法的返回类型、变量的引用类型时，尽可能使用抽象类型而不用具体类型，因为抽象类型可以被它的任何一个子类型所替代，请参考下面的里氏替换原则。）

*  里氏替换原则：任何时候都可以用子类型替换掉父类型。（关于里氏替换原则的描述，[Barbara Liskov][]女士的描述比这个要复杂得多，但简单的说就是能用父类型的地方就一定能使用子类型。里氏替换原则可以检查继承关系是否合理，如果一个继承关系违背了里氏替换原则，那么这个继承关系一定是错误的，需要对代码进行重构。例如让猫继承狗，或者狗继承猫，又或者让正方形继承长方形都是错误的继承关系，因为你很容易找到违反里氏替换原则的场景。需要注意的是：子类一定是增加父类的能力而不是减少父类的能力，因为子类比父类的能力更多，把能力多的对象当成能力少的对象来用当然没有任何问题。）

*  接口隔离原则：接口要小而专，绝不能大而全。（臃肿的接口是对接口的污染，既然接口表示能力，那么一个接口只应该描述一种能力，接口也应该是高度内聚的。例如，琴棋书画就应该分别设计为四个接口，而不应设计成一个接口中的四个方法，因为如果设计成一个接口中的四个方法，那么这个接口很难用，毕竟琴棋书画四样都精通的人还是少数，而如果设计成四个接口，会几项就实现几个接口，这样的话每个接口被复用的可能性是很高的。Java中的接口代表能力、代表约定、代表角色，能否正确的使用接口一定是编程水平高低的重要标识。）

*  合成聚合复用原则：优先使用聚合或合成关系复用代码。（通过继承来复用代码是面向对象程序设计中被滥用得最多的东西，因为所有的教科书都无一例外的对继承进行了鼓吹从而误导了初学者，类与类之间简单的说有三种关系，IS-A关系、HAS-A关系、USE-A关系，分别代表继承、关联和依赖。其中，关联关系根据其关联的强度又可以进一步划分为关联、聚合和合成，但说白了都是HAS-A关系，合成聚合复用原则想表达的是优先考虑HAS-A关系而不是IS-A关系复用代码，原因嘛可以自己从百度上找到一万个理由，需要说明的是，即使在Java的API中也有不少滥用继承的例子，例如Properties类继承了Hashtable类，Stack类继承了Vector类，这些继承明显就是错误的，更好的做法是在Properties类中放置一个Hashtable类型的成员并且将其键和值都设置为字符串来存储数据，而Stack类的设计也应该是在Stack类中放一个Vector对象来存储数据。记住：任何时候都不要继承工具类，工具是可以拥有并可以使用的（HAS/USE），而不是拿来继承的。）

*  迪米特法则：迪米特法则又叫最少知识原则，一个对象应当对其他对象有尽可能少的了解。（迪米特法则简单的说就是如何做到“低耦合”，门面模式和调停者模式就是对迪米特法则的践行。对于门面模式可以举一个简单的例子，你去一家公司洽谈业务，你不需要了解这个公司内部是如何运作的，你甚至可以对这个公司一无所知，去的时候只需要找到公司入口处的前台美女，告诉她们你要做什么，她们会找到合适的人跟你接洽，前台的美女就是公司这个系统的门面。再复杂的系统都可以为用户提供一个简单的门面，Java Web开发中作为前端控制器的Servlet或Filter不就是一个门面吗，浏览器对服务器的运作方式一无所知，但是通过前端控制器就能够根据你的请求得到相应的服务。调停者模式也可以举一个简单的例子来说明，例如一台计算机，CPU、内存、硬盘、显卡、声卡各种设备需要相互配合才能很好的工作，但是如果这些东西都直接连接到一起，计算机的布线将异常复杂，在这种情况下，主板作为一个调停者的身份出现，它将各个设备连接在一起而不需要每个设备之间直接交换数据，这样就减小了系统的耦合度和复杂度。迪米特法则用通俗的话来将就是不要和陌生人打交道，如果真的需要，找一个自己的朋友，让他替你和陌生人打交道。）

![20141009134505482][]![20141009134249656][]

**74、Java企业级开发中常用的设计模式有哪些？**

答： 按照分层开发的观点，可以将应用划分为：表示层、业务逻辑层和持久层，每一层都有属于自己类别的设计模式。

表示层设计模式：

1)Interceptor Filter：拦截过滤器，提供请求预处理和后处理的方案，可以对请求和响应进行过滤。

2)Front Controller：通过中央控制器提供请求管理和处理，管理内容读取、安全性、视图管理和导航等功能。Struts 2中的StrutsPrepareAndExecuteFilter、Spring MVC中的DispatcherServlet都是前端控制器，后者如下图所示：

![20141009150401541][]

3)View Helper：视图帮助器，负责将显示逻辑和业务逻辑分开。显示的部分放在视图组件中，业务逻辑代码放在帮助器中，典型的功能是内容读取、验证与适配。

4)Composite View：复合视图。

业务逻辑层设计模式：

1)Business Delegate：业务委托，减少表示层和业务逻辑层之间的耦合。

2)Value Object：值对象，解决层之间交换数据的开销问题。

3)Session Façade：会话门面，隐藏业务逻辑组件的细节，集中工作流程。

4)Value Object Assembler：灵活的组装不同的值对象

5)Value List Handler：提供执行查询和处理结果的解决方案，还可以缓存查询结果，从而达到提升性能的目的。

6)Service Locator：服务定位器，可以查找、创建和定位服务工厂，封装其实现细节，减少复杂性，提供单个控制点，通过缓存提高性能。

持久层设计模式：

1)Data Access Object：数据访问对象，以面向对象的方式完成对数据的增删改查。

【补充】如果想深入的了解Java企业级应用的设计模式和架构模式，可以参考这些书籍：[ 《Pro Java EE Spring Patterns》][Pro Java EE Spring Patterns]、[《POJO in Action》][POJO in Action]、[《Patterns of Enterprise Application Architecture》][Patterns of Enterprise Application Architecture]。

**75、你在开发中都用到了那些设计模式？用在什么场合？**

答：面试被问到关于设计模式的知识时，可以拣最常用的作答，例如：

1)工厂模式：工厂类可以根据条件生成不同的子类实例，这些子类有一个公共的抽象父类并且实现了相同的方法，但是这些方法针对不同的数据进行了不同的操作（多态方法）。当得到子类的实例后，开发人员可以调用基类中的方法而不必考虑到底返回的是哪一个子类的实例。

2)代理模式：给一个对象提供一个代理对象，并由代理对象控制原对象的引用。实际开发中，按照使用目的的不同，代理可以分为：远程代理、虚拟代理、保护代理、Cache代理、防火墙代理、同步化代理、智能引用代理。

3)适配器模式：把一个类的接口变换成客户端所期待的另一种接口，从而使原本因接口不匹配而无法在一起使用的类能够一起工作。

4)模板方法模式：提供一个抽象类，将部分逻辑以具体方法或构造器的形式实现，然后声明一些抽象方法来迫使子类实现剩余的逻辑。不同的子类可以以不同的方式实现这些抽象方法（多态实现），从而实现不同的业务逻辑。

除此之外，还可以讲讲上面提到的门面模式、桥梁模式、单例模式、装潢模式（Collections工具类里面的synchronizedXXX方法把一个线程不安全的容器变成线程安全容器就是对装潢模式的应用，而Java IO里面的过滤流（有的翻译成处理流）也是应用装潢模式的经典例子）等，反正原则就是拣自己最熟悉的用得最多的作答，以免言多必失。

**76、XML 文档定义有几种形式？它们之间有何本质区别？解析XML 文档有哪几种方式？**

答：XML文档定义分为DTD和Schema两种形式；其本质区别在于Schema本身也是一个XML文件，可以被XML解析器解析。对XML的解析主要有DOM（文档对象模型）、SAX、StAX（JDK 1.6中引入的新的解析XML的方式，Streaming API for XML） 等，其中DOM处理大型文件时其性能下降的非常厉害，这个问题是由DOM 的树结构所造成的，这种结构占用的内存较多，而且DOM 必须在解析文件之前把整个文档装入内存,适合对XML 的随机访问（典型的用空间换取时间的策略）；SAX是事件驱动型的XML解析方式，它顺序读取XML文件，不需要一次全部装载整个文件。当遇到像文件开头，文档结束，或者标签开头与标签结束时，它会触发一个事件，用户通过在其回调事件中写入处理代码来处理XML文件，适合对XML 的顺序访问；如其名称所暗示的那样，StAX把重点放在流上。实际上，StAX与其他方法的区别就在于应用程序能够把XML作为一个事件流来处理。将XML作为一组事件来处理的想法并不新颖（事实上 SAX 已经提出来了），但不同之处在于StAX允许应用程序代码把这些事件逐个拉出来，而不用提供在解析器方便时从解析器中接收事件的处理程序。

**77、你在项目中哪些地方用到了XML？**

答:XML的主要作用有两个方面：数据交换（曾经被称为业界数据交换的事实标准，现在此项功能在很多时候都被JSON取代）和信息配置。在做数据交换时，XML将数据用标签组装成起来，然后压缩打包加密后通过网络传送给接收者，接收解密与解压缩后再从XML文件中还原相关信息进行处理。目前很多软件都使用XML来存储配置信息，很多项目中我们通常也会将作为配置的硬代码（hard code）写在XML文件中，Java的很多框架也是这么做的。

**78、在进行数据库编程时，连接池有什么作用？**

答：由于创建连接和释放连接都有很大的开销（尤其是数据库服务器不在本地时，每次建立连接都需要进行TCP的三次握手，再加上网络延迟，造成的开销是不可忽视的），为了提升系统访问数据库的性能，可以事先创建若干连接置于连接池中，需要时直接从连接池获取，使用结束时归还连接池而不必关闭连接，从而避免频繁创建和释放连接所造成的开销，这是典型的用空间换取时间的策略（浪费了空间存储连接，但节省了创建和释放连接的时间）。池化技术在Java开发中是很常见的，在使用线程时创建线程池的道理与此相同。基于Java的开源数据库连接池主要有： [C3P0][]、[Proxool][]、[DBCP][]、[BoneCP][]、[Druid][]等。

【补充】在计算机系统中时间和空间是不可调和的矛盾，理解这一点对设计满足性能要求的算法是至关重要的。大型网站性能优化的一个关键就是使用缓存，而缓存跟上面讲的连接池道理非常类似，也是使用空间换时间的策略。可以将热点数据置于缓存中，当用户查询这些数据时可以直接从缓存中得到，这无论如何也快过去数据库中查询。当然，缓存的置换策略等也会对系统性能产生重要影响，对于这个问题的讨论已经超出了这里要阐述的范围。

**79、什么是DAO模式？**

答：DAO（DataAccess Object）顾名思义是一个为数据库或其他持久化机制提供了抽象接口的对象，在不暴露数据库实现细节的前提下提供了各种数据操作。为了建立一个健壮的Java EE应用，应该将所有对数据源的访问操作进行抽象化后封装在一个公共API中。用程序设计语言来说，就是建立一个接口，接口中定义了此应用程序中将会用到的所有事务方法。在这个应用程序中，当需要和数据源进行交互的时候则使用这个接口，并且编写一个单独的类来实现这个接口，在逻辑上该类对应一个特定的数据存储。DAO模式实际上包含了两个模式，一是Data Accessor（数据访问器），二是Data Object（数据对象），前者要解决如何访问数据的问题，而后者要解决的是如何用对象封装数据。

**80、什么是ORM？**

答：对象关系映射（Object-Relational Mapping，简称ORM）是一种为了解决程序的面向对象模型与数据库的关系模型互不匹配问题的技术；简单的说，ORM 是通过使用描述对象和数据库之间映射的元数据（可以用XML或者是注解），将Java程序中的对象自动持久化到关系数据库中或者将关系数据库表中的行转换成Java对象，其本质上就是将数据从一种形式转换到另外一种形式。

**81、JDBC中如何进行事务处理？**

答：Connection提供了事务处理的方法，通过调用setAutoCommit(false)可以设置手动提交事务；当事务完成后用commit()显式提交事务；如果在事务处理过程中发生异常则通过rollback()进行事务回滚。除此之外，较新的JDBC标准还引入了Savepoint（保存点）的概念，允许事务回滚到指定的保存点。

**82、 事务的ACID是指什么？**

答：

1)原子性(Atomic)：事务中各项操作，要么全做要么全不做，任何一项操作的失败都会导致整个事务的失败；

2)一致性(Consistent)：事务结束后系统状态是一致的；

3)隔离性(Isolated)：并发执行的事务彼此无法看到对方的中间状态；

4)持久性(Durable)：事务完成后所做的改动都会被持久化，即使发生灾难性的失败。通过日志和同步备份可以在故障发生后重建数据。

【补充】关于事务，在面试中被问到的概率是很高的，可以问的问题也是很多的。首先需要知道的是，只有存在并发数据访问时才需要事务。当多个事务访问同一数据时，可能会存在5类问题，包括3类数据读取问题（脏读、不可重复读和幻读）和2类数据更新问题（第1类丢失更新和第2类丢失更新）。

*  脏读（Dirty Read）：A事务读取B事务尚未提交的数据并在此基础上操作，而B事务执行回滚，那么A读取到的数据就是脏数据。

<table> 
 <tbody> 
 <tr> 
 <td> 时间 </td> 
 <td> 转账事务A </td> 
 <td> 取款事务B </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(211,223,238)"> T1 </td> 
 <td style="background:rgb(211,223,238)"> &nbsp; </td> 
 <td style="background:rgb(211,223,238)"> 开始事务 </td> 
 </tr> 
 <tr> 
 <td> T2 </td> 
 <td> 开始事务 </td> 
 <td> &nbsp; </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(211,223,238)"> T3 </td> 
 <td style="background:rgb(211,223,238)"> </td> 
 <td style="background:rgb(211,223,238)"> 查询账户余额为1000元 </td> 
 </tr> 
 <tr> 
 <td> T4 </td> 
 <td> &nbsp; </td> 
 <td> 取出500元余额修改为500元 </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(211,223,238)"> T5 </td> 
 <td style="background:rgb(211,223,238)"> 查询账户余额为500元（脏读） </td> 
 <td style="background:rgb(211,223,238)"> </td> 
 </tr> 
 <tr> 
 <td> T6 </td> 
 <td> &nbsp; </td> 
 <td> 撤销事务余额恢复为1000元 </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(211,223,238)"> T7 </td> 
 <td style="background:rgb(211,223,238)"> 汇入100元把余额修改为600元 </td> 
 <td style="background:rgb(211,223,238)"> &nbsp; </td> 
 </tr> 
 <tr> 
 <td> T8 </td> 
 <td> 提交事务 </td> 
 <td> &nbsp; </td> 
 </tr> 
 </tbody> 
</table>

*  不可重复读（Unrepeatable Read）：事务A重新读取前面读取过的数据，发现该数据已经被另一个已提交的事务B修改过了。

<table> 
 <tbody> 
 <tr> 
 <td> 时间 </td> 
 <td> 转账事务A </td> 
 <td> 取款事务B </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(211,223,238)"> T1 </td> 
 <td style="background:rgb(211,223,238)"> &nbsp; </td> 
 <td style="background:rgb(211,223,238)"> 开始事务 </td> 
 </tr> 
 <tr> 
 <td> T2 </td> 
 <td> 开始事务 </td> 
 <td> &nbsp; </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(211,223,238)"> T3 </td> 
 <td style="background:rgb(211,223,238)"> &nbsp; </td> 
 <td style="background:rgb(211,223,238)"> 查询账户余额为1000元 </td> 
 </tr> 
 <tr> 
 <td> T4 </td> 
 <td> 查询账户余额为1000元 </td> 
 <td> &nbsp; </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(211,223,238)"> T5 </td> 
 <td style="background:rgb(211,223,238)"> &nbsp; </td> 
 <td style="background:rgb(211,223,238)"> 取出100元修改余额为900元 </td> 
 </tr> 
 <tr> 
 <td> T6 </td> 
 <td> &nbsp; </td> 
 <td> 提交事务 </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(211,223,238)"> T7 </td> 
 <td style="background:rgb(211,223,238)"> 查询账户余额为900元（不可重复读） </td> 
 <td style="background:rgb(211,223,238)"> &nbsp; </td> 
 </tr> 
 </tbody> 
</table>

*  幻读（Phantom Read）：事务A重新执行一个查询，返回一系列符合查询条件的行，发现其中插入了被事务B提交的行。

<table> 
 <tbody> 
 <tr> 
 <td> 时间 </td> 
 <td> 统计金额事务A </td> 
 <td> 转账事务B </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(211,223,238)"> T1 </td> 
 <td style="background:rgb(211,223,238)"> &nbsp; </td> 
 <td style="background:rgb(211,223,238)"> 开始事务 </td> 
 </tr> 
 <tr> 
 <td> T2 </td> 
 <td> 开始事务 </td> 
 <td> &nbsp; </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(211,223,238)"> T3 </td> 
 <td style="background:rgb(211,223,238)"> 统计总存款为10000元 </td> 
 <td style="background:rgb(211,223,238)"> &nbsp; </td> 
 </tr> 
 <tr> 
 <td> T4 </td> 
 <td> &nbsp; </td> 
 <td> 新增一个存款账户存入100元 </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(211,223,238)"> T5 </td> 
 <td style="background:rgb(211,223,238)"> &nbsp; </td> 
 <td style="background:rgb(211,223,238)"> 提交事务 </td> 
 </tr> 
 <tr> 
 <td> T6 </td> 
 <td> 再次统计总存款为10100元（幻读） </td> 
 <td> &nbsp; </td> 
 </tr> 
 </tbody> 
</table>

*  第1类丢失更新：事务A撤销时，把已经提交的事务B的更新数据覆盖了。

<table> 
 <tbody> 
 <tr> 
 <td> 时间 </td> 
 <td> 取款事务A </td> 
 <td> 转账事务B </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(211,223,238)"> T1 </td> 
 <td style="background:rgb(211,223,238)"> 开始事务 </td> 
 <td style="background:rgb(211,223,238)"> &nbsp; </td> 
 </tr> 
 <tr> 
 <td> T2 </td> 
 <td> </td> 
 <td> 开始事务 </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(211,223,238)"> T3 </td> 
 <td style="background:rgb(211,223,238)"> 查询账户余额为1000元 </td> 
 <td style="background:rgb(211,223,238)"> &nbsp; </td> 
 </tr> 
 <tr> 
 <td> T4 </td> 
 <td> &nbsp; </td> 
 <td> 查询账户余额为1000元 </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(211,223,238)"> T5 </td> 
 <td style="background:rgb(211,223,238)"> &nbsp; </td> 
 <td style="background:rgb(211,223,238)"> 汇入100元修改余额为1100元 </td> 
 </tr> 
 <tr> 
 <td> T6 </td> 
 <td> &nbsp; </td> 
 <td> 提交事务 </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(211,223,238)"> T7 </td> 
 <td style="background:rgb(211,223,238)"> 取出100元将余额修改为900元 </td> 
 <td style="background:rgb(211,223,238)"> &nbsp; </td> 
 </tr> 
 <tr> 
 <td> T8 </td> 
 <td> 撤销事务 </td> 
 <td> &nbsp; </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(211,223,238)"> T9 </td> 
 <td style="background:rgb(211,223,238)"> 余额恢复为1000元（丢失更新） </td> 
 <td style="background:rgb(211,223,238)"> &nbsp; </td> 
 </tr> 
 </tbody> 
</table>

*  第2类丢失更新：事务A覆盖事务B已经提交的数据，造成事务B所做的操作丢失。

<table> 
 <tbody> 
 <tr> 
 <td> 时间 </td> 
 <td> 转账事务A </td> 
 <td> 取款事务B </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(211,223,238)"> T1 </td> 
 <td style="background:rgb(211,223,238)"> &nbsp; </td> 
 <td style="background:rgb(211,223,238)"> 开始事务 </td> 
 </tr> 
 <tr> 
 <td> T2 </td> 
 <td> 开始事务 </td> 
 <td> &nbsp; </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(211,223,238)"> T3 </td> 
 <td style="background:rgb(211,223,238)"> </td> 
 <td style="background:rgb(211,223,238)"> 查询账户余额为1000元 </td> 
 </tr> 
 <tr> 
 <td> T4 </td> 
 <td> 查询账户余额为1000元 </td> 
 <td> </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(211,223,238)"> T5 </td> 
 <td style="background:rgb(211,223,238)"> </td> 
 <td style="background:rgb(211,223,238)"> 取出100元将余额修改为900元 </td> 
 </tr> 
 <tr> 
 <td> T6 </td> 
 <td> &nbsp; </td> 
 <td> 提交事务 </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(211,223,238)"> T7 </td> 
 <td style="background:rgb(211,223,238)"> 汇入100元将余额修改为1100元 </td> 
 <td style="background:rgb(211,223,238)"> </td> 
 </tr> 
 <tr> 
 <td> T8 </td> 
 <td> 提交事务 </td> 
 <td> &nbsp; </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(211,223,238)"> T9 </td> 
 <td style="background:rgb(211,223,238)"> 查询账户余额为1100元（丢失更新） </td> 
 <td style="background:rgb(211,223,238)"> &nbsp; </td> 
 </tr> 
 </tbody> 
</table>

数据并发访问所产生的问题，在有些场景下可能是允许的，但是有些场景下可能就是致命的，数据库通常会通过锁机制来解决数据并发访问问题，按锁定对象不同可以分为表级锁和行级锁；按并发事务锁定关系可以分为共享锁和独占锁，具体的内容大家可以自行查阅资料进行了解。

直接使用锁是非常麻烦的，为此数据库为用户提供了自动锁机制，只要用户指定会话的事务隔离级别，数据库就会通过分析SQL语句然后为事务访问的资源加上合适的锁，此外，数据库还会维护这些锁通过各种手段提高系统的性能，这些对用户来说都是透明的（就是说你不用理解，事实上我确实也不知道）。ANSI/ISO SQL 92标准定义了4个等级的事务隔离级别，如下表所示：

<table> 
 <tbody> 
 <tr> 
 <td> 隔离级别 </td> 
 <td> 脏读 </td> 
 <td> 不可重复读 </td> 
 <td> 幻读 </td> 
 <td> 第一类丢失更新 </td> 
 <td> 第二类丢失更新 </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(211,223,238)"> READ UNCOMMITED </td> 
 <td style="background:rgb(211,223,238)"> 允许 </td> 
 <td style="background:rgb(211,223,238)"> 允许 </td> 
 <td style="background:rgb(211,223,238)"> 允许 </td> 
 <td style="background:rgb(211,223,238)"> 不允许 </td> 
 <td style="background:rgb(211,223,238)"> 允许 </td> 
 </tr> 
 <tr> 
 <td> READ COMMITTED </td> 
 <td> 不允许 </td> 
 <td> 允许 </td> 
 <td> 允许 </td> 
 <td> 不允许 </td> 
 <td> 允许 </td> 
 </tr> 
 <tr> 
 <td style="background:rgb(211,223,238)"> REPEATABLE READ </td> 
 <td style="background:rgb(211,223,238)"> 不允许 </td> 
 <td style="background:rgb(211,223,238)"> 不允许 </td> 
 <td style="background:rgb(211,223,238)"> 允许 </td> 
 <td style="background:rgb(211,223,238)"> 不允许 </td> 
 <td style="background:rgb(211,223,238)"> 不允许 </td> 
 </tr> 
 <tr> 
 <td> SERIALIZABLE </td> 
 <td> 不允许 </td> 
 <td> 不允许 </td> 
 <td> 不允许 </td> 
 <td> 不允许 </td> 
 <td> 不允许 </td> 
 </tr> 
 </tbody> 
</table>

需要说明的是，事务隔离级别和数据访问的并发性是对立的，事务隔离级别越高并发性就越差。所以要根据具体的应用来确定合适的事务隔离级别，这个地方没有万能的原则。

**83、Statement和PreparedStatement有什么区别？哪个性能更好？**

答： 与Statement相比，①PreparedStatement接口代表预编译的语句，它主要的优势在于可以减少SQL的编译错误并增加SQL的安全性（减少SQL注射攻击的可能性）；②PreparedStatement中的SQL语句是可以带参数的；③当批量处理SQL时或频繁执行相同的查询时，PreparedStatement有明显的性能上的优势，由于数据库可以将编译优化后的SQL语句缓存起来，下次执行相同语句时就会很快。

【补充】为了提供对存储过程的调用，JDBC API中还提供了CallableStatement接口。存储过程（Stored Procedure）是数据库系统中，一组为了完成特定功能的SQL语句的集合，经编译后存储在数据库中，用户通过指定存储过程的名字并给出参数（如果该存储过程带有参数）来执行它。虽然调用存储过程会带来网络开销、安全性、性能上的好处，但是存在如果底层数据库发生迁移时就会有很多麻烦，因为每种数据库的存储过程在书写上存在不少的差别。

**84、使用JDBC操作数据库时，如何提升读取数据的性能？如何提升更新数据的性能？**

答：要提升读取数据的性能，可以指定通过结果集（ResultSet）对象指定每次抓取数据的大小（fetch size）；要提升更新数据的性能可以使用PreparedStatement语句构建批处理（batch）。

**85、JDBC能否处理Blob和Clob？**

答： Blob是指二进制大对象（Binary Large Object），而Clob是指大字符对象（Character Large Objec），因此其中Blob是为存储大的二进制数据而设计的，而Clob是为存储大的文本数据而设计的。JDBC的PreparedStatement和ResultSet都提供了相应的方法来支持Blob和Clob操作。下面的代码展示了如何使用JDBC操作LOB：

我使用的数据库是MySQL，创建一个张有三个字段的用户表，包括编号（id）、姓名（name）和照片（photo），建表语句如下：

create table tb_user
    (
    id int primary key auto_increment,
    name varchar(20) unique not null,
    photo longblob
    );

下面的Java代码向数据库中插入一条记录：

package com.lovo.demo;
    
    import java.io.FileInputStream;
    import java.io.IOException;
    import java.io.InputStream;
    import java.sql.Connection;
    import java.sql.DriverManager;
    import java.sql.PreparedStatement;
    import java.sql.SQLException;
    
    class JdbcLobTest {
    
    	public static void main(String[] args) {
    		Connection con = null;
    		try {
    			// 1. 加载驱动（Java6以上版本可以省略）
    			Class.forName("com.mysql.jdbc.Driver");
    			// 2. 建立连接
    			con = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "123456");
    			// 3. 创建语句对象
    			PreparedStatement ps = con.prepareStatement("insert into tb_user values (default, ?, ?)");
    			ps.setString(1, "骆昊");				// 将SQL语句中第一个占位符换成字符串
    			try (InputStream in = new FileInputStream("test.jpg")) {	// Java 7的TWR
    				ps.setBinaryStream(2, in);		// 将SQL语句中第二个占位符换成二进制流
    				// 4. 发出SQL语句获得受影响行数
    				System.out.println(ps.executeUpdate() == 1 ? "插入成功" : "插入失败");
    			} catch(IOException e) {
    				System.out.println("读取照片失败!");
    			}
    		} catch (ClassNotFoundException | SQLException e) {		// Java 7的多异常捕获
    			e.printStackTrace();
    		} finally {	// 释放外部资源的代码都应当放在finally中保证其能够得到执行
    			try {
    				if(con != null && !con.isClosed()) {
    					con.close();	// 5. 释放数据库连接 
    					con = null;     // 指示垃圾回收器可以回收该对象
    				}
    			} catch (SQLException e) {
    				e.printStackTrace();
    			}
    		}
    	}
    }

[20141009173424301]: /images/20210920/963d615f7f8a476c84af3f3950555cb6.png
[20141009173429652]: /images/20210920/13822a0ade2e4db697e4676bba859e13.png
[20141009173433411]: /images/20210920/e3fc1577d30f41b38bbb6a8ea22f7ec5.png
[Link 1]: http://www.amazon.cn/%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F%E8%A7%A3%E6%9E%90-%E6%B2%99%E6%B4%9B%E7%BB%B4/dp/B004DPHY7A/ref=sr_1_1?ie=UTF8&qid=1412830033&sr=8-1&keywords=%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F%E7%B2%BE%E8%A7%A3
[Barbara Liskov]: http://baike.baidu.com/view/2886313.htm?fr=aladdin
[20141009134505482]: https://img-blog.csdn.net/20141009134505482
[20141009134249656]: /images/20210920/8748f1de22224daca97212006c7ff7d0.png
[20141009150401541]: /images/20210920/9d237f6f5442451fb75d3276ba02bd3f.png
[Pro Java EE Spring Patterns]: http://www.amazon.cn/s/ref=nb_sb_noss_2?__mk_zh_CN=%E4%BA%9A%E9%A9%AC%E9%80%8A%E7%BD%91%E7%AB%99&url=search-alias%3Daps&field-keywords=pro+java+EE+spring+pattern&rh=i%3Aaps%2Ck%3Apro+java+EE+spring+pattern
[POJO in Action]: http://www.amazon.cn/POJOs-in-Action-Lightweight-Frameworks-for-Enterprise-Applications-Richardson-Chris/dp/1932394583/ref=sr_1_1?ie=UTF8&qid=1412837604&sr=8-1&keywords=pojo+in+action
[Patterns of Enterprise Application Architecture]: http://www.amazon.cn/%E4%BC%81%E4%B8%9A%E5%BA%94%E7%94%A8%E6%9E%B6%E6%9E%84%E6%A8%A1%E5%BC%8F-%E7%A6%8F%E5%8B%92/dp/B003LBSRDM/ref=sr_1_22?ie=UTF8&qid=1412837042&sr=8-22&keywords=%E8%AE%BE%E8%AE%A1%E6%A8%A1%E5%BC%8F
[C3P0]: http://sourceforge.net/projects/c3p0/
[Proxool]: http://proxool.sourceforge.net/
[DBCP]: http://commons.apache.org/proper/commons-dbcp/
[BoneCP]: https://github.com/wwadge/bonecp
[Druid]: https://github.com/alibaba/druid