一、iHiberBaseDAO类
package basic;
import java.util.*; /**
* 基于hibernate技术实现的BaseDAO基类
* @author ZHANGYANTAO
* @since 2014-12-19
* @version 2017-4-20
*/
public interface iHiberBaseDAO {
/**
* 实现单个的新瞬时实体类对象的持久化操作（添加对象到数据库中）
* 该hibernate添加方法仅用于对单个的瞬时对象进行持久化操作
* @param Object 任意的Hibernate的表映射实体类对象
* @return Object 主键id， null则表示添加失败
*/
public Object insert(Object obj); /**
* 实现批量的新瞬时实体类对象的持久化操作（添加对象到数据库中）
* 该hibernate添加方法仅用于对单个的瞬时对象进行持久化操作
* @param List<Object> 任意的Hibernate的表映射实体类对象列表
* @return boolean true成功，false失败
*/
public boolean insert(List<Object> list); /**
* 执行表数据删除操作
* 该hibernate删除方法仅用于对单个的瞬时对象使用其id属性进行持久化操作
* @param Class 给出对应表的Pojo类类型，如User.class
* @param Serializable 对应表中主键字段的Pojo类的成员属性的值，如用户编号id
* @return boolean true 成功 false 失败
*/
public boolean delete(Class cls, java.io.Serializable id); /**
* 执行表数据删除操作
* 该hibernate删除方法仅用于对单个的瞬时对象进行持久化删除操作
* @param Object Hibernate的表映射对象 当前为要删除表的实体类对象
* @return boolean true 成功 false 失败
*/
public boolean delete(Object obj) ; /**
* 修改表记录，使用对应表的实体类对象实现
* 该hibernate更新方法仅用于对单个的瞬时对象进行持久化操作
* @param Object Hibernate的表映射对象
* @return boolean true 成功 false 失败
*/
public boolean update(Object obj) ; /**
* 使用无参数的hql实现查询的，他将返回基于hql中查询对象的List数组对象
* @param String 符合hql结构的无参数查询语句
* @return List 失败返回null
*/
public List select(String hql) ; /**
* 使用无参数的hql实现查询的，他将返回基于hql中查询对象的List数组对象,实现top功能
* @param String 符合hql结构的无参数查询语句
* @param String 取List值的开始索引
* @param String 取List值得结束索引
* @return List 失败返回null
*/
public List select(String hql,int startIndex, int length) ; /**
* 使用带有参数的hql实现查询的，他将返回基于hql中查询对象的List数组对象
* @param String 符合hql结构的有参数查询语句
* @param Object[] 参数值数组
* @return List 失败返回null
*/
public List select(String hql,Object[] para) ; /**
* 使用无参数的hql实现查询的，他将返回基于hql中查询对象的List数组对象,实现top功能
* @param String 符合hql结构的无参数查询语句
* @param String 取List值的开始索引
* @param String 取List值得结束索引
* @return List 失败返回null
*/
public List select(String hql,Object[] para,
int startIndex, int length) ; /**
* 获取带聚合函数hql语句的查询结果
* @param hql 带聚合函数的hql结构的无参数查询语句
* @return List 失败返回null
*/
public int selectValue(String hql); /**
* 使用带有参数的hql,获取聚合函数查询的结果
* @param hql 带聚合函数的hql结构的有参数查询语句
* @param para Object[]类型的参数值数组
* @return List 失败返回null
*/
public int selectValue(String hql,Object[] para); /**
* 分页查询返回总页数
* 可使用的hql语句为(1)"from DForum"
* (2)from DForum order by forumid desc"
* (3)from DForum where DUser.userid = 'zhangjs' order by forumid desc"
* @param String hql 分页查询的hql字符串
* @param String pageSize 每页的结果数量
* @return int 查询得到的总页数结果
*/
public int selectPages(String hql,int pageSize); /**
* 分页查询返回总页数
* 可使用的hql语句为(1)"from DForum"
* (2)from DForum order by forumid desc"
* (3)from DForum where DUser.userid = 'zhangjs' order by forumid desc"
* @param String hql 分页查询的hql字符串
* @param Object[] para 对应hql中参数的值数组
* @param String pageSize 每页的结果数量
* @return int 查询得到的总页数结果
*/
public int selectPages(String hql,Object[] para, int pageSize); /**
* 分页查询
* 可使用的hql语句为(1)"from DForum"
* (2)from DForum order by forumid desc"
* (3)from DForum where DUser.userid = 'zhangjs' order by forumid desc"
* @param String hql 分页查询的无参数hql字符串
* @param int startPage 查询开始的页数
* @param int pageSize 查询要求的每页的记录数
* @return List 查询返回的记录队列
*/
public List selectByPage(String hql,int startPage, int pageSize); /**
* 分页查询
* 可使用的hql语句为(1)"from DForum"
* (2)from DForum order by forumid desc"
* (3)from DForum where DUser.userid = 'zhangjs' order by forumid desc"
* @param String hql 分页查询的无参数hql字符串
* @param Object[] para 对应分页查询hql中参数的值数组
* @param int startPage 查询开始的页数
* @param int pageSize 查询要求的每页的记录数
* @return List 查询返回的记录队列
*/
public List selectByPage(String hql,Object[] para, int startPage, int pageSize); /**
* 根据cls对应表的主键属性id来查询并返回cls类型的对象
* @param Class cls 要查询的Hibernate的表映射类对象名，如User对象的类型为User.class
* @param java.io.Serializable id 查询所用的对应主键的值
* @return Object 返回的cls类型的对象
*/
public Object findById(Class cls, java.io.Serializable id); /**
* 利用无参数的sql实现数据表对象的更新操作
* @param String sql 无参数的update的sql语句
* @return boolean true 成功 false 失败
*/
public boolean update(String sql); /**
* 利用带参数的sql实现数据表对象的更新操作
* @param String sql 带参数的update的sql语句
* @param Object[] para 对应sql语句中的参数值
* @return boolean true 成功 false 失败
*/
public boolean update(String hql,Object[] para); /**
* 利用sql实现数据表的批量删除
* @param String sql 无参数的delete的sql语句
* @return boolean true 成功 false 失败
*/
public boolean delete(String sql); /**
* 利用带参数的sql实现数据表的批量删除
* @param String sql 带参数的delete的sql语句
* @param Object[] para 对应sql语句中的参数值
* @return boolean true 成功 false 失败
*/
public boolean delete(String sql,Object[] para); /**
* 调用数据库存储过程（无参数）
* 参数：String procName 数据库存储过程名
* 输出参数:ResultSet rs 返回存储过程中查询的结果
* 返回值：0 更新语句执行失败 >0 更新语句成功
*/
public Object executeProduce(String procName); /**
* 调用数据库存储过程（带参数）
* 参数：String procName 数据库存储过程名
* 输出参数:ResultSet rs 返回存储过程中查询的结果
* 返回值：0 更新语句执行失败 >0 更新语句成功
*/
public Object executeProduce(String procName,Object[] para); /**
* 执行更新操作的批处理语句，这里将采用多个结果的事务方式，一起提交，一起回滚
*
* @param Object Hibernate的表映射对象 当前为要删除表的实体类对象
* @return boolean true 成功 false 失败
*/
public boolean executeBatch(Object[] obj, int[] model); public boolean executeBatch(List<Object> list,List<Integer> models);
}
二、iHiberDAOImpl类
package basic; import java.io.Serializable;
import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.List; import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction; public class iHiberDAOImpl implements iHiberBaseDAO { public static final int INSERT = 1; //代表添加操作
public static final int UPDATE = 2; //代表修改操作
public static final int DELETE = 3; //代表删除操作 @Override
public Object insert(Object obj) { //obj必须是符合hibernate的pojo对象
Session session = HibernateSessionFactory.getSession();//每次执行前需引入session对象
Transaction tx = null;
try{
tx = session.beginTransaction(); //开启一个事务
Serializable key = session.save(obj);
tx.commit(); //持久化操作
session.close();
return key;
}catch(Exception e){
e.printStackTrace();
if(tx!=null) tx.rollback(); //撤销
if(session!=null) session.close();
}
return null; } @Override
public boolean insert(List<Object> list) {
Session session = HibernateSessionFactory.getSession();
Transaction tx = null;
try{
tx = session.beginTransaction(); //开启一个事务
for(Object obj : list){
session.save(obj);
}
tx.commit(); //持久化操作
session.close();
return true;
}catch(Exception e){
e.printStackTrace();
if(tx!=null) tx.rollback(); //撤销
if(session!=null) session.close();
}
return false; } @Override
public boolean delete(Class cls, Serializable id) {
Session session = HibernateSessionFactory.getSession();
Transaction tx = null;
try{
tx = session.beginTransaction(); //开启一个事务
//先用cls和id查出要删除的对象
session.delete(session.get(cls, id));
tx.commit(); //持久化操作
session.close();
return true;
}catch(Exception e){
e.printStackTrace();
if(tx!=null) tx.rollback(); //撤销
if(session!=null) session.close();
}
return false; } @Override
public boolean delete(Object obj) {
Session session = HibernateSessionFactory.getSession();
Transaction tx = null;
try{
tx = session.beginTransaction(); //开启一个事务
session.delete(obj);
tx.commit(); //持久化操作
session.close();
return true;
}catch(Exception e){
e.printStackTrace();
if(tx!=null) tx.rollback(); //撤销
if(session!=null) session.close();
}
return false; } @Override
public boolean update(Object obj) {
Session session = HibernateSessionFactory.getSession();
Transaction tx = null;
try{
tx = session.beginTransaction(); //开启一个事务
session.update(obj);
tx.commit(); //持久化操作
session.close();
return true;
}catch(Exception e){
e.printStackTrace();
if(tx!=null) tx.rollback(); //撤销
if(session!=null) session.close();
}
return false; } @Override
public List select(String hql) {
Session session = HibernateSessionFactory.getSession();
try{
Query query = session.createQuery(hql);
List list = query.list();
session.close();
return list;
}catch(Exception e){
e.printStackTrace();
if(session!=null) session.close();
}
return null;
} @Override
public List select(String hql, int startIndex, int length) {
Session session = HibernateSessionFactory.getSession();
try {
Query query =session.createQuery(hql);
query.setFirstResult(startIndex); //设置起始记录位置
query.setMaxResults(length); //设置返回记录数
List list = query.list();
session.close();
return list;
} catch (Exception e) {
e.printStackTrace();
if(session!=null) session.close();
}
return null; } @Override
public List select(String hql, Object[] para) {
Session session = HibernateSessionFactory.getSession();
try {
Query query =session.createQuery(hql);
//根据para设置参数
for(int i=0;i<para.length;i++){
query.setParameter(i, para[i]);
}
List list = query.list();
session.close();
return list;
} catch (Exception e) {
e.printStackTrace();
if(session!=null) session.close();
}
return null; } @Override
public List select(String hql, Object[] para, int startIndex, int length) {
Session session = HibernateSessionFactory.getSession();
try {
Query query =session.createQuery(hql);
//根据para设置参数
for(int i=0;i<para.length;i++){
query.setParameter(i, para[i]);
}
query.setFirstResult(startIndex); //设置起始记录位置
query.setMaxResults(length); //设置返回记录数
List list = query.list();
session.close();
return list;
} catch (Exception e) {
e.printStackTrace();
if(session!=null) session.close();
}
return null; } @Override
public int selectValue(String hql) {
Session session = HibernateSessionFactory.getSession();
try {
Query query = session.createQuery(hql);
Object obj = query.uniqueResult();
session.close();
if(obj instanceof Long)
return ((Long)obj).intValue();
else if(obj instanceof Integer)
return ((Integer)obj).intValue();
} catch (Exception e) {
e.printStackTrace();
if(session!=null) session.close();
}
return 0; } @Override
public int selectValue(String hql, Object[] para) {
Session session = HibernateSessionFactory.getSession();
try {
Query query = session.createQuery(hql);
//根据para设置参数
for(int i=0;i<para.length;i++){
query.setParameter(i, para[i]);
}
Object obj = query.uniqueResult();
session.close();
if(obj instanceof Long)
return ((Long)obj).intValue();
else if(obj instanceof Integer)
return ((Integer)obj).intValue();
} catch (Exception e) {
e.printStackTrace();
if(session!=null) session.close();
}
return 0; } @Override
public int selectPages(String hql, int pageSize) {
Session session = HibernateSessionFactory.getSession();
long pages_all = 0;
try {
Query query = session.createQuery(hql);
List list = query.list();
//获得查询记录总数
long records = list.size();
//计算分页数
pages_all =records%pageSize==0?records/pageSize:records/pageSize + 1; //获得总页数
session.close();
return (int)pages_all;
}catch(Exception e){
e.printStackTrace();
if(session!=null) session.close();
}
return 0; } @Override
public int selectPages(String hql, Object[] para, int pageSize) {
Session session = HibernateSessionFactory.getSession();
//编程思想：先获得查询记录数，再使用算法来计算出分页的页数
long pages_all = 0;
try {
Query query = session.createQuery(hql);
//根据para设置参数
for(int i=0;i<para.length;i++){
query.setParameter(i, para[i]);
}
List list = query.list();
//获得查询记录总数
long records = list.size();
//计算分页数
pages_all =
records%pageSize==0?records/pageSize:records/pageSize + 1; //获得总页数
session.close();
return (int)pages_all;
}catch(Exception e){
e.printStackTrace();
if(session!=null) session.close();
}
return 0; } @Override
public List selectByPage(String hql, int startPage, int pageSize) {
Session session = HibernateSessionFactory.getSession();
List pList = null;
int currentPage;
try {
Query query = session.createQuery(hql);
//先求出按照pageSize得到的分页的页数
List list = query.list();
//获得查询记录总数
long records = list.size();
//获得总页数
int pages_all =(int)(records%pageSize==0?records/pageSize:records/pageSize + 1); //获得总页数 //设置类成员当前页面的操作页码
if(startPage<=1){
currentPage = 1;
}else if(startPage >=pages_all){
currentPage = pages_all;
}else {
currentPage = startPage;
}
Query query2 = session.createQuery(hql);
query2.setFirstResult((currentPage -1)* pageSize);//从第几条记录开始查询 query2.setMaxResults(pageSize);//每页显示多少条记录
pList = query2.list();
session.close();
} catch (Exception e) {
e.printStackTrace();
if(session!=null) session.close();
}
return pList; } @Override
public List selectByPage(String hql, Object[] para, int startPage, int pageSize) {
Session session = HibernateSessionFactory.getSession();
List pList = null;
int currentPage;
try {
Query query = session.createQuery(hql);
//根据para设置参数
for(int i=0;i<para.length;i++){
query.setParameter(i, para[i]);
}
List list = query.list();
//获得查询记录总数
long records = list.size();
//获得总页数
int pages_all =
(int)(records%pageSize==0?records/pageSize:records/pageSize + 1); //获得总页数 //设置类成员当前页面的操作页码
if(startPage<=1){
currentPage = 1;
}else if(startPage >=pages_all){
currentPage = pages_all;
}else {
currentPage = startPage;
}
Query query2 = session.createQuery(hql);
//根据para设置参数
for(int i=0;i<para.length;i++){
query2.setParameter(i, para[i]);
}
query2.setFirstResult((currentPage -1)* pageSize);//从第几条记录开始查询 query2.setMaxResults(pageSize);//每页显示多少条记录
pList = query2.list();
session.close();
} catch (Exception e) {
e.printStackTrace();
if(session!=null) session.close();
}
return pList; } @Override
public Object findById(Class cls, Serializable id) {
Session session = HibernateSessionFactory.getSession();
try {
Object obj = session.get(cls, id);
session.close();
return obj;
} catch (Exception e) {
e.printStackTrace();
if(session!=null) session.close();
}
return null; } @Override
public boolean update(String sql) {
Session session = HibernateSessionFactory.getSession();
Transaction tx = null;
try{
tx = session.beginTransaction(); //开启一个事务
//将会话Session对象转换成jdbc的Connection
Connection con = session.connection();
PreparedStatement ptmt = con.prepareStatement(sql);
int row = ptmt.executeUpdate();
tx.commit(); //持久化操作
session.close();
if(row > 0)
return true;
else
return false;
}catch(Exception e){
e.printStackTrace();
if(tx!=null) tx.rollback(); //撤销
if(session!=null) session.close();
}
return false; } @Override
public boolean update(String sql, Object[] para) {
Session session = HibernateSessionFactory.getSession();
Transaction tx = null;
try{
tx = session.beginTransaction(); //开启一个事务
//将会话Session对象转换成jdbc的Connection
Connection con = session.connection();
PreparedStatement ptmt = con.prepareStatement(sql);
for(int i=0; i<para.length; i++){
ptmt.setObject(i+1, para[i]);
}
int row = ptmt.executeUpdate();
tx.commit(); //持久化操作
session.close();
if(row > 0)
return true;
else
return false;
}catch(Exception e){
e.printStackTrace();
if(tx!=null) tx.rollback(); //撤销
if(session!=null) session.close();
}
return false; } @Override
public boolean delete(String sql) {
Session session = HibernateSessionFactory.getSession();
Transaction tx = null;
try{
tx = session.beginTransaction(); //开启一个事务
//将会话Session对象转换成jdbc的Connection
Connection con = session.connection();
PreparedStatement ptmt = con.prepareStatement(sql);
int row = ptmt.executeUpdate();
tx.commit(); //持久化操作
session.close();
if(row > 0)
return true;
else
return false;
}catch(Exception e){
e.printStackTrace();
if(tx!=null) tx.rollback(); //撤销
if(session!=null) session.close();
}
return false; } @Override
public boolean delete(String sql, Object[] para) {
Session session = HibernateSessionFactory.getSession();
Transaction tx = null;
try{
tx = session.beginTransaction(); //开启一个事务
//将会话Session对象转换成jdbc的Connection
Connection con = session.connection();
PreparedStatement ptmt = con.prepareStatement(sql);
for(int i=0; i<para.length; i++){
ptmt.setObject(i+1, para[i]);
}
int row = ptmt.executeUpdate();
tx.commit(); //持久化操作
session.close();
if(row > 0)
return true;
else
return false;
}catch(Exception e){
e.printStackTrace();
if(tx!=null) tx.rollback(); //撤销
if(session!=null) session.close();
} return false; } @Override
public Object executeProduce(String procName) {
Session session = HibernateSessionFactory.getSession();
Transaction tx = null;
try {
tx = session.beginTransaction();
Connection conn=session.connection();
CallableStatement ctmt=conn.prepareCall("{? = call procName}");
ctmt.registerOutParameter(1,java.sql.Types.INTEGER);
boolean type = ctmt.execute();
tx.commit();
if(type){ //为true表明存储过程是一个select语句
ResultSet rs = ctmt.getResultSet();
//globesession.close();
return rs;
}else{ //不是select，则获取返回值
int isSuccess = ctmt.getInt(1); //获得返回值。
session.close();
return new Integer(isSuccess);
}
} catch (Exception e) {
e.printStackTrace();
if (tx != null) tx.rollback(); //错误时，回滚操作
if(session!=null) session.close();
}
return null;
} @Override
public Object executeProduce(String procName, Object[] para) {
Session session = HibernateSessionFactory.getSession();
Transaction tx = null;
try {
tx = session.beginTransaction();
Connection conn=session.connection();
CallableStatement ctmt=conn.prepareCall("{? = call procName}");
ctmt.registerOutParameter(1,java.sql.Types.INTEGER);
for(int i=0;i<para.length;i++){
ctmt.setObject(i+2, para[i]);
}
boolean type = ctmt.execute();
tx.commit();
if(type){ //为true表明存储过程是一个select语句
ResultSet rs = ctmt.getResultSet();
//globesession.close();
return rs;
}else{ //不是select，则获取返回值
int isSuccess = ctmt.getInt(1); //获得返回值。
session.close();
return new Integer(isSuccess);
}
} catch (Exception e) {
e.printStackTrace();
if (tx != null) tx.rollback(); //错误时，回滚操作
if(session!=null) session.close();
}
return null; } @Override
public boolean executeBatch(Object[] obj, int[] model) {
Session session = HibernateSessionFactory.getSession();
Transaction tx = null;
tx = session.beginTransaction();
try {
for(int i=0; i<obj.length; i++){
if(model[i]==INSERT)
session.save(obj[i]);
else if(model[i]==UPDATE)
session.update(obj[i]);
else if(model[i]==DELETE)
session.delete(obj[i]);
}
tx.commit();
session.close();
return true;
}catch(Exception e){
e.printStackTrace();
if (tx != null) tx.rollback(); //错误时，回滚操作
if (session!=null) session.close();
}
return false; } @Override
public boolean executeBatch(List<Object> list, List<Integer> models) {
Session session = HibernateSessionFactory.getSession();
Transaction tx = null;
try {
tx = session.beginTransaction();
for(int i=0; i<list.size(); i++){
Object obj = list.get(i);
Integer model = (Integer)models.get(i);
if(model.intValue()==INSERT){
session.save(obj);
}else if(model.intValue()==UPDATE){
session.update(obj);
}else if(model.intValue()==DELETE){
session.delete(obj);
}
}
tx.commit();
session.close();
return true;
}catch(Exception e){
e.printStackTrace();
if (tx != null) tx.rollback(); //错误时，回滚操作
if (session!=null) session.close();
}
return false;
} }
附加给大家一个junit测试方法书写
package Test; import static org.junit.Assert.*; import java.util.List; import org.junit.After;
import org.junit.Before;
import org.junit.Test;
import basic.*;
import model.TForumTitle;
import model.Tuser;
public class TestHiberBaseDAOImpl {
iHiberDAOImpl bdao=null; @Before
public void init(){
bdao=new iHiberDAOImpl();
}
@After
public void tearDown() throws Exception {
} @Test
public void testInsertObject() {
Tuser user=new Tuser();
user.setUserid("zhangsanfeng");
user.setNickname("太极宗师");
user.setPwd("123456");
user.setAgend("男");
user.setUsertype(2);
System.out.println(bdao.insert(user));
} @Test
public void testInsertListOfObject() {
fail("Not yet implemented");
} @Test
public void testDeleteClassSerializable() {
bdao.delete(Tuser.class,"zhangsanfeng"); } @Test
public void testDeleteObject() {
fail("Not yet implemented");
} @Test
public void testUpdateObject() {
Tuser user=(Tuser)bdao.findById(Tuser.class, "zhangsanfeng");
user.setNickname("太极宗师太极拳");
System.out.println(bdao.update(user));
} @Test
public void testSelectString() {
String hql="from Tuser where usertype =2";
List<Tuser> list =bdao.select(hql);
for (Tuser user : list) {
System.out.println(user.getNickname()+" "+user.getRealname());
}
} @Test
public void testSelectStringIntInt() {
fail("Not yet implemented");
} @Test
public void testSelectStringObjectArray() {
fail("Not yet implemented");
} @Test
public void testSelectStringObjectArrayIntInt() {
fail("Not yet implemented");
} @Test
public void testSelectValueString() {
//查询普通用户的数量
String hql="select count(*) from Tuser where usertype =1";
System.out.println(bdao.selectValue(hql));
} @Test
public void testSelectValueStringObjectArray() {
//查询博主用户数量
String hql="select count(*) from Tuser where usertype=?";
Object[] para={2};
System.out.println(bdao.selectValue(hql,para));
} @Test
public void testSelectPagesStringInt() {
fail("Not yet implemented");
} @Test
public void testSelectPagesStringObjectArrayInt() {
fail("Not yet implemented");
} @Test
public void testSelectByPageStringIntInt() {
//按照分页查询
String hql= "from TForumTitle where userid='zhangtao' order by titleid desc";
List<TForumTitle> list =bdao.select(hql,2,5);
for (TForumTitle obj : list) {
System.out.println(obj.getTopic());
}
} @Test
public void testSelectByPageStringObjectArrayIntInt() {
fail("Not yet implemented");
} @Test
public void testFindById() {
fail("Not yet implemented");
} @Test
public void testUpdateString() {
String sql ="update T_User set nickname =' 费柏设' where userid='zhangsanfeng'";
System.out.println(bdao.update(sql));
} @Test
public void testUpdateStringObjectArray() {
fail("Not yet implemented");
} @Test
public void testDeleteString() {
fail("Not yet implemented");
} @Test
public void testDeleteStringObjectArray() {
fail("Not yet implemented");
} @Test
public void testExecuteProduceString() {
fail("Not yet implemented");
} @Test
public void testExecuteProduceStringObjectArray() {
fail("Not yet implemented");
} @Test
public void testExecuteBatchObjectArrayIntArray() {
//删除对象
TForumTitle forum =(TForumTitle)bdao.findById(TForumTitle.class, 30);
//修改对应Tuser的文章数
Tuser user =(Tuser)bdao.findById(Tuser.class, "zhangtao");
user.setArticlecounter(user.getArticlecounter()-1);
Object[] objs={forum,user};
int[] models={bdao.DELETE,bdao.UPDATE};
//第一个对象删除，第二个对象修改
System.out.println(bdao.executeBatch(objs,models)); } @Test
public void testExecuteBatchListOfObjectListOfInteger() {
fail("Not yet implemented");
} }
我对不定期给大家提供java类的编写代码，及方式，敬请期待