目录

前言

接上级通知，准备部门内部培训一次，由于没有找到好的主题，就准备讲一些零散的知识，旨在表达我在编程学习过程中体会到的一些思想，内容很多地方不够完善，还请大家见谅。

泛型的应用

泛型是.Net 2.0中就有的一个新功能，使用泛型类或方式可将一个或多个类型的指定推迟到客户端代码声明并实例化该类或方法的时候，可避免运行时强制转换或装箱操作的成本或风险。我们在项目里也经常会使用泛型集合代替ArrayList，例如：

List<FA_User_bean> list = new List<FA_User_bean>();

除此之外，我们还可以将现有的框架扩展支持泛型类，在Dao基类指定一个参数T，同时在增、删、改、查等方法里使用占位符参数T，代码如下：

Dao泛型基类
  1public class BaseDao<T> where T : BaseBean, new()
  2...{
  3
  4    protected IDbExecutor DbExecutor = DbFactory.CreateDbExecutor();
  5
  6    public BaseDao() ...{ }
  7
  8
  9    
 10    /**//// <summary>
 11    /// 创建一次查询的实例
 12    /// </summary>
 13    public Query<T> CreateQuery()
 14    ...{
 15        ...#region
 16        Query<T> query = new Query<T>();
 17        return query;
 18        #endregion
 19    }
 20
 21    
 22    /**//// <summary>
 23    /// 插入数据，返回所影响的记录条数
 24    /// </summary>
 25    public virtual int Insert(T t)
 26    ...{
 27        ...#region
 28        return CreateQuery().Insert(t);
 29        #endregion
 30    }
 31    
 32
 33    /**//// <summary>
 34    /// 插入数据，并返回主键值
 35    /// </summary>
 36    /// <param name="t"></param>
 37    /// <returns></returns>
 38    public virtual object Save(T t)
 39    ...{
 40        ...#region
 41        return CreateQuery().Save(t);
 42        #endregion
 43    }
 44    
 45
 46    /**//// <summary>
 47    /// 根据ID删除数据，返回所影响的记录条数
 48    /// </summary>
 49    public virtual int Delete(object id)
 50    ...{
 51        ...#region
 52        return CreateQuery().Delete(id);
 53        #endregion
 54    }
 55    
 56    
 57    public virtual int Delete(object[] ids)
 58    ...{
 59        ...#region
 60        return CreateQuery().Delete(ids);
 61        #endregion
 62    }
 63    
 64        
 65    public virtual int Delete()
 66    ...{
 67        ...#region
 68        return CreateQuery().Delete();
 69        #endregion
 70    }
 71    
 72        
 73    /**//// <summary>
 74    /// 根据ID更新数据，返回所影响的记录条数
 75    /// </summary>
 76    public virtual int Update(T t)
 77    ...{
 78        ...#region
 79        return CreateQuery().Update(t);
 80        #endregion
 81    }
 82    
 83        
 84    /**//// <summary>
 85    /// 根据ID获取数据，返回实体对象
 86    /// </summary>
 87    public virtual T Load(object id)
 88    ...{
 89        ...#region
 90        return CreateQuery().Load(id);
 91        #endregion
 92    }
 93    
 94    
 95    /**//// <summary>
 96    /// 获取数据列表
 97    /// </summary>
 98    public virtual List<T> List()
 99    ...{
100        ...#region
101        return CreateQuery().List();
102        #endregion
103    }
104    
105    
106    /**//// <summary>
107    /// 根据指定的分页控件参数获取数据列表
108    /// </summary>
109    public virtual List<T> List(Pager pager)
110    ...{
111        ...#region
112        return CreateQuery().List(pager);
113        #endregion
114    }
115    
116
117
118}

接着，我们在Dao子类指定参数T为对应的实体对象，这样在调用Dao子类的增、删、改、查方法时参数T也就为对应的实体对象。

使用自定义属性

自定义属性是标识类或属性的一个很好的办法，例如我们可以使用Serializable指示一个类可以序列化。同样，我们也可以使用自定义属性来标识ORM中的Mapping部分。我们现在的框架部分代码如下：

public partial class FA_User_dao : Dao_Base
{
    public FA_User_dao()
    {
        this._propTable = "FA_User";
        this._propPK = "fdUserID";
        this._propFields = "fdUserID,fdUserPWD,fdUserCreateAt,fdUserName,fdUserDesc";
    }
}

虽然功能是可以实现，但我总觉得代码不够优雅，于是使用自定义属性将这些信息标识到实体类里，代码如下：

自定义属性标识实体类
 1[EntityFlag(TableName = "FA_User")]
 2public class FA_User : BaseBean
 3...{
 4
 5    
 6    private Int32 fdUserIdentity;
 7
 8    [ColumnFlag]
 9    public Int32 FdUserIdentity
10    ...{
11        get ...{ return fdUserIdentity; }
12        set ...{ fdUserIdentity = value; }
13    }
14    
15    private String fdUserID;
16
17    [ColumnFlag(PrimaryKey = true)]
18    public String FdUserID
19    ...{
20        get ...{ return fdUserID; }
21        set ...{ fdUserID = value; }
22    }
23    
24    private String fdUserPWD;
25
26    [ColumnFlag(ColumnName = "fdUserPWD")]
27    public String FdUserPWD
28    ...{
29        get ...{ return fdUserPWD; }
30        set ...{ fdUserPWD = value; }
31    }
32    
33    private DateTime fdUserCreateAt;
34
35    [ColumnFlag]
36    public DateTime FdUserCreateAt
37    ...{
38        get ...{ return fdUserCreateAt; }
39        set ...{ fdUserCreateAt = value; }
40    }
41    
42    private String fdUserName;
43
44    [ColumnFlag]
45    public String FdUserName
46    ...{
47        get ...{ return fdUserName; }
48        set ...{ fdUserName = value; }
49    }
50    
51    private String fdUserDesc;
52
53    [ColumnFlag]
54    public String FdUserDesc
55    ...{
56        get ...{ return fdUserDesc; }
57        set ...{ fdUserDesc = value; }
58    }
59    
60
61}

