博客园_张艺聍

.Net通用基础框架（.Net Common Infrastructure）-数据访问

2011-03-18T07:35:00Z

IBatis=Internet+aBatis，由于Apache的支持力度不够，项目组在Google Code上另起炉灶，改为MyBatis。和Hibernate相比，IBatis在上手度、系统兼容性、OOA/D要求、Sql监控/优化方面略胜一筹，获得了大多数互联网公司的青睐。唯一不爽的是Java版本很活跃，.Net版本静悄悄。

MyBatisBase基类，支持读写库分离，IBatis在解析Dom时很耗时，实现时做了缓存处理。

using Common.Core;
using IBatisNet.DataMapper;
using IBatisNet.DataMapper.Configuration;
using IBatisNet.DataMapper.SessionStore;

namespace Common.Data
{
/// <summary>
/// MyBatis基类
/// </summary>
/// <typeparam name="T">类型</typeparam>
public abstract class MyBatisBase<T>
{
/// <summary>
/// 读
/// </summary>
public ISqlMapper Reader
{
get;
set;
}

/// <summary>
/// 写
/// </summary>
public ISqlMapper Writer
{
get;
set;
}

/// <summary>
/// 构造函数
/// </summary>
/// <param name="readerName">读名称</param>
/// <param name="writerName">写名称</param>
public MyBatisBase(string readerName, string writerName)
{
this.Reader = ObjectFactory<ISqlMapper>.GetObject(readerName, this.CreateMapper, null);
this.Writer = ObjectFactory<ISqlMapper>.GetObject(writerName, this.CreateMapper, null);
}

/// <summary>
/// 创建映射器
/// </summary>
/// <param name="name">名称</param>
/// <param name="args">参数集合</param>
/// <returns>Sql映射器</returns>
public ISqlMapper CreateMapper(string name, object[] args)
{
ISqlMapper result = null;
DomSqlMapBuilder builder = new DomSqlMapBuilder();
result = builder.Configure(name);
result.SessionStore = new HybridWebThreadSessionStore(result.Id);

return result;
}

/// <summary>
/// 获取声明名称
/// </summary>
/// <param name="name">名称</param>
/// <returns>声明名称</returns>
protected virtual string GetStatementName(string name)
{
return string.Format("{0}.{1}", typeof(T).Namespace, name);
}
}
}

其中用到的对象工厂

using System;
using System.Collections.Generic;
using System.Configuration;
using System.Linq;

namespace Common.Core
{
/// <summary>
/// 对象工厂
/// </summary>
/// <typeparam name="T">类型</typeparam>
public sealed class ObjectFactory<T>
{
private static readonly IDictionary<string, T> objects = new Dictionary<string, T>();
private static readonly object syncLock = new object();

/// <summary>
/// 构造函数
/// </summary>
private ObjectFactory()
{

}

/// <summary>
/// 创建
/// </summary>
/// <param name="typeName">类型名称</param>
/// <param name="args">参数集合</param>
/// <returns>结果</returns>
private static T Create(string typeName, object[] args)
{
return (T)Activator.CreateInstance(Type.GetType(typeName), args);
}

/// <summary>
/// 获取对象
/// </summary>
/// <param name="name">名称</param>
/// <returns>对象</returns>
public static T GetObject(string name)
{
T result = default(T);
string[] parameters = ConfigurationManager.AppSettings[name].Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
if (parameters.Length > 0)
{
string typeName = parameters[0];
object[] args = parameters.Skip<object>(1).ToArray<object>();
result = GetObject(name, typeName, null, args);
}

return result;
}

/// <summary>
/// 获取对象
/// </summary>
/// <param name="name">名称</param>
/// <param name="func">函数</param>
/// <param name="args">参数集合</param>
/// <returns>对象</returns>
public static T GetObject(string name, Func<string, object[], T> func, params object[] args)
{
return GetObject(name, name, func, args);
}

/// <summary>
/// 获取对象
/// </summary>
/// <param name="name">名称</param>
/// <param name="typeName">类型名称</param>
/// <param name="func">函数</param>
/// <param name="args">参数集合</param>
/// <returns>对象</returns>
public static T GetObject(string name, string typeName, Func<string, object[], T> func, params object[] args)
{
T result = default(T);
if (!string.IsNullOrWhiteSpace(name))
{
if (objects.ContainsKey(name))
{
result = objects[name];
}
else
{
lock (syncLock)
{
if (!objects.ContainsKey(name))
{
result = func == null ? Create(typeName, args) : func(typeName, args);
if (result != null)
{
objects.Add(name, result);
}
}
else
{
result = objects[name];
}
}
}
}

return result;
}
}
}

