C# DbUtils操作数据库类

最新推荐文章于 2021-01-20 01:52:09 发布
原创 最新推荐文章于 2021-01-20 01:52:09 发布 · 2.7k 阅读 · 1 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
收录于
C#

当前文章被收录于：

C#
77 篇文章 0 人学习

基础类

订阅专栏 查看详情
C#

当前文章被收录于：

C#
28 篇文章 1 人学习
订阅专栏 查看详情
SQL Serve

当前文章被收录于：

SQL Serve
4 篇文章 0 人学习
订阅专栏 查看详情
本文提供了一系列针对SQL数据库操作的方法，包括数据的增删改查、批量操作及存储过程调用等，通过C#实现，适用于需要高效管理和操作SQL Server数据库的应用场景。 
using System;
using System.Collections.Generic;
using System.Data;
using System.Data.SqlClient;
using System.Linq;
using System.Text;
using Omu.ValueInjecter;
using System.Configuration;
using Common.Data.SqlServer;


namespace Common.Data
{
    public static class DbUtils
    {
        static string cs = SqlEasy.connString; //数据库连接字符串
        public static IEnumerable<T> GetWhere<T>(object where) where T : new()
        {
            using (var conn = new SqlConnection(cs))
            {
                using (var cmd = conn.CreateCommand())
                {
                    cmd.CommandType = CommandType.Text;

                    cmd.CommandText = "select * from " + TableConvention.Resolve(typeof(T)) + " where "
                        .InjectFrom(new FieldsBy()
                        .SetFormat("{0}=@{0}")
                        .SetNullFormat("{0} is null")
                        .SetGlue("and"),
                        where);
                    cmd.InjectFrom<SetParamsValues>(where);
                    conn.Open();

                    using (var dr = cmd.ExecuteReader())
                    {
                        while (dr.Read())
                        {
                            var o = new T();
                            o.InjectFrom<ReaderInjection>(dr);
                            yield return o;
                        }
                    }
                }
            }
        }

        public static int CountWhere<T>(object where) where T : new()
        {
            using (var conn = new SqlConnection(cs))
            {
                using (var cmd = conn.CreateCommand())
                {
                    cmd.CommandType = CommandType.Text;
                    cmd.CommandText = "select count(*) from " + TableConvention.Resolve(typeof(T)) + " where "
                        .InjectFrom(new FieldsBy()
                        .SetFormat("{0}=@{0}")
                        .SetNullFormat("{0} is null")
                        .SetGlue("and"),
                        where);
                    cmd.InjectFrom<SetParamsValues>(where);
                    conn.Open();

                    return (int)cmd.ExecuteScalar();
                }
            }
        }

        public static int Delete<T>(int id)
        {
            using (var conn = new SqlConnection(cs))
            using (var cmd = conn.CreateCommand())
            {
                cmd.CommandType = CommandType.Text;
                cmd.CommandText = "delete from " + TableConvention.Resolve(typeof(T)) + " where KeyID=@KeyID";

                cmd.InjectFrom<SetParamsValues>(new { KeyID = id });
                conn.Open();
                return cmd.ExecuteNonQuery();
            }
        }

        public static int Delete<T>(string ids)
        {
            using (var conn = new SqlConnection(cs))
            using (var cmd = conn.CreateCommand())
            {
                cmd.CommandType = CommandType.Text;
                cmd.CommandText = "delete from " + TableConvention.Resolve(typeof(T)) + " where charindex(',' + cast(keyid AS varchar(50)) + ',',','  + @KeyID + ',') > 0";

                cmd.InjectFrom<SetParamsValues>(new { KeyID = ids });
                conn.Open();
                return cmd.ExecuteNonQuery();
            }
        }

        ///<returns> the id of the inserted object </returns>
        public static int Insert(object o)
        {
            using (var conn = new SqlConnection(cs))
            using (var cmd = conn.CreateCommand())
            {
                cmd.CommandType = CommandType.Text;
                o.ToString();
                cmd.CommandText = "insert " + TableConvention.Resolve(o) + " ("
                    .InjectFrom(new FieldsBy().IgnoreFields("keyid"), o) + ") values("
                    .InjectFrom(new FieldsBy().IgnoreFields("keyid").SetFormat("@{0}"), o)
                    + ") select @@identity";

                cmd.InjectFrom(new SetParamsValues().IgnoreFields("keyid"), o);

                conn.Open();
                object obj = cmd.ExecuteScalar();
                return Convert.ToInt32(obj);
            }
        }

