个人中心
gpt4 book ai didi

利用AOP实现SqlSugar自动事务

转载 作者：qq735679552 更新时间：2022-09-28 22:32:09 26 4
gpt4 key购买 nike

CFSDN坚持开源创造价值，我们致力于搭建一个资源共享平台，让每一个IT人在这里找到属于你的精彩世界.

这篇CFSDN的博客文章利用AOP实现SqlSugar自动事务由作者收集整理，如果你对这篇文章有兴趣，记得点赞哟.

本文实例为大家分享了如何利用AOP实现SqlSugar自动事务，供大家参考，具体内容如下 。

先看一下效果,带接口层的三层架构

BL层:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
public class StudentBL : IStudentService
   {
     private ILogger mLogger;
     private readonly IStudentDA mStudentDa;
     private readonly IValueService mValueService;
 
     public StudentService(IStudentDA studentDa,IValueService valueService)
     {
       mLogger = LogManager.GetCurrentClassLogger();
       mStudentDa = studentDa;
       mValueService = valueService;
 
     }
 
     [TransactionCallHandler]
     public IList<Student> GetStudentList(Hashtable paramsHash)
     {
       var list = mStudentDa.GetStudents(paramsHash);
       var value = mValueService.FindAll();
       return list;
     }
   }

假设GetStudentList方法里的mStudentDa.GetStudents和mValueService.FindAll不是查询操作，而是更新操作，当一个失败另一个需要回滚，就需要在同一个事务里，当一个出现异常就要回滚事务.

特性TransactionCallHandler就表明当前方法需要开启事务，并且当出现异常的时候回滚事务,方法执行完后提交事务.

DA层:

?
1
2
3
4
5
6
7
8
9
10
11
12
13
public class StudentDA : IStudentDA
   {
 
     private SqlSugarClient db;
     public StudentDA()
     {
       db = SugarManager.GetInstance().SqlSugarClient;
     }
     public IList<Student> GetStudents(Hashtable paramsHash)
     {
       return db.Queryable<Student>().AS( "T_Student" ).With(SqlWith.NoLock).ToList();
     }
   }

对SqlSugar做一下包装 。

  。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
public class SugarManager
   {
     private static ConcurrentDictionary< string ,SqlClient> _cache =
       new ConcurrentDictionary< string , SqlClient>();
     private static ThreadLocal< string > _threadLocal;
     private static readonly string _connStr = @"Data Source=localhost;port=3306;Initial Catalog=thy;user id=root;password=xxxxxx;Charset=utf8" ;
     static SugarManager()
     {
       _threadLocal = new ThreadLocal< string >();
     }
 
     private static SqlSugarClient CreatInstance()
     {
       SqlSugarClient client = new SqlSugarClient( new ConnectionConfig()
       {
         ConnectionString = _connStr, //必填
         DbType = DbType.MySql, //必填
         IsAutoCloseConnection = true , //默认false
         InitKeyType = InitKeyType.SystemTable
       });
       var key=Guid.NewGuid().ToString().Replace( "-" , "" );
       if (!_cache.ContainsKey(key))
       {
         _cache.TryAdd(key, new SqlClient(client));
         _threadLocal.Value = key;
         return client;
       }
       throw new Exception( "创建SqlSugarClient失败" );
     }
     public static SqlClient GetInstance()
     {
       var id= _threadLocal.Value;
       if ( string .IsNullOrEmpty(id)||!_cache.ContainsKey(id))
         return new SqlClient(CreatInstance());
       return _cache[id];
     }
 
 
     public static void Release()
     {
       try
       {
         var id = GetId();
         if (!_cache.ContainsKey(id))
           return ;
         Remove(id);
       }
       catch (Exception e)
       {
         throw e;
       }
     }
     private static bool Remove( string id)
     {
       if (!_cache.ContainsKey(id)) return false ;
 
       SqlClient client;
 
       int index = 0;
       bool result = false ;
       while (!(result = _cache.TryRemove(id, out client)))
       {
         index++;
         Thread.Sleep(20);
         if (index > 3) break ;
       }
       return result;
     }
     private static string GetId()
     {
       var id = _threadLocal.Value;
       if ( string .IsNullOrEmpty(id))
       {
         throw new Exception( "内部错误: SqlSugarClient已丢失." );
       }
       return id;
     }
 
     public static void BeginTran()
     {
       var instance=GetInstance();
       //开启事务
       if (!instance.IsBeginTran)
       {
         instance.SqlSugarClient.Ado.BeginTran();
         instance.IsBeginTran = true ;
       }
     }
 
     public static void CommitTran()
     {
       var id = GetId();
       if (!_cache.ContainsKey(id))
         throw new Exception( "内部错误: SqlSugarClient已丢失." );
       if (_cache[id].TranCount == 0)
       {
         _cache[id].SqlSugarClient.Ado.CommitTran();
         _cache[id].IsBeginTran = false ;
       }
     }
 
     public static void RollbackTran()
     {
       var id = GetId();
       if (!_cache.ContainsKey(id))
         throw new Exception( "内部错误: SqlSugarClient已丢失." );
       _cache[id].SqlSugarClient.Ado.RollbackTran();
       _cache[id].IsBeginTran = false ;
       _cache[id].TranCount = 0;
     }
 
     public static void TranCountAddOne()
     {
       var id = GetId();
       if (!_cache.ContainsKey(id))
         throw new Exception( "内部错误: SqlSugarClient已丢失." );
       _cache[id].TranCount++;
     }
     public static void TranCountMunisOne()
     {
       var id = GetId();
       if (!_cache.ContainsKey(id))
         throw new Exception( "内部错误: SqlSugarClient已丢失." );
       _cache[id].TranCount--;
     }
   }