源码下载

本文链接

.Net通用基础框架（.Net Common Infrastructure）-缓存

2011-03-16T07:32:00Z

缓存可以提高网站性能，减轻数据库压力。网站中常用的缓存分为业务数据缓存和页面文件缓存两类，其中业务数据缓存常用AspnetCache，Memcached等，而页面文件缓存常用Squid和Nginx，今天介绍的内容是业务数据缓存。

Common.Cache类图

缓存接口ICache：使用Add方法时，如果key存在，则返回false。使用Set方法时，key不存在则添加，否则更新。

using System;
using System.Collections.Generic;

namespace Common.Cache
{
/// <summary>
/// 缓存
/// </summary>
public interface ICache
{
/// <summary>
/// 增加
/// </summary>
/// <typeparam name="T">类型</typeparam>
/// <param name="key">键</param>
/// <param name="value">值</param>
/// <returns>结果</returns>
bool Add<T>(string key, T value);

/// <summary>
/// 增加
/// </summary>
/// <typeparam name="T">类型</typeparam>
/// <param name="key">键</param>
/// <param name="value">值</param>
/// <param name="duration">持续时间</param>
/// <returns>结果</returns>
bool Add<T>(string key, T value, TimeSpan duration);

/// <summary>
/// 清除
/// </summary>
void Clear();

/// <summary>
/// 获取
/// </summary>
/// <typeparam name="T">类型</typeparam>
/// <param name="key">键</param>
/// <returns>值</returns>
T Get<T>(string key);

/// <summary>
/// 多线程获取
/// </summary>
/// <param name="keys">键集合</param>
/// <returns>值集合</returns>
IDictionary<string, object> MultiGet(IList<string> keys);

/// <summary>
/// 移除
/// </summary>
/// <param name="key">键</param>
void Remove(string key);

/// <summary>
/// 设置
/// </summary>
/// <typeparam name="T">类型</typeparam>
/// <param name="key">键</param>
/// <param name="value">值</param>
/// <returns>结果</returns>
bool Set<T>(string key, T value);

/// <summary>
/// 设置
/// </summary>
/// <typeparam name="T">类型</typeparam>
/// <param name="key">键</param>
/// <param name="value">值</param>
/// <param name="duration">持续时间</param>
/// <returns>结果</returns>
bool Set<T>(string key, T value, TimeSpan duration);
}
}

缓存基类

using System;
using System.Collections.Generic;

namespace Common.Cache
{
/// <summary>
/// 缓存基类
/// </summary>
public abstract class CacheBase : ICache
{
private TimeSpan maxDuration = TimeSpan.FromDays(15);

/// <summary>
/// 最长持续时间
/// </summary>
public TimeSpan MaxDuration
{
get
{
return this.maxDuration;
}
set
{
this.maxDuration = value;
}
}

/// <summary>
/// 前缀
/// </summary>
public string Prefix
{
get;
set;
}

public bool Add<T>(string key, T value)
{
return this.Add<T>(key, value, this.MaxDuration);
}

public abstract bool Add<T>(string key, T value, TimeSpan duration);

public abstract void Clear();

public abstract T Get<T>(string key);

/// <summary>
/// 获取全名
/// </summary>
/// <param name="key">键</param>
/// <returns>全名</returns>
public virtual string GetFullName(string key)
{
string result = key;
if (!string.IsNullOrWhiteSpace(this.Prefix))
{
result = string.Format("{0}.{1}", this.Prefix, key);
}

return result;
}

public abstract IDictionary<string, object> MultiGet(IList<string> keys);

public abstract void Remove(string key);

public bool Set<T>(string key, T value)
{
return this.Set<T>(key, value, this.MaxDuration);
}

public abstract bool Set<T>(string key, T value, TimeSpan duration);
}
}

