基于.NET平台的分层架构实战（二）——需求分析与数据库设计

数据库设计：
设计数据表之前，首先进行实体和关系的识别与确定。
通过需求分析，可以观察得出，本项目的实体有：管理员（不包括超级管理员），留言，评论。本项目的关系有：留言与评论间的一对多关系。

进一步，数据库各表的设计如下：

管理员表（TAdmin）
ID    int    管理员ID    NotNull    主键，自增
Name    varchar(20)    登录名    NotNull
Password    varchar(50)    登录密码    NotNull    使用MD5加密

留言表（TMessage）
ID    int    留言ID    NotNull    主键，自增
GuestName    varchar(20)    留言者用户名    NotNull
GuestEmail    varchar(100)    留言者E-mail    Null
Content    text    留言内容    NotNull
Time    datetime    发表留言时间    NotNull    
Reply    text    回复    Null

评论表（TComment）
ID    int    评论ID    NotNull    主键，自增
Content    text    评论内容    NotNull
Time    datetime    发表评论时间    NotNull
MessageID    int    所属留言的ID    外键

基于.NET平台的分层架构实战（四）——实体类的设计与实现

namespace NGuestBook.Entity
{
    /// <summary>
    /// 实体类-管理员
    /// </summary>
    [Serializable]
    public class AdminInfo
    {
        private int id;
        private string name;
        private string password;

public int ID
        {
            get { return this.id; }
            set { this.id = value; }
        }

public string Name
        {
            get { return this.name; }
            set { this.name = value; }
        }

public string Password
        {
            get { return this.password; }
            set { this.password = value; }
        }
    }
}

namespace NGuestBook.Entity
{
    /// <summary>
    /// 实体类-留言
    /// </summary>
    [Serializable]
    public class MessageInfo
    {
        private int id;
        private string guestName;
        private string guestEmail;
        private string content;
        private DateTime time;
        private string reply;
        private string isPass;

public int ID
        {
            get { return this.id; }
            set { this.id = value; }
        }

public string GuestName
        {
            get { return this.guestName; }
            set { this.guestName = value; }
        }

public string GuestEmail
        {
            get { return this.guestEmail; }
            set { this.guestEmail = value; }
        }

public string Content
        {
            get { return this.content; }
            set { this.content = value; }
        }

public DateTime Time
        {
            get { return this.time; }
            set { this.time = value; }
        }

public string Reply
        {
            get { return this.reply; }
            set { this.reply = value; }
        }

public string IsPass
        {
            get { return this.isPass; }
            set { this.isPass = value; }
        }
    }
}

namespace NGuestBook.Entity
{
    /// <summary>
    /// 实体类-评论
    /// </summary>
    [Serializable]
    public class CommentInfo
    {
        private int id;
        private string content;
        private DateTime time;
        private int message;

public int ID
        {
            get { return this.id; }
            set { this.id = value; }
        }

public string Content
        {
            get { return this.content; }
            set { this.content = value; }
        }

public DateTime Time
        {
            get { return this.time; }
            set { this.time = value; }
        }

public int Message
        {
            get { return this.message; }
            set { this.message = value; }
        }
    }
}

基于.NET平台的分层架构实战（五）——接口的设计与实现

namespace NGuestBook.IBLL
{
    /// <summary>
    /// 业务逻辑层接口-管理员
    /// </summary>
    public interface IAdminBLL
    {
        /// <summary>
        /// 添加管理员
        /// </summary>
        /// <param name="admin">新管理员实体类</param>
        /// <returns>是否成功</returns>
        bool Add(AdminInfo admin);

/// <summary>
        /// 删除管理员
        /// </summary>
        /// <param name="id">欲删除的管理员的ID</param>
        /// <returns>是否成功</returns>
        bool Remove(int id);

/// <summary>
        /// 修改管理员密码
        /// </summary>
        /// <param name="id">欲修改密码的管理员的ID</param>
        /// <param name="password">新密码</param>
        /// <returns>是否成功</returns>
        bool ChangePassword(int id,string password);

/// <summary>
        /// 管理员登录
        /// </summary>
        /// <param name="name">管理员登录名</param>
        /// <param name="password">管理员密码</param>
        /// <returns>如果登录成功，则返回相应管理员的实体类，否则返回null</returns>
        AdminInfo Login(string name,string password);

/// <summary>
        /// 取得全部管理员信息
        /// </summary>
        /// <returns>管理员实体类集合</returns>
        IList<AdminInfo> GetAll();
    }
}

/// <summary>
        /// 删除留言
        /// </summary>
        /// <param name="id">欲删除的留言的ID</param>
        /// <returns>是否成功</returns>
        bool Remove(int id);