_cache保存SqlSugar实例，_threadLocal确保同一线程下取出的是同一个SqlSugar实例.

不知道SqlSugar判断当前实例是否已经开启事务，所以又将SqlSugar包了一层.

?
1
2
3
4
5
6
7
8
9
10
11
public class SqlClient
   {
     public SqlSugarClient SqlSugarClient;
     public bool IsBeginTran = false ;
     public int TranCount = 0;
 
     public SqlClient(SqlSugarClient sqlSugarClient)
     {
       this .SqlSugarClient = sqlSugarClient;
     }
   }

IsBeginTran标识当前SqlSugar实例是否已经开启事务，TranCount是一个避免事务嵌套的计数器.

一开始的例子 。

?
1
2
3
4
5
6
7
[TransactionCallHandler]
      public IList<Student> GetStudentList(Hashtable paramsHash)
      {
        var list = mStudentDa.GetStudents(paramsHash);
        var value = mValueService.FindAll();
        return list;
      }

TransactionCallHandler表明该方法要开启事务，但是如果mValueService.FindAll也标识了TransactionCallHandler,又要开启一次事务？所以用TranCount做一个计数.

使用Castle.DynamicProxy 。

要实现标识了TransactionCallHandler的方法实现自动事务，使用Castle.DynamicProxy实现BL类的代理 。

Castle.DynamicProxy一般操作 。

  。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
public class MyClass : IMyClass
  {
    public void MyMethod()
    {
      Console.WriteLine( "My Mehod" );
    }
}
public class TestIntercept : IInterceptor
   {
     public void Intercept(IInvocation invocation)
     {
       Console.WriteLine( "before" );
       invocation.Proceed();
       Console.WriteLine( "after" );
     }
   }
 
  var proxyGenerate = new ProxyGenerator();
  TestIntercept t= new TestIntercept();
  var pg = proxyGenerate.CreateClassProxy<MyClass>(t);
  pg.MyMethod();
  //输出是
  //before
  //My Mehod
  //after

before就是要开启事务的地方，after就是提交事务的地方 。

最后实现 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
public class TransactionInterceptor : IInterceptor
   {
     private readonly ILogger logger;
     public TransactionInterceptor()
     {
       logger = LogManager.GetCurrentClassLogger();
     }
     public void Intercept(IInvocation invocation)
     {
       MethodInfo methodInfo = invocation.MethodInvocationTarget;
       if (methodInfo == null )
       {
         methodInfo = invocation.Method;
       }
 
       TransactionCallHandlerAttribute transaction =
         methodInfo.GetCustomAttributes<TransactionCallHandlerAttribute>( true ).FirstOrDefault();
       if (transaction != null )
       {
         SugarManager.BeginTran();
         try
         {
           SugarManager.TranCountAddOne();
           invocation.Proceed();
           SugarManager.TranCountMunisOne();
           SugarManager.CommitTran();
         }
         catch (Exception e)
         {
           SugarManager.RollbackTran();
           logger.Error(e);
           throw e;
         }
 
       }
       else
       {
         invocation.Proceed();
       }
     }
   }
   [AttributeUsage(AttributeTargets.Method, Inherited = true )]
   public class TransactionCallHandlerAttribute : Attribute
   {
     public TransactionCallHandlerAttribute()
     {
 
     }
   }

Autofac与Castle.DynamicProxy结合使用 。

创建代理的时候一个BL类就要一次操作 。

?
1
proxyGenerate.CreateClassProxy<MyClass>(t);

而且项目里BL类的实例化是交给IOC容器控制的，我用的是Autofac。当然Autofac和Castle.DynamicProxy是可以结合使用的 。

?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
using System.Reflection;
using Autofac;
using Autofac.Extras.DynamicProxy;
using Module = Autofac.Module;
public class BusinessModule : Module
   {
     protected override void Load(ContainerBuilder builder)
     {
       var business = Assembly.Load( "FTY.Business" );
       builder.RegisterAssemblyTypes(business)
         .AsImplementedInterfaces().InterceptedBy( typeof (TransactionInterceptor)).EnableInterfaceInterceptors();
       builder.RegisterType<TransactionInterceptor>();
     }
   }

以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持我.

原文链接：http://www.cnblogs.com/jaycewu/archive/2017/10/25/7733114.html 。

最后此篇关于利用AOP实现SqlSugar自动事务的文章就讲到这里了,如果你想了解更多关于利用AOP实现SqlSugar自动事务的内容请搜索CFSDN的文章或继续浏览相关文章，希望大家以后支持我的博客！ 。

26 4 0
文章推荐： NancyFx框架检测任务管理器详解
文章推荐： 一次内核问题引起的 Kubernetes 节点故障解决纪实
文章推荐： 手把手教你如何上传代码到Gitee服务器
文章推荐： C# 判断时间段是否相交的实现方法
qq735679552
个人简介

我是一名优秀的程序员,十分优秀！

滴滴打车优惠券免费领取
滴滴打车优惠券
全站热门文章
Copyright 2021 - 2024 cfsdn All Rights Reserved 蜀ICP备2022000587号
广告合作:1813099741@qq.com 6ren.com