引言
 

 
 
   在项目需求中需要用到动态批量的删除数据库中的表，我们都知道在数据库中的数据是需要历史记录的所以我
 

 
 
们这所谓的删除其实只是给它重命名然后打上时间戳，这样就可以标志着这个数据表在数据库中已经没有用了，但是
 

 
 
其中的数据还是有用的，下面和大家分享这几天在项目中学习到的东西！！
 

 
 
   底层封装好的SQLhelper类，代码如下：
 

 
 
 
<span style="font-size:18px;">using System;
using System.Collections;
using System.Collections.Generic;
using System.Configuration;
using System.Data;
using System.Data.SqlClient;
using System.Linq;
using System.Text;
using System.Transactions;

namespace ITOO.Library.Core.Common
{
    /// <summary>
    /// 数据库助手类
    /// </summary>
    public class SQLHelper
    {
        private SqlCommand cmd = null;
        private SqlConnection conn = null;
        private SqlDataReader sdr = null;

        /// <summary>
        /// 
        /// </summary>
        /// <param name="strDatabaseName"></param>
        /// <param name="IsGetNewConnection"></param>
        public SQLHelper(string strDatabaseName, bool IsGetNewConnection = false)
        {
            if (IsGetNewConnection == false)
            {
                conn = ConnectionFactory.GetCurrentConn(strDatabaseName);
            }
            else
            {
                conn = ConnectionFactory.GetNewConn(strDatabaseName);
            }
        }

        /// <summary>
        /// 无参构造函数
        /// </summary>
        public SQLHelper()
        {
        }

        private SqlConnection GetConnection(string strDatabaseName)
        {
            string strConnValue = ConfigHelper.ReadAppSetting(strDatabaseName);
            return new SqlConnection(strConnValue);
        }

        /// <summary>
        /// 获得数据库连接
        /// </summary>
        /// <returns></returns>
        private SqlConnection GetConnection()
        {
            if (conn.State == ConnectionState.Closed)
            {
                conn.Open();
            }
            return conn;
        }

        /// <summary>
        /// 关闭连接
        /// </summary>
        /// <param name="conn">数据库连接</param>
        public static void Close(SqlConnection conn)
        {
            if (conn != null)
            {
                try
                {
                    conn.Close();
                }
                catch (SqlException e)
                {
                    throw e;
                }
            }
        }

        /// <summary>
        /// 执行带参数的增删改命令
        /// </summary>
        /// <param name="cmmText"></param>
        /// <param name="para"></param>
        /// <param name="cmmType"></param>
        /// <returns></returns>
        public int ExecuteNonQuery(string cmmText, SqlParameter[] para, CommandType cmmType)
        {
            cmd = new SqlCommand(cmmText, GetConnection());
            cmd.CommandType = cmmType;

            try
            {
                cmd.Parameters.AddRange(para);
                return cmd.ExecuteNonQuery();
            }
            catch (SqlException e)
            {
                throw e;
            }
        }

        /// <summary>
        /// 执行不带参数的增删改命令
        /// </summary>
        /// <param name="cmmText"></param>
        /// <param name="cmmType"></param>
        /// <returns></returns>
        public int ExecuteNonQuery(string cmmText, CommandType cmmType)
        {
            cmd = new SqlCommand(cmmText, GetConnection());
            cmd.CommandType = cmmType;

            try
            {
                return cmd.ExecuteNonQuery();
            }
            catch (SqlException e)
            {
                throw e;
            }
        }

        /// <summary>
        /// 执行带参数的查询命令
        /// </summary>
        /// <param name="cmmText"></param>
        /// <param name="para"></param>
        /// <param name="cmmType"></param>
        /// <returns></returns>
        public DataTable ExecuteQuery(string cmmText, SqlParameter[] para, CommandType cmmType)
        {
            DataTable dt = new DataTable();
            cmd = new SqlCommand(cmmText, GetConnection());
            cmd.CommandType = cmmType;
            cmd.Parameters.AddRange(para);

            try
            {
                using (sdr = cmd.ExecuteReader(CommandBehavior.CloseConnection))
                {
                    dt.Load(sdr);
                    return dt;
                }
            }
            catch (SqlException e)
            {
                throw e;
            }
        }

