Oracle的oci和thin的不一樣

前幾天同事跑過來跟我說， 機房中的一臺tomcat服務器跟oracle數據庫機鏈接很慢，查看控制檯中的hibernate日誌， 基本上是一條sql出來要等個1-2秒再出第二條。但一樣的程序在他本身機器上的tomcat運行，一樣是連那臺數據庫機器，就快不少，不會出現前面的每執行1條sql就卡一次殼的狀況。 
初步分析，我就想到多是網絡緣由， 機房兩臺機器鏈接不順暢通， 程序和機器差的緣由基本能夠排除， 機房的tomcat機比咱們開發機要強多了， 並且程序在他的機器上運行又沒有問題。因而我就勸他到機房去檢查一下網絡狀態， 但他一時也沒法進入，由於機房的管理人員不在。 
過了一會， 他告訴我問題解決了， 把數據庫訪問的url更換成了oci方式就行了， oci對我來講有些陌生， 我一直是用的thin，也沒想過其餘鏈接方式。對於oci我也只能想到oracle 的client中貌似是有oci什麼的，當時有其餘事情也沒管了。 

今天有意瞭解一下區別，先看看thin和oci的url寫法上的區別： 
jdbc:oracle:thin:@server ip: service 
jdbc:oracle:oci:@service 
看來oci的還更加簡潔，ip能夠省掉不寫了。 

接下來再找找oci和thin的其餘區別，發現有以下解釋： 

引用

Oracle provides four different types of JDBC drivers, for use in different deployment scenarios. The 10.1.0 drivers can access Oracle 8.1.7 and higher. While all Oracle JDBC drivers are similar, some features apply only to JDBC OCI drivers and some apply only to the JDBC Thin driver. 

JDBC OCI client-side driver: This is a JDBC Type 2 driver that uses Java native methods to call entrypoints in an underlying C library. That C library, called OCI (Oracle Call Interface), interacts with an Oracle database. The JDBC OCI driver requires an Oracle client installation of the same version as the driver. 

The use of native methods makes the JDBC OCI driver platform specific. Oracle supports Solaris, Windows, and many other platforms. This means that the Oracle JDBC OCI driver is not appropriate for Java applets, because it depends on a C library. 

Starting from 10.1.0, the JDBC OCI driver is available for install with the OCI Instant Client feature, which does not require a complete Oracle client-installation. Please refer to Oracle Call Interface for more information. 

JDBC Thin client-side driver: This is a JDBC Type 4 driver that uses Java to connect directly to Oracle. It implements Oracle's SQL*Net Net8 and TTC adapters using its own TCP/IP based Java socket implementation. The JDBC Thin driver does not require Oracle client software to be installed, but does require the server to be configured with a TCP/IP listener. 

Because it is written entirely in Java, this driver is platform-independent. The JDBC Thin driver can be downloaded into any browser as part of a Java application. (Note that if running in a client browser, that browser must allow the applet to open a Java socket connection back to the server.) 

JDBC Thin server-side driver: This is another JDBC Type 4 driver that uses Java to connect directly to Oracle. This driver is used internally within the Oracle database. This driver offers the same functionality as the client-side JDBC Thin driver (above), but runs inside an Oracle database and is used to access remote databases. 

Because it is written entirely in Java, this driver is platform-independent. There is no difference in your code between using the Thin driver from a client application or from inside a server. 

鏈接方式有如下幾種： 

Oralce provides four types of JDBC driver. 

Thin Driver, a 100% Java driver for client-side use without an Oracle installation, particularly with applets. The Thin driver type is thin. To connect user scott with password tiger to a database with SID (system identifier) orcl through port 1521 of host myhost, using the Thin driver, you would write : 
Connection conn = DriverManager.getConnection 
("jdbc:oracle:thin:@myhost:1521:orcl", "scott", "tiger"); 

OCI Driver for client-side use with an Oracle client installation. The OCI driver type is oci. To connect user scott with password tiger to a database with SID (system identifier) orcl through port 1521 of host myhost, using the OCI driver, you would write : 
Connection conn = DriverManager.getConnection 
("jdbc:oracle:oci:@myhost:1521:orcl", "scott", "tiger"); 

Note that you can also specify the database by a TNSNAMES entry. You can find the available TNSNAMES entries listed in the file tnsnames.ora on the client computer from which you are connecting. For example, if you want to connect to the database on host myhost as user scott with password tiger that has a TNSNAMES entry of MyHostString, enter: 
Connection conn = DriverManager.getConnection 
("jdbc:oracle:oci8:@MyHostString","scott","tiger"); 

If your JDBC client and Oracle server are running on the same machine, the OCI driver can use IPC (InterProcess Communication) to connect to the database instead of a network connection. An IPC connection is much faster than a network connection. 
Connection conn = DriverManager.getConnection 
("jdbc:oracle:oci8:@","scott","tiger"); 

Server-Side Thin Driver, which is functionally the same as the client-side Thin driver, but is for code that runs inside an Oracle server and needs to access a remote server, including middle-tier scenarios. The Server-Side Thin driver type is thin and there is no difference in your code between using the Thin driver from a client application or from inside a server. 
Server-Side Internal Driver for code that runs inside the target server, that is, inside the Oracle server that it must access. The Server-Side Internal driver type is kprb and it actually runs within a default session. You are already "connected". Therefore the connection should never be closed. 
To access the default connection, write: 
DriverManager.getConnection("jdbc:oracle:kprb:"); 
or: 
DriverManager.getConnection("jdbc:default:connection:"); 

You can also use the Oracle-specific defaultConnection() method of the OracleDriver class which is generally recommended: 
OracleDriver ora = new OracleDriver(); 
Connection conn = ora.defaultConnection(); 

Note: You are no longer required to register the OracleDriver class for connecting with the Server-Side Internal driver, although there is no harm in doing so. This is true whether you are using getConnection() or defaultConnection() to make the connection. 
Any user name or password you include in the URL string is ignored in connecting to the server default connection. The DriverManager.getConnection() method returns a new Java Connection object every time you call it. Note that although the method is not creating a new physical connection (only a single implicit connection is used), it is returning a new object. 
Again, when JDBC code is running inside the target server, the connection is an implicit data channel, not an explicit connection instance as from a client. It should never be closed. 

這下基本明白了 
1）從使用上來講，oci必須在客戶機上安裝oracle客戶端或才能鏈接，而thin就不須要，所以從使用上來說thin仍是更加方便，這也是thin比較常見的緣由。 
2）原理上來看，thin是純java實現tcp/ip的c/s通信；而oci方式,客戶端經過native java method調用c library訪問服務端，而這個c library就是oci(oracle called interface)，所以這個oci老是須要隨着oracle客戶端安裝（從oracle10.1.0開始，單獨提供OCI Instant Client，不用再完整的安裝client） 
3）它們分別是不一樣的驅動類別，oci是二類驅動， thin是四類驅動，但它們在功能上並沒有差別。 
4）雖然不少人說oci的速度快於thin，但找了半天沒有找到相關的測試報告。