Aspnet缓存实现

using System;
using System.Collections;
using System.Collections.Generic;
using System.Web;
using System.Web.Caching;

namespace Common.Cache
{
/// <summary>
/// Aspnet缓存
/// </summary>
public class AspnetCache : CacheBase
{
private System.Web.Caching.Cache cache = HttpRuntime.Cache;

/// <summary>
/// 构造函数
/// </summary>
public AspnetCache()
: this("Common.Cache")
{

}

/// <summary>
/// 构造函数
/// </summary>
/// <param name="prefix">前缀</param>
public AspnetCache(string prefix)
{
this.Prefix = prefix;
}

public override bool Add<T>(string key, T value, TimeSpan duration)
{
bool result = false;
if (value != null)
{
if (duration <= TimeSpan.Zero)
{
duration = this.MaxDuration;
}
result = this.cache.Add(this.GetFullName(key), value, null, DateTime.Now.Add(duration), System.Web.Caching.Cache.NoSlidingExpiration, CacheItemPriority.Default, null) == null;
}

return result;
}

public override void Clear()
{
// 获取键集合
IList<string> keys = new List<string>();
IDictionaryEnumerator caches = this.cache.GetEnumerator();
while (caches.MoveNext())
{
string key = caches.Key.ToString();
if (key.StartsWith(this.Prefix))
{
keys.Add(key);
}
}
// 移除全部
foreach (string key in keys)
{
this.cache.Remove(key);
}
}

public override T Get<T>(string key)
{
T result = default(T);
object value = this.cache.Get(this.GetFullName(key));
if (value is T)
{
result = (T)value;
}

return result;
}

public override IDictionary<string, object> MultiGet(IList<string> keys)
{
IDictionary<string, object> result = new Dictionary<string, object>();
foreach (string key in keys)
{
result.Add(key, this.Get<object>(key));
}

return result;
}

public override void Remove(string key)
{
this.cache.Remove(this.GetFullName(key));
}

public override bool Set<T>(string key, T value, TimeSpan duration)
{
bool result = false;
if (value != null)
{
if (duration <= TimeSpan.Zero)
{
duration = this.MaxDuration;
}
this.cache.Insert(this.GetFullName(key), value, null, DateTime.Now.Add(duration), System.Web.Caching.Cache.NoSlidingExpiration);
result = true;
}

return result;
}
}
}

Memcached分布式缓存实现：EnyimMemcached客户端中实现了一致性哈希算法

using System;
using System.Collections.Generic;
using System.Linq;
using Enyim.Caching;
using Enyim.Caching.Memcached;

namespace Common.Cache
{
/// <summary>
/// Memcached缓存
/// </summary>
public class MemcachedCache : CacheBase
{
private static MemcachedClient memcached = new MemcachedClient();

public override bool Add<T>(string key, T value, TimeSpan duration)
{
if (duration <= TimeSpan.Zero)
{
duration = this.MaxDuration;
}

return memcached.Store(StoreMode.Add, this.GetFullName(key), value, duration);
}

public override void Clear()
{
memcached.FlushAll();
}

public override T Get<T>(string key)
{
return memcached.Get<T>(this.GetFullName(key));
}

public override IDictionary<string, object> MultiGet(IList<string> keys)
{
IEnumerable<string> fullKeys = keys.Select<string, string>(k => this.GetFullName(k));

return memcached.Get(fullKeys);
}

public override void Remove(string key)
{
memcached.Remove(this.GetFullName(key));
}

public override bool Set<T>(string key, T value, TimeSpan duration)
{
if (duration <= TimeSpan.Zero)
{
duration = this.MaxDuration;
}

return memcached.Store(StoreMode.Set, this.GetFullName(key), value, duration);
}
}
}