        /// <summary>
        /// 执行不带参数的查询命令
        /// </summary>
        /// <param name="cmmText"></param>
        /// <param name="cmmType"></param>
        /// <returns></returns>
        public DataTable ExecuteQuery(string cmmText, CommandType cmmType)
        {
            DataTable dt = new DataTable();
            cmd = new SqlCommand(cmmText, GetConnection());
            cmd.CommandType = cmmType;
            using (sdr = cmd.ExecuteReader(CommandBehavior.CloseConnection))
            {
                dt.Load(sdr);
            }
            return dt;
        }

        /// <summary>
        /// 执行创建表的方法
        /// 先读取文件，以GO为段落，把每一个GO的段落当做一条SQL命令，在通过事务一起执行。
        /// </summary>
        /// <param name="varSqlList">传入执行的sql脚本</param>
        public void ExecuteCommand(ArrayList varSqlList)
        {
            SqlTransaction varTrans = GetConnection().BeginTransaction();
            cmd = new SqlCommand();
            cmd.Connection = GetConnection();
            cmd.Transaction = varTrans;
            try
            {
                foreach (string varcommandText in varSqlList)
                {
                    cmd.CommandText = varcommandText;
                    cmd.ExecuteNonQuery();
                }
                varTrans.Commit();
            }
            catch (Exception ex)
            {
                varTrans.Rollback();
                throw ex;
            }
        }

        #region 批量导入DataTable

        /// <summary>
        /// 批量导入DataTable
        /// </summary>
        /// <param name="strDatabaseName">配置文件key</param>
        /// <param name="dt">datatable名称</param>
        /// <param name="tableName">表名称</param>
        /// <param name="dtColum">所有列（dt.columns)</param>
        /// <returns>返回true，or false</returns>
        public Boolean InsertTable(string strDatabaseName, DataTable dt, string tableName, DataColumnCollection dtColum)
        {
            using (TransactionScope scope1 = new TransactionScope(TransactionScopeOption.Required))
            {
                using (SqlBulkCopy sqlBC = new SqlBulkCopy(
                           GetConnection(strDatabaseName).ConnectionString, SqlBulkCopyOptions.KeepIdentity))
                {
                    sqlBC.BatchSize = 1000;
                    sqlBC.DestinationTableName = tableName;

                    // Write from the source to the destination.
                    // This should fail with a duplicate key error.
                    for (int i = 0; i < dtColum.Count; i++)
                    {
                        sqlBC.ColumnMappings.Add(dtColum[i].ColumnName.ToString(), dtColum[i].ColumnName.ToString());
                    }
                    try
                    {
                        //批量写入
                        sqlBC.WriteToServer(dt);
                        scope1.Complete();
                        return true;
                    }
                    catch
                    {
                        throw new Exception("导入数据失败！");
                    }
                }
            }
        }

        #endregion 批量导入DataTable
    }</span>

 
  
 
     删除 数据表的方法
 

 
 
 
<span style="font-size:18px;">  /// <summary>
        /// 批量假删除数据表（重命名，打上时间戳）
        /// </summary>
        /// <param name="db">指定的数据库</param>
        /// <param name="listDt">要删除的数据库表集合</param>
        /// <param name="connKey">数据库连接串</param>
        /// <returns>执行是否成功，true表示成功，false表示失败</returns>
        public bool FalseDropTable(string db, List<string> listDt, string connKey)
        {
            SQLHelper helper = null;
            try
            {
                 helper = new SQLHelper("ITOOExamEntities");
            }
            catch (Exception e)
            {

                throw e;
            }
           

            string connToMaster = ConfigurationManager.ConnectionStrings[connKey].ToString();

            //判断数据库是否存在
            if (IsDBExist(db, connKey) == false)
            {
                throw new Exception("数据库不存在！");
            }

            string timeStamp = DateTime.Now.ToString();            // 2008-9-4 20:02:10

            for (int i = 0; i < listDt.Count(); i++)
            {
                //如果数据库表存在，则抛出错误
                if (IsTableExist(db, listDt[i], connKey) == false)
                {
                    //如果数据库表已经删除，则跳过该表
                    continue;
                }
                else//数据表存在，则进行删除数据表
                {
                    //其后判断数据表是否存在，然后创建数据表
                    //string createTableStr = "use " + db + " drop table " + listDt[i] + " ";
                    string createTableStr = "use " + db + " exec sp_rename '" + listDt[i] + "','" + listDt[i] + "_" + timeStamp + "'";
                    helper.ExecuteNonQuery(createTableStr, CommandType.Text);
                }
            }
            return true;
        }</span>

