关于三层结构各层责任的问题

Question

例如用户注册的时候
1 判断用户是否存在
2 插入数据2显然是dal的责任
但1呢
如果放在dal
那1 2就可以放在同一个sql中效率比较高
但感觉应该放在bll中判断才符合结构遇到类似的问题该怎么办呢
有没有相关的判断标准

Answer 1

考虑一个问题,sql查询不慢,,计算机运算也不慢.慢的传输.因此层次的目的只是为了增加代码的复用率和版本控制.

Answer 2

把判断用户的语句写在dal里面
在bll里写判断的函数，调用在dal里面的方法

Answer 3

把判断用户的语句写在dal里面
这是肯定的
但判断应该在bll还是dal呢
就是说 判断该用户是否能注册 
这个工作到底是谁的责任ps:我只是举一个例子，并不是在讨论程序本身的问题，而是讨论责任的问题
我是想知道在一些责任分配比较模糊的地方要有怎么样的标准
不然就只会推卸责任了

Answer 4

判断该用户是否能注册   bll調用dal返回結果再判斷
也就是說在bll中判斷我的理解 

Answer 5

三层就是
界面层  登录时需要验证帐号密码
业务逻辑层就 调用 帐号密码的方法 把帐号密码传过去
数据访问层就 写具体的Select方法 返回结果集

Answer 6

你这样来理解吧，怎么取数据是数据层负责的事，而如何判断是业务层的事情。这样分开写更符合设计需要。
业务层不需要知道数据是怎么来的，只需要得到结果，具体怎么来的数据，那是数据层的事。
你可以把数据层写成，直接返回取数据的
bool GetUser(string Name,string Pwd)
{
//数据读取，返回bool值
}也可以一个通用的取数据方法，然后通过业务层来判断是否正确。具体怎么用看你项目的需求。总之分层是为了让项目更灵活，复用性更高，而不是滥用设计。

Answer 7

你的问题能体现出分层开发的一个好处：便于维护！具体不说了。但按你的逻辑也是没错的，而且分层开发就要用到存储过程，1和2应该写在一个存储过程里，最终在业务层得到一个返回结果就行。记住，分层开发最好不要在类里写sql，不便于维护。

Answer 8

给你一个实际的代码吧.其实是DAL返回数据.看我写的吧.我推荐只有一个存储过程,我认为我这样很合理(当然我不会说自己设计的不合理.)
第一次贴代码.现丑了.
首先是存储过程,这是部分代码.注意返回值.
ALTER PROCEDURE [dbo].[SuperJ_InsertAdmin] 
@AdminName nvarchar(63),
    @Password nvarchar(63),
    @ShowName nvarchar(63),
    @IsPass bit,
    @IsSingleLogin tinyint
AS
BEGIN
SET NOCOUNT ON;
IF EXISTS(SELECT * FROM SuperJ_Admin WHERE AdminName=@AdminName)
RETURN -1;
IF EXISTS(SELECT * FROM SuperJ_Admin WHERE ShowName=@ShowName)
RETURN -2;
INSERT INTO [dbo].[SuperJ_Admin]
           ([AdminName]
           ,[Password]
           ,[ShowName]
           ,[IsPass]
           ,[IsSingleLogin])
     VALUES
           (@AdminName,
            @Password,
            @ShowName,
            @IsPass,
            @IsSingleLogin) Return 1;
END
这是DAL,插入ADMIN,如果插入不成功.(其实就是影响的行数为0),这时我读取数据库的反回值.-1是帐号重复-2是显示名重复.AdminInfo.是Admin表的MODEL,其实就是把表写成类.只有属性.        #region Insert Admin
        
        public int InsertAdmin(AdminInfo ai)
        {
            using (SqlConnection connection = SQLHelper.GetSqlConnection())
            {
                SqlCommand command = new SqlCommand("SuperJ_InsertAdmin", connection);
                //SqlDataReader reader;                command.CommandType = CommandType.StoredProcedure;
                command.Parameters.Add("@AdminName", SqlDbType.NVarChar, 63).Value = ai.AdminName;
                command.Parameters.Add("@Password", SqlDbType.NVarChar, 63).Value = ai.Password;
                command.Parameters.Add("@ShowName", SqlDbType.NVarChar, 63).Value = ai.ShowName;
                command.Parameters.Add("@IsPass", SqlDbType.Bit).Value = ai.IsPass;
                command.Parameters.Add("@IsSingleLogin", SqlDbType.TinyInt).Value = ai.IsSingleLogin;
                command.Parameters.Add("@ReturnValue", SqlDbType.Int);
                command.Parameters["@ReturnValue"].Direction = ParameterDirection.ReturnValue;
                connection.Open();
                int val = command.ExecuteNonQuery();
                connection.Close();
                if (val < 1)
                {
                    val = Convert.ToInt32(command.Parameters["@ReturnValue"].Value);
                }
                return val;
            }
        }
        #endregion这是BLL.他什么也没做.        public int InsertAdmin(AdminInfo ai)
        {
            return dal.InsertAdmin(ai);
        }