缓存结果通知：实现了Spring.Aop中的IMethodInterceptor接口，用Spring的表达式解析得出key的值，使用时在方法上打特性标签，如Common.Mom项目中用到的[CacheResult(CacheName = "Aspnet", Key = "'Cmr.Dsr.GetSubscriber.' + #id", TimeToLive = "0:5:0")]

using System.Collections;
using System.Collections.Generic;
using System.Reflection;
using AopAlliance.Intercept;
using Spring.Caching;
using Spring.Context;
using Spring.Expressions;

namespace Common.Cache.Aspects
{
/// <summary>
/// 缓存结果通知
/// </summary>
public class CacheResultAdvice : IApplicationContextAware, IMethodInterceptor
{
private IDictionary<MethodInfo, CacheResultAttribute> cacheResults = new Dictionary<MethodInfo, CacheResultAttribute>();

public IApplicationContext ApplicationContext
{
get;
set;
}

/// <summary>
/// 获取缓存结果
/// </summary>
/// <param name="invocation">调用</param>
/// <returns>缓存结果</returns>
private CacheResultAttribute GetCacheResult(IMethodInvocation invocation)
{
CacheResultAttribute result = null;
MethodInfo method = invocation.Method;
if (this.cacheResults.ContainsKey(method))
{
result = this.cacheResults[method];
}
if (result == null)
{
object[] attributes = method.GetCustomAttributes(typeof(CacheResultAttribute), false);
if (attributes.Length > 0)
{
result = (CacheResultAttribute)attributes[0];
this.cacheResults[method] = result;
}
}

return result;
}

/// <summary>
/// 获取参数集合
/// </summary>
/// <param name="invocation">调用</param>
/// <returns>参数集合</returns>
private IDictionary GetParameters(IMethodInvocation invocation)
{
IDictionary result = new Hashtable();
MethodInfo method = invocation.Method;
object[] arguments = invocation.Arguments;
ParameterInfo[] parameters = method.GetParameters();
for (int i = 0; i < parameters.Length; i++)
{
ParameterInfo parameter = parameters[i];
result[parameter.Name] = arguments[i];
}

return result;
}

public object Invoke(IMethodInvocation invocation)
{
object result = null;
IDictionary parameters = this.GetParameters(invocation);
CacheResultAttribute cacheResult = this.GetCacheResult(invocation);
if (cacheResult != null && cacheResult.KeyExpression != null)
{
string key = cacheResult.KeyExpression.GetValue(null, parameters).ToString();
if (!string.IsNullOrEmpty(key))
{
ICache cache = this.ApplicationContext.GetObject(cacheResult.CacheName) as ICache;
if (cache != null)
{
result = cache.Get<object>(key);
if (result == null)
{
result = invocation.Proceed();
if (this.IsMatch(cacheResult.ConditionExpression, result, parameters))
{
cache.Set<object>(key, result, cacheResult.TimeToLiveTimeSpan);
}
}
}
}
}
if (result == null)
{
result = invocation.Proceed();
}

return result;
}

/// <summary>
/// 是否匹配
/// </summary>
/// <param name="expression">表达式</param>
/// <param name="context">上下文</param>
/// <param name="parameters">参数集合</param>
/// <returns>结果</returns>
private bool IsMatch(IExpression expression, object context, IDictionary parameters)
{
bool result = expression == null;
if (!result)
{
result = (bool)expression.GetValue(result, parameters);
}

return result;
}
}
}

测试时启动Common.Cache.ConsoleTest即可

源码下载

本文链接

.Net通用基础框架（.Net Common Infrastructure）-核心库

2011-03-13T06:36:00Z

核心库目前包含集合及管道过滤器，项目结构及命名空间参照了大名鼎鼎的Spring.Net，除了Spring.Net外，原则上不再引入其他第三方类库。

集合

提供一个泛型队列接口，契约如下：

namespace Common.Core.Collections.Generic
{
    /// <summary>
    /// 队列
    /// </summary>
    /// <typeparam name="T">类型</typeparam>
    public interface IQueue<T>
    {
        /// <summary>
        /// 数量
        /// </summary>
        int Count
        {
            get;
        }

