A. hibernate 事務是否支持分布式事務，spring託管hibernate是怎麼支持分布式事務
Spring分布式事務實現
分布式事務是指操作多個資料庫之間的事務，spring的org.springframework.transaction.jta.JtaTransactionManager，提供了分布式事務支持。
一、使用JOTM例子
(1)、Dao及實現
publicinterfaceGenericDao{
publicintsave(Stringds,Stringsql,Object[]obj)throwsException;
publicintfindRowCount(Stringds,Stringsql);
}{
;
;
publicvoidsetJdbcTemplateA(JdbcTemplatejdbcTemplate){
this.jdbcTemplateA=jdbcTemplate;
}
publicvoidsetJdbcTemplateB(JdbcTemplatejdbcTemplate){
this.jdbcTemplateB=jdbcTemplate;
}
publicintsave(Stringds,Stringsql,Object[]obj)throwsException{
if(null==ds||"".equals(ds))return-1;
try{
if(ds.equals("A")){
returnthis.jdbcTemplateA.update(sql,obj);
}else{
returnthis.jdbcTemplateB.update(sql,obj);
}
}catch(Exceptione){
e.printStackTrace();
thrownewException("執行"+ds+"資料庫時失敗！");
}
}
publicintfindRowCount(Stringds,Stringsql){
if(null==ds||"".equals(ds))return-1;
if(ds.equals("A")){
returnthis.jdbcTemplateA.queryForInt(sql);
}else{
returnthis.jdbcTemplateB.queryForInt(sql);
}
}
}
(2)、Service及實現
publicinterfaceUserService{
publicvoidsaveUser()throwsException;
}{
privateGenericDaogenericDao;
publicvoidsetGenericDao(GenericDaogenericDao){
this.genericDao=genericDao;
}
publicvoidsaveUser()throwsException{
StringuserName="user_"+Math.round(Math.random()*10000);
System.out.println(userName);
StringBuildersql=newStringBuilder();
sql.append("insertintot_user(username,gender)values(?,?);");
Object[]objs=newObject[]{userName,"1"};
genericDao.save("A",sql.toString(),objs);
sql.delete(0,sql.length());
sql.append("insertintot_user(name,sex)values(?,?);");
objs=newObject[]{userName,"男的"};//值超出范圍
genericDao.save("B",sql.toString(),objs);
}
}
(3)、applicationContext-jotm.xml
<?xmlversion="1.0"encoding="UTF-8"?>
<beansxmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xmlns:aop="http://www.springframework.org/schema/aop"
xmlns:tx="http://www.springframework.org/schema/tx"
xsi:schemaLocation="http://www.springframework.org/schema/beanshttp://www.springframework.org/schema/beans/spring-beans-2.5.xsd
http://www.springframework.org/schema/contexthttp://www.springframework.org/schema/context/spring-context-2.5.xsd
http://www.springframework.org/schema/txhttp://www.springframework.org/schema/tx/spring-tx-2.5.xsd
http://www.springframework.org/schema/aophttp://www.springframework.org/schema/aop/spring-aop-2.5.xsd">
<description>springJTA</description>
<!--指定Spring配置中用到的屬性文件-->
<beanid="propertyConfig"
class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer">
<propertyname="locations">
<list>
<value>classpath:jdbc.properties</value>
</list>
</property>
</bean>
<!--JOTM實例-->
<beanid="jotm"class="org.springframework.transaction.jta.JotmFactoryBean">
<propertyname="defaultTimeout"value="500000"/>
</bean>
<!--JTA事務管理器-->
<beanid="jtaTransactionManager"class="org.springframework.transaction.jta.JtaTransactionManager">
<propertyname="userTransaction"ref="jotm"/>
</bean>
<!--數據源A-->
<beanid="dataSourceA"class="org.enhydra.jdbc.pool.StandardXAPoolDataSource"destroy-method="shutdown">
<propertyname="dataSource">
<beanclass="org.enhydra.jdbc.standard.StandardXADataSource"destroy-method="shutdown">
<propertyname="transactionManager"ref="jotm"/>
<propertyname="driverName"value="${jdbc.driver}"/>
<propertyname="url"value="${jdbc.url}"/>
</bean>
</property>
<propertyname="user"value="${jdbc.username}"/>
<propertyname="password"value="${jdbc.password}"/>
</bean>
<!--數據源B-->
<beanid="dataSourceB"class="org.enhydra.jdbc.pool.StandardXAPoolDataSource"destroy-method="shutdown">
<propertyname="dataSource">
<beanclass="org.enhydra.jdbc.standard.StandardXADataSource"destroy-method="shutdown">
<propertyname="transactionManager"ref="jotm"/>
<propertyname="driverName"value="${jdbc2.driver}"/>
<propertyname="url"value="${jdbc2.url}"/>
</bean>
</property>
<propertyname="user"value="${jdbc2.username}"/>
<propertyname="password"value="${jdbc2.password}"/>
</bean>
<beanid="jdbcTemplateA"
class="org.springframework.jdbc.core.JdbcTemplate">
<propertyname="dataSource"ref="dataSourceA"/>
</bean>
<beanid="jdbcTemplateB"
class="org.springframework.jdbc.core.JdbcTemplate">
<propertyname="dataSource"ref="dataSourceB"/>
</bean>
<!--事務切面配置-->
<aop:config>
<aop:pointcutid="pointCut"
expression="execution(*com.logcd.service..*.*(..))"/><!--包及其子包下的所有方法-->
<aop:advisorpointcut-ref="pointCut"advice-ref="txAdvice"/>
<aop:advisorpointcut="execution(**..common.service..*.*(..))"advice-ref="txAdvice"/>
</aop:config>
<!--通知配置-->
<tx:adviceid="txAdvice"transaction-manager="jtaTransactionManager">
<tx:attributes>
<tx:methodname="delete*"rollback-for="Exception"/>
<tx:methodname="save*"rollback-for="Exception"/>
<tx:methodname="update*"rollback-for="Exception"/>
<tx:methodname="find*"read-only="true"rollback-for="Exception"/>
</tx:attributes>
</tx:advice>
<beanid="genericDao"
class="com.logcd..impl.GenericDaoImpl"autowire="byName">
</bean>
<beanid="userService"
class="com.logcd.service.impl.UserServiceImpl"autowire="byName">
</bean>
</beans>
(4)、測試
publicclassTestUserService{
;
@BeforeClass
publicstaticvoidinit(){
ApplicationContextapp=("applicationContext-jotm.xml");
userService=(UserService)app.getBean("userService");
}
@Test
publicvoidsave(){
System.out.println("begin...");
try{
userService.saveUser();
}catch(Exceptione){
System.out.println(e.getMessage());
}
System.out.println("finish...");
}
}
B. SpringHibernate（spring_sh_jotm(跨資料庫事務管理)分布式資料庫事務處理的源碼（帶jar包和sql腳本）
我不太清楚你那個矩陣A到底表示什麼。
但你現在就把這些敲進去，正確啊。（A只是我假設的一個隨機矩陣）
A=rand(100,100)*50;
type=4;as=5;cd=6;cr=7;cu=8;hg=9;ni=10;pb=11;zn=12;
x=A(:,1);y=A(:,2);z=A(:,3);
As=A(:,as);Cd=A(:,cd);Cr=A(:,cr);Cu=A(:,cu);Hg=A(:,hg);Ni=A(:,ni);Pb=A(:,pb);Zn=A(:,zn);
C. java的框架spring如何配置分布式事務
分布式事務本身不是程序做的，我們不需要在代碼中明確地做這些事，因為是不是分布式對於代碼來說，代碼寫起來完全相同。
只是選擇支持 JTA XA （也叫 2-Phase Commit, 2PC) 的數據源就可以了，你默認使用的 DataSource 可能不是 XA ( Weblogic 把它叫 TX）。
一般在網站編程時多數人可能是用 Spring 搭配 tomcat commons-dbcp 那個數據源，那個可能就不是支持 XA 的數據源，如果你打算在復雜企業應用生態系統中使用J2EE 就不要用 Spring 提供 commonbs-dbcp 那種小作坊式的做法，因為它是假設自己的程序就是獨立生態系統，當你需要與外界打交道時就碰到諸多問題，這也是為什麼很多大企業依然還是會使用 EJB 的原因（EJB 已經考慮到這點，並把它寫入到J2EE 標准中），我們推薦用伺服器自己的數據源，也就是 lookup JNDI，這樣的話，是不是 XA 事務就由伺服器的配置來定製，代碼就不需要任何配置來決定是不是 XA 了 ；事務本身是不是 XA (分布式的）是伺服器的事，伺服器來管理「資源」 （包括數據源，JMS 連接等，一個資源（JDBC連接）如何參與事務是「資源管理器」（驅動程序）的職責，跟程序無關），伺服器提供事務管理並作為「事務協調者」來處理多個「資源管理器」（不同的資料庫連接）之間的事務一致性，，而 Spring 的職責很簡單，對於我們希望 Spring 自動提交或回滾事務時，在配置中指定需要回滾的異常的類型。
不過我沒有實際使用過 Spring，我有多年的 EJB 經驗，這其中的原理是相同的，因為這是 J2EE 標准規范要求達到的。
D. 如何使用MongoDB+Springboot實現分布式ID
MongoDB的ObjectId設計成輕量型的，不同的機器都能用全局唯一的同種方法方便地生成它。MongoDB 從一開始就設計用來作為分布式資料庫，處理多個節點是一個核心要求。使其在分片環境中要容易生成得多。
它的格式：
mongo.png
前4 個位元組是從標准紀元開始的時間戳，單位為秒。時間戳，與隨後的5 個位元組組合起來，提供了秒級別的唯一性。由於時間戳在前，這意味著ObjectId 大致會按照插入的順序排列。這對於某些方面很有用，如將其作為索引提高效率。這4 個位元組也隱含了文檔創建的時間。絕大多數客戶端類庫都會公開一個方法從ObjectId 獲取這個信息。
接下來的3 位元組是所在主機的唯一標識符。通常是機器主機名的散列值。這樣就可以確保不同主機生成不同的ObjectId，不產生沖突。
為了確保在同一台機器上並發的多個進程產生的ObjectId 是唯一的，接下來的兩位元組來自產生ObjectId 的進程標識符（PID）。
前9 位元組保證了同一秒鍾不同機器不同進程產生的ObjectId 是唯一的。
後3 位元組就是一個自動增加的計數器，確保相同進程同一秒產生的ObjectId 也是不一樣的。同一秒鍾最多允許每個進程擁有2563（16 777 216）個不同的ObjectId。
E. java中Spring是什麼
1.1.1 Spring是什麼
Spring是一個開源的輕量級Java SE（Java 標准版本）/Java EE（Java
企業版本）開發應用框架，其目的是用於簡化企業級應用程序開發。應用程序是由一組相互協作的對象組成。而在傳統應用程序開發中，一個完整的應用是由一組相互協作的對象組成。所以開發一個應用除了要開發業務邏輯之外，最多的是關注如何使這些對象協作來完成所需功能，而且要低耦合、高內聚。業務邏輯開發是不可避免的，那如果有個框架出來幫我們來創建對象及管理這些對象之間的依賴關系。可能有人說了，比如「抽象工廠、工廠方法設計模式」不也可以幫我們創建對象，「生成器模式」幫我們處理對象間的依賴關系，不也能完成這些功能嗎？可是這些又需要我們創建另一些工廠類、生成器類，我們又要而外管理這些類，增加了我們的負擔，如果能有種通過配置方式來創建對象，管理對象之間依賴關系，我們不需要通過工廠和生成器來創建及管理對象之間的依賴關系，這樣我們是不是減少了許多工作，加速了開發，能節省出很多時間來干其他事。Spring框架剛出來時主要就是來完成這個功能。
Spring框架除了幫我們管理對象及其依賴關系，還提供像通用日誌記錄、性能統計、安全控制、異常處理等面向切面的能力，還能幫我管理最頭疼的資料庫事務，本身提供了一套簡單的JDBC訪問實現，提供與第三方數據訪問框架集成（如Hibernate、JPA），與各種Java
EE技術整合（如Java Mail、任務調度等等），提供一套自己的web層框架Spring
MVC、而且還能非常簡單的與第三方web框架集成。從這里我們可以認為Spring是一個超級粘合平台，除了自己提供功能外，還提供粘合其他技術和框架的能力，從而使我們可以更自由的選擇到底使用什麼技術進行開發。而且不管是JAVA
SE（C/S架構）應用程序還是JAVA EE（B/S架構）應用程序都可以使用這個平台進行開發。讓我們來深入看一下Spring到底能幫我們做些什麼？
1.1.2 Spring能幫我們做什麼
Spring除了不能幫我們寫業務邏輯，其餘的幾乎什麼都能幫助我們簡化開發：
一、傳統程序開發，創建對象及組裝對象間依賴關系由我們在程序內部進行控制，這樣會加大各個對象間的耦合，如果我們要修改對象間的依賴關系就必須修改源代碼，重新編譯、部署；而如果採用Spring，則由Spring根據配置文件來進行創建及組裝對象間依賴關系，只需要改配置文件即可，無需重新編譯。所以，Spring能幫我們根據配置文件創建及組裝對象之間的依賴關系。
二、當我們要進行一些日誌記錄、許可權控制、性能統計等時，在傳統應用程序當中我們可能在需要的對象或方法中進行，而且比如許可權控制、性能統計大部分是重復的，這樣代碼中就存在大量重復代碼，即使有人說我把通用部分提取出來，那必然存在調用還是存在重復，像性能統計我們可能只是在必要時才進行，在診斷完畢後要刪除這些代碼；還有日誌記錄，比如記錄一些方法訪問日誌、數據訪問日誌等等，這些都會滲透到各個要訪問方法中；還有許可權控制，必須在方法執行開始進行審核，想想這些是多麼可怕而且是多麼無聊的工作。如果採用Spring，這些日誌記錄、許可權控制、性能統計從業務邏輯中分離出來，通過Spring支持的面向切面編程，在需要這些功能的地方動態添加這些功能，無需滲透到各個需要的方法或對象中；有人可能說了，我們可以使用「代理設計模式」或「包裝器設計模式」，你可以使用這些，但還是需要通過編程方式來創建代理對象，還是要耦合這些代理對象，而採用Spring
面向切面編程能提供一種更好的方式來完成上述功能，一般通過配置方式，而且不需要在現有代碼中添加任何額外代碼，現有代碼專注業務邏輯。所以，Spring
面向切面編程能幫助我們無耦合的實現日誌記錄，性能統計，安全控制。
三、在傳統應用程序當中，我們如何來完成資料庫事務管理？需要一系列「獲取連接，執行SQL，提交或回滾事務，關閉連接」，而且還要保證在最後一定要關閉連接，多麼可怕的事情，而且也很無聊；如果採用Spring，我們只需獲取連接，執行SQL，其他的都交給Spring來管理了，簡單吧。所以，Spring能非常簡單的幫我們管理資料庫事務。
四、Spring還提供了與第三方數據訪問框架（如Hibernate、JPA）無縫集成，而且自己也提供了一套JDBC訪問模板，來方便資料庫訪問。
五、Spring還提供與第三方Web（如Struts、JSF）框架無縫集成，而且自己也提供了一套Spring MVC框架，來方便web層搭建。
六、Spring能方便的與Java EE（如Java Mail、任務調度）整合，與更多技術整合（比如緩存框架）。
Spring能幫我們做這么多事情，提供這么多功能和與那麼多主流技術整合，而且是幫我們做了開發中比較頭疼和困難的事情，那可能有人會問，難道只有Spring這一個框架，沒有其他選擇？當然有，比如EJB需要依賴應用伺服器、開發效率低、在開發中小型項目是宰雞拿牛刀，雖然發展到現在EJB比較好用了，但還是比較笨重還需要依賴應用伺服器等。那為何需要使用Spring，而不是其他框架呢？讓我們接著往下看。
1.1.3 為何需要Spring
一 首先闡述幾個概念
1、應用程序：是能完成我們所需要功能的成品，比如購物網站、OA系統。
2、框架：是能完成一定功能的半成品，比如我們可以使用框架進行購物網站開發；框架做一部分功能，我們自己做一部分功能，這樣應用程序就創建出來了。而且框架規定了你在開發應用程序時的整體架構，提供了一些基礎功能，還規定了類和對象的如何創建、如何協作等，從而簡化我們開發，讓我們專注於業務邏輯開發。
3、非侵入式設計：從框架角度可以這樣理解，無需繼承框架提供的類，這種設計就可以看作是非侵入式設計，如果繼承了這些框架類，就是侵入設計，如果以後想更換框架之前寫過的代碼幾乎無法重用，如果非侵入式設計則之前寫過的代碼仍然可以繼續使用。
4、輕量級及重量級：輕量級是相對於重量級而言的，輕量級一般就是非入侵性的、所依賴的東西非常少、資源佔用非常少、部署簡單等等，其實就是比較容易使用，而重量級正好相反。
5、POJO：POJO（Plain Old Java
Objects）簡單的Java對象，它可以包含業務邏輯或持久化邏輯，但不擔當任何特殊角色且不繼承或不實現任何其它Java框架的類或介面。
6、容器：在日常生活中容器就是一種盛放東西的器具，從程序設計角度看就是裝對象的的對象，因為存在放入、拿出等操作，所以容器還要管理對象的生命周期。
7、控制反轉：即Inversion of Control，縮寫為IoC，控制反轉還有一個名字叫做依賴注入（Dependency
Injection），就是由容器控製程序之間的關系，而非傳統實現中，由程序代碼直接操控。
8、Bean：一般指容器管理對象，在Spring中指Spring IoC容器管理對象。
二
為什麼需要Spring及Spring的優點
●
非常輕量級的容器：以集中的、自動化的方式進行應用程序對象創建和裝配，負責對象創建和裝配，管理對象生命周期，能組合成復雜的應用程序。Spring容器是非侵入式的（不需要依賴任何Spring特定類），而且完全採用POJOs進行開發，使應用程序更容易測試、更容易管理。而且核心JAR包非常小，Spring3.0.5不到1M，而且不需要依賴任何應用伺服器，可以部署在任何環境（Java
SE或Java EE）。
● AOP：AOP是Aspect Oriented
Programming的縮寫，意思是面向切面編程，提供從另一個角度來考慮程序結構以完善面向對象編程（相對於OOP），即可以通過在編譯期間、裝載期間或運行期間實現在不修改源代碼的情況下給程序動態添加功能的一種技術。通俗點說就是把可重用的功能提取出來，然後將這些通用功能在合適的時候織入到應用程序中；比如安全，日記記錄，這些都是通用的功能，我們可以把它們提取出來，然後在程序執行的合適地方織入這些代碼並執行它們，從而完成需要的功能並復用了這些功能。
●
簡單的資料庫事務管理：在使用資料庫的應用程序當中，自己管理資料庫事務是一項很讓人頭疼的事，而且很容易出現錯誤，Spring支持可插入的事務管理支持，而且無需JEE環境支持，通過Spring管理事務可以把我們從事務管理中解放出來來專注業務邏輯。
●
JDBC抽象及ORM框架支持：Spring使JDBC更加容易使用；提供DAO（數據訪問對象）支持，非常方便集成第三方ORM框架，比如Hibernate等；並且完全支持Spring事務和使用Spring提供的一致的異常體系。
● 靈活的Web層支持：Spring本身提供一套非常強大的MVC框架，而且可以非常容易的與第三方MVC框架集成，比如Struts等。
● 簡化各種技術集成：提供對Java Mail、任務調度、JMX、JMS、JNDI、EJB、動態語言、遠程訪問、Web Service等的集成。
Spring能幫助我們簡化應用程序開發，幫助我們創建和組裝對象，為我們管理事務，簡單的MVC框架，可以把Spring看作是一個超級粘合平台，能把很多技術整合在一起，形成一個整體，使系統結構更優良、性能更出眾，從而加速我們程序開發，有如上優點，我們沒有理由不考慮使用它。
1.1.4 如何學好Spring
要學好Spring，首先要明確Spring是個什麼東西，能幫我們做些什麼事情，知道了這些然後做個簡單的例子，這樣就基本知道怎麼使用Spring了。Spring核心是IoC容器，所以一定要透徹理解什麼是IoC容器，以及如何配置及使用容器，其他所有技術都是基於容器實現的；理解好IoC後，接下來是面向切面編程，首先還是明確概念，基本配置，最後是實現原理，接下來就是資料庫事務管理，其實Spring管理事務是通過面向切面編程實現的，所以基礎很重要，IoC容器和面向切面編程搞定後，其餘都是基於這倆東西的實現，學起來就更加輕鬆了。要學好Spring不能急，一定要把基礎打牢，基礎牢固了，這就是磨刀不誤砍柴工。
1.2 Spring基礎
1.2.1 Spring架構圖
圖 1-1 Spring架構圖
核心容器：包括Core、Beans、Context、EL模塊。
●
Core模塊：封裝了框架依賴的最底層部分，包括資源訪問、類型轉換及一些常用工具類。
●
Beans模塊：提供了框架的基礎部分，包括反轉控制和依賴注入。其中Bean
Factory是容器核心，本質是「工廠設計模式」的實現，而且無需編程實現「單例設計模式」，單例完全由容器控制，而且提倡面向介面編程，而非面向實現編程；所有應用程序對象及對象間關系由框架管理，從而真正把你從程序邏輯中把維護對象之間的依賴關系提取出來，所有這些依賴關系都由BeanFactory來維護。
● Context模塊：以Core和Beans為基礎，集成Beans模塊功能並添加資源綁定、數據驗證、國際化、Java
EE支持、容器生命周期、事件傳播等；核心介面是ApplicationContext。
●
EL模塊：提供強大的表達式語言支持，支持訪問和修改屬性值，方法調用，支持訪問及修改數組、容器和索引器，命名變數，支持算數和邏輯運算，支持從Spring
容器獲取Bean，它也支持列表投影、選擇和一般的列表聚合等。
AOP、Aspects模塊：
● AOP模塊：Spring
AOP模塊提供了符合 AOP Alliance規范的面向方面的編程（aspect-oriented
programming）實現，提供比如日誌記錄、許可權控制、性能統計等通用功能和業務邏輯分離的技術，並且能動態的把這些功能添加到需要的代碼中；這樣各專其職，降低業務邏輯和通用功能的耦合。
● Aspects模塊：提供了對AspectJ的集成，AspectJ提供了比Spring ASP更強大的功能。
數據訪問/集成模塊：該模塊包括了JDBC、ORM、OXM、JMS和事務管理。
●
事務模塊：該模塊用於Spring管理事務，只要是Spring管理對象都能得到Spring管理事務的好處，無需在代碼中進行事務控制了，而且支持編程和聲明性的事物管理。
●
JDBC模塊：提供了一個JBDC的樣例模板，使用這些模板能消除傳統冗長的JDBC編碼還有必須的事務控制，而且能享受到Spring管理事務的好處。
●
ORM模塊：提供與流行的「對象-關系」映射框架的無縫集成，包括Hibernate、JPA、Ibatiss等。而且可以使用Spring事務管理，無需額外控制事務。
●
OXM模塊：提供了一個對Object/XML映射實現，將java對象映射成XML數據，或者將XML數據映射成java對象，Object/XML映射實現包括JAXB、Castor、XMLBeans和XStream。
● JMS模塊：用於JMS(Java Messaging Service)，提供一套
「消息生產者、消息消費者」模板用於更加簡單的使用JMS，JMS用於用於在兩個應用程序之間，或分布式系統中發送消息，進行非同步通信。
●
Web/Remoting模塊：Web/Remoting模塊包含了Web、Web-Servlet、Web-Struts、Web-Porlet模塊。
● Web模塊：提供了基礎的web功能。例如多文件上傳、集成IoC容器、遠程過程訪問（RMI、Hessian、Burlap）以及Web
Service支持，並提供一個RestTemplate類來提供方便的Restful services訪問。
●
Web-Servlet模塊：提供了一個Spring MVC Web框架實現。Spring
MVC框架提供了基於註解的請求資源注入、更簡單的數據綁定、數據驗證等及一套非常易用的JSP標簽，完全無縫與Spring其他技術協作。
●
Web-Struts模塊：提供了與Struts無縫集成，Struts1.x 和Struts2.x都支持
Test模塊：
Spring支持Junit和TestNG測試框架，而且還額外提供了一些基於Spring的測試功能，比如在測試Web框架時，模擬Http請求的功能。
1.2.2 典型應用場景
Spring可以應用到許多場景，從最簡單的標准Java
SE程序到企業級應用程序都能使用Spring來構建。以下介紹幾個比較流行的應用場景：
● 典型Web應用程序應用場景：
圖1-2 web應用程序應用場景
在Web應用程序應用場景中，典型的三層架構：數據模型層實現域對象；數據訪問層實現數據訪問；邏輯層實現業務邏輯；web層提供頁面展示；所有這些層組件都由Spring進行管理，享受到Spring事務管理、AOP等好處，而且請求唯一入口就是DispachterServlet，它通過把請求映射為相應web層組件來實現相應請求功能。
● 遠程訪問應用場景：
Spring能非常方便的提供暴露RMI服務，遠程訪問服務如Hessian、Burlap等，實現非常簡單只需通過在Spring中配置相應的地址及需要暴露的服務即可輕松實現，後邊會有介紹；
● EJB應用場景：
Spring也可以與EJB輕松集成，後邊會詳細介紹。
F. spring-data-jpa支持分布式資料庫嗎
JPA(Java Persistence API)是Sun官方提出的Java持久化規范。它為Java開發人員提供了一種對象/關聯映射工具來管理Java應用中的關系數據。他的出現主要是為了簡化現有的持久化開發工作和整合ORM技術，結束現在Hibernate，TopLink，JDO等ORM框架各自為營的局面。值得注意的是，JPA是在充分吸收了現有Hibernate，TopLink，JDO等ORM框架的基礎上發展而來的，具有易於使用，伸縮性強等優點。從目前的開發社區的反應上看，JPA受到了極大的支持和贊揚，其中就包括了Spring與EJB3.0的開發團隊。
G. 如何利用Spring Cloud構建起自我修復型分布式系統
Spring Cloud項目的既定目標在於為Spring開發人員提供一整套易於使用的工具集，從而保證其輕松構建起自己需要的分布式系統方案。為了實現這一目標，Spring Cloud以Netflix OSS堆棧為基礎將大量實現堆棧加以整合並打包。這些堆棧而後可以通過大家所熟知的各類基於注釋的配置工具、Java配置工具以及基於模板的編程工具實現交付。下面就讓我們一起了解Spring Cloud當中的幾類常見組件。 Spring Cloud Config Server Spring Cloud Config Server能夠提供一項具備橫向擴展能力的集中式配置服務。它所使用的數據被保存在一套可插拔庫層當中，後者目前能夠支持本地存儲、Git以及Subversion。通過利用一套版本控制系統作為配置存儲方案，開發人員能夠輕松實現版本與審計配置的內容調整。 如何利用Spring Cloud構建起自我修復型分布式系統 配置內容會以Java屬性或者YAML文件的形式體現。該Config Server會將這些文件合並為環境對象，其中包含易於理解的Spring屬性模型以及作為REST API存在的配置文件。任何應用程序都能夠直接調用該REST API當中所包含的配置數據，但我們也可以將智能客戶端綁定方案添加到Spring Boot應用程序當中，並由後者自動將接收自Config Server的配置信息分配至任意本地配置當中。 Spring Cloud Bus Spring Cloud Config Server是一套強大的配置分發機制，能夠在保障一致性的前提下將配置內容分發到多個應用程序實例當中。然而根據其設計思路的限定，我們目前只能在應用程序啟動時對其配置進行更新。在向Git中的某一屬性發送新值時，我們需要以手動方式重啟每個應用程序進程，從而保證該值被切實納入應用當中。很明顯，大家需要能夠在無需重啟的前提下完成對應用程序配置內容的更新工作。 如何利用Spring Cloud構建起自我修復型分布式系統 Spring Cloud Bus的任務正是為應用程序實例添加一套管理背板。它目前依靠將一套客戶端綁定至一組AMQP交換與隊列當中來實現，但這一後端在設計上也實現了可插拔特性。Spring Cloud Bus為我們的應用程序帶來了更多管理端點。在圖二中，我們可以看到一個面向greeting屬性的值被發送至Git當中，而後一條請求被發送至應用A中的/bus/refresh端點。該請求會觸發以下三個事件： 應用A從Config Server處請求獲取最新版本的配置內容。任意註明了@RefreshScope的Spring Bean都會被重新初始化並載入新的配置內容。 應用A向AMQP交換機制發送一條消息，表明其已經收到更新指示。 通過監聽AMQP隊列而被納入Cloud Bus的應用B與應用C會獲取到上述消息，並以與應用A同樣的方式實現配置更新。 現在我們已經有能力在無需重啟的情況下對應用程序配置進行更新了。
H. 如何實現XA式，非XA式Spring分布式事務
Java Transaction API和XA協議是Spring常用的分布式事務機制，不過你可以選擇選擇其他的實現方式。理想的實現取決於你的應用程序使用何種資源，你願意在性能、安全、系統穩健性、數據完整方面做出何種權衡。在這次JavaWorld大會上，來自SpringSource的David Syer跟大家分享了Spring應用的幾種事務處理機制、三種XA式、四種非XA式事務協議。
Spring框架支持Java Transaction API（JTA），這樣應用就可以脫離Java EE容器，轉而利用分布式事務以及XA協議。然而即使有這樣的支持，XA開銷是昂貴的，不穩定而且笨重不利於管理，不過一些其他的應用可以避免使用XA協議。
為了讓大家對所涉及的幾種分布式事務有所了解，我會分析七種事務處理模式，並 給出具體代碼實現。並且從安全或者穩定性入手倒序展示，可以看看從安全、穩定性出發，如何在一般場景下，保障數據高完整性和原子性。當然隨著話題的深入， 更多的說明以及限制就會出現。模式也可以從運行時開銷倒序展示。考慮到所有模式都是結構化或者學術性的，這一點有別於業務模型，因此我不打算展開業務用例 分析，僅僅關注每種模式其少部分代碼如何工作的。
盡管只有起初的三種模式涉及到 XA協議，不過從性能角度出發，這些模式或許無法滿足需求。考慮到這些模式無處不在，我不想做過多地擴展，只是對第一種模式做一個簡單的展示。讀完此文，你可以了解可以用分布式事務做些什麼、不能做什麼以及如何、何時避免使用XA，何時必須使用。
回到頂部
分布式事務以及原子性
分布式事務涉及不止一個事務資源。比如，在關系資料庫和消息中間件之間通信的連接器，通常這些資源擁有類似begin()、rollback()、commit()的API。在此，一個事務資源通常是一個工廠產品，這個工廠通常由底層平台提供：以資料庫為例，DataSource提供Connection，或者Java Persistence API(JPA)的EntityManager介面；又如Java Message Service(JMS)提供的Session。