/// <summary>
        /// 回复留言
        /// </summary>
        /// <param name="id">要回复的留言的ID</param>
        /// <param name="reply">回复信息</param>
        /// <returns>是否成功</returns>
        bool Revert(int id, string reply);

/// <summary>
        /// 将留言通过验证
        /// </summary>
        /// <param name="id">通过验证的留言的ID</param>
        /// <returns>是否成功</returns>
        bool Pass(int id);

/// <summary>
        /// 按分页取得留言信息
        /// </summary>
        /// <param name="pageSize">每页显示几条留言</param>
        /// <param name="pageNumber">当前页码</param>
        /// <returns>留言实体类集合</returns>
        IList<MessageInfo> GetByPage(int pageSize,int pageNumber);
    }
}

namespace NGuestBook.IBLL
{
    /// <summary>
    /// 业务逻辑层接口-评论
    /// </summary>
    public interface ICommentBLL
    {
        /// <summary>
        /// 添加评论
        /// </summary>
        /// <param name="comment">新评论实体类</param>
        /// <returns>是否成功</returns>
        bool Add(CommentInfo comment);

/// <summary>
        /// 删除评论
        /// </summary>
        /// <param name="id">欲删除的评论的ID</param>
        /// <returns>是否成功</returns>
        bool Remove(int id);

/// <summary>
        /// 取得指定留言的全部评论
        /// </summary>
        /// <param name="messageId">指定留言的ID</param>
        /// <returns>评论实体类集合</returns>
        IList<CommentInfo> GetByMessage(int messageId);
    }
}

namespace NGuestBook.IDAL
{
    /// <summary>
    /// 数据访问层接口-管理员
    /// </summary>
    public interface IAdminDAL
    {
        /// <summary>
        /// 插入管理员
        /// </summary>
        /// <param name="admin">管理员实体类</param>
        /// <returns>是否成功</returns>
        bool Insert(AdminInfo admin);

/// <summary>
        /// 删除管理员
        /// </summary>
        /// <param name="id">欲删除的管理员的ID</param>
        /// <returns>是否成功</returns>
        bool Delete(int id);

/// <summary>
        /// 更新管理员信息
        /// </summary>
        /// <param name="admin">管理员实体类</param>
        /// <returns>是否成功</returns>
        bool Update(AdminInfo admin);

/// <summary>
        /// 按ID取得管理员信息
        /// </summary>
        /// <param name="id">管理员ID</param>
        /// <returns>管理员实体类</returns>
        AdminInfo GetByID(int id);

/// <summary>
        /// 按管理员名取得管理员信息
        /// </summary>
        /// <param name="name">管理员名</param>
        /// <returns>管理员实体类</returns>
        AdminInfo GetByName(string name);

/// <summary>
        /// 按用户名及密码取得管理员信息
        /// </summary>
        /// <param name="name">用户名</param>
        /// <param name="password">密码</param>
        /// <returns>管理员实体类，不存在时返回null</returns>
        AdminInfo GetByNameAndPassword(string name,string password);

/// <summary>
        /// 取得全部管理员信息
        /// </summary>
        /// <returns>管理员实体类集合</returns>
        IList<AdminInfo> GetAll();
    }
}

namespace NGuestBook.IDAL
{
    /// <summary>
    /// 数据访问层接口-留言
    /// </summary>
    public interface IMessageDAL
    {
        /// <summary>
        /// 插入留言
        /// </summary>
        /// <param name="message">留言实体类</param>
        /// <returns>是否成功</returns>
        bool Insert(MessageInfo message);

/// <summary>
        /// 删除留言
        /// </summary>
        /// <param name="id">欲删除的留言的ID</param>
        /// <returns>是否成功</returns>
        bool Delete(int id);

/// <summary>
        /// 更新留言信息
        /// </summary>
        /// <param name="message">留言实体类</param>
        /// <returns>是否成功</returns>
        bool Update(MessageInfo message);

/// <summary>
        /// 按ID取得留言信息
        /// </summary>
        /// <param name="id">留言ID</param>
        /// <returns>留言实体类</returns>
        MessageInfo GetByID(int id);

/// <summary>
        /// 按分页取得留言信息
        /// </summary>
        /// <param name="pageSize">每页显示几条留言</param>
        /// <param name="pageNumber">当前页码</param>
        /// <returns>留言实体类集合</returns>
        IList<MessageInfo> GetByPage(int pageSize,int pageNumber);
    }
}