        #region 添加数据并且返回guid
        /// <summary>
        /// 添加数据并且返回guid
        /// </summary>
        /// <param name="o">数据</param>
        /// <param name="name">列名称</param>
        /// <returns></returns>
        public static Boolean InsertGuid(object o, string name, out string err)
        {
            var conn = new SqlConnection(cs);
            var cmd = conn.CreateCommand();
            Boolean IsTrue = false;
            err = "";
            try
            {
                cmd.CommandType = CommandType.Text;
                o.ToString();
                cmd.CommandText = "insert " + TableConvention.Resolve(o) + " ("
                    .InjectFrom(new FieldsBy().IgnoreFields(name), o) + ") values("
                    .InjectFrom(new FieldsBy().IgnoreFields(name).SetFormat("@{0}"), o)
                    + ") select @@identity";
                cmd.InjectFrom(new SetParamsValues().IgnoreFields(name), o);
                conn.Open();
                object obj = cmd.ExecuteScalar();
                if (o != null)
                {
                    IsTrue = true;
                }
            }
            catch (Exception ex)
            {
                IsTrue = false;
                err = ex.Message;
            }
            return IsTrue;
        }
        #endregion

        public static int Update(object o)
        {
            using (var conn = new SqlConnection(cs))
            using (var cmd = conn.CreateCommand())
            {
                cmd.CommandType = CommandType.Text;
                cmd.CommandText = "update " + TableConvention.Resolve(o) + " set "
                    .InjectFrom(new FieldsBy().IgnoreFields("keyid").SetFormat("{0}=@{0}"), o)
                    + " where KeyID = @KeyID";

                cmd.InjectFrom<SetParamsValues>(o);

                conn.Open();
                return Convert.ToInt32(cmd.ExecuteNonQuery());
            }
        }

        #region
        /// <summary>
        /// 根据guid修改数据
        /// </summary>
        /// <param name="o">数据</param>
        /// <param name="name">主键列名称</param>
        /// <param name="err">错误信息</param>
        /// <returns></returns>
        public static Boolean UpdateGuid(object o, string name, out string err)
        {
            var conn = new SqlConnection(cs);
            var cmd = conn.CreateCommand();
            Boolean IsTrue = false;
            err = "";
            try
            {
                cmd.CommandType = CommandType.Text;
                cmd.CommandText = "update " + TableConvention.Resolve(o) + " set "
                    .InjectFrom(new FieldsBy().IgnoreFields(name).SetFormat("{0}=@{0}"), o)
                    + " where" + " " + name + "=" + "@" + name;
                cmd.InjectFrom<SetParamsValues>(o);
                conn.Open();
                object obj = cmd.ExecuteScalar();
                if (o != null)
                {
                    IsTrue = true;
                }
            }
            catch (Exception ex)
            {
                IsTrue = false;
                err = ex.Message;
            }
            return IsTrue;
        }
        #endregion

        public static int Update(object o, params string[] fields)
        {
            using (var conn = new SqlConnection(cs))
            using (var cmd = conn.CreateCommand())
            {
                cmd.CommandType = CommandType.Text;
                cmd.CommandText = "update " + TableConvention.Resolve(o) + " set "
                    .InjectFrom(new FieldsBy().IgnoreFields(fields).SetFormat("{0}=@{0}"), o)
                    + " where KeyID = @KeyID";

                cmd.InjectFrom<SetParamsValues>(o);

                conn.Open();
                return Convert.ToInt32(cmd.ExecuteNonQuery());
            }
        }