     判断指定的数据库是否存在 
 

 
 
 
 
<span style="font-size:18px;">/// <summary>
        /// 判断数据库是否存在
        /// </summary>
        /// <param name="db">数据库的名称</param>
        /// <param name="connKey">数据库的连接Key</param>
        /// <returns>true:表示数据库已经存在；false，表示数据库不存在</returns>
        public Boolean IsDBExist(string db, string connKey)
        {
            SQLHelper helper = new SQLHelper("ITOOExamEntities");

            string connToMaster = ConfigurationManager.ConnectionStrings[connKey].ToString();
            string createDbStr = " select * from master.dbo.sysdatabases where name " + "= '" + db + "'";

            DataTable dt = helper.ExecuteQuery(createDbStr, CommandType.Text);
            if (dt.Rows.Count == 0)
            {
                return false;
            }
            else
            {
                return true;
            }
        }</span>

  
 
  判断数据库中的指定的表是否存在
 

 
 
 
<span style="font-size:18px;">/// <summary>
        /// 判断数据库表是否存在
        /// </summary>
        /// <param name="db">数据库</param>
        /// <param name="tb">数据表名</param>
        /// <param name="connKey">连接数据库的key</param>
        /// <returns>true:表示数据表已经存在；false，表示数据表不存在</returns>
        public Boolean IsTableExist(string db, string tb, string connKey)
        {
            SQLHelper helper = new SQLHelper("ITOOExamEntities");

            string connToMaster = ConfigurationManager.ConnectionStrings[connKey].ToString();
            string createDbStr = "use " + db + " select 1 from  sysobjects where  id = object_id('" + tb + "') and type = 'U'";

            //在指定的数据库中  查找 该表是否存在
            DataTable dt = helper.ExecuteQuery(createDbStr, CommandType.Text);
            if (dt.Rows.Count == 0)
            {
                return false;
            }
            else
            {
                return true;
            }

        }</span>

  
    以上是小编在刚接手的项目中学习到的一些对于自己来说比较新的东西，在这分享给大家，希望能给大家带来帮
 

 
 
助！！
 
 

 

mybatis动态Sql实现批量添加和批量删除：
 新建一个domainMapper接口：
 接下来写：domainMapper.xml配置，在本利中即：UserMapper.xml
 
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<!--
namespace:命名空间 -> 要求:一个项目中命名空间必须唯一;
一般:domain的路径来唯一
-->
<mapper namespace="cn.itsource.mybatis.batch_options.UserMapper">
    <!--
      select:标签名字:  CRUD的时候对应的名字
      id:这个语句的唯一标识;   【必须和接口的方法名字一样】;
      parameterType:传入参数类型
      resultType:返回值类型
      #{id}:参数的接收

      collection=""  遍历集合
      index=""  遍历时候的索引
      item=""   每此遍历得到的对象
      open=""   以什么开始
      close=""  以什么结束
      separator="" 以什么作为分割符
    -->
    <select id="saveBatch" parameterType="list">

        INSERT INTO user (username,password) VALUES

