MVC实战起步（一）：一个简易框架的搭建

一：引言

这仅仅是一个新手写给新手共同入门的博文！这是一个使用MVC，和一些主流框架（Autofac,Log4Net等）来完成的一个简单的项目。和各位学习MVC的朋友们一起学习。

二：项目分层

如左图所示，先建好文件夹，然后再来填充内容。

一：Zero,MVC4.0项目

二：Domain: Abstract仓储类接口，Concrete仓储类实现，Entities实体模型

三：Infrastructure：基础设施

四：IOC：主要用于解耦仓储类接口

三：Infrastructure层建设

首先，从最底层写起：

第一步，写一个操作数据库的类

我这边采用的是底层使用ADO.NET，通过泛型约束和反射来实现一个简单的ORM

1：先在Conntion里面放一个SQLHelper类（找个自己熟悉的），这里就不做工厂了。怎么简单怎么来，先让东西跑起来

2：写个属于自己的ORM类：我们先来想想，如果不考虑存储过程（返回集合，直接LINQ处理数据），我们需要什么东西来拼接SQL语句，首先，要有表名，然后主键，然后各个字段名称，其他的先不考虑，现在写一个IDateBase抽象类来约束实体类，往Infrastructure层的IBase文件夹里新建一个IDateBase抽象类，代码如下：

namespace Zero.Infrastructure.IBase
{
    public abstract class IDataBase
    {
        public virtual string TableName { get; set; }

        public virtual int ID { get; set; }

    }
}

abstract class IDataBase

这样就解决了表名和主键名称在用泛型的时候，取不到的问题了，但是字段名称不行啊，每个表的字段都不一样，所以最后还是要用到反射，写一个特性来反射，在Infrastructure层的Attributes文件夹下面建立一个类DataFieldAttribute

代码如下：

namespace Zero.Infrastructure.Attributes
{
    public class DataFieldAttribute : Attribute
    {
        private string _FieldName;
        public DataFieldAttribute(string fieldname)
        {
            this._FieldName = fieldname;
        }
        public string FieldName
        {
            get { return this._FieldName; }
            set { this._FieldName = value; }
        }
    }
}

完事具备，我们先写一个实体类，然后开始写ORM

实体里建立在Domain的Entities文件夹下面，记得Domain层要引用Infrastructure层

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Zero.Infrastructure.Attributes;
using Zero.Infrastructure.IBase;

namespace Zero.Domain.Entities
{
    public class User: IDataBase
    {

        public User()
        {
            TableName = "User";
        }

        private string _TableName;

        public override string TableName
        {
            get
            {
                if (_TableName == null)
                { return "User"; }
                else { return _TableName; }
            }
            set { _TableName = value; }
        }

        public override int ID { get; set; }

        [DataFieldAttribute("UserName")]
        public string UserName { get; set; }

    }
}

代码如上

现在开始写自己的ORM类

在Infrastructure层的Conntion文件夹下面建立一个ZeroORM类，ORM需要实现的功能有：查询，添加，更改，删除，4个基本功能

public class ZeroORMwhere<T> where T : IBase.IDataBase
{

    public string SqlConnctionString { get; set; }
    public SqlConnection conn { get; set; }
    public SqlTransaction tran { get; set; }

}

然后增加查询方法：

/// <summary>
    /// 获得实体T所有数据
    /// </summary>
    /// <returns></returns>
    public List<T> Select(T t)
    {
        List<T> list = new List<T>();
        string sql = "select * from " + t.TableName + " WITH (NOLOCK) order by id desc";

        DataSet ds = SqlHelper.ExecuteDataset(SqlConnctionString, CommandType.Text, sql);
        for (int i = 0; i < ds.Tables[0].Rows.Count; i++)
        {
            list.Add(DataSetToEntity.DsToEntity<T>(ds, i));
        }
        return list;
    }

DataSetToEntity这个类就是网上找的Dataset转实体的方法，大家可以网上找下，最后返回一个List集合

然后是添加方法