        public static int UpdateWhatWhere<T>(object what, object where)
        {
            using (var conn = new SqlConnection(cs))
            using (var cmd = conn.CreateCommand())
            {
                cmd.CommandType = CommandType.Text;
                cmd.CommandText = "update " + TableConvention.Resolve(typeof(T)) + " set "
                    .InjectFrom(new FieldsBy().SetFormat("{0}=@{0}"), what)
                    + " where "
                    .InjectFrom(new FieldsBy()
                    .SetFormat("{0}=@wp{0}")
                    .SetNullFormat("{0} is null")
                    .SetGlue("and"),
                    where);

                cmd.InjectFrom<SetParamsValues>(what);
                cmd.InjectFrom(new SetParamsValues().Prefix("wp"), where);

                conn.Open();
                return cmd.ExecuteNonQuery();
            }
        }


        public static int InsertNoIdentity(object o)
        {
            using (var conn = new SqlConnection(cs))
            using (var cmd = conn.CreateCommand())
            {
                cmd.CommandType = CommandType.Text;
                cmd.CommandType = CommandType.Text;
                cmd.CommandText = "insert " + TableConvention.Resolve(o) + " ("
                    .InjectFrom(new FieldsBy().IgnoreFields("keyid"), o) + ") values("
                    .InjectFrom(new FieldsBy().IgnoreFields("keyid").SetFormat("@{0}"), o) + ")";

                cmd.InjectFrom<SetParamsValues>(o);

                conn.Open();
                return cmd.ExecuteNonQuery();
            }
        }

        /// <returns>rows affected</returns>
        public static int ExecuteNonQuerySp(string sp, object parameters)
        {
            using (var conn = new SqlConnection(cs))
            {
                using (var cmd = conn.CreateCommand())
                {
                    cmd.CommandType = CommandType.StoredProcedure;
                    cmd.CommandText = sp;
                    cmd.InjectFrom<SetParamsValues>(parameters);
                    conn.Open();
                    return cmd.ExecuteNonQuery();
                }
            }
        }

        public static int ExecuteNonQuery(string commendText, object parameters)
        {
            using (var conn = new SqlConnection(cs))
            {
                using (var cmd = conn.CreateCommand())
                {
                    cmd.CommandType = CommandType.Text;
                    cmd.CommandText = commendText;
                    cmd.InjectFrom<SetParamsValues>(parameters);
                    conn.Open();
                    return cmd.ExecuteNonQuery();
                }
            }
        }

        public static IEnumerable<T> ExecuteReader<T>(string sql, object parameters) where T : new()
        {
            using (var conn = new SqlConnection(cs))
            {
                using (var cmd = conn.CreateCommand())
                {
                    cmd.CommandType = CommandType.Text;
                    cmd.CommandText = sql;
                    cmd.InjectFrom<SetParamsValues>(parameters);
                    conn.Open();
                    using (var dr = cmd.ExecuteReader())
                        while (dr.Read())
                        {
                            var o = new T();
                            o.InjectFrom<ReaderInjection>(dr);
                            yield return o;
                        }
                }
            }
        }


        public static IEnumerable<T> ExecuteReaderSp<T>(string sp, object parameters) where T : new()
        {
            using (var conn = new SqlConnection(cs))
            {
                using (var cmd = conn.CreateCommand())
                {
                    cmd.CommandType = CommandType.StoredProcedure;
                    cmd.CommandText = sp;
                    cmd.InjectFrom<SetParamsValues>(parameters);
                    conn.Open();
                    using (var dr = cmd.ExecuteReader())
                        while (dr.Read())
                        {
                            var o = new T();
                            o.InjectFrom<ReaderInjection>(dr);
                            yield return o;
                        }
                }
            }
        }

        public static IEnumerable<T> ExecuteReaderSpValueType<T>(string sp, object parameters)
        {
            using (var conn = new SqlConnection(cs))
            {
                using (var cmd = conn.CreateCommand())
                {
                    cmd.CommandType = CommandType.StoredProcedure;
                    cmd.CommandText = sp;
                    cmd.InjectFrom<SetParamsValues>(parameters);
                    conn.Open();
                    using (var dr = cmd.ExecuteReader())
                        while (dr.Read())
                        {
                            yield return (T)dr.GetValue(0);
                        }
                }
            }
        }