        <foreach collection="list" item="user" separator=",">
            (#{user.username},#{user.password})
        </foreach>

    </select>


    <delete id="deleteBatch" parameterType="list">

        delete from user where id in

        <foreach collection="list" item="id" open="(" close=")" separator=",">
            #{id}
        </foreach>

    </delete>
</mapper>
 
注意在mybatis的主配置文件中，引入该UserMapper.xml文件：
 自定义工具类获得SqlSession对象：
 
 
测试：
 

一、首先要有mapper接口
 
/**
* 
* 方法描述：根据ids集合进行删除
* @return
*/
int deleteByIds(List<Integer> ids);
 
二、Mapper.xml动态sql
 
collection：传递来的参数，可以是list,array(数组),还可以是map的key，可以是pojo中的属性
          item：循环中的当前元素
          index：当前元素的下标
          open：循环的开始
          close：循环的结束
          separator：分隔符
 
<delete id="deleteByIds" parameterType="list">
	delete from user where id in
	<foreach collection="list" item="id" open="(" close=")" separator=",">
		#{id}
	</foreach>
</delete>
 
 这段SQL最终会被自动组合成：delete from user where id in ( ? , ? ) 
 
三、测试
 
public class TestMapper {
	public static void main(String[] args) {
		//1.获取会话
		SqlSession sqlSession = SqlSessionFactoryUtil.getFactory().openSession();
		//2.获取mapper接口的代理对象
		UserMapper userMapper = sqlSession.getMapper(UserMapper.class);
		List<Integer> ids = new ArrayList<>();
		//添加要删除的id
		ids.add(22);
		ids.add(23);
		//调用mapper动态SQL的批量删除
		userMapper.deleteByIds(ids);
		sqlSession.commit();
	}
}
 
 

Mybatis 使用动态语句实现批量删除（delete结合foreach）
 

 
 
在下面的案例本人将演示如何使用动态语句批量删除数据库数据，本人在数据库建了一张emp员工表（表的数据自己填充），表的结构如下：
 

 
 
批量删除的核心代码为，在实体映射文件中配置如下的代码：
 
 
<!-- 批量删除 -->
	<delete id="deleteMoreEmp" parameterType="int[]">
		<!-- delete from emp where empno in(7789,7790) -->
		<!-- forEach : 用来循环 collection : 用来指定循环的数据的类型 可以填的值有：array,list,map item 
			: 循环中为每个循环的数据指定一个别名 index : 循环中循环的下标 open : 开始 close : 结束 separator : 数组中元素之间的分隔符 -->
		delete from emp where empno in
		<foreach collection="array" item="arr" index="no" open="("
			separator="," close=")">
			#{arr}
		</foreach>
	</delete>

  
 
下面是项目的结构（本人使用的是maven搭建的web项目）：
 

 
 

 
 
IEmpDAO.java为接口提供批量删除数据方法，EmpDAOImpl.java为接口的实现类，MybatisSqlSessionFactory.java为本人创建的获取sqlSession的工具类，Emp.java为实体类，Emp.xml为映射文件，mybatis_cfg.xml为mybatis主配置文件，Test.java为测试类，pom.xml为maven引入依赖的文件。
 
 
1、IEmpDAO.java为接口提供批量删除数据方法
 
 
/**
	 * 批量删除
	 * 
	 * @param arr
	 * @return
	 */
	public boolean doRemoveeMore(int[] arr);
 传入的参数为emp的主键数组。

 

 
 
2、EmpDAOImpl.java为接口的实现类
 
 
	public boolean doRemoveeMore(int[] arr) {
		SqlSession sqlSession = null;
		try {
			sqlSession = MybatisSqlSessionFactory.getMySqlSession();
			int result = sqlSession.delete("cn.sz.hcq.pojo.Emp.deleteMoreEmp",
					arr);
			sqlSession.commit();
			return result > 0 ? true : false;
		} catch (Exception e) {
			e.printStackTrace();
			sqlSession.rollback();
		} finally {
			MybatisSqlSessionFactory.closeSqlSession();
		}
		return false;
	}

 
 
3、MybatisSqlSessionFactory.java为本人创建的获取sqlSession的工具类
 
 
package cn.sz.hcq.factory;

import java.io.IOException;
import java.io.Reader;

import org.apache.ibatis.io.Resources;
import org.apache.ibatis.session.SqlSession;
import org.apache.ibatis.session.SqlSessionFactory;
import org.apache.ibatis.session.SqlSessionFactoryBuilder;

public class MybatisSqlSessionFactory {
	// 配置文件
	private static final String RESOURCE = "mybatis_cfg.xml";
	private static Reader reader = null;
	private static SqlSessionFactoryBuilder builder = null;
	private static SqlSessionFactory factory = null;
	// 可以在同一个线程范围内，共享一个对象
	private static ThreadLocal<SqlSession> threadLocal = new ThreadLocal<SqlSession>();

	// 静态代码块（类加载的时候执行一次）
	static {
		try {
			reader = Resources.getResourceAsReader(RESOURCE);
			builder = new SqlSessionFactoryBuilder();
			factory = builder.build(reader);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	public static SqlSession getMySqlSession() {
		// 从本地线程中获取session连接
		SqlSession sqlSession = threadLocal.get();
		// 连接为空则创建连接，并将该连接添加到本地线程中去
		if (sqlSession == null) {
			if (factory == null) {
				rebuildFactory();
			}
			sqlSession = factory.openSession();
		}
		threadLocal.set(sqlSession);
		return sqlSession;
	}

	// 创建工厂
	public static void rebuildFactory() {
		try {
			reader = Resources.getResourceAsReader(RESOURCE);
			builder = new SqlSessionFactoryBuilder();
			factory = builder.build(reader);
		} catch (IOException e) {
			e.printStackTrace();
		}
	}

	// 关闭连接
	public static void closeSqlSession() {
		SqlSession sqlSession = threadLocal.get();
		if (sqlSession != null) {
			// 关闭session
			sqlSession.close();
		}
		// 同时将本地线程中置为null（防止用户再次调用时出现空的session）
		threadLocal.set(null);
	}

}


 

 
 
4、Emp.java为实体类
 
 
public class Emp implements Serializable {
	private Integer empno;
	private String ename;
	private String job;
	private Integer mgr;
	private Date hiredate;
	private Double sal;
	private Double comm;
	private Integer deptno;

	public Integer getEmpno() {
		return empno;
	}

	public void setEmpno(Integer empno) {
		this.empno = empno;
	}

	public String getEname() {
		return ename;
	}

	public void setEname(String ename) {
		this.ename = ename;
	}

	public String getJob() {
		return job;
	}

	public void setJob(String job) {
		this.job = job;
	}

	public Integer getMgr() {
		return mgr;
	}

	public void setMgr(Integer mgr) {
		this.mgr = mgr;
	}

	public Date getHiredate() {
		return hiredate;
	}

	public void setHiredate(Date hiredate) {
		this.hiredate = hiredate;
	}

	public Double getSal() {
		return sal;
	}

	public void setSal(Double sal) {
		this.sal = sal;
	}

	public Double getComm() {
		return comm;
	}

	public void setComm(Double comm) {
		this.comm = comm;
	}

	public Integer getDeptno() {
		return deptno;
	}

	public void setDeptno(Integer deptno) {
		this.deptno = deptno;
	}

}


 

 
 
5、Emp.xml为映射文件
 
 
<?xml version="1.0" encoding="UTF-8"?>
 <!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" 
		"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="cn.sz.hcq.pojo.Emp">
	<!-- 批量删除 -->
	<delete id="deleteMoreEmp" parameterType="int[]">
		<!-- delete from emp where empno in(7789,7790) -->
		<!-- forEach : 用来循环 collection : 用来指定循环的数据的类型 可以填的值有：array,list,map item 
			: 循环中为每个循环的数据指定一个别名 index : 循环中循环的下标 open : 开始 close : 结束 separator : 数组中元素之间的分隔符 -->
		delete from emp where empno in
		<foreach collection="array" item="arr" index="no" open="("
			separator="," close=")">
			#{arr}
		</foreach>
	</delete>
</mapper>

 
 
6、mybatis_cfg.xml为mybatis主配置文件
 
 
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
		"http://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
	<!--数据源 -->
	<environments default="myconn">
		<environment id="myconn">
			<!--事务管理方式 -->
			<transactionManager type="JDBC"></transactionManager>
			<!--数据库连接参数 -->
			<dataSource type="POOLED">
				<!-- type:数据源连接的方式 ，POOLED:连接池方式， UNPOOLED: 非连接池的方式 ，JNDI：java命名与目录接口方式 -->
				<property name="driver" value="org.gjt.mm.mysql.Driver"></property>
				<property name="url" value="jdbc:mysql://localhost:3306/db"></property>
				<property name="username" value="root"></property>
				<property name="password" value="root"></property>
			</dataSource>
		</environment>
	</environments>

	<!-- 引入实体映射文件 -->
	<mappers>
		<mapper resource="cn/sz/hcq/pojo/Emp.xml" />
	</mappers>
	<!-- 配置的参数 -->
</configuration>


 

 
 
7、pom.xml为maven引入依赖的文件
 
 
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
	<modelVersion>4.0.0</modelVersion>
	<groupId>cn.sz.hcq.pro</groupId>
	<artifactId>Mybatis_04</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>war</packaging>
	<dependencies>
		<!-- https://mvnrepository.com/artifact/org.mybatis/mybatis -->
		<dependency>
			<groupId>org.mybatis</groupId>
			<artifactId>mybatis</artifactId>
			<version>3.2.3</version>
		</dependency>
		<!-- https://mvnrepository.com/artifact/mysql/mysql-connector-java -->
		<dependency>
			<groupId>mysql</groupId>
			<artifactId>mysql-connector-java</artifactId>
			<version>5.1.39</version>
		</dependency>
	</dependencies>
</project>

 

 
 
8、Test.java为测试类
 

public class Test {
	public static void main(String[] args) {
		IEmpDAO empDAO = new EmpDAOImpl();
		System.out.println("----------批量删除----------");
		int[] arr = { 7791, 7792 };//删除的主键
		boolean removeeMore = empDAO.doRemoveeMore(arr);
		System.out.println("批量删除的结果：" + removeeMore);
	}
}



 
 
 
完成代码后，运行测试类就可以完成批量删除。