使用castle的自动事务控制

直接使用castle的事务控制需要如下几步

1. 配置文件中要求isTransactional="true" 属性,如

xml 代码

1. <component id="Test" service="wygl.service.test.ITest, wygl.service" 
2. type="wygl.service.test.TestImpl, wygl.service" lifestyle="Singleton" 
3. isTransactional="true" />  

2. 必须在容器中注册TransactionFacility ,配置文件片段如下

xml 代码

1. <facility id="transaction" 
2. type="Castle.Facilities.AutomaticTransactionManagement.TransactionFacility, 
3. Castle.Facilities.AutomaticTransactionManagement">facility>  

3. 必须在容其中注册一个实现 Castle.Services.Transaction.ITransactionManager 接口的组件,下面时castle源码中的一个实现

c# 代码

1. // Copyright 2004-2006 Castle Project - http://www.castleproject.org/   
2. //    
3. // Licensed under the Apache License, Version 2.0 (the "License");   
4. // you may not use this file except in compliance with the License.   
5. // You may obtain a copy of the License at   
6. //    
7. //     http://www.apache.org/licenses/LICENSE-2.0   
8. //    
9. // Unless required by applicable law or agreed to in writing, software   
10. // distributed under the License is distributed on an "AS IS" BASIS,   
11. // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.   
12. // See the License for the specific language governing permissions and   
13. // limitations under the License.   
14.   
15. namespace Castle.Services.Transaction   
16. {   
17.     using System;   
18.     using System.Collections;   
19.     using System.ComponentModel;   
20.   
21.     using Castle.Core.Logging;   
22.   
23.     /// <summary></summary>   
24.     /// TODO: Ensure this class is thread-safe   
25.     ///    
26.     public class DefaultTransactionManager : MarshalByRefObject, ITransactionManager   
27.     {   
28.         private static readonly object TransactionCreatedEvent = new object();   
29.         private static readonly object ChildTransactionCreatedEvent = new object();   
30.         private static readonly object TransactionCommittedEvent = new object();   
31.         private static readonly object TransactionRolledbackEvent = new object();   
32.         private static readonly object TransactionDisposedEvent = new object();   
33.   
34.         private EventHandlerList events = new EventHandlerList();   
35.         private ILogger logger = new NullLogger();   
36.         private Stack transactions = new Stack(5);   
37.   
38.         public DefaultTransactionManager()   
39.         {   
40.         }   
41.   
42.         public ILogger Logger   
43.         {   
44.             get { return logger; }   
45.             set { logger = value; }   
46.         }  
47.  
48.         #region MarshalByRefObject   
49.   
50.         public override object InitializeLifetimeService()   
51.         {   
52.             return null;   
53.         }  
54.  
55.         #endregion  
56.  
57.         #region ITransactionManager Members   
58.   
59.         public virtual ITransaction CreateTransaction(TransactionMode transactionMode, IsolationMode isolationMode)   
60.         {   
61.             if (transactionMode == TransactionMode.Unspecified)   
62.             {   
63.                 transactionMode = ObtainDefaultTransactionMode(transactionMode);   
64.             }   
65.   
66.             CheckNotSupportedTransaction(transactionMode);   
67.   
68.             if (CurrentTransaction == null &&    
69.                 (transactionMode == TransactionMode.Supported ||    
70.                  transactionMode == TransactionMode.NotSupported))   
71.             {   
72.                 return null;   
73.             }   
74.   
75.             StandardTransaction transaction = null;   
76.   
77.             if (CurrentTransaction != null)   
78.             {   
79.                 if (transactionMode == TransactionMode.Requires || transactionMode == TransactionMode.Supported)   
80.                 {   
81.                     transaction = (CurrentTransaction as StandardTransaction).CreateChildTransaction();   
82.   
83.                     RaiseChildTransactionCreated(transaction, transactionMode, isolationMode);   
84.   
85.                     logger.Debug("Child Transaction {0} created", transaction.GetHashCode());   
86.                 }   
87.             }   
88.   
89.             if (transaction == null)   
90.             {   
91.                 transaction = new StandardTransaction(   
92.                     new TransactionDelegate(RaiseTransactionCommitted),    
93.                     new TransactionDelegate(RaiseTransactionRolledback) );   
94.   
95.                 RaiseTransactionCreated(transaction, transactionMode, isolationMode);   
96.   
97.                 logger.Debug("Transaction {0} created", transaction.GetHashCode());   
98.             }   
99.   
100.             transaction.Logger = logger.CreateChildLogger( transaction.GetType().FullName );   
101.   
102.             transactions.Push(transaction);   
103.   
104.             return transaction;   
105.         }   
106.   
107.         public event TransactionCreationInfoDelegate TransactionCreated   
108.         {   
109.             add { events.AddHandler(TransactionCreatedEvent, value); }   
110.             remove { events.RemoveHandler(TransactionCreatedEvent, value); }   
111.         }   
112.   
113.         public event TransactionCreationInfoDelegate ChildTransactionCreated   
114.         {   
115.             add { events.AddHandler(ChildTransactionCreatedEvent, value); }   
116.             remove { events.RemoveHandler(ChildTransactionCreatedEvent, value); }   
117.         }   
118.   
119.         public event TransactionDelegate TransactionCommitted   
120.         {   
121.             add { events.AddHandler(TransactionCommittedEvent, value); }   
122.             remove { events.RemoveHandler(TransactionCommittedEvent, value); }   
123.         }   
124.   
125.         public event TransactionDelegate TransactionRolledback   
126.         {   
127.             add { events.AddHandler(TransactionRolledbackEvent, value); }   
128.             remove { events.RemoveHandler(TransactionRolledbackEvent, value); }   
129.         }   
130.   
131.         public event TransactionDelegate TransactionDisposed   
132.         {   
133.             add { events.AddHandler(TransactionDisposedEvent, value); }   
134.             remove { events.RemoveHandler(TransactionDisposedEvent, value); }   
135.         }   
136.   
137.         public virtual ITransaction CurrentTransaction   
138.         {   
139.             get  
140.             {   
141.                 if (transactions.Count == 0)   
142.                 {   
143.                     return null;   
144.                 }   
145.                 return transactions.Peek() as ITransaction;   
146.             }   
147.         }   
148.   
149.         public virtual void Dispose(ITransaction transaction)   
150.         {   
151.             if (transaction == null)   
152.             {   
153.                 throw new ArgumentNullException("transaction", "Tried to dispose a null transaction");   
154.             }   
155.   
156.             lock(transactions)   
157.             {   
158.                 if (CurrentTransaction != transaction)   
159.                 {   
160.                     throw new ArgumentException("transaction", "Tried to dispose a transaction that is not on the current active transaction");   
161.                 }   
162.   
163.                 transactions.Pop();   
164.             }   
165.   
166.             if (transaction is IDisposable)   
167.             {   
168.                 (transaction as IDisposable).Dispose();   
169.             }   
170.   
171.             RaiseTransactionDisposed(transaction);   
172.   
173.             logger.Debug("Transaction {0} disposed successfully", transaction.GetHashCode());   
174.         }  
175.  
176.         #endregion   
177.   
178.         protected void RaiseTransactionCreated(ITransaction transaction, TransactionMode transactionMode, IsolationMode isolationMode)   
179.         {   
180.             TransactionCreationInfoDelegate eventDelegate = (TransactionCreationInfoDelegate) events[TransactionCreatedEvent];   
181.                
182.             if (eventDelegate != null)   
183.             {   
184.                 eventDelegate(transaction, transactionMode, isolationMode);   
185.             }   
186.         }   
187.   
188.         protected void RaiseChildTransactionCreated(ITransaction transaction, TransactionMode transactionMode, IsolationMode isolationMode)   
189.         {   
190.             TransactionCreationInfoDelegate eventDelegate = (TransactionCreationInfoDelegate) events[ChildTransactionCreatedEvent];   
191.                
192.             if (eventDelegate != null)   
193.             {   
194.                 eventDelegate(transaction, transactionMode, isolationMode);   
195.             }   
196.         }   
197.   
198.         protected void RaiseTransactionDisposed(ITransaction transaction)   
199.         {   
200.             TransactionDelegate eventDelegate = (TransactionDelegate) events[TransactionDisposedEvent];   
201.                
202.             if (eventDelegate != null)   
203.             {   
204.                 eventDelegate(transaction);   
205.             }   
206.         }   
207.   
208.         protected void RaiseTransactionCommitted(ITransaction transaction)   
209.         {   
210.             TransactionDelegate eventDelegate = (TransactionDelegate) events[TransactionCommittedEvent];   
211.                
212.             if (eventDelegate != null)   
213.             {   
214.                 eventDelegate(transaction);   
215.             }   
216.         }   
217.   
218.         protected void RaiseTransactionRolledback(ITransaction transaction)   
219.         {   
220.             TransactionDelegate eventDelegate = (TransactionDelegate) events[TransactionRolledbackEvent];   
221.                
222.             if (eventDelegate != null)   
223.             {   
224.                 eventDelegate(transaction);   
225.             }   
226.         }   
227.   
228.         protected virtual TransactionMode ObtainDefaultTransactionMode(TransactionMode transactionMode)   
229.         {   
230.             return TransactionMode.Requires;   
231.         }   
232.   
233.         private void CheckNotSupportedTransaction(TransactionMode transactionMode)   
234.         {   
235.             if (transactionMode == TransactionMode.NotSupported &&    
236.                 CurrentTransaction != null &&    
237.                 CurrentTransaction.Status == TransactionStatus.Active)   
238.             {   
239.                 String message = "There is a transaction active and the transaction mode " +    
240.                     "specified explicit says that no transaction is supported for this context";   
241.   
242.                 logger.Error(message);   
243.   
244.                 throw new TransactionException(message);   
245.             }   
246.         }   
247.     }   
248. }   