        public static int Count<T>()
        {
            using (var conn = new SqlConnection(cs))
            {
                using (var cmd = conn.CreateCommand())
                {
                    cmd.CommandType = CommandType.Text;
                    cmd.CommandText = "select count(*) from " + TableConvention.Resolve(typeof(T));
                    conn.Open();

                    return (int)cmd.ExecuteScalar();
                }
            }
        }

        public static int GetPageCount(int pageSize, int count)
        {
            var pages = count / pageSize;
            if (count % pageSize > 0) pages++;
            return pages;
        }

        public static IEnumerable<T> GetAll<T>() where T : new()
        {
            using (var conn = new SqlConnection(cs))
            {
                using (var cmd = conn.CreateCommand())
                {
                    cmd.CommandType = CommandType.Text;
                    cmd.CommandText = "select * from " + TableConvention.Resolve(typeof(T));
                    conn.Open();

                    using (var dr = cmd.ExecuteReader())
                    {
                        while (dr.Read())
                        {
                            var o = new T();
                            o.InjectFrom<ReaderInjection>(dr);
                            yield return o;
                        }
                    }
                }
            }
        }

        public static IEnumerable<T> GetList<T>(string sql, object parameters) where T : new()
        {
            using (var conn = new SqlConnection(cs))
            {
                using (var cmd = conn.CreateCommand())
                {
                    cmd.CommandType = CommandType.Text;
                    cmd.CommandText = sql;
                    cmd.InjectFrom<SetParamsValues>(parameters);
                    conn.Open();

                    using (var dr = cmd.ExecuteReader())
                    {
                        while (dr.Read())
                        {
                            var o = new T();
                            o.InjectFrom<ReaderInjection>(dr);
                            yield return o;
                        }
                    }
                }
            }
        }

        public static DataTable GetPageWithSp(ProcCustomPage pcp, out int recordCount)
        {
            using (var conn = new SqlConnection(cs))
            {
                using (var cmd = conn.CreateCommand())
                {
                    cmd.CommandType = CommandType.StoredProcedure;
                    cmd.CommandText = pcp.Sp_PagerName;
                    cmd.InjectFrom(new SetParamsValues().IgnoreFields("sp_pagername"), pcp);

                    SqlParameter outputPara = new SqlParameter("@RecordCount", SqlDbType.Int);
                    outputPara.Direction = ParameterDirection.Output;
                    cmd.Parameters.Add(outputPara);

                    conn.Open();

                    using (var da = new SqlDataAdapter(cmd))
                    {
                        DataSet ds = new DataSet();
                        da.Fill(ds);
                        cmd.Parameters.Clear();
                        recordCount = PublicMethod.GetInt(outputPara.Value);
                        conn.Close();
                        return ds.Tables[0];
                    }
                }
            }
        }

        public static void GetCountWhere(ProcCustomPage pcp, out int recordCount)
        {
            using (var conn = new SqlConnection(cs))
            {
                using (var cmd = conn.CreateCommand())
                {
                    cmd.CommandType = CommandType.StoredProcedure;
                    SqlParameter outputPara = new SqlParameter("@RecordCount", SqlDbType.Int);
                    outputPara.Direction = ParameterDirection.Output;
                    cmd.Parameters.Add(outputPara);

                    conn.Open();

                    using (var da = new SqlDataAdapter(cmd))
                    {
                        cmd.Parameters.Clear();
                        recordCount = PublicMethod.GetInt(outputPara.Value);
                        conn.Close();
                    }
                }
            }
        }

        public static IEnumerable<T> GetPage<T>(int page, int pageSize) where T : new()
        {
            using (var conn = new SqlConnection(cs))
            {
                using (var cmd = conn.CreateCommand())
                {
                    var name = TableConvention.Resolve(typeof(T));

                    cmd.CommandType = CommandType.Text;
                    cmd.CommandText = string.Format(@"with result as(select *, ROW_NUMBER() over(order by keyid desc) nr
                            from {0}
                    )
                    select  * 
                    from    result
                    where   nr  between (({1} - 1) * {2} + 1)
                            and ({1} * {2}) ", name, page, pageSize);
                    conn.Open();

                    using (var dr = cmd.ExecuteReader())
                    {
                        while (dr.Read())
                        {
                            var o = new T();
                            o.InjectFrom<ReaderInjection>(dr);
                            yield return o;
                        }
                    }
                }
            }
        }