        /// <summary>
        /// 清空
        /// </summary>
        void Clear();

        /// <summary>
        /// 出列
        /// </summary>
        /// <returns>结果</returns>
        T Dequeue();

        /// <summary>
        /// 入列
        /// </summary>
        /// <param name="item">项</param>
        void Enqueue(T item);

        /// <summary>
        /// 窥视
        /// </summary>
        /// <returns>结果</returns>
        T Peek();
    }
}

内存队列实现如下:

using System.Collections.Generic;

namespace Common.Core.Collections.Generic
{
    /// <summary>
    /// 内存队列
    /// </summary>
    /// <typeparam name="T">类型</typeparam>
    public class MemoryQueue<T> : Queue<T>, IQueue<T>
    {

    }
}

Msmq队列实现如下:

using System;
using System.Messaging;

namespace Common.Core.Collections.Generic
{
    /// <summary>
    /// Msmq队列
    /// </summary>
    /// <typeparam name="T">类型</typeparam>
    public class MsmqQueue<T> : IDisposable, IQueue<T>
    {
        private string prefix = ".\\private$";
        private MessageQueue queue;

        public int Count
        {
            get
            {
                return this.queue.GetAllMessages().Length;
            }
        }

        /// <summary>
        /// 前缀
        /// </summary>
        public string Prefix
        {
            get
            {
                return this.prefix;
            }
            set
            {
                this.prefix = value;
            }
        }

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="name">名称</param>
        public MsmqQueue(string name)
        {
            string fullname = string.Format("{0}\\{1}", this.Prefix, name);
            if (!MessageQueue.Exists(fullname))
            {
                this.queue = MessageQueue.Create(fullname);
            }
            else
            {
                this.queue = new MessageQueue(fullname);
            }
        }

        public void Clear()
        {
            this.queue.Purge();
        }

        /// <summary>
        /// 转换
        /// </summary>
        /// <param name="message">消息</param>
        /// <returns>结果</returns>
        private T Convert(Message message)
        {
            T result = default(T);
            message.Formatter = new XmlMessageFormatter(new[] { typeof(T) });
            result = (T)message.Body;

            return result;
        }

        public T Dequeue()
        {
            return this.Convert(this.queue.Receive());
        }

        public void Dispose()
        {
            if (this.queue != null)
            {
                this.queue.Dispose();
            }
        }

        public void Enqueue(T item)
        {
            Message message = new Message();
            message.Body = item;
            message.Formatter = new XmlMessageFormatter(new[] { typeof(T) });
            this.queue.Send(message);
        }

        public T Peek()
        {
            return this.Convert(this.queue.Peek());
        }
    }
}

并发内存队列实现如下：

using System.Collections.Concurrent;

namespace Common.Core.Collections.Generic
{
    /// <summary>
    /// 并发内存队列
    /// </summary>
    /// <typeparam name="T">类型</typeparam>
    public class ConcurrentMemoryQueue<T> : ConcurrentQueue<T>, IQueue<T>
    {
        public void Clear()
        {
            while (!this.IsEmpty)
            {
                this.Dequeue();
            }
        }

        public T Dequeue()
        {
            T result = default(T);
            this.TryDequeue(out result);

            return result;
        }

        public T Peek()
        {
            T result = default(T);
            this.TryPeek(out result);

            return result;
        }
    }
}

管道过滤器

管道过滤器模式不在常见的Gof23种设计模式之中，单独抽象出来放到核心库是因为应用场景很多，如Asp.net的请求管道，可以放置N多种过滤器（HttpModule），比较典型的实现有Forms验证Module，授权Module。

管道过滤器Uml类图如下：

源码下载

本文链接

.Net通用基础框架（.Net Common Infrastructure）-开篇

2011-03-01T14:29:00Z

讲述企业开发中通用的技术

1、核心库（Core）

Collections，Pipes，Pileline，Filter
2、数据访问（Dao）
IBatis.net
3、缓存（Cache）
AspnetCache，Memcached
4、日志（Logging）
NLog，MongoDB，Ice
5、规则引擎（Rule Engine）
Rete
6、消息中间件（Mom，Message Oriented Middleware）
Msmq，MongoDB
7、工作流引擎（Workflow Engine）