/// <summary>
       /// 插入新数据
       /// </summary>
       /// <param name="t">实体类</param>
       /// <returns></returns>
       public int Insert(T t)
       {
           try
           {
               Type mytype = t.GetType();
               // 获取类的所有公共属性
               System.Reflection.PropertyInfo[] pInfo = mytype.GetProperties();
               string FieldName = "";//字段名称
               string Values = "";//值
               StringBuilder sql = new StringBuilder();
               List<SqlParameter> paras = new List<SqlParameter>();//不定参集合，防注入

               sql.Append("Insert into ");
               sql.Append(mytype.Name);//数据库表名，可以放t.TableName
               sql.Append("(");
               object[] objDataFieldAttribute = null;
               foreach (System.Reflection.PropertyInfo pio in pInfo)
               {
                   objDataFieldAttribute = pio.GetCustomAttributes(typeof(DataFieldAttribute), false);
                   if (objDataFieldAttribute != null && objDataFieldAttribute.Length > 0)
                   {
                       FieldName += ((DataFieldAttribute)objDataFieldAttribute[0]).FieldName + ",";//给字段赋值
                       Values += "@" + ((DataFieldAttribute)objDataFieldAttribute[0]).FieldName + ",";//给对应字段的值赋值
                       paras.Add(new SqlParameter("@" + ((DataFieldAttribute)objDataFieldAttribute[0]).FieldName, pio.GetValue(t, null)));//添加不定参
                   }
               }
               FieldName = FieldName.TrimEnd(‘,‘);
               Values = Values.TrimEnd(‘,‘);
               sql.Append(FieldName);
               sql.Append(") VAlUES (");
               sql.Append(Values);
               sql.Append(")");
               int i = SqlHelper.ExecuteNonQuery(SqlConnctionString, CommandType.Text, sql.ToString(), paras.ToArray());
               return i;
           }
           catch (Exception)
           {
               return -1;
               throw;
           }

       }

还有修改和删除方法，以及带事务的方法，一起贴出来。

using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Linq;
using System.Reflection;
using System.Text;
using Zero.Infrastructure.Attributes;
using Zero.Infrastructure.Utilities;

namespace Zero.Infrastructure.Conntion
{
    public class ZeroORM<T> where T : IBase.IDataBase
    {

        public string SqlConnctionString { get; set; }
        public SqlConnection conn { get; set; }
        public SqlTransaction tran { get; set; }

        /// <summary>
        /// 获得实体T所有数据
        /// </summary>
        /// <returns></returns>
        public List<T> Select(T t)
        {
            List<T> list = new List<T>();
            string sql = "select * from [" + t.TableName + "] WITH (NOLOCK) order by id desc";  //出于性能考虑，不用反射来获取表名
            DataSet ds = SqlHelper.ExecuteDataset(SqlConnctionString, CommandType.Text, sql);
            for (int i = 0; i < ds.Tables[0].Rows.Count; i++)
            {
                list.Add(DataSetToEntity.DsToEntity<T>(ds, i));
            }
            return list;
        }

        /// <summary>
        /// 根据主键ID获取数据（一条）
        /// </summary>
        /// <param name="id"></param>
        /// <param name="TableName"></param>
        /// <returns></returns>
        public T SelectByID(int id, T t)
        {

            string sql = "select * from [" + t.TableName + "] WITH (NOLOCK) where [email protected]"; //出于性能考虑，不用反射来获取表名
            DataSet ds = SqlHelper.ExecuteDataset(SqlConnctionString, CommandType.Text, sql, new SqlParameter("@ID", id));
            t = DataSetToEntity.DsToEntity<T>(ds, 0);
            PropertyInfo[] prop = t.GetType().GetProperties();
            return t;

        }