namespace NGuestBook.IDAL
{
    /// <summary>
    /// 数据访问层接口-评论
    /// </summary>
    public interface ICommentDAL
    {
        /// <summary>
        /// 插入评论
        /// </summary>
        /// <param name="comment">评论实体类</param>
        /// <returns>是否成功</returns>
        bool Insert(CommentInfo comment);

/// <summary>
        /// 删除评论
        /// </summary>
        /// <param name="id">欲删除的评论的ID</param>
        /// <returns>是否成功</returns>
        bool Delete(int id);

/// <summary>
        /// 取得指定留言的全部评论
        /// </summary>
        /// <param name="messageId">指定留言的ID</param>
        /// <returns>评论实体类集合</returns>
        IList<CommentInfo> GetByMessage(int messageId);
    }
}

基于.NET平台的分层架构实战（六）——依赖注入机制及IoC的设计与实现

namespace NGuestBook.Utility
{
    /// <summary>
    /// 辅助类，用于缓存操作
    /// </summary>
    public sealed class CacheAccess
    {
        /// <summary>
        /// 将对象加入到缓存中
        /// </summary>
        /// <param name="cacheKey">缓存键</param>
        /// <param name="cacheObject">缓存对象</param>
        /// <param name="dependency">缓存依赖项</param>
        public static void SaveToCache(string cacheKey, object cacheObject, CacheDependency dependency)
        {
            Cache cache = HttpRuntime.Cache;
            cache.Insert(cacheKey, cacheObject, dependency);
        }

/// <summary>
        /// 从缓存中取得对象，不存在则返回null
        /// </summary>
        /// <param name="cacheKey">缓存键</param>
        /// <returns>获取的缓存对象</returns>
        public static object GetFromCache(string cacheKey)
        {
            Cache cache = HttpRuntime.Cache;

return cache[cacheKey];
        }
    }
}

namespace NGuestBook.Factory
{
    /// <summary>
    /// 依赖注入提供者
    /// 使用反射机制实现
    /// </summary>
    public sealed class DependencyInjector
    {
        /// <summary>
        /// 取得数据访问层对象
        /// 首先检查缓存中是否存在，如果不存在，则利用反射机制返回对象
        /// </summary>
        /// <param name="className">数据访问类名称</param>
        /// <returns>数据访问层对象</returns>
        public static object GetDALObject(string className)
        {
            /// <summary>
            /// 取得数据访问层名称，首先检查缓存，不存在则到配置文件中读取
            /// 缓存依赖项为Web.Config文件
            /// </summary>
            object dal = CacheAccess.GetFromCache("DAL");
            if (dal == null)
            {
                CacheDependency fileDependency = new CacheDependency(HttpContext.Current.Server.MapPath("Web.Config"));
                dal = ConfigurationManager.AppSettings["DAL"];
                CacheAccess.SaveToCache("DAL", dal, fileDependency);
            }

/// <summary>
            /// 取得数据访问层对象
            /// </summary>
            string dalName = (string)dal;
            string fullClassName = dalName + "." + className;
            object dalObject = CacheAccess.GetFromCache(className);
            if (dalObject == null)
            {
                CacheDependency fileDependency = new CacheDependency(HttpContext.Current.Server.MapPath("Web.Config"));
                dalObject = Assembly.Load(dalName).CreateInstance(fullClassName);
                CacheAccess.SaveToCache(className, dalObject, fileDependency);
            }

return dalObject;
        }

/// <summary>
        /// 取得业务逻辑层对象
        /// 首先检查缓存中是否存在，如果不存在，则利用反射机制返回对象
        /// </summary>
        /// <param name="className">业务逻辑类名称</param>
        /// <returns>业务逻辑层对象</returns>
        public static object GetBLLObject(string className)
        {
            /// <summary>
            /// 取得业务逻辑层名称，首先检查缓存，不存在则到配置文件中读取
            /// 缓存依赖项为Web.Config文件
            /// </summary>
            object bll = CacheAccess.GetFromCache("BLL");
            if (bll == null)
            {
                CacheDependency fileDependency = new CacheDependency(HttpContext.Current.Server.MapPath("Web.Config"));
                bll = ConfigurationManager.AppSettings["BLL"];
                CacheAccess.SaveToCache("BLL", bll, fileDependency);
            }

/// <summary>
            /// 取得业务逻辑层对象
            /// </summary>
            string bllName = (string)bll;
            string fullClassName = bllName + "." + className;
            object bllObject = CacheAccess.GetFromCache(className);
            if (bllObject == null)
            {
                CacheDependency fileDependency = new CacheDependency(HttpContext.Current.Server.MapPath("Web.Config"));
                bllObject = Assembly.Load(bllName).CreateInstance(fullClassName);
                CacheAccess.SaveToCache(className, bllObject, fileDependency);
            }

return bllObject;
        }
    }
}

