`
phantom
  • 浏览: 163204 次
社区版块
存档分类
最新评论

我自己的数据对象处理类 BaseDAO

SQLlog4jDAOJDBCIDEA 
阅读更多

package com.jh.core.db.jdbc;

import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.sql.Statement;
import java.sql.Timestamp;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;

import org.apache.log4j.Logger;


import com.jh.core.util.JHPage;

/**
 * Created by IntelliJ IDEA. User: wanglch Date: 2005-6-15 Time: 9:48:20
 * 通用DAO数据处理类 辅助完成数据的相关的装载更新的操作 自行管理数据库联接类
 */
abstract public class BaseDAO<T> {
 public  abstract String getDBName();
 private Class clazz = null;

 static Logger log = Logger.getLogger(BaseDAO.class);

 // 获得结果集中数据的拷贝对象一个
 // RsInfo rsInfo=new RsInfo(rs);

 protected BaseDAO(Class<T> clazz) {
  this.clazz = clazz;
 }

 /**
  * 获得结果集中数据的拷贝对象一个 RsInfo rsInfo=new RsInfo(rs);
  *
  * @param rs
  *            结果集
  * @param rsInfo
  *            该对象辅助sql对象装载工具
  * @return 返回具体对象
  * @throws Exception
  */

 @SuppressWarnings("unchecked")
 static private Object rs2Bean(java.sql.ResultSet rs, RsInfo rsInfo)
   throws Exception {
  if(String.class.equals(rsInfo.clazz)){
   return rs.getString(1);
  }
  if(long.class.equals(rsInfo.clazz)){
   return rs.getLong(1);
  }
  if(Long.class.equals(rsInfo.clazz)){
   return rs.getLong(1);
  }
  if(int.class.equals(rsInfo.clazz)){
   return rs.getInt(1);
  }
  if(Integer.class.equals(rsInfo.clazz)){
   return rs.getInt(1);
  }
  Object obj = rsInfo.clazz.newInstance();
       
  try {
   List<LoadRs2P> list = rsInfo.getList();
   for (LoadRs2P lrp : list)
    lrp.set(rs, obj);
  } catch (Exception e) {
   e.printStackTrace();
  }
  return obj;
 }

 // 获得sql数据的拷贝对象

 /**
  * 获得一个对象 sql 查询到一个对象的装载过程实现
  *
  * @param sql
  * @param clazz
  * @return 具体的类的实例
  * @throws Exception
  */
 @SuppressWarnings("unchecked")
  public T getObj( final String sql) throws Exception {
  return (T) DBUtil.execute(getDBName(), new DBCallBack() {
   public Object execute(Connection conn) throws Exception {
    Statement stmt = conn.createStatement();
    log.debug("\n开始执行查询[ " + sql + " ] 嘿咻嘿咻 ");
    ResultSet rs = stmt.executeQuery(sql);
    RsInfo rsInfo = null;
    if (rs.next()) {
     rsInfo = new RsInfo(rs, clazz);
     return (T) rs2Bean(rs, rsInfo);
    }
    return null;
   }
  });
 }

 protected static Object getObj(String dbName, final String sql,
   final Class clazz0) throws Exception {
  return DBUtil.execute(dbName, new DBCallBack() {

   public Object execute(Connection conn) throws Exception {
    Statement stmt = conn.createStatement();
    ResultSet rs = stmt.executeQuery(sql);
    if (rs.next()) {
     RsInfo rsInfo = new RsInfo(rs, clazz0);
     return rs2Bean(rs, rsInfo);
    }
    return null;
   }
  });
 }
 public List<T> getObjList( final String sql,String countSql, JHPage page)
 throws Exception {
  page.setCount(BaseDAO.getIValue(getDBName(), countSql));
  List<T> list = getObjList( sql + " limit " + page.getStart() + " ,"
  + page.getSize());
  page.setList(list);
  return list;
 }
 public List<T> getObjList( final String sql, JHPage page)
   throws Exception {
  return getObjList(sql,"select count(1) from ( " + sql+ " ) as c",page);
 }

 public List<T> getObjList( final String sql, int limit)
   throws Exception {
  return getObjList( sql + " limit " + limit);
  
 }

 @SuppressWarnings("unchecked")
 public List<T> getObjList( final String sql)
   throws Exception {
  log.debug("\n  getObjectList sql = " + sql + "");
  return (List<T>) DBUtil.execute(getDBName(), new DBCallBack() {
   public Object execute(Connection conn) throws Exception {
    List<T> list = new ArrayList();
    Statement pstmt = conn.createStatement();
    ResultSet rs = pstmt.executeQuery(sql);
    RsInfo<T> rsInfo = null;
    if (rs.next()) {
     rsInfo = new RsInfo<T>(rs, clazz);
     list.add((T) rs2Bean(rs, rsInfo));
    }
    while (rs.next()) {
     list.add((T) rs2Bean(rs, rsInfo));
    }
    return list;
   }

  });

 }
 protected static List getObjList(String dbName, final String sql, String countSql,
   final Class clazz0, JHPage page) throws Exception {
  page.setCount(BaseDAO.getIValue(dbName, countSql));
  List list = getObjList(dbName, sql + " limit " + page.getStart() + " ,"
    + page.getSize(), clazz0);
  page.setList(list);
  return list;
  
 }
 protected static List getObjList(String dbName, final String sql,
  final Class clazz0, JHPage page) throws Exception {
  return getObjList(dbName,sql,"select count(1) from ( " + sql+ " ) as c",clazz0,page);
 }

 protected static List getObjList(String dbName, final String sql,
   final Class clazz0) throws Exception {
  log.debug("\n  getObjectList sql = " + sql + "");
  return (List) DBUtil.execute(dbName, new DBCallBack() {
   @SuppressWarnings("unchecked")
   public Object execute(Connection conn) throws Exception {
    List list = new ArrayList();
    Statement pstmt = conn.createStatement();
    ResultSet rs = pstmt.executeQuery(sql);
    RsInfo rsInfo = null;
    if (rs.next()) {
     rsInfo = new RsInfo(rs, clazz0);
     list.add(rs2Bean(rs, rsInfo));
    }
    while (rs.next()) {
     list.add(rs2Bean(rs, rsInfo));
    }
    return list;
   }

  });

 }

 public static List getMapList(String dbName, final String sql)
   throws Exception {
  log.debug("\n  getObjectList sql = " + sql + "");
  return (List) DBUtil.execute(dbName, new DBCallBack() {
   public Object execute(Connection conn) throws Exception {
    List<Map<?, ?>> list = new ArrayList<Map<?, ?>>();
    Statement pstmt = conn.createStatement();
    ResultSet rs = pstmt.executeQuery(sql);

    while (rs.next()) {
     list.add(rs2Map(rs));
    }
    return list;
   }
  });
 }

 public static Map getMapObj(String dbName, final String sql)
   throws Exception {
  log.debug("\n  getObjectList sql = " + sql + "");
  return (Map) DBUtil.execute(dbName, new DBCallBack() {
   public Object execute(Connection conn) throws Exception {
    Statement pstmt = conn.createStatement();
    ResultSet rs = pstmt.executeQuery(sql);

    if (rs.next()) {
     return (rs2Map(rs));
    }
    return null;
   }
  });
 }

 @SuppressWarnings("unchecked")
 static private Map rs2Map(ResultSet rs) {
  try {
   Map map = new HashMap();
   ResultSetMetaData m = rs.getMetaData();
   for (int i = 0; i < m.getColumnCount(); i++) {
    // System.out.println(m.getColumnName(i+1)+"="+rs.getString(i+1));
    if ("java.sql.Timestamp".equals(m.getColumnClassName(i + 1))) {
     try {
      map.put(m.getColumnName(i + 1), new java.util.Date(rs
        .getTimestamp(i + 1).getTime()));
     } catch (Exception e) {
     }
    } else {
     if(rs.getString(i + 1)==null||rs.getString(i + 1).equals("null")){
      map.put(m.getColumnName(i + 1), "0" );
     }else{
      map.put(m.getColumnName(i + 1), "" + rs.getString(i + 1));
     }
     
    }
   }
   return map;
  } catch (SQLException e) {
   e.printStackTrace();
  }
  return null;
 }

 // 把对象中的数据形成sql语句段

 /**
  * 通过对象，字段名字 获得相关的数据库所需要的值类型
  *
  * @param str
  * @param obj
  * @return 返回对应数据库的相应代码。
  */
 private static String getSqlValue(String str, Object obj) {
  Class clazz = obj.getClass();
  Field field = null;
  try {
   field = clazz.getDeclaredField(str);
   field.setAccessible(true);
   if (field.getType().equals(String.class)) {
    String value = (String) (field.get(obj));
    if ("".equals(value) || value == null)
     value = "";
    // value = value.replaceAll("'", "''");
    // value = value.replaceAll("\"", "&quot;");
    return "" + value + "";

   } else if (field.getType().equals(Date.class)) {
    String dateStr = UtilTime.getDateToString(
      (Date) field.get(obj), "yyyy-MM-dd HH:mm:ss");
    if (dateStr != null)
     return "" + dateStr + "";
   } else if (field.getType().equals(int.class)) {
    return "" + field.get(obj) + "";
   } else {
    return "" + field.get(obj) + "";
   }
  } catch (NoSuchFieldException e) {
   log.debug("对象中没有找到相应的列:" + e);
   return "''";
  } catch (Exception e) {
   return "''";
  }
  return "''";
 }
 private static java.sql.Timestamp getSqlDateValue(String str, Object obj) {
  Class clazz = obj.getClass();
  Field field = null;
  try {
   field = clazz.getDeclaredField(str);
   field.setAccessible(true);
     if (field.getType().equals(Date.class)) {
    
     java.util.Date date=(java.util.Date) field.get(obj);
      if(date==null)return new  java.sql.Timestamp(new Date().getTime());  
     return new  java.sql.Timestamp(date.getTime());
     }
  } catch (NoSuchFieldException e) {
   log.debug("对象中没有找到相应的列:" + e);
   return null;
  } catch (Exception e) {
   return null;
  }
  return null;
 }
 private static String genPUpdateSql(String tableName, String[] columnName,
   String[] whereColumn) {
  StringBuffer buff = new StringBuffer();

  buff.append(" update   ");
  buff.append(" " + tableName + " set ");
  buff.append(columnName[0] + "= ? ");
  for (int i = 1; i < columnName.length; i++) {
   buff.append(", " + columnName[i]);
   buff.append("= ? ");
  }
  buff.append(" where 1=1 ");
  for (int i = 0; whereColumn != null && i < whereColumn.length; i++) {
   buff.append(" and " + whereColumn[i]);
   buff.append("= ? ");
  }
  return buff.toString();
 }

 /**
  * 预编译更新
  *
  * @param tableName
  * @param columnName
  * @param whereColumn
  * @param obj
  */
 protected static void updateObj(String dbName, String tableName,
   final String[] columnName, final String[] whereColumn,
   final Object obj) {

  PreparedDBCallBack pcallBack = new PreparedDBCallBack() {
   @Override
   public Object execute(PreparedStatement ps) throws SQLException {
    int k = 1;
    StringBuffer s = new StringBuffer();
    for (int i = 0; columnName != null && i < columnName.length; i++) {
     if(isDateTime(columnName[i], obj)){
        Timestamp dateSql=getSqlDateValue(columnName[i], obj);
        ps.setTimestamp(k, dateSql);
        s.append("\n参数" + k + "=  " + dateSql);
     }else{
       String str = getSqlValue(columnName[i], obj);
       s.append("\n参数" + k + "=  " + str);
       ps.setString(k, str);

     }
     k++;
    }
    for (int i = 0; whereColumn != null && i < whereColumn.length; i++) {
     if(isDateTime(whereColumn[i], obj)){
        Timestamp dateSql=getSqlDateValue(whereColumn[i], obj);
        ps.setTimestamp(k, dateSql);
        s.append("\n参数" + k + "=  " + dateSql);
     }else{
       String str = getSqlValue(whereColumn[i], obj);
       s.append("\n参数" + k + "=  " + str);
       ps.setString(k, str);

     }
     k++;
    }
    log.debug(s.toString());
    return ps.execute();
   }
  };

  String sql = genPUpdateSql(tableName, columnName, whereColumn);
  log.debug("\n开始执行 sql=  " + sql);
  DBUtil.preparedExecute(dbName, pcallBack, sql);
 }
 
 protected static void updateObj(String dbName, String tableName,
   final String[] columnName, final String[] whereColumn,
   final List list) {

  PreparedDBCallBack pcallBack = new PreparedDBCallBack() {
   @Override
   public Object execute(PreparedStatement ps) throws SQLException {
    
    StringBuffer s = new StringBuffer();
    for(Object obj:list){
     int k = 1;
    for (int i = 0; columnName != null && i < columnName.length; i++) {
     if(isDateTime(columnName[i], obj)){
        Timestamp dateSql=getSqlDateValue(columnName[i], obj);
        ps.setTimestamp(k, dateSql);
        s.append("\n参数" + k + "=  " + dateSql);
     }else{
       String str = getSqlValue(columnName[i], obj);
       s.append("\n参数" + k + "=  " + str);
       ps.setString(k, str);

     }
     k++;
    }
    for (int i = 0; whereColumn != null && i < whereColumn.length; i++) {
     if(isDateTime(whereColumn[i], obj)){
        Timestamp dateSql=getSqlDateValue(whereColumn[i], obj);
        ps.setTimestamp(k, dateSql);
        s.append("\n参数" + k + "=  " + dateSql);
     }else{
       String str = getSqlValue(whereColumn[i], obj);
       s.append("\n参数" + k + "=  " + str);
       ps.setString(k, str);

     }
     k++;
    }
    s.append("\n#---------------------------#");
    ps.addBatch();
    }
    log.debug(s.toString());
    return ps.executeBatch();
   }
  };

  String sql = genPUpdateSql(tableName, columnName, whereColumn);
  log.debug("\n开始执行 sql=  " + sql);
  DBUtil.preparedExecute(dbName, pcallBack, sql);
 }
 protected static void updateObj(String dbName, String tableName,
   final String[] columnName, final String where, final Object obj) {

  PreparedDBCallBack pcallBack = new PreparedDBCallBack() {
   @Override
   public Object execute(PreparedStatement ps) throws SQLException {
    int k = 1;
    StringBuffer s = new StringBuffer();
    for (int i = 0; i < columnName.length; i++) {
     if(isDateTime(columnName[i], obj)){
        Timestamp dateSql=getSqlDateValue(columnName[i], obj);
        ps.setTimestamp(k, dateSql);
        s.append("\n参数" + k + "=  " + dateSql);
     }else{
       String str = getSqlValue(columnName[i], obj);
       s.append("\n参数" + k + "=  " + str);
       ps.setString(k, str);

     }
     k++;
    }

    return ps.execute();
   }
  };

  String sql = genPUpdateSql(tableName, columnName, null) + " and "
    + where;
  DBUtil.preparedExecute(dbName, pcallBack, sql);
 }
 protected static void updateObj(String dbName, String tableName,
   final String[] columnName, final String where, final List list) {

  PreparedDBCallBack pcallBack = new PreparedDBCallBack() {
   @Override
   public Object execute(PreparedStatement ps) throws SQLException {
    StringBuffer s = new StringBuffer();
    for (Object obj:list){
    int k = 1;
    for (int i = 0; i < columnName.length; i++) {
     if(isDateTime(columnName[i], obj)){
        Timestamp dateSql=getSqlDateValue(columnName[i], obj);
        ps.setTimestamp(k, dateSql);
        s.append("\n参数" + k + "=  " + dateSql);
      }else{
       String str = getSqlValue(columnName[i], obj);
       s.append("\n参数" + k + "=  " + str);
       ps.setString(k, str);

      }
     k++;
    }
    ps.addBatch();
    }
    log.debug(s.toString());
    
    return ps.executeBatch();
   }
  };

  String sql = genPUpdateSql(tableName, columnName, null) + " and "
    + where;
  DBUtil.preparedExecute(dbName, pcallBack, sql);
 }

 
 static private boolean isDateTime(String columnName, Object obj){
  Class clazz = obj.getClass();
 
  try {
   Field
   field = clazz.getDeclaredField(columnName);
   if(field.getType().equals(java.util.Date.class)){
    return true;
   }
  }catch(Exception e){
   
  }
  return false;
 }
 /**
  * 预编译增加
  *
  * @param tableName
  * @param columnName
  * @param obj
  */
 protected static long insertObj(String dbName, String tableName,
   final String[] columnName, final Object obj) {
  PreparedDBCallBack pcallBack = new PreparedDBCallBack() {
   @Override
   public Object execute(PreparedStatement ps) throws SQLException {
    int k = 1;
    StringBuffer s = new StringBuffer();
    for (int i = 0; i < columnName.length; i++) {
     if(isDateTime(columnName[i], obj)){
       Timestamp dateSql=getSqlDateValue(columnName[i], obj);
       ps.setTimestamp(k, dateSql);
       s.append("\n参数" + k + "=  " + dateSql);
     }else{
      String str = getSqlValue(columnName[i], obj);
      s.append("\n参数" + k + "=  " + str);
      ps.setString(k, str);

     }
     // System.out.println(k);
     k++;
    }
    log.debug(s.toString());
    ps.execute();
    String sql="select LAST_INSERT_ID()";
       java.sql.ResultSet rs= ps.executeQuery(sql);
    if(rs.next()){
     return rs.getLong(1);
    }
    return new Long(0) ;
   }
  };

  String sql = genPInsertSql(tableName, columnName);
  log.debug("\n psql=" + sql);
  // System.out.println("psql=" + sql);
  return (Long)DBUtil.preparedExecute(dbName, pcallBack, sql);
 }
 protected static void insertObjList(String dbName, String tableName,
   final String[] columnName, final List list) {
  PreparedDBCallBack pcallBack = new PreparedDBCallBack() {
   @Override
   public Object execute(PreparedStatement ps) throws SQLException {
    StringBuffer s = new StringBuffer();
    for(Object obj: list) {
    int k = 1;
    
    
    for (int i = 0; i < columnName.length; i++) {
     if(isDateTime(columnName[i], obj)){
        Timestamp dateSql=getSqlDateValue(columnName[i], obj);
        ps.setTimestamp(k, dateSql);
        s.append("\n参数" + k + "=  " + dateSql);
     }else{
       String str = getSqlValue(columnName[i], obj);
       s.append("\n参数" + k + "=  " + str);
       ps.setString(k, str);

     }
     k++;
    }
    s.append("\n#####################################\n");
    ps.addBatch();
    
    }
    ps.executeBatch();
    log.debug(s.toString());
    return null;
   }
  };

  String sql = genPInsertSql(tableName, columnName);
  log.debug("\n psql=" + sql);
  // System.out.println("psql=" + sql);
  DBUtil.preparedExecute(dbName, pcallBack, sql);
 }

 private static String genPInsertSql(String tableName, String[] columnName) {
  StringBuffer buff = new StringBuffer();
  StringBuffer buff2 = new StringBuffer();
  buff.append(" insert into  ");
  buff.append(" " + tableName + "(");
  buff.append(columnName[0]);
  buff2.append(" ? ");
  for (int i = 1; i < columnName.length; i++) {
   buff.append(", " + columnName[i]);
   buff2.append(",? ");
  }
  buff.append(") values (");
  buff.append(buff2.toString());
  buff.append(")");
  return buff.toString();
 }

 /**
  * 取值特定统计或者查询方法 <br>
  * 该查询不检查查询的合法性
  *
  * @param sql
  * @return
  * @throws Exception
  */
 public static Object getValue(String dbName, final String sql)
   throws Exception {
  log.debug("\n  getPObjects sql = " + sql + "");
  return (Object) DBUtil.execute(dbName, new DBCallBack() {
   public Object execute(Connection conn) throws Exception {
    Statement pstmt = conn.createStatement();
    ResultSet rs = pstmt.executeQuery(sql);
    if (rs.next()) {
     return rs.getObject(1);
    }
    return null;
   }
  });
 }
 public static int getIValue(String dbName, final String sql)
 throws Exception {
 return (Integer) DBUtil.execute(dbName, new DBCallBack() {
 public Object execute(Connection conn) throws Exception {
  Statement pstmt = conn.createStatement();
  ResultSet rs = pstmt.executeQuery(sql);
  if (rs.next()) {
   return rs.getInt(1);
  }
  return 0;
 }
});
}
 public static long getLValue(String dbName, final String sql)
 throws Exception {
 return (Long) DBUtil.execute(dbName, new DBCallBack() {
 public Object execute(Connection conn) throws Exception {
  Statement pstmt = conn.createStatement();
  ResultSet rs = pstmt.executeQuery(sql);
  if (rs.next()) {
   return rs.getLong(1);
  }
  return 0l;
 }
});
}
 /**
  * 执行更新
  *
  * @param sql
  * @return 返回执行执行状态
  * @throws SQLException
  */
 protected static boolean execute(String dbName, String sql)
   throws SQLException {
  log.debug("sql=" + sql);
  Connection conn = null;
  try {
   conn = DBConnection.getDBConnection(dbName);
   Statement stmt = conn.createStatement();
   try {
    return stmt.execute(sql);
   } finally {
    // stmt.close();
   }
  } finally {
   conn.close();
  }

 }

 /**
  * 批处理更新并返回每个批次的更新结果
  *
  * @param sqlList
  * @return 每个批次的更新结果
  * @throws SQLException
  */
 public static int[] update(String dbName, List sqlList)
   throws SQLException {
     
  Connection conn = null;
  try {
   conn = DBConnection.getDBConnection(dbName);
   Statement stmt = conn.createStatement();
   try {
    Iterator it = sqlList.iterator();
    while (it.hasNext()) {
     stmt.addBatch((String) it.next());
    }
    return stmt.executeBatch();
   } finally {
    stmt.close();
   }
  } finally {
   conn.close();
  }

 }

 /**
  * 执行更新
  *
  * @param sql
  * @return 更新数量
  * @throws SQLException
  */
 public static int update(String dbName, String sql) throws SQLException {
  log.debug("updateSql=" + sql);
  Connection conn = null;
  try {
   conn = DBConnection.getDBConnection(dbName);
   Statement stmt = conn.createStatement();
   try {
    return stmt.executeUpdate(sql);
   } finally {
    stmt.close();
   }
  } finally {
   conn.close();
  }
 }

 /**
  * 获得有限条数的对象list
  *
  * @param db_name
  * @param sql
  * @param clazz0
  * @param limit
  * @return
  * @throws Exception
  */
 public static List getObjList(String db_name, String sql, Class clazz0,
   int limit) throws Exception {
  return getObjList(db_name, sql + " limit " + limit, clazz0);
 }


 
 
}

分享到：
| java-flash
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    basedao_basedao数据库_

    在描述中提到的"手动实现BaseDao"意味着开发者需要自己编写这些基础方法的具体实现，而不是依赖于框架或者工具。这可能涉及到JDBC（Java Database Connectivity）的使用，包括连接数据库、准备SQL语句、执行SQL以及...

    SSH集成查询分页处理BaseDao

    在标题提到的"SSH集成查询分页处理BaseDao"中，我们主要关注的是如何在SSH框架下实现数据的分页查询。 分页是大型Web应用中必不可少的功能，它能够帮助用户更有效地浏览和管理大量数据。在这个场景中，"BaseDao...

    hibernate>>BaseDAO

    `BaseDAO`是许多项目中常见的一种设计模式，它代表了数据访问对象（Data Access Object）的基础类，用于封装对数据库的通用操作。现在我们来深入探讨`hibernate`中的`BaseDAO`及其相关知识点。 首先，DAO设计模式是...

    springboot+mybatis 多数据源 basedao +分页

    本项目涉及到的主题是“SpringBoot+MyBatis实现多数据源以及基于BaseDAO的分页功能”。 多数据源是指在一个应用中同时管理多个数据库。这在分布式系统或者需要隔离不同业务数据的场景中非常常见。SpringBoot可以...

    基于hibernate的baseDao

    BaseDAO是一种通用的设计模式，它封装了Hibernate框架的基本操作，使得业务逻辑层可以更加专注于业务处理，而不需要关心底层的数据访问细节。本压缩包提供的"baseDAO"文件，包含了一个详细注释的BaseDAO实现，旨在...

    mybatis basedao

    此外，由于BaseDAO通常会包含事务管理的支持，因此在处理复杂的业务场景时，也能保证数据的一致性。 在实际项目中，MyBatis BaseDAO 还可能包含其他实用功能，如分页查询、条件构造器等，这些都是为了进一步提高...

    jdbcBaseDao

    创建具体的数据访问对象（DAO）类时，可以继承`BaseDao`，并提供数据库表相关的常量和方法。 2. **调用父类方法**： 在子类中调用`BaseDao`的`executeQuery()`和`executeUpdate()`等方法，传入SQL语句和参数。 3...

    SpringBoot_BaseDao.zip

    在BaseDao中，泛型可以用来定义通用的类型参数，比如，使得BaseDao能够处理任何类型的实体对象，而无需为每种实体创建一个新的DAO类。 反射是Java的一个重要特性，它允许运行时动态地获取类的信息并调用其方法。在...

    ssh+baseDao实现分页

    在IT行业中，SSH（Spring、Struts、Hibernate）是一个经典的Java Web开发框架组合，而BaseDao是常用于数据访问层的一个基类设计。本话题主要围绕如何利用SSH框架结合BaseDao实现分页功能来展开。 首先，让我们了解...

    java泛型BaseDao与BaseService

    BaseDao是数据访问对象（DAO）的基类，通常包含了对数据库的基本操作，如增删查改。在Java中，我们可以使用泛型来让BaseDao更加通用。例如，我们可以声明一个泛型接口`BaseDao&lt;T&gt;`，其中T代表我们将要操作的实体类型...

    BaseDao的封装

    `BaseDao`的封装使得每个具体的DAO类只需要关注业务逻辑，无需关心底层的数据访问细节。 例如，一个简单的`BaseDao`可能包含如下方法： 1. `save(T entity)`: 保存实体对象到数据库。 2. `update(T entity)`: 更新...

    hibernate BASEDAO

    BaseDAO类通常会继承自Hibernate的Session接口或SessionFactory接口，或者自定义一个抽象的DAO基类，以实现对实体对象的操作。`BaseDAO.java`文件很可能是这个基类的源代码，它会包含如下的核心方法： 1. **保存...

    全面了解JAVA_BaseDAO数据处理类

    下面我们将全面解析给出的JAVA_BaseDAO数据处理类，探讨其核心功能和设计思路。 首先，BaseDAO类中定义了一些私有的成员变量，包括数据库驱动（drive）、数据库URL（url）、用户名（user）和密码（password）。这些...

    dbutils封装ORM 实现BaseDAO

    `BaseDAO` 的封装则是一种常见的设计模式，用于简化数据访问对象（DAO）的实现，使得业务代码更加简洁、可维护。 `dbutils` 主要包含以下几个核心概念和功能： 1. **QueryRunner**: QueryRunner类是dbutils的主要...

    基于SpringJDBC的BaseDAO

    本文将详细介绍如何基于Spring JDBC模块创建一个通用的数据访问对象(BaseDAO)类，实现简单的对象关系映射(ORM)功能，包括增删改查等基本操作。 #### Spring JDBC简介 Spring JDBC是Spring框架的一部分，它简化了...

    BaseDao.java，DaoUtil.java

    `BaseDao.java` 可能是一个基础数据访问对象（DAO）接口或抽象类，它定义了通用的数据库操作方法。这些方法可能包括增删改查（CRUD）操作，如插入（insert）、更新（update）、删除（delete）和查询（select）。通过...

    java BaseDao

    在Java编程语言中，BaseDao（基础数据访问对象）是一个常见的设计模式，它为数据库操作提供了一种统一的接口。BaseDao通常包含了CRUD（创建、读取、更新、删除）的基本方法，使得开发者可以方便地对数据库进行操作，...

    企业通用BaseDao方法集

    BaseDao通常包含CRUD方法、分页查询以及事务管理等核心功能，能够帮助开发人员快速地处理数据访问层的逻辑，从而更加专注于业务的实现。对于初学者，理解和掌握BaseDao的设计与实现，对于提升编程技能和理解企业级...

    BaseDAO.js

    例如，如果我们的应用需要处理用户数据，我们可以创建一个`UserDAO`类，它继承自`BaseDAO`并提供针对用户表的定制操作。 在博文链接中，作者可能详细解释了BaseDAO.js的实现细节、最佳实践以及如何在实际项目中使用...

    BaseDao代码

    ### BaseDao代码详解 在Java开发中，尤其是企业级应用开发中，数据库操作是不可或缺的一...在实际项目中，开发者可以根据具体需求继承`BaseDao`类，并扩展或重写其中的方法，以满足更复杂的业务逻辑和数据操作需求。

Magicbox
Global site tag (gtag.js) - Google Analytics