        /// <summary>
        /// 插入新数据
        /// </summary>
        /// <param name="t">实体类</param>
        /// <returns></returns>
        public int Insert(T t)
        {
            try
            {
                Type mytype = t.GetType();
                // 获取类的所有公共属性
                System.Reflection.PropertyInfo[] pInfo = mytype.GetProperties();
                string FieldName = "";//字段名称
                string Values = "";//值
                StringBuilder sql = new StringBuilder();
                List<SqlParameter> paras = new List<SqlParameter>();

                sql.Append("Insert into [");
                sql.Append(mytype.Name);//数据库表名
                sql.Append("](");
                object[] objDataFieldAttribute = null;
                foreach (System.Reflection.PropertyInfo pio in pInfo)
                {
                    objDataFieldAttribute = pio.GetCustomAttributes(typeof(DataFieldAttribute), false);
                    if (objDataFieldAttribute != null && objDataFieldAttribute.Length > 0)
                    {
                        FieldName += ((DataFieldAttribute)objDataFieldAttribute[0]).FieldName + ",";
                        Values += "@" + ((DataFieldAttribute)objDataFieldAttribute[0]).FieldName + ",";
                        paras.Add(new SqlParameter("@" + ((DataFieldAttribute)objDataFieldAttribute[0]).FieldName, pio.GetValue(t, null)));
                    }
                }
                FieldName = FieldName.TrimEnd(‘,‘);
                Values = Values.TrimEnd(‘,‘);
                sql.Append(FieldName);
                sql.Append(") VAlUES (");
                sql.Append(Values);
                sql.Append(")");
                int i = SqlHelper.ExecuteNonQuery(SqlConnctionString, CommandType.Text, sql.ToString(), paras.ToArray());
                return i;
            }
            catch (Exception)
            {
                return -1;
                throw;
            }

        }

        /// <summary>
        /// 更新数据
        /// </summary>
        /// <param name="t">需更新的实体类</param>
        /// <returns></returns>
        public int Update(T t)
        {
            try
            {
                int i = 0;
                int primarykey = t.ID;
                T oldT = t;
                Type mytype = t.GetType();
                System.Reflection.PropertyInfo[] pInfo = mytype.GetProperties();
                oldT = SelectByID(primarykey, oldT);//获得原始值，为日志做准备
                if (t != oldT)
                {
                    string SetValue = "";//字段名称
                    string Where = " where [email protected]";//值
                    StringBuilder sql = new StringBuilder();
                    List<SqlParameter> paras = new List<SqlParameter>();
                    sql.Append("Update [");
                    sql.Append(mytype.Name);
                    sql.Append("] Set ");
                    object[] objDataFieldAttribute = null;
                    foreach (System.Reflection.PropertyInfo pio in pInfo)
                    {
                        objDataFieldAttribute = pio.GetCustomAttributes(typeof(DataFieldAttribute), false);
                        if (objDataFieldAttribute != null && objDataFieldAttribute.Length > 0 && pio.GetValue(t, null).ToString() != pio.GetValue(oldT, null).ToString())
                        {
                            SetValue += ((DataFieldAttribute)objDataFieldAttribute[0]).FieldName + "=" + "@" + ((DataFieldAttribute)objDataFieldAttribute[0]).FieldName + ",";
                            paras.Add(new SqlParameter("@" + ((DataFieldAttribute)objDataFieldAttribute[0]).FieldName, pio.GetValue(t, null)));
                        }
                    }

                    SetValue = SetValue.TrimEnd(‘,‘);
                    sql.Append(SetValue);
                    sql.Append(Where);
                    paras.Add(new SqlParameter("@ID", primarykey));
                    i = SqlHelper.ExecuteNonQuery(SqlConnctionString, CommandType.Text, sql.ToString(), paras.ToArray());
                    return i;
                }
                else
                {
                    return -2;
                }

            }
            catch (Exception)
            {
                return -1;
                throw;
            }

        }

        /// <summary>
        /// 删除数据
        /// </summary>
        /// <param name="t"></param>
        /// <returns></returns>
        public int Delete(T t)
        {
            int i = 0;
            int primarykey = t.ID;
            Type mytype = t.GetType();
            string TableName = mytype.Name;
            string Where = " where ID [email protected]";
            string sql = "DELETE FROM " + TableName + Where;
            try
            {
                i = SqlHelper.ExecuteNonQuery(SqlConnctionString, CommandType.Text, sql, new SqlParameter("@ID", primarykey));
                return i;
            }
            catch (Exception)
            {
                return -1;
                throw;
            }

        }

        /// <summary>
        /// 开始事务
        /// </summary>
        /// <returns></returns>
        public void BeginTran()
        {
            try
            {
                conn = new SqlConnection(SqlConnctionString);
                conn.Open();
                tran = conn.BeginTransaction();

            }
            catch (Exception)
            {
                tran.Rollback();
                conn.Close();

                throw;
            }

        }