4. 需要使用事务控制的类增加属性,例子如下

c# 代码

1. using System;   
2. using System.Collections.Generic;   
3. using System.Text;   
4. using System.Data;   
5. using wygl.db;   
6. using wygl.util;   
7. using wygl.util.Transaction;   
8.   
9. namespace wygl.service.test   
10. {   
11.     [Castle.Services.Transaction.Transactional]   
12.     public class TestImpl : ITest   
13.     {  
14.           
15.         #region ITest 成员   
16.   
17.         [Castle.Services.Transaction.Transaction(Castle.Services.Transaction.TransactionMode.Requires)]   
18.         public virtual string execute()   
19.         {   
20.             string conString = configs.connString;   
21.   
22.             string SQL = "insert into test(name) values ('test') ";   
23.             int count = wygl.db.OleDbHelper.ExecuteNonQuery(conString,CommandType.Text, SQL);   
24.   
25.             SQL = "insert into test1(name) values ('test') ";   
26.             count = wygl.db.OleDbHelper.ExecuteNonQuery(conString, CommandType.Text, SQL);   
27.   
28.             return "ok:" + count.ToString();   
29.         }  
30.  
31.         #endregion   
32.     }   
33. }   

 

感谢   thh  的提醒,以后写东西一定注意,免得误导了大家就不好了,呵呵   

上面的内容忘记写一个核心内容，就是 Castle.Facilities.NHibernateIntegration。如果没有使用Castle.Facilities.NHibernateIntegration.Internal.OpenSession(string alias)中的this.EnlistIfNecessary,那么StandardTransaction里的IResource List 是空的，就不会有任何的事务控制产生。