其中的EntityFlag、ColumnFlag就是自定义属性类了，而PrimaryKey、ColumnName就分别用来设置属性是否为主键、对应的列名称。数据实体映射是一个ORM框架的核心，使用自定义属性标识也可进行良好的扩展。像Hibernate除开提供类似自定义属性的注解功能外，还可使用XML配置实体对象映射，另外还可以根据这些配置的信息反向生成数据库结构。

程序的解耦

1）面向接口设计

当我们碰到复杂的业务逻辑时，可能需要使用多个if else动作条件的判断时，如对多种类型的数据库访问，我们可以考虑使用接口来实现，下图为我的IDbExecutor数据库访问接口的类图：

2）细化分解

一个ORM框架不应该只是提供简单的拼接SQL功能，而应该提供更细腻的参数方法。例如Hibernate除开可以使用HQL查询语言，还提供了Criteria条件、Order排序等操作类。个人觉得，提供的条件元素越细，底层越容易分解实现，扩展性越好。

★不使用ORM，直接一整条SQL语句；

★★把SQL分解为查询字段、where和排序条件再进行拼接；

★★★使用ORM框架，将SQL细化分解为多个元素，在底层进行组合实现；

3）多层结构

使用分层结构也可将程序进行解耦。一般的应用程序大都可分为表现层、业务逻辑层、数据访问层3大层，每一层向上提供接口，向下弱耦合，如下图所示：

良好的层次结构的划分，可以降低系统的复杂性，其中的业务层起到了承上启下的作用。如果一个系统架构中缺少了业务层，那么一些类似事物处理等业务逻辑会在表现层和数据层界限中间徘徊不定，造成代码混乱臃肿的情况。当然，对于一些简单的业务流程，业务层仅仅只是完成对数据层中数据对象的简单封装而已。

为解除业务层对数据层的强依赖性，还可在业务层引入接口和创建具体数据对象的工厂，与数据层保持松散弱耦合关系，这样就可最大程度的支持架构的扩展。如PetShop在BLL层就使用这种方法提供对SQLServer和Oracle数据库的访问。

PetShop.BLL.Product
 1namespace PetShop.BLL ...{
 2
 3    /**//// <summary>
 4    /// A business component to manage products
 5    /// </summary>
 6    public class Product ...{
 7
 8        // Get an instance of the Product DAL using the DALFactory
 9        // Making this static will cache the DAL instance after the initial load
10        private static readonly IProduct dal = PetShop.DALFactory.DataAccess.CreateProduct();        
11
12           /**//// <summary>
13        /// A method to retrieve products by category name
14        /// </summary>
15        /// <param name="category">The category name to search by</param>    
16        /// <returns>A Generic List of ProductInfo</returns>
17        public IList<ProductInfo> GetProductsByCategory(string category) ...{
18
19            // Return new if the string is empty
20            if(string.IsNullOrEmpty(category))
21                return new List<ProductInfo>();
22
23            // Run a search against the data store
24            return dal.GetProductsByCategory(category);
25        }
26    }
27}

面向切面编程

面向对象编程相比面向过程编程已经是一种质的飞跃，为什么还要有面向切面编程呢？Aspect Oriented Programming(AOP)，面向切面编程，是针对业务逻辑处理中的一方面内容提取，以获得过程各部分之间低耦合性的隔离效果。例如，在Java里使用Spring代理就可在服务层轻松的实现对事务的管理。

MemberService服务类
 1public class MemberServiceImpl implements MemberService ...{
 2
 3    private AccountDao accountDao;
 4    private DepartmentDao departmentDao;
 5
 6    @Transactional
 7    public void editAccount(Account account) ...{
 8
 9        if (account.getUuid() == null) ...{
10            accountDao.create(account);
11        } else ...{
12            accountDao.update(account);
13        }
14        
15    }
16    
17    public void setAccountDao(AccountDao accountDao) ...{
18        this.accountDao = accountDao;
19    }
20
21    public void setDepartmentDao(DepartmentDao departmentDao) ...{
22        this.departmentDao = departmentDao;
23    }
24
25}

如上代码所示，使用@Transactional标识了的方法整个过程进入事务控制，简单方便灵活，可大大减少了我们的工作量。而在.Net平台下，我们可以使用上下文（Context）+自定义属性（Attribute）对方法调用进行截取，前提是这个类必须从ContextBoundObject类派生，这点让我很懊恼，因为ContextBoundObject不支持泛型类或具有泛型方法的非泛型类，所以.Net下的事务控制我只能想其他办法来实现。

结束语

好了，今天就说到这里，谢谢大家！