这是界面        protected void btnSubmit_Command(object sender, CommandEventArgs e)
        {
            int val;
            SuperJ_CMS.Model.AdminInfo ai = new SuperJ_CMS.Model.AdminInfo();
            ai = GetFormValue();
            SuperJ_CMS.BLL.Admin a = new SuperJ_CMS.BLL.Admin();
            if (ai.AdminId <= 0)
                val = a.InsertAdmin(ai);
            else
                val = a.UpdateAdmin(ai);            switch (val)
            {
                case 0:
                    break;
                case -1:
                    lblAdminNameMsg.Text = "此用户名已经存在,请更换!";
                    break;
                case -2:
                    lblShowNameMsg.Text = "此显示名已经存在,请更换!";
                    break;
                case 1:
                    if (e.CommandName == "OK")
                    { }
                    else
                    { }
                    break;
            }
        }
        private SuperJ_CMS.Model.AdminInfo GetFormValue()
        {
            string adminName = txtAdminName.Text;
            string showName = txtShowName.Text;
            string password = txtPassword.Text;
            string confirm = txtConfirm.Text;
            int adminId = this.IdPK;
            bool isPass = radlIsPass.SelectedValue == "1" ? true : false;
            int isSingleLogin =Convert.ToInt32(radlIsSingleLogin.SelectedValue);
            SuperJ_CMS.Model.AdminInfo ai = new SuperJ_CMS.Model.AdminInfo(adminId,adminName, showName, password, isPass, isSingleLogin);
            return ai;
        }
献丑了.

Answer 9

首先我们建立User 的数据实体模型 (以下是横向扩展的 带View 功能的贫血模型，类似POJO的思路)
[Entity("Models.Users", "Users")]
    [EntityID(Hanker.Persistence.Attribute.EntityIDType.Identity, "UserCode")]
    public class Users
    {
        private string userCode = string.Empty;
        [Field("UserNo",typeof(string),30,1)]
        public string UserCode
        {
            get { return userCode; }
            set { userCode = value; }
        }        private string userName = string.Empty;
        [Field("UserName",typeof(string),30,2)]
        public string UserName
        {
            get { return userName; }
            set { userName = value; }
        }        private int id;        [Field("ID", typeof(int), 30,true,true)]
        public int Id
        {
            get { return id; }
            set { id = value; }
        }        private string departCode;
        [Field("DepartNo", typeof(string))]
        public string  DepartCode
        {
            get { return departCode; }
            set { departCode = value; }
        }        private string departName = string.Empty;
        [Field("departName", typeof(string),false,false,true)]
        [Relation(typeof(Departments), "DepartCode", RelationType.OneToMany)]
        public string DepartName
        {
            get { return departName; }
            set { departName = value; }
        }        private string address;
        [Field("address", typeof(string), false, false, true)]
        [Relation(typeof(Departments), "DepartCode", RelationType.OneToMany)]
        public string Address
        {
            get { return address; }
            set { address = value; }
        }    }
模型是UI，BAL 联系的主线 ，它贯穿系统整个领域。然后，BAL 接受UI提供的搜索信息，我们暂时用Condition 对象表示例如：
  EntityFactory factory = new EntityFactory();
            ConditionCollection conditions = new ConditionCollection();
            Condition condition = new Condition();
            condition.ColumnName = "UserName";
            condition.ColumnType = DbType.String;
            condition.Symbol = SqlCompareSymbol.Equal;
            condition.Value = "Test";
            conditions.Add(condition);
            List<Users> userList = factory.Query<Users>(conditions);
            //判断是否存 的一些处理等等            if (userList.Count>0)
            {
            }
            else
            {
            }
            
然后将这些结果 返回UI。在Bal 中使用的ORM组件，它替代了传统意义的DAL。重要的是减少了SQL的出现还有，如果真的把所有判断放置到BAL 中，有些不现实。例如 在输入某模型的长度限制什么的，因为放置到BAL，考虑到有可能是
分布式程序，那么这样会加大网路流量等等。所以具体情况，具体分析。说错了别怪我！