        /// <summary>
        /// 带事务的插入方法
        /// </summary>
        /// <param name="t"></param>
        /// <returns></returns>
        public int InsertByTran(T t)
        {

            try
            {
                Type mytype = t.GetType();
                // 获取类的所有公共属性
                System.Reflection.PropertyInfo[] pInfo = mytype.GetProperties();
                string FieldName = "";//字段名称
                string Values = "";//值
                StringBuilder sql = new StringBuilder();
                List<SqlParameter> paras = new List<SqlParameter>();
                sql.Append("Insert into [");
                sql.Append(mytype.Name);//数据库表名
                sql.Append("](");
                object[] objDataFieldAttribute = null;
                foreach (System.Reflection.PropertyInfo pio in pInfo)
                {
                    objDataFieldAttribute = pio.GetCustomAttributes(typeof(DataFieldAttribute), false);
                    if (objDataFieldAttribute != null && objDataFieldAttribute.Length > 0)
                    {
                        FieldName += ((DataFieldAttribute)objDataFieldAttribute[0]).FieldName + ",";
                        Values += "@" + ((DataFieldAttribute)objDataFieldAttribute[0]).FieldName + ",";
                        paras.Add(new SqlParameter("@" + ((DataFieldAttribute)objDataFieldAttribute[0]).FieldName, pio.GetValue(t, null)));
                    }
                }
                FieldName = FieldName.TrimEnd(‘,‘);
                Values = Values.TrimEnd(‘,‘);
                sql.Append(FieldName);
                sql.Append(") VAlUES (");
                sql.Append(Values);
                sql.Append(")");
                int i = SqlHelper.ExecuteNonQuery(tran, CommandType.Text, sql.ToString(), paras.ToArray());
                return i;
            }
            catch (Exception)
            {
                tran.Rollback();
                return -1;
                throw;
            }

        }

        /// <summary>
        /// 带事务的更新方法
        /// </summary>
        /// <param name="t"></param>
        /// <returns></returns>
        public int UpdateByTran(T t)
        {
            try
            {
                int i = 0;
                int primarykey = t.ID;
                T oldT = t;
                Type mytype = t.GetType();
                System.Reflection.PropertyInfo[] pInfo = mytype.GetProperties();
                oldT = SelectByID(primarykey, oldT);//获得原始值，为日志做准备
                if (t != oldT)
                {
                    string SetValue = "";//字段名称
                    string Where = " where [email protected]";//值
                    StringBuilder sql = new StringBuilder();
                    List<SqlParameter> paras = new List<SqlParameter>();
                    sql.Append("Update [");
                    sql.Append(mytype.Name);
                    sql.Append("] Set ");
                    object[] objDataFieldAttribute = null;
                    foreach (System.Reflection.PropertyInfo pio in pInfo)
                    {
                        objDataFieldAttribute = pio.GetCustomAttributes(typeof(DataFieldAttribute), false);
                        if (objDataFieldAttribute != null && objDataFieldAttribute.Length > 0 && pio.GetValue(t, null).ToString() != pio.GetValue(oldT, null).ToString())
                        {
                            SetValue += ((DataFieldAttribute)objDataFieldAttribute[0]).FieldName + "=" + "@" + ((DataFieldAttribute)objDataFieldAttribute[0]).FieldName + ",";
                            paras.Add(new SqlParameter("@" + ((DataFieldAttribute)objDataFieldAttribute[0]).FieldName, pio.GetValue(t, null)));
                        }
                    }

                    SetValue = SetValue.TrimEnd(‘,‘);
                    sql.Append(SetValue);
                    sql.Append(Where);
                    paras.Add(new SqlParameter("@ID", primarykey));
                    i = SqlHelper.ExecuteNonQuery(tran, CommandType.Text, sql.ToString(), paras.ToArray());
                    return i;
                }
                else
                {
                    tran.Rollback();
                    return -2;
                }

            }
            catch (Exception)
            {
                tran.Rollback();
                return -1;
                throw;
            }
        }