namespace NGuestBook.Factory
{
    /// <summary>
    /// 数据访问层工厂，用于获取相应的数据访问层对象
    /// 使用Abstract Factory设计模式+Facace设计模式+反射机制+缓存机制设计
    /// </summary>
    public sealed class DALFactory
    {
        /// <summary>
        /// 获取管理员数据访问层对象
        /// </summary>
        /// <returns>管理员数据访问层对象</returns>
        public static IAdminDAL CreateAdminDAL()
        {
            return (IAdminDAL)DependencyInjector.GetDALObject("AdminDAL");
        }

/// <summary>
        /// 获取留言数据访问层对象
        /// </summary>
        /// <returns>留言数据访问层对象</returns>
        public static IMessageDAL CreateMessageDAL()
        {
            return (IMessageDAL)DependencyInjector.GetDALObject("MessageDAL");
        }

/// <summary>
        /// 获取评论数据访问层对象
        /// </summary>
        /// <returns>评论数据访问层对象</returns>
        public static ICommentDAL CreateCommentDAL()
        {
            return (ICommentDAL)DependencyInjector.GetDALObject("CommentDAL");
        }
    }
}

namespace NGuestBook.Factory
{
    /**//// <summary>
    /// 业务逻辑层工厂，用于获取相应的业务逻辑层对象
    /// 使用Abstract Factory设计模式+Facace设计模式+反射机制+缓存机制设计
    /// </summary>
    public sealed class BLLFactory
    {
        /**//// <summary>
        /// 获取管理员业务逻辑层对象
        /// </summary>
        /// <returns>管理员业务逻辑层对象</returns>
        public static IAdminBLL CreateAdminBLL()
        {
            return (IAdminBLL)DependencyInjector.GetBLLObject("AdminBLL");
        }

/**//// <summary>
        /// 获取留言业务逻辑层对象
        /// </summary>
        /// <returns>留言业务逻辑层对象</returns>
        public static IMessageBLL CreateMessageBLL()
        {
            return (IMessageBLL)DependencyInjector.GetBLLObject("MessageBLL");
        }

/**//// <summary>
        /// 获取评论业务逻辑层对象
        /// </summary>
        /// <returns>评论业务逻辑层对象</returns>
        public static ICommentBLL CreateCommentBLL()
        {
            return (ICommentBLL)DependencyInjector.GetBLLObject("CommentBLL");
        }
    }
}

经过上面篇文章的介绍，整个系统的框架算是基本搭建完了，下面，我们要具体实现各个层次。关于数据访问层的实现，我准备讨论三种实现方式，这一篇文章讨论第一种：Access+动态生成SQL。
顾名思义，这种实现将使用Access作为后台数据库，而操作方式也是最基本的使用SQL命令。
在具体编写实现代码之前，我们需要做一些准备工作：

第一步，我们要将Access数据库搭建完成，具体做法如下。
在Web工程下新建一个文件夹，命名为AccessData，并在其中新建一个mdb文件（即Access数据库文件），按照前面介绍过的数据库设计构架，将数据表及表间关系建好，这里不再赘述。

第二步，我们要进行一些配置。
打开Web工程下的Web.config文件，在其中的appSettings节点下，添加如下键值：
<add key="AccessConnectionString" value="Provider=Microsoft.Jet.OLEDB.4.0;Data Source={DBPath}"/>
<add key="AccessPath" value="~/AccessData/AccessDatabase.mdb"/>
第一条为Access的连接字符串，第二条为Access数据库文件的路径，其中“~”表示网站根目录。

第三步，新建一个工程。
我们要新建一个工程AccessDAL，用来存放Access数据访问层的代码。

准备工作做完了，现在来实现具体的代码。

1.编写数据访问助手类
因为很多数据访问操作流程很相似，所以，这里将一些可复用的代码抽取出来，编写成助手类，以此减少代码量，提高代码复用性。
这个助手类放在AccessDAL下，叫AccessDALHelper，主要负责Access数据库的访问。它包括三个方法：
GetConnectionString：从配置文件中读取配置项，组合成连接字符串。
ExecuteSQLNonQuery：执行指定SQL语句，不返回任何值，一般用于Insert，Delete，Update命令。
ExecuteSQLDataReader：执行SQL语句返回查询结果，一般用于Select命令。
具体代码如下：

AccessDALHelper.cs:

2.实现具体的数据访问操作类
因为前面已经定义了数据访问层接口，所以实现数据访问操作类就是很机械的工作了。下面仅以Admin的数据访问操作类为例：

AdminDAL:

可以看到，这里主要包括三种类型的操作，一种是修改型，如Insert；一种是返回单个实体类型，如GetByID；还有一种是返回实体类集合型，如GetAll。
MessageDAL和CommentDAL的实现非常相似，在这里不再赘述。