        public static T Get<T>(long keyid) where T : new()
        {
            using (var conn = new SqlConnection(cs))
            using (var cmd = conn.CreateCommand())
            {
                cmd.CommandType = CommandType.Text;
                cmd.CommandText = "select * from " + TableConvention.Resolve(typeof(T)) + " where keyid = " + keyid;
                conn.Open();

                using (var dr = cmd.ExecuteReader())
                    while (dr.Read())
                    {
                        var o = new T();
                        o.InjectFrom<ReaderInjection>(dr);
                        return o;
                    }
            }
            return default(T);
        }

        #region
        /// <summary>
        /// 根据guid获取数据
        /// </summary>
        /// <typeparam name="T">表名</typeparam>
        /// <param name="keyid">主键id</param>
        /// <param name="name">需要改的主键列</param>
        /// <returns></returns>
        public static T GetGuid<T>(string keyid, string name) where T : new()
        {
            using (var conn = new SqlConnection(cs))
            using (var cmd = conn.CreateCommand())
            {
                cmd.CommandType = CommandType.Text;
                cmd.CommandText = "select * from " + TableConvention.Resolve(typeof(T)) + " where " + name + "=" + "'" + keyid + "'";
                conn.Open();

                using (var dr = cmd.ExecuteReader())
                    while (dr.Read())
                    {
                        var o = new T();
                        o.InjectFrom<ReaderInjection>(dr);
                        return o;
                    }
            }
            return default(T);
        }
        #endregion

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Common.Data
{
    public class ProcCustomPage
    {


        public ProcCustomPage() 
        {
            ShowFields = "*";
            KeyFields = "keyid";
            OrderFields = "keyid desc";
            PageIndex = 1;
            PageSize = 20;
            WhereString = "";
            Sp_PagerName = "ProcCustomPage";
        }

        public string Sp_PagerName
        {
            get;
            set;
        }

        public ProcCustomPage(string tablename) :this()
        {
            TableName = tablename;
        }
        
        /// <summary>
        /// 表名或视图名称
        /// </summary>
        public string TableName { get; set; }

        /// <summary>
        /// 查询字段
        /// </summary>
        public string ShowFields { get; set; }

        /// <summary>
        /// 主键或标识字段
        /// </summary>
        public string KeyFields { get; set; }

        /// <summary>
        /// 排序字段 如：keyid desc,name asc
        /// </summary>
        public string OrderFields { get; set; }

        /// <summary>
        /// 页码
        /// </summary>
        public int PageIndex { get; set; }

        /// <summary>
        /// 每页记录数
        /// </summary>
        public int PageSize { get; set; }

        /// <summary>
        /// 查询条件
        /// </summary>
        public string WhereString { get; set; }
    }
}


ProcCustomPage类：


TableConvention类：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace Common.Data
{
    public static class TableConvention
    {

        public static string Resolve(Type t)
        {
            string _tablename = "";
            TableNameAttribute tableName;
            var name = t.Name;
            foreach(Attribute  attr in t.GetCustomAttributes(true))
            {
                tableName = attr as TableNameAttribute;
                if(tableName!=null)
                    _tablename = tableName.Name;
            }

            if (string.IsNullOrEmpty(_tablename))
            {
                if (name.EndsWith("s"))
                    _tablename = t.Name + "es";
                _tablename = t.Name + "s";
            }

            return _tablename;
        }

        public static string Resolve(object o)
        {
            return Resolve(o.GetType());
        }
    }
}




标签
#C#
DBUtils（通用的数据库工具类）
01-05
DBUtils（通用的数据库工具类）DBUtils（通用的数据库工具类）
DBUtil(ASP。NET数据库连接工具类)
07-14
DBUtil(ASP。NET数据库连接工具类)，集成了目前常用数据库，开发程序时不用再写一大堆连接代码 ，直接调用就行，节省时间，方便快速
一个通用数据库操作组件DBUtil(c#)、支持SqlServer、Oracle、Mysql、postgres、Access、SQLITE
火焰
02-05 8205
DBUtil 使用说明 一、简介 这是一个.net下操作数据库(结构数据库)的工具类库，支持sqlserver、oracle、mysql、postgres、sqlite、access等常见数据库。 注意：它并不是一个orm工具(常见的orm框架如：EF、NHibernate等)。本框架与dapper相比更加轻量，你看一看做是DbHelper的扩展封装。 二、快速示例 2.1 引入DBU...
C#编写的集dao+dbUtil+分页+自定义验证+自定义控件的asp.net网站实例
06-25
本案例优势突出，简单通俗，移植性非常好（相对路径数据库技术），主要有以下特色： 1、相对数据库路径，通过db的数据库连接文件可用直接连接相对路径数据库，所以本人案例支持外部IIS的支持asp.net的动态服务器空间； 2、CRUD标准化处理代码，等于是通用方法，移植到任何程序，直接调用dbApp类的增删查改方法，就可以得到预期表格； 3、借鉴javaEE的dao+daoUtil模式，对于user类，直接赋一个实例，可实现userLogin(user u)(用户登陆验证)、userReg(user u)（用户注册），直接封装到PO对象user类，对于不同的数据，只需更改user类的名称和字段，如book类，把userDao类代码复制为bookDao代码，基本可以直接移植使用； 4、分页代码，完全依据通用代码写成的分页程序，不是依赖控件，整个案例的登陆、验证、注册、分页等全部使用代码完成，所以很容易移植，而不是程序中杂乱的控件名称，所以我比较偏爱用代码来写asp.net网站； 5、代码简洁高效，基本整合了asp.net网站必须的增删查改，而且连接到数据库，只用了5个页面，每个几乎不到10行的代码就完成，便于新手掌握面向对象编程，高效的dao方式，对于快速部署的重要意义。
JDBC相关（三）：DButils工具类的使用详解
hu_huawei的博客
08-14 807
前言：DbUtils是一个为简化JDBC操作的小类库，其依赖的JAR包可在此处下载：点此处下载DButils的JAR包 commons-dbutils是Apache组织提供的一个开源JDBC工具类库，它是对JDBC的简单封装，学习成本极低，并且使用dbutils能极大简化jdbc编码的工作量，同时也不会影响程序的性能。因此dbutils成为很多不喜欢hibernate的公司的首选。 整个dbuti
C#三层架构第五课之DBUtil层设计
张晨光老师的播客
10-12 704
DBUtil层设计一般用来设计通用的数据库连接类或者其他字符编码处理、IO处理等通用类的设计。 参考代码如下： using System; using System.Collections.Generic; using System.Linq; using System.Text; using System.Threading.Tasks; using System.Data; using System.Data.SqlClient; namespace DbUtil { public cla
DBUtils使用详解一
热门推荐
luxiaoyu_sdc的专栏
03-16 2万+
一, 先熟悉DBUtils的API：  简介： DbUtils是一个为简化JDBC操作的小类库。 以下使用的是最新版的commons-dbutils-1.4，先给个简介，以便迅速掌握API的使用。       整个dbutils总共才3个包： 1、包org.apache.commons.dbutils          接口摘要 ResultSetHandler
DBUtils
qq_46893497的博客
12-17 939
DBUtils1 概述2 准备数据3 QueryRunner核心类介绍提供数据源(==不管事务==)提供连接(==管事务==)4 QueryRunner实现添加、更新、删除操作添加更新删除5 QueryRunner实现查询操作ResultSetHandler 结果集JavaBeanBeanHandlerBeanListHandlerScalarHanderColumnListHandler6 小结DBUtils工具DBUtils常用类与方法 如果只使用JDBC进行开发，我们会发现冗余代码过多，为了简化JD
.NET C#到Java没那么难，DB篇
wangyunfeis的博客
07-31 1177
前言 .NET C#到Java没那么难，都是面向对象的语言，而且语法还是相似的，先对比一下开发环境，再到Servlet，再到MVC，都是一样一样的，只是JAVA的配制项比较多而已，只要配好一个，后面都是copy，简直so easy，而且用myeclipse可以省一些配制 Java与.NET的区别不在它们的本身，最大的区别在于他们背后的力量，相信大家都能感觉得到，我就不多说。     系列
自定义DbUtils通用类
W5952322的博客
12-11 322
本实例使用C3P0连接池做连接，详见https://www.cnblogs.com/qf123/p/10097662.html开源连接池C3P0的使用 DBUtils.java 1 package com.qf.util; 2 3 import java.sql.Connection; 4 import java.sql.ResultSet; 5 import...
DbUtils操作数据库的用法
廖世勇
06-07 918
DbUtils操作数据库的用法 最经写web程序越来越想用DbUtils这个组建，屡试不爽。DbUtils组件也不是做了什么复杂的的事，只是封装了一些JDBC常用的操作，让我们省去好多的数据业务的代码，简直就是忒了。 下面我就来说说这个DbUtils的常用方法说明： 对于数据库操作，就是增删改查。 1）          在进行查询（select）时，对于直接利用JDBC API访问数
dbutils连接mysql_基于DBUtils实现数据库连接池
weixin_42184548的博客
01-20 471
小知识：1、子类继承父类的三种方式class Dog(Animal): #子类 派生类def __init__(self,name,breed, life_value,aggr):#Animal.__init__(self,name,breed, life_value,aggr)#让子类执行父类的方法 就是父类名.方法名(参数)，连self都得传super().__init__(name,lif...
轻量级数据库ORM框架DbUtils
12-14
轻量级数据库ORM框架DbUtils DbUtils介绍 Apache组织下的一个轻量级ORM框架    Commons DbUtils: JDBC Utility Component 两个核心方法    update方法 ==> insert，update，delete    query方法 ==> select 一个核心类     QueryRunner DbUtils的核心类 DbUtils ORM工具使用 代码示例： student表中有id,name, age, gender, score, address import com.qfedu.b_studentsys.entity.S
C#对数据库操作类包括多种操作数据库的方法
09-23
C#对数据库操作的类，包括各种操作数据库的方法，用存储过程的方法，用查询语句的方法，都有。。简单调用就可以。。绝对方便！
DBUtils 查询操作的九种结果集处理
Joker_MikeLi的博客
12-04 1万+
DBUtils 查询结果集的九种实现类:ArrayHandler,ArrayListHandler,BeanHandler,BeanListHander,ColumnListHander,KeyedHander,MapHander,MapListHandler ,ScalarHandler 的作用及用法
dbutils---原理以及使用
weixin_30940783的博客
05-28 216
　　原始的操作（增删改）数据库，得到连接后，需要写sql模板，以及设置模板中的参数，其余步骤都相同。 　　原始的操作（查单个，以及查所有）数据库，也是得到连接后，写sql模板，以及设置模板中的参数，然后会返回结果集，其余步骤都一样。 1.dbutils原理 自己仿写的工具类（部分代码）==可以实现增删改和查 使用的是c3p0数据库连接池得到的数据库池对象datasource===其实...
DBUtils使用方法
qq_48843047的博客
10-08 285
一、 先熟悉DBUtils的API： 简介：DbUtils是一个为简化JDBC操作的小类库。 以下使用的是最新版的commons-dbutils-1.4，先给个简介，以便迅速掌握API的使用。 整个dbutils总共才3个包： 1、包org.apache.commons.dbutils 接口摘要 ResultSetHandler 将ResultSet转换为别的对象的工具。 RowProcessor 将ResultSet行转换为别的对象的工具。 类摘要 BasicRowProcessor
DBUtils增删改查
A_mnesia_的博客
10-14 189
一.导入mysql包 mysql-connector-java-5.0.8-bin.jar 二.封装DButils DButils类(关闭流和取得连接) package util; import java.sql.*; public class DBUtil { private static String driver = "com.mysql.jdbc.Driver"; private...
dbutils框架的使用
zone的博客
07-09 328
前言 先说一下原生JDBC的弊端： 1、数据库连接对象、sql语句操作对象、封装结果集对象，重复定义 2、封装数据的代码重复，而且操作复杂，代码量大 3、释放资源的代码重复。总结：开发的时候有大量重复劳动，开发周期长，效率低 在涉及mybatis框架之前，先学习一下轻量方便的dbutils框架也是很有必要的，比如小型的管理系统之类的，不需要java代码和sql语句分离，sql语句也不复杂的情况...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值