        /// <summary>
        /// 带事务的删除方法
        /// </summary>
        /// <param name="t"></param>
        /// <returns></returns>
        public int DeleteByTran(T t)
        {
            int i = 0;
            int primarykey = t.ID;
            Type mytype = t.GetType();
            string TableName = mytype.Name;
            string Where = "] where ID [email protected]";
            string sql = "DELETE FROM [" + TableName + Where;
            try
            {
                i = SqlHelper.ExecuteNonQuery(tran, CommandType.Text, sql, new SqlParameter("@ID", primarykey));
                return i;
            }
            catch (Exception)
            {
                tran.Rollback();
                return -1;
                throw;
            }

        }

        /// <summary>
        /// 带事务和条件的删除方法
        /// </summary>
        /// <param name="t"></param>
        /// <returns></returns>
        public int DeleteByTran(T t, string where)
        {
            if (where.IndexOf("1=1") > 0)
            {
                return -1;
            }
            int i = 0;
            string Where = "] where " + where;
            string sql = "DELETE FROM [" + t.TableName + Where;
            try
            {
                i = SqlHelper.ExecuteNonQuery(tran, CommandType.Text, sql, null);
                return i;
            }
            catch (Exception)
            {
                tran.Rollback();
                return -1;
                throw;
            }

        }

        /// <summary>
        /// 提交事务
        /// </summary>
        /// <returns></returns>
        public void CommitTran()
        {
            try
            {
                tran.Commit();
                conn.Close();

            }
            catch (Exception)
            {
                tran.Rollback();
                conn.Close();
                throw;
            }
            finally
            {
                tran.Dispose();
                conn.Dispose();
            }

        }

        /// <summary>
        /// 回滚事务
        /// </summary>
        public void RollBackTran()
        {
            try
            {
                tran.Rollback();
            }
            catch (Exception)
            {

                throw;
            }
        }

    }
}

好了，整个ORM就写完了，这样我们数据处理的类就写完了！

三：Domain层

ORM写完后，因为不同的表可能在不同的库中，所以ZeroORM还不能直接拿来用，需要在上面隔离一层，我们这里选择最简单的方式，大牛勿喷。

首先写一个Repository基类（这里就不抽象类了），代码如下

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Zero.Domain.Abstract;
using Zero.Infrastructure.IBase;

namespace Zero.Domain.Concrete
{
    public class ConcreteBase<T> where T : IDataBase
    {
        public Zero.Infrastructure.Conntion.ZeroORM<T> DbHelper;

        public ConcreteBase()
        {
            DbHelper = new Infrastructure.Conntion.ZeroORM<T>();
        }

        public string SqlConnctionString { get { return DbHelper.SqlConnctionString; } set { DbHelper.SqlConnctionString = value; } }

        public List<T> GetAllList(T t)
        {
            List<T> ubiList = new List<T>();
            ubiList = DbHelper.Select(t);
            return ubiList;
        }

        public bool Insert(T t)
        {
            int i = 0;
            i = DbHelper.Insert(t);
            return i > 0;
        }

        public bool Update(T t)
        {
            int i = 0;
            i = DbHelper.Update(t);
            return i > 0;
        }

        public bool Delete(T t)
        {
            int i = 0;
            i = DbHelper.Delete(t);
            return i > 0;
        }

        /// <summary>
        /// 带事务的插入方法
        /// </summary>
        /// <param name="t"></param>
        /// <returns></returns>
        public bool InsertByTran(T t)
        {
            if (DbHelper.tran == null)
            {
                DbHelper.BeginTran();
            }
            int i = DbHelper.InsertByTran(t);
            return i > 0;
        }

        /// <summary>
        /// 带事务的更新方法
        /// </summary>
        /// <param name="t"></param>
        /// <returns></returns>
        public bool UpdateByTran(T t)
        {
            if (DbHelper.tran == null)
            {
                DbHelper.BeginTran();
            }
            int i = DbHelper.UpdateByTran(t);
            return i > 0;
        }

        /// <summary>
        /// 带事务的删除方法
        /// </summary>
        /// <param name="t"></param>
        /// <returns></returns>
        public bool DeleteByTran(T t)
        {
            if (DbHelper.tran == null)
            {
                DbHelper.BeginTran();
            }
            int i = DbHelper.DeleteByTran(t);
            return i > 0;
        }