源码下载

本文链接

管道过滤器设计模式及应用

2011-02-14T01:54:00Z

技术交流幻灯片，大纲如下：

管道过滤器设计模式及应用
定场诗
管道过滤器（PIPE AND FILTERS）
ASP.NET请求管道
管道过滤器V1版
管道过滤器V5版
看图讲故事
击鼓传花
前世：职责链（CHAIN OF RESPONSIBILITY）
规则引擎（RULE ENGINE）
前世：基于规则的专家系统
规则引擎分类
RETE算法
COMMON.BRE时序图
COMMON.BRE类图
示例：商品评价积分规则
Q&A

ppt下载

本文链接

消息中间件Spring.Mom v1设计

2010-10-21T05:23:00Z

消息中间件自从产生以来发展迅速，在分布式联机事务处理环境中，它担当通讯资源管理器（CRM）的角色，为分布式应用提供实时、高效、可靠的、跨越不同操作系统、不同网络的消息传递服务，同时消息中间件减少了开发跨平台应用程序的复杂性。在要求可靠传输的系统中可以利用消息中间件作为一个通讯平台，向应用提供可靠传输功能来传递消息和文件。

消息中间件（Mom）有两种传递模型：点对点模型（PTP）和发布-订阅模型（Pub/Sub）。

1. 点对点模型（PTP）

点对点模型用于消息生产者和消息消费者之间点到点的通信。消息生产者将消息发动到由某个名字标识的特定消费者。这个名字实际上对应于消息服务中的一个队列（Queue），在消息传动给消费者之前它被存储在这个队列中。队列可以是持久的，以保证在消息服务出现故障时仍然能够传递消息。

2. 发布-订阅模型（Pub/Sub）

发布-订阅模型用称为主题（topic）的内容分层结构代替了PTP模型中的惟一目的地，发送应用程序发布自己的消息，指出消息描述的是有关分层结构中的一个主题的信息。希望接收这些消息的应用程序订阅了这个主题。订阅包含子主题的分层结构中的主题的订阅者可以接收该主题和其子主题发表的所有消息。

服务端设计类图：

客户端设计类图：

参考文献：

消息中间件原理及JMS简介

本文链接

敏捷OA，免费的OAv1.1

2008-06-26T15:13:00Z

一、AgileOA.2008 v1.1包括如下功能：前台功能：1 公文流转1.1 起草公文1.2 待办公文2 公文管理2.1 监控公文后台管理：1 工作流管理1.1 工作流角色列表1.2 维护工作流角色1.3 工作流定义列表1.4 维护工作流定义2 部门管理2.1 维护部门3 用户管理3.1 用户列表3.2 维护用户4 角色管理4.1 角色列表4.2 维护角色三、本版本修改功能：1 支持动态处理流...

敏捷OA，免费的OA

2008-06-09T07:53:00Z

一、AgileOA.2008 v1.0包括如下功能：前台功能：1 公文流转1.1 起草公文1.2 待办公文2 公文管理2.1 监控公文后台管理：1 工作流管理1.1 工作流角色列表1.2 维护工作流角色1.3 工作流定义列表1.4 维护工作流定义2 部门管理2.1 维护部门3 用户管理3.1 用户列表3.2 维护用户4 角色管理4.1 角色列表4.2 维护角色二、下一版本将包括如下功能：1 支持动...

.Net中导入Excel数据时应注意的事

2008-03-31T01:29:00Z

从Excel向数据库导数据的时候，最常用的方式是使用Provider=Microsoft.Jet.OLEDB.4.0;Data Source=D:"Demo.xls; Extended Properties='Excel 8.0;HDR=YES;IMEX=1'。但是当一列中既有数字，又有文本的时候，总是莫名其妙的出现部分数据读不到的现象，有时是读不到文本数据，有时是读不到数字数据。这是为什么呢？...

Asp.Net 2.0使用总结

2007-07-06T15:05:00Z

Asp.Net 2.0使用总结