        /// <summary>
        /// 带事务和条件的删除方法
        /// </summary>
        /// <param name="t"></param>
        /// <returns></returns>
        public bool DeleteByTran(T t, string where)
        {
            if (DbHelper.tran == null)
            {
                DbHelper.BeginTran();
            }
            int i = DbHelper.DeleteByTran(t, where);
            return i > 0;
        }

        /// <summary>
        ///
        /// </summary>
        /// <param name="t"></param>
        /// <returns></returns>
        public void RollBackTran()
        {
            DbHelper.RollBackTran();

        }

        /// <summary>
        ///
        /// </summary>
        /// <param name="t"></param>
        /// <returns></returns>
        public void BeginTran()
        {
            DbHelper.BeginTran();

        }

        /// <summary>
        /// 提交事务 提交成功返回"";失败返回错误信息
        /// </summary>
        /// <returns>提交成功返回"";失败返回错误信息</returns>
        public string CommitTran()
        {
            if (DbHelper.tran != null)
            {
                try
                {
                    DbHelper.CommitTran();
                    return "";
                }
                catch (Exception e)
                {
                    return e.ToString();
                    throw;
                }
            }
            else
            {
                return "不存在可提交的事务";
            }
        }

        /// <summary>
        /// 根据主键ID查询结果，返回T
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public T SelectByID(string id, T t)
        {
            if (id != "")
            {

                return DbHelper.SelectByID(int.Parse(id), t);
            }
            else
            {
                return null;
            }
        }

    }
}

然后去写Repository类和IRepository接口

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Zero.Domain.Entities;

namespace Zero.Domain.Abstract
{
    public interface IUserRepository
    {
        User GetEntity();
        IQueryable<User> Users { get; }
    }
}

实现类：

using System;
using System.Collections.Generic;
using System.Configuration;
using System.Linq;
using System.Text;
using Zero.Domain.Abstract;
using Zero.Domain.Entities;

namespace Zero.Domain.Concrete
{
    public class UserRepository : ConcreteBase<User>, IUserRepository
    {
        public User GetEntity()
        {
            return new User();
        }
        public IQueryable<User> BaseTitleTypes
        {
            get { return GetAllList(GetEntity()).AsQueryable(); }
        }

        public UserRepository()
            : base()
        {
            SqlConnctionString = ConfigurationManager.ConnectionStrings["ZeroTest"].ConnectionString;//获取连接字符串
        }

    }
}

然后去数据库建表


链接字符串的位置写的有点蠢，不过先这样做吧，一切已快速为目的

现在，所有的准备工作都做完了，开始测试一下数据交互是否有问题！

在Zero项目中建一个Index控制器

然后右键Index添加视图。先不做IOC解耦，引用Domain层和基础设施层。

添加如下代码

//
  // GET: /Index/

  public ActionResult Index()
  {

      UserRepository us = new UserRepository();
      bool b =us.Insert(new Domain.Entities.User { UserName = "Ambre" });
      if (b)
      {
          var ListEntity = from o in us.Users
                           select o;
          return Json(ListEntity, JsonRequestBehavior.AllowGet);
      }
      else
      {
          return Content(b.ToString());
      }
  }

然后去改下路由设置

启动项目

好了，完成！下篇文章将写如何快速的将IOC应用到项目中，然后前端类似于EasyUi的grid控件如何编写。

谢谢大家，喜欢的话，点个赞，这可是我的处女文呢！

时间： 2024-07-31 16:52:58

MVC实战起步（一）：一个简易框架的搭建的相关文章

利用MVC编程模式-开发一个简易记事本app

学了极客学院一个开发记事本的课程,利用自己对MVC编程模式的简单理解重写了一遍该app. github地址:https://github.com/morningsky/MyNote MVC即,模型(model)-视图(view)-控制器(controller),有效的实现了数据-业务逻辑-视图显示的代码分离,使得加入新功能时不需要重新编写业务逻辑,大大提高了代码的可维护性. 在这个案列中,一开始只是开发了添加文字内容的记事功能,添加图片功能时在activity文件中写入imageview的逻辑

Netty实战：设计一个IM框架就这么简单！

bitchat 是一个基于 Netty 的 IM 即时通讯框架 项目地址:https://github.com/all4you/bitchat 快速开始 bitchat-example 模块提供了一个服务端与客户端的实现示例,可以参照该示例进行自己的业务实现. 启动服务端 要启动服务端,需要获取一个 Server 的实例,可以通过 ServerFactory 来获取. 目前只实现了单机模式下的 Server ,通过 SimpleServerFactory 只需要定义一个端口即可获取一个单机的 S

SSH框架的搭建

1 导言 目的 本文档是根据个人的工作经验搭建的轻量级SSH框架,也是实际应用中比较全面的基础框架,用于指导SSH框架初学者学习搭建SSH框架,希望能给各位使用者提供帮助,同时也希望朋友们尽量去帮助其他人. 说明 本文档是个人总结的经验,仅供参考学习,同时欢迎朋友们一起沟通学习,文档中会对使用的jar做详细解说,对配置的过程使用图文说明,因为SSH博大精深,很多知识在搭建过程中没有使用到,只是一个基础框架的搭建,能测试通过就可以,所以对于高要求的开发,需要自己添加jar.增加方法和配置,同时文档

springBoot框架的搭建

1新建一个项目: 2.注意选择JDK1.8,和选择spring initializr加载springBoot相关jar包: 3.下一步next: 4.下一步next,选择Web和MyBatis然后next,finish就完成了一个SpringBoot框架的搭建了: 5.测试一下搭建的项目是不是可以启动运行,新建一个Hello类,写一个hello方法: 6.因为SpringBoot是默认加载数据源的所以加上@EnableAutoConfiguration(exclude = {DataSource

从零开始实现一个简易的Java MVC框架(三)--实现IOC

Spring中的IOC IoC全称是Inversion of Control,就是控制反转,他其实不是spring独有的特性或者说也不是java的特性,他是一种设计思想.而DI(Dependency Injection),即依赖注入就是Ioc的一种实现方式.关于Ioc和DI的具体定义和优缺点等大家可以自行查找资料了解一下,这里就不详细赘述,总之spring的IoC功能很大程度上便捷了我们的开发工作. 在实现我们的Ioc之前,我们先了解一下spring的依赖注入,在spring中依赖注入有三种方式

使用EF Code First搭建一个简易ASP.NET MVC网站,允许数据库迁移

本篇使用EF Code First搭建一个简易ASP.NET MVC 4网站,并允许数据库迁移. 创建一个ASP.NET MVC 4 网站. 在Models文件夹内创建Person类. public class Person { public int ID { get; set; } public string FirstName { get; set; } public string LastName { get; set; } } 在Controls文件夹内创建PersonControlle

自行实现一个简易RPC框架

10分钟写一个RPC框架 1.RpcFramework package com.alibaba.study.rpc.framework; import java.io.ObjectInputStream; import java.io.ObjectOutputStream; import java.lang.reflect.InvocationHandler; import java.lang.reflect.Method; import java.lang.reflect.Proxy; imp

依赖注入[4]: 创建一个简易版的DI框架[上篇]

本系列文章旨在剖析.NET Core的依赖注入框架的实现原理,到目前为止我们通过三篇文章(<控制反转>.<基于IoC的设计模式>和< 依赖注入模式>)从纯理论的角度对依赖注入进行了深入论述,为了让读者朋友能够更好地理解.NET Core的依赖注入框架的设计思想和实现原理,我们创建了一个简易版本的DI框架,也就是我们在前面文章中多次提及的Cat.我们会上下两篇来介绍这个被称为为Cat的DI框架,上篇介绍编程模型,下篇关注设计实现.[源代码从这里下载] 目录一.DI容器的层

依赖注入[5]: 创建一个简易版的DI框架[下篇]

为了让读者朋友们能够对.NET Core DI框架的实现原理具有一个深刻而认识,我们采用与之类似的设计构架了一个名为Cat的DI框架.在<依赖注入[4]: 创建一个简易版的DI框架[上篇]>中我们介绍了Cat的基本编程模式,接下来我们就来聊聊Cat的设计和实现. 目录一.服务注册:ServiceRegistry 二.DI容器:Cat 三.扩展方法 一.服务注册:ServiceRegistry 由于作为DI容器的Cat对象总是利用预先添加到服务注册来提供对应的服务实例,所以服务注册至关重要.如下