JAVA实现DAO层基本CRUD操作

    随着shh2框架各种操作的便利性，越来越多的Java WEB开发人员选择通过加入这些框架以提高开发效率，但是，如果在不了解这些框架使用的场合的情况下，一拿到项目就盲目地选择这些框架进行系统架构的搭建，就有可能造成很多没必要的资源浪费。

      在项目开发中，对数据库的CRUD操作我们一般都是无法避免的操作，虽然hibernate封装的很完美，但是，由于本人对这个框架的底层原理不是很了解，每次使用的时候心里总觉得没底，代码一旦出现异常，很多时候都没法快速有效地解决，因此，为了让代码异常处理风险控制在自己的可控范围内，还是决定先将数据的CRUD持久化操作（DAO）用自己的方式通过JDBC进行一次封装，以便更好地管理自己的代码。关于Hibernate框架的使用，还是先弄懂它的一些底层实现原理后，再根据项目的需要酌情选择使用。 

      下面具体讲讲通过我自己的方式对有关DAO层数据库基本CRUD操作的Java实现（此处已MySQL为例，其他数据库只需做部分修改即可）。

      备注：若要试用本示例，只需按照给出的顺序依次复制代码建立相应的类即可。另外，在项目lib目录下加入mysql链接jar包。

  （1）定义数据源常量类

 package com.jkitn.jkits.common;

 /**
  * 定义数据源常量类
  * @author xdweleven
  * @version 1.0
  */
 public class JdbcConfig {
      /** 数据库驱动 */
      public static final String DRIVERCLASSNAME = "com.mysql.jdbc.Driver";
      /** 数据库URL */
      public static final String URL = "jdbc:mysql://localhost:3306/app_jkit";
      /** 数据库用户名 */
      public static final String USERNAME = "root";
      /** 数据库密码 */
      public static final String PASSWORD = "root";
 }

（2）定义结果集（ResultSet）到pojo对象的映射

 package com.jkitn.jkits.dao.common;

 import java.lang.reflect.Field;
 import java.sql.ResultSet;
 import java.sql.ResultSetMetaData;
 import java.sql.SQLException;
 import java.util.ArrayList;
 import java.util.List;

 /**
  * 说明：实现结果集到pojo对象的映射
  * @author xdweleven
  * @version 1.0
  */
 public class RowMapper{
     private Class objectClass;

     public RowMapper(Class objectClass) {
         this.objectClass = objectClass;
     }

     /**
      * 实现单条记录到对象的映射
      * @param rs 结果集
      * @param rowNum 当前行数
      * @return
      * @throws SQLException
      */
     public T mapRow(ResultSet rs, int rowNum) throws SQLException {
         try {
             T object = objectClass.newInstance();
             // 得到结果集的字段集合
             ResultSetMetaData metaData = rs.getMetaData();
             int columnNum = metaData.getColumnCount();
             Field[] fields = object.getClass().getDeclaredFields();
             // 设置对象属性的值，若不存在，则设置为null.
             for (int i = 0; i < fields.length; i++) {
                 Field field = fields[i];
                 int flag = 0;
                 for (int j = 1; j <= columnNum; j++) {
                     if (metaData.getColumnName(j).toLowerCase().equals(field.getName().toLowerCase())) {
                         flag = 1;
                         break;
                     }
                 }
                 field.setAccessible(true);
                 if (flag == 1) {
                     this.typeMapper(field, object, rs);
                 }else {
                     field.set(object, null);
                 }
                 field.setAccessible(false);
             }
             return object;
         } catch (InstantiationException e) {
             e.printStackTrace();
         } catch (IllegalAccessException e) {
             e.printStackTrace();
         }
         return null;
     }

     /**
      * 实现多条记录到结果集的映射
      * @param rs
      * @return
      */
     public List mapRows(ResultSet rs){
         int rowNum = 0;
         List objList = new ArrayList();
         try {
             while(rs.next()){
                 objList.add(this.mapRow(rs, rowNum++));
             }
             rs.close();
         } catch (SQLException e) {
             e.printStackTrace();
         }
         return objList;
     }


     /**
      * 类型的映射
      * @param field
      * @param obj
      * @param rs
      * @throws IllegalArgumentException
      * @throws IllegalAccessException
      * @throws SQLException
      */
     private void typeMapper(Field field, Object obj, ResultSet rs) {
         String typeName = field.getType().getName(); // 得到字段类型
         try {
             if (typeName.equals("java.lang.String")) {
                 field.set(obj, rs.getString(field.getName()));
             } else if (typeName.equals("int")
                     || typeName.equals("java.lang.Integer")) {
                 field.set(obj, rs.getInt(field.getName()));
             } else if (typeName.equals("long")
                     || typeName.equals("java.lang.Long")) {
                 field.set(obj, rs.getLong(field.getName()));
             } else if (typeName.equals("float")
                     || typeName.equals("java.lang.Float")) {
                 field.set(obj, rs.getFloat(field.getName()));
             } else if (typeName.equals("double")
                     || typeName.equals("java.lang.Double")) {
                 field.set(obj, rs.getDouble(field.getName()));
             } else if (typeName.equals("boolean")
                     || typeName.equals("java.lang.Boolean")) {
                 field.set(obj, rs.getBoolean(field.getName()));
             } else if (typeName.equals("java.util.Date")) {
                 field.set(obj, rs.getTimestamp(field.getName()));
             } else {
             }
         } catch (IllegalArgumentException e) {
             e.printStackTrace();
         } catch (IllegalAccessException e) {
             e.printStackTrace();
         } catch (SQLException e) {
             e.printStackTrace();
         }
     }
 }

  (3)定义数据库连接辅助类DBConn

 package com.jkitn.jkits.common;

 import java.sql.Connection;
 import java.sql.DriverManager;
 import java.sql.PreparedStatement;
 import java.sql.ResultSet;
 import java.sql.SQLException;
 import java.util.List;

 import com.jkitn.jkits.dao.common.RowMapper;

 /**
  * 定义数据库连接辅助类DBConn
  * @author xdweleven
  * @version 1.0
  */
 public class DBConn {
     private Connection conn = null;
     private PreparedStatement pstmt = null;
     private ResultSet rs = null;

     /**
      * 创建数据库的连接
      * @return 返回数据库连接对象
      */
     public Connection getConn(){
         try {
             // 加载数据库驱动
             Class.forName(JdbcConfig.DRIVERCLASSNAME);
             // 创建Connection接口对象，用于获取MySQL数据库的连接对象
             conn = DriverManager.getConnection(JdbcConfig.URL, JdbcConfig.USERNAME, JdbcConfig.PASSWORD);
         } catch (ClassNotFoundException e) {
             e.printStackTrace();
         } catch (SQLException e) {
             e.printStackTrace();
         }
         return conn;
     }

     /**
      * 更新数据库操作（包括增删改操作）
      * @param sql  待执行sql语句
      * @param objs 用于设置预编译语句中带入的参数
      * @return null
      * @throws Exception
      */
     public int execUpdate(String sql, Object ...objs) throws Exception{
             // 获取预编译环境
             pstmt = this.getConn().prepareStatement(sql);
             if(objs != null && objs.length > 0){
                 for(int i = 0; i < objs.length; i++){
                     pstmt.setObject(i+1, objs[i]);
                 }
             }
             // 执行更新语句
             int result = pstmt.executeUpdate();
             // 断开连接，释放资源
             this.close(rs, pstmt, conn);
             return result;
     }

     /**
      * 数据库查询操作
      * @param sql 待执行sql语句
      * @param objs 用于设置预编译语句中带入的参数
      * @return 类T的List数据类型，即返回查询到的所有数据信息
      * @throws Exception
      */
     public  List execQuery(String sql, RowMapper mapper, Object ...objs) throws Exception{
         // 获取预编译环境
         pstmt = this.getConn().prepareStatement(sql);
         if(objs != null && objs.length > 0){
             for(int i = 0; i < objs.length; i++){
                 pstmt.setObject(i+1, objs[i]);
             }
         }
         // 执行更新语句
         rs = pstmt.executeQuery();
         // 执行关系到对象的映射
         List result = mapper.mapRows(rs);
         // 断开连接，释放资源
         this.close(rs, pstmt, conn);
         return result;
     }

     /**
      * 执行执行的SQL语句并返回结果集
      * @param sql SQL语句
      * @param params 参数
      * @return 返回结果集
      */
     public ResultSet queryForResultSet(String sql, Object... objs) throws Exception{
         // 获取预编译环境
         pstmt = conn.prepareStatement(sql);
         if(objs != null && objs.length > 0){
             for(int i = 0; i < objs.length; i++){
                 pstmt.setObject(i+1, objs[i]);
             }
         }
         // 执行更新语句
         rs = pstmt.executeQuery();
         // 断开连接，释放资源
         this.close(null, pstmt, conn);
         return rs;
     }

     /**
      * 关闭数据库连接，释放所占的系统资源
      * @param rs结果集、ppst预编译命令、conn数据库
      * @return null
      * @throws Exception
      */
     public void close(ResultSet rs, PreparedStatement ppst, Connection conn) throws Exception{
         if(rs != null){
             rs.close();
         }
         if(ppst != null){
             ppst.close();
         }
         if(conn != null){
             conn.close();
         }
     }
 }

 (4)定义通用分页查询实体类

 package com.jkitn.jkits.common;

 import java.util.List;

 /**
  * 说明：实现通用分页查询实体类
  * @author xdweleven
  * @version 1.0
  */
 public class PageBean {
     private int totalRows; // 总记录数
     private int totalPages; // 总页数
     private int curPage; // 当前页码
     private int prePage; // 上一页页码
     private int nextPage; // 下一页页码
     private int rowsPerPage; // 每页显示的记录数
     private List pageList; // 当前页的数据集

     /**
      * 初始化分页bean对象
      * @param totalRows 总记录数
      * @param rowsPerPage 每页显示的记录数
      */
     public void initPageBean(int totalRows, int rowsPerPage){
         this.rowsPerPage = rowsPerPage;
         this.totalRows = totalRows;
         this.totalPages = (this.totalRows-1)/this.rowsPerPage + 1;
         // 设置上一页
         if(this.curPage == 1){
             this.setPrePage(1);
         }else{
             this.setPrePage(this.curPage-1);
         }
         // 设置下一页
         if(this.curPage == this.totalPages){
             this.setNextPage(this.totalPages);
         }else{
             this.setNextPage(this.curPage + 1);
         }
     }

     /**
      * 生成SQLServer的分页查询语句
      * @param sql 原始sql语句
      * @param curPage 第几页
      * @param rowsPerPage 每页多少行
      */
     public String getPageSQLServer(String sql, int curPage, int rowsPerPage){
         String afterFrom = sql.toLowerCase().substring(sql.indexOf("from"));
         String pageSql = null;
         if(afterFrom.indexOf("where") == -1){
              pageSql = "select top "+ rowsPerPage + " * "+afterFrom
             +" where id not in(select top "+rowsPerPage*(curPage-1)+" id "
             +afterFrom+" order by id desc)"+"order by id desc";
         }else{
             pageSql = "select top "+ rowsPerPage + " * "+afterFrom
             +" and id not in(select top "+rowsPerPage*(curPage-1)+" id "
             +afterFrom+" order by id desc)"+"order by id desc";
         }
         return pageSql;
     }

     /**
      * 生成MySql分页sql语句
      * @param sql 原始sql语句
      * @param curPage 第几页
      * @param rowsPerPage 每页多少行
      * @return 返回分页SQL语句
      */
     public String getPageMySQL(String sql, int curPage, int rowsPerPage){
         String pageSql = sql+" limit "+ (curPage-1)*rowsPerPage+","+rowsPerPage;
         return pageSql;
     }

     /**
      * 生成Oracle分页查询语句
      * @param sql 原始sql语句
      * @return 返回分页SQL语句
      */
     public String getOrclPageSql(String sql){
         int begin = (curPage - 1) * rowsPerPage;
         int end = begin + rowsPerPage;
         StringBuffer pagingSelect = new StringBuffer(300);
         pagingSelect.append("select * from ( select row_.*, rownum rownum_ from ( ");
         pagingSelect.append(sql);
         pagingSelect.append(" ) row_ where rownum <= "+end+") where rownum_ > "+begin);
         return pagingSelect.toString();
     }

     public List getPageList() {
         return pageList;
     }

     public void setPageList(List pageList) {
         this.pageList = pageList;
     }
     public int getTotalRows() {
         return totalRows;
     }

     public void setTotalRows(int totalRows) {
         this.totalRows = totalRows;
     }

     public int getTotalPages() {
         return totalPages;
     }

     public void setTotalPages(int totalPages) {
         this.totalPages = totalPages;
     }

     public int getCurPage() {
         return curPage;
     }

     public void setCurPage(int curPage) {
         this.curPage = curPage;
     }

     public int getPrePage() {
         return prePage;
     }

     public void setPrePage(int prePage) {
         this.prePage = prePage;
     }

     public int getNextPage() {
         return nextPage;
     }

     public void setNextPage(int nextPage) {
         this.nextPage = nextPage;
     }

     public int getRowsPerPage() {
         return rowsPerPage;
     }

     public void setRowsPerPage(int rowsPerPage) {
         this.rowsPerPage = rowsPerPage;
     }
 }

 (5)定义SQL语句的常用方法工具类

 package com.jkitn.jkits.util;

 import java.lang.reflect.Field;
 import java.util.ArrayList;
 import java.util.Date;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;

 /**
  * 说明：自动生成对象的增删改查SQL语句的通用方法工具类
  * @author xdweleven
  * @version 1.0
  */
 public class SQLUtil {
     /**
      * 自动生成插入指定对象的SQL语句,不包括对象属性的值为空的字段
      * @param obj 待生成插入SQL语句的对象
      * @param tableName 待插入语句对应的数据库表的名称
      * @return 返回一个包含SQL语句、SQL语句参数值及参数值类型的Map对象
      */
     public static Map generateInsertExceptNull(Object obj, String tableName) {
         StringBuffer columnStrBuf = new StringBuffer(); // 记录数据表的字段名称
         StringBuffer paramStrBuf = new StringBuffer(); // 记录SQL语句对应插入的占位符
         List paramValues = new ArrayList(); // 记录对象参数值  
         List paramsType = new ArrayList(); // 记录参数值类型  
         // 查询待插入对象的属性值不为空的属性名称  
         List fieldList = ReflectionUtil.getNotNullField(obj);  
         try {  
             for (int i = 0; i < fieldList.size(); i++) {  
                 Field field = (Field) fieldList.get(i);  
                 field.setAccessible(true);  
                 // 记录对象属性名称  
                 columnStrBuf.append(field.getName());  
                 if (i != fieldList.size() - 1) {  
                     columnStrBuf.append(",");  
                 }  
                   
                 // 记录插入SQL语句的参数占位符  
                 if("class java.util.Date".equals(field.getType().toString())  
                         && field.get(obj) != null){  
                     String timeStr = DateUtil.formatDate((Date)field.get(obj), "yyyy-MM-dd HH:mm:ss");  
                     paramStrBuf.append("to_date(?, 'yyyy-MM-dd HH24:mi:ss')");  
                     paramValues.add(timeStr);  
                     // 记录对象属性的数据类型  
                     paramsType.add(getOrclDataType(field.getType().toString()));  
                 }else{  
                     paramStrBuf.append("?");  
                     paramValues.add(field.get(obj));  
                     // 记录对象属性的数据类型  
                     paramsType.add(getOrclDataType(field.getType().toString()));  
                 }  
                   
                 if (i != fieldList.size() - 1) {  
                     paramStrBuf.append(",");  
                 }  
             }  
         } catch (Exception e) {  
             throw new RuntimeException(e);  
         }  
         // 生成插入操作的SQL语句  
         StringBuffer sb = new StringBuffer();  
         sb.append("insert into ");  
         sb.append(tableName);  
         sb.append(" (");  
         sb.append(columnStrBuf);  
         sb.append(") ");  
         sb.append("values");  
         sb.append(" (");  
         sb.append(paramStrBuf);  
         sb.append(")");  
         // 将生成的SQL语句、SQL语句参数值及各参数值的数据类型用map保存并返回  
         Map sqlMap = new HashMap();  
         sqlMap.put("sql", sb.toString());  
         sqlMap.put("paramsValues", paramValues.toArray());  
         sqlMap.put("paramsTypes", paramsType.toArray());  
         return sqlMap;  
     }  
   
     /** 
      * 自动生成插入指定对象的SQL语句,包括对象属性的值为空的字段，不包括自增长主键,若不存在，调用时直接置为null. 
      * @param obj 待生成插入SQL语句的对象 
      * @param tableName 待插入语句对应的数据库表的名称 
      * @param keyColumn 数据表主键名称 
      * @return 返回一个包含SQL语句、SQL语句参数值及参数值类型的Map对象 
      * @throws IllegalAccessException  
      * @throws IllegalArgumentException  
      */  
     public static Map generateInsertWithNull(Object obj,   
             String tableName, String keyColumn) throws IllegalArgumentException, IllegalAccessException {  
         StringBuffer columnStrBuf = new StringBuffer();   
         StringBuffer paramStrBuf = new StringBuffer(); // 记录SQL语句对应插入的占位符  
         List columnNameList = new ArrayList(); // 记录数据表的字段名称  
         List paramValues = new ArrayList(); // 记录对象参数值  
         List paramsType = new ArrayList(); // 记录参数值类型  
         Field[] fields = obj.getClass().getDeclaredFields();  
         for(int i = 0; i < fields.length; i++){  
             fields[i].setAccessible(true);  
             // 记录对象属性名称  
             if(!fields[i].getName().equalsIgnoreCase(keyColumn)){ // 非主键列记录插入SQL语句的参数占位符  
                 columnStrBuf.append(fields[i].getName());  
                 columnNameList.add(fields[i].getName());  
                 if (i != fields.length - 1) {  
                     columnStrBuf.append(",");  
                 }  
                 if("class java.util.Date".equals(fields[i].getType().toString())  
                         && fields[i].get(obj) != null){  
                     String timeStr = DateUtil.formatDate((Date)fields[i].get(obj), "yyyy-MM-dd HH:mm:ss");  
                     paramStrBuf.append("to_date(?, 'yyyy-MM-dd HH24:mi:ss')");  
                     paramValues.add(timeStr);  
                     // 记录对象属性的数据类型  
                     paramsType.add(getOrclDataType(fields[i].getType().toString()));  
                 }else{  
                     paramStrBuf.append("?");  
                     paramValues.add(fields[i].get(obj));  
                     // 记录对象属性的数据类型  
                     paramsType.add(getOrclDataType(fields[i].getType().toString()));  
                 }  
                 if (i != fields.length - 1) {  
                     paramStrBuf.append(",");  
                 }  
             }  
         }  
         // 生成插入操作的SQL语句  
         StringBuffer sb = new StringBuffer();  
         sb.append("insert into ");  
         sb.append(tableName);  
         sb.append(" (");  
         sb.append(columnStrBuf);  
         sb.append(") ");  
         sb.append("values");  
         sb.append(" (");  
         sb.append(paramStrBuf);  
         sb.append(")");  
         // 将生成的SQL语句、SQL语句的列名称用map保存并返回  
         Map sqlMap = new HashMap();  
           
     /*       
         System.out.println(sb.toString()); 
         System.out.println(columnNameList.toString()); 
         System.out.println(paramValues.toString()); 
         System.out.println(paramsType.toString()); 
     */        
         sqlMap.put("sql", sb.toString());  
         sqlMap.put("columnNameList", columnNameList.toArray());  
         sqlMap.put("paramsValues", paramValues.toArray());  
         sqlMap.put("paramsTypes", paramsType.toArray());  
         return sqlMap;  
     }  
       
       
     /** 
      * 自动生成更新指定对象的SQL语句 
      * @param obj 待生成更新SQL语句的对象 
      * @param tableName 待更新语句对应的数据库表的名称 
      * @param keyColumn 待更新记录的限定字段 
      * @return 返回一个包含SQL语句及参数值的数组 
      */  
     public static Object[] generateUpdate(Object obj, String tableName, String keyColumn) {  
         StringBuffer columnSB = new StringBuffer();  
         List params = new ArrayList();  
         Object keyValue = null;  
         // 获取属性值不为空的数据表字段名称  
         List fieldList = ReflectionUtil.getNotNullField(obj);  
         try {  
             for (int i = 0; i < fieldList.size(); i++) {  
                 Field field = (Field) fieldList.get(i);  
                 field.setAccessible(true);  
   
                 if (field.getName().equalsIgnoreCase(keyColumn)) {  
                     keyValue = field.get(obj);  
                 } else {  
                     columnSB.append(field.getName());     
                     if("class java.util.Date".equals(field.getType().toString())  
                             && field.get(obj) != null){  
                         String timeStr = DateUtil.formatDate((Date)field.get(obj), "yyyy-MM-dd HH:mm:ss");  
                         columnSB.append("=to_date(?, 'yyyy-MM-dd HH24:mi:ss')");  
                         params.add(timeStr);  
                     }else{  
                         columnSB.append("=?");  
                         params.add(field.get(obj));  
                     }  
                     if (i != fieldList.size() - 1) {  
                         columnSB.append(",");  
                     }  
                 }  
             }  
         } catch (Exception e) {  
             throw new RuntimeException(e);  
         }  
         if (keyValue == null) {  
             throw new IllegalArgumentException("数据表 [" + tableName+ "] 中的字段'"+keyColumn+"'的值不能为空.");  
         }else{  
             params.add(keyValue);  
         }  
         StringBuffer sb = new StringBuffer();  
         sb.append("update ");  
         sb.append(tableName);  
         sb.append(" set ");  
         if(columnSB.length() >= 0){  
             sb.append(columnSB);  
         }else{  
             sb.append(keyColumn);  
             sb.append("=? ");  
             params.add(keyValue);  
         }         
         sb.append(" where ");  
         sb.append(keyColumn);  
         sb.append("=? ");  
         return new Object[] { sb.toString(), params.toArray() };  
     }  
       
     /** 
      * 返回java数据类型对应的Oracle数据库的数据类型值 
      * @param javaType java数据类型 
      * @return 返回Oracle数据表的字段数据类型 
      */  
     public static int getOrclDataType(String javaType){  
         if("class java.lang.String".equals(javaType)){  
             return java.sql.Types.VARCHAR;  
         }else if("class java.lang.Integer".equals(javaType) || "int".equals(javaType)){  
             return java.sql.Types.INTEGER;  
         }else if("class java.lang.Double".equals(javaType) || "double".equals(javaType)){  
             return java.sql.Types.DOUBLE;  
         }else if("class java.lang.Float".equals(javaType) || "float".equals(javaType)){  
             return java.sql.Types.FLOAT;  
         }else if("char".equals(javaType)){  
             return java.sql.Types.CHAR;  
         }else if("class java.lang.Long".equals(javaType) || "long".equals(javaType)){  
             return java.sql.Types.NUMERIC;  
         }else if("class java.util.Date".equals(javaType)){  
             return java.sql.Types.DATE;  
         }else{  
             return java.sql.Types.VARCHAR;  
         }  
     }  
   
     /** 
      * 生成SQL语句中的where子句及where子句中参数值 
      * @param obj where条件子句的对象 
      * @return 返回条件不为空的where子句 
      * @throws Exception  
      * @throws   
      */  
     public static Map generateWhereStr(Object obj) throws  Exception{  
         StringBuffer whereStrBuf = new StringBuffer(); // where子句  
         List whereParamValues = new ArrayList(); // where子句中的参数值  
         whereStrBuf.append("  where 1 = 1 ");  
         if(obj != null){  
             Field[] fields = obj.getClass().getDeclaredFields();  
             for(int i = 0; i < fields.length; i++){  
                 fields[i].setAccessible(true);  
                 Object columnName = fields[i].get(obj);  
                 if(columnName != null && !"".equals(columnName)){  
                     whereStrBuf.append(" and ");  
                     whereStrBuf.append(fields[i].getName());  
                     whereStrBuf.append("=?");  
                     whereParamValues.add(columnName);  
                 }  
             }             
         }  
         Map whereMap = new HashMap();  
           
 /*      System.out.println(whereStrBuf.toString()); 
         System.out.println(whereParamValues); 
         */  
         whereMap.put("whereStr", whereStrBuf.toString());  
         whereMap.put("whereParamValues", whereParamValues.toArray());  
         return whereMap;  
     }  
   
 }  



 (6)扩展JAVA对象的反射工具类


 package com.jkitn.jkits.util;

 import java.lang.reflect.Field;
 import java.util.ArrayList;
 import java.util.List;

 /**
  * 说明：扩展JAVA对象的反射机制
  * @author xdweleven
  * @version 1.0
  */
 public class ReflectionUtil {

     /**
      * 设置对象的指定属性名称的属性值
      * @param obj 待设置的对象
      * @param fieldName 对象属性名称
      * @param value 属性值
      */
     public static void setFieldValue(Object obj, String fieldName, Object value) {
         Classextends Object> c = obj.getClass();
         try {
             Field field = null;
             Field[] fields = c.getDeclaredFields();
             for(int i = 0; i < fields.length; i++){
                 String fieldNameTemp = fields[i].getName();
                 if(fieldNameTemp.equalsIgnoreCase(fieldName)){
                     field = c.getDeclaredField(fieldNameTemp);
                     field.setAccessible(true);
                     field.set(obj, value);
                     return;
                 }
             }
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
     }

     /**
      * 获取对象的指定属性名称的属性值
      * @param obj 待设置的对象
      * @param fieldName 对象属性名称
      */
     public static Object getFieldValue(Object obj, String fieldName) {
         Classextends Object> c = obj.getClass();
         Field[] fields = c.getDeclaredFields();
         try {
             for(int i = 0; i < fields.length; i++){
                 if(fields[i].getName().equalsIgnoreCase(fieldName)){
                     fields[i].setAccessible(true);
                     return fields[i].get(obj);
                 }
             }
         } catch (Exception e) {
             throw new RuntimeException(e);
         }
         return null;
     }

     /**
      * 获取对象的属性值不为空的属性名称
      * @param obj 待获取的对象
      * @return 返回属性值不为空的对象的属性名称列表
      */
     public static List getNotNullField(Object obj) {  
         Classextends Object> c = obj.getClass();  
         List list = new ArrayList();  
         try {  
             Field[] fields = c.getDeclaredFields();  
             for(int i = 0; i < fields.length; i++){  
                 fields[i].setAccessible(true);  
                 if(fields[i].get(obj) != null){  
                     list.add(fields[i]);  
                 }  
             }  
         } catch (Exception e) {  
             throw new RuntimeException(e);  
         }  
         return list;  
     }      
 }  



 (7)定义实现数据库的CRUD基本操作BaseDao 
 package com.jkitn.jkits.dao.common;

 import java.io.Serializable;
 import java.sql.ResultSet;
 import java.util.List;
 import java.util.Map;

 import com.jkitn.jkits.common.DBConn;
 import com.jkitn.jkits.common.PageBean;
 import com.jkitn.jkits.util.ReflectionUtil;
 import com.jkitn.jkits.util.SQLUtil;

 /**
  * 说明：封装实现数据库的CRUD相关的底层操作。
  * @author xdweleven
  * @version 1.0
  */
 public class BaseDao{
     // 获取数据库链接实例
     private DBConn dbconn = new DBConn();
     /** 数据库表的前缀  */
     public static final String TB_PREFIX = "tb_jkit_";
     /** 数据库表的查询前缀  */
     public static final String SELECT_TB_PREFIX = "select * from tb_jkit_";
     /** 升序排列  */
     public static final String ASC = "asc";
     /** 降序排列 */
     public static final String DESC = "desc";

     /**
      * 根据ID查找对象
      * @param classType 对象类型
      * @param columnName 编号字段名称
      * @param id 对象编号
      * @return 返回实体对象
      */
     public  T queryById(Class classType, String columnName, Serializable id)
             throws Exception{
         StringBuffer sqlBuffer = new StringBuffer();
         sqlBuffer.append(SELECT_TB_PREFIX);
         sqlBuffer.append(this.toLowerCaseFirstOne(classType.getSimpleName()));
         sqlBuffer.append(" where ");
         sqlBuffer.append(columnName);
         sqlBuffer.append(" = ? ");
         this.showSQL(sqlBuffer.toString());
         return dbconn.execQuery(sqlBuffer.toString(), new RowMapper(classType),
                     new Object[]{id}).get(0);
     }

     /**
      * 查询所有指定class类型的对象信息
      * @param classType 对象类型
      * @return 返回实体对象列表
      */
     public  List queryAll(Class classType) throws Exception{
         String sql = SELECT_TB_PREFIX + this.toLowerCaseFirstOne(classType.getSimpleName());
         this.showSQL(sql);
         return dbconn.execQuery(sql, new RowMapper(classType));
     }

      /**
      * 查询指定对象类型的对象信息，并按照指定的排序字段进行升序或降序排序
      * @param classType 对象类型
      * @param orderColumn 排序字段
      * @param ascOrDesc 降序或升序:asc表示升序，desc表示降序
      * @return 返回实体对象列表
      */
     public  List queryAllWithOrder(Class classType, String orderColumn,
             String ascOrDesc) throws Exception{
         StringBuffer sqlBuffer = new StringBuffer();
         sqlBuffer.append(SELECT_TB_PREFIX);
         sqlBuffer.append(this.toLowerCaseFirstOne(classType.getSimpleName()));
         sqlBuffer.append(" order by ");
         sqlBuffer.append(orderColumn);
         sqlBuffer.append(" ");
         sqlBuffer.append(ascOrDesc);
         this.showSQL(sqlBuffer.toString());
         return dbconn.execQuery(sqlBuffer.toString(), new RowMapper(classType));
     }

     /**
      * 查询指定SQL语句的对象信息列表
      * @param sql 查询语句
      * @param classType 对象类型
      * @param params SQL语句参数
      * @return 返回实体对象列表
      */
     public  List query(String sql, Class classType, Object... params)
               throws Exception{
         this.showSQL(sql);
         return dbconn.execQuery(sql, new RowMapper(classType), params);
     }

     /**
      * 查询指定SQL语句的对象信息列表
      * @param sql 查询语句
      * @param classType 对象类型
      * @param params SQL语句参数
      * @return 返回实体对象列表
      */
     public  T queryForObj(String sql, Class classType, Object... params)
             throws Exception{
         this.showSQL(sql);
         return dbconn.execQuery(sql, new RowMapper(classType), params).get(0);
     }

     /**
      * 分页查询实体对象列表信息
      * @param sql 原始的SQL语句
      * @param classType 对象类型
      * @param curPage 当前页码
      * @param rowsPerPage 每页显示的记录数
      * @param params SQL语句参数
      * @return 返回当前页码的分页对象
      */
     public  PageBean queryByPage(String sql, Class classType, int curPage,
             int rowsPerPage, Object... params) throws Exception{
          // 获取记录总数
          int totalRows = this.getTotalRows(sql, params);
          PageBean pageBean = new PageBean();
          pageBean.setCurPage(curPage); // 设置当前页码
          pageBean.initPageBean(totalRows, rowsPerPage); // 初始化分页对象的相关属性
          // 生成当前分页查询语句（MySql）
          String pageSql = pageBean.getPageMySQL(sql, curPage, rowsPerPage);
          this.showSQL(pageSql);
          // 执行查询操作
          pageBean.setPageList(dbconn.execQuery(sql, new RowMapper(classType), params));
          return pageBean;
     }

      /**
      * 保存对象到数据库中，若数据库中的用户表有自增序列，则需要指出表中自增列的字段名称，另外，
      * 数据库中相应的自增序列的名称需按如下格式取名：class名称_自增列字段名称_SEQ,
      * 例如用户的class为Users，自增序列字段名称为id，则数据库中的自增序列的名称取名为USERS_ID_SEQ.
      * @param obj 实体对象
      * @param sequenceKeyColumn 数据表自增序列的字段名称，若不存在，则置为null。
      * @return 返回被更新的记录数
      * @throws IllegalAccessException
      * @throws IllegalArgumentException
      */
     public  int insert(T obj, String sequenceKeyColumn) throws Exception{
         String tableName = TB_PREFIX + this.toLowerCaseFirstOne(obj.getClass().getSimpleName());
         // 自动生成对象的无自增序列插入SQL语句及其相关插入的参数值和类型
         Map sqlMap = SQLUtil.generateInsertWithNull(obj, tableName, sequenceKeyColumn);
         String sql = sqlMap.get("sql").toString(); // SQL语句
         Object[] paramsValues = (Object[])sqlMap.get("paramsValues"); // SQL语句的参数值
         // int[] paramsTypes = this.parseArrayToInt((Object[])sqlMap.get("paramsTypes")); // 参数值类型
         this.showSQL(sql);
         return dbconn.execUpdate(sql, paramsValues);
     }

     /**
      * 更新对象
      * @param obj 待更新的实体对象
      * @param keyColumn 更新对象的限定条件字段名称
      * @return 返回被更新的记录数
      */
     public  int update(T obj, String keyColumn) throws Exception{
         String tableName = TB_PREFIX + this.toLowerCaseFirstOne(obj.getClass().getSimpleName());
         // 自动生成对象的更新操作的SQL语句及其参数值
         Object[] updateSql = SQLUtil.generateUpdate(obj, tableName, keyColumn);
         this.showSQL(updateSql[0].toString());
         return dbconn.execUpdate(updateSql[0].toString(), (Object[])updateSql[1]);
     }

     /**
      * 删除对象
      * @param obj 待更新的实体对象
      * @param keyColumn 删除的限定条件字段
      * @return 返回被删除的记录数
      */
     public  int delete(T obj, String keyColumn) throws Exception{
         // 获取限定条件的值
         Object keyValue = ReflectionUtil.getFieldValue(obj, keyColumn);
         if(keyValue == null){
             throw new RuntimeException("["+obj.getClass()+"]中不存在属性'"+keyColumn+"'或属性值为空.");
         }
         StringBuffer sqlBuffer = new StringBuffer();
         sqlBuffer.append("delete from ");
         sqlBuffer.append(TB_PREFIX);
         sqlBuffer.append(this.toLowerCaseFirstOne(obj.getClass().getSimpleName()));
         sqlBuffer.append(" where ");
         sqlBuffer.append(keyColumn);
         sqlBuffer.append(" = ? ");
         this.showSQL(sqlBuffer.toString());
         return dbconn.execUpdate(sqlBuffer.toString(), keyValue.toString());
     }

     /**
      * 删除指定编号的实体对象
      * @param classType 对象类型
      * @param keyColumn ID对应的数据表列名称
      * @param id 实体对象编号
      * @return 返回删除的记录数
      */
     public  int deleteById(Class classType, String keyColumn, Serializable id)
             throws Exception{
         StringBuffer sqlBuffer = new StringBuffer();
         sqlBuffer.append("delete from ");
         sqlBuffer.append(TB_PREFIX);
         sqlBuffer.append(this.toLowerCaseFirstOne(classType.getSimpleName()));
         sqlBuffer.append(" where ");
         sqlBuffer.append(keyColumn);
         sqlBuffer.append(" = ? ");
         this.showSQL(sqlBuffer.toString());
         return dbconn.execUpdate(sqlBuffer.toString(), id);
     }

      /**
      * 批量删除指定编号的实体对象
      * @param classType 对象类型
      * @param idColumnName 编号字段名称
      * @param ids 待删除对象的编号数组
      */
     public  int deleteByIds(Class classType, String idColumnName,
             Serializable[] ids) throws Exception{
         StringBuffer sqlBuffer = new StringBuffer();
         sqlBuffer.append("delete from ");
         sqlBuffer.append(TB_PREFIX);
         sqlBuffer.append(this.toLowerCaseFirstOne(classType.getSimpleName()));
         sqlBuffer.append(" where ");
         sqlBuffer.append(idColumnName);
         sqlBuffer.append(" = ? ");
         this.showSQL(sqlBuffer.toString());
         int rowNums = 0; // 删除的记录数
         for(int i = 0; i < ids.length; i++){
             rowNums += this.deleteById(classType, idColumnName, ids[i]);
         }
         return rowNums;
     }

     /**
      * 更新操作
      * @param sql 删除操作的SQL语句
      * @param params SQL语句中的参数值
      * @return 返回删除的记录数
      */
     public int update(String sql, Object... params) throws Exception{
         this.showSQL(sql);
         return dbconn.execUpdate(sql, params);
     }

     /**
      * 批量更新对象
      * @param objs 待更新的实体对象列表
      * @param keyColumn 主键字段名称
      */
     public  int batchUpdate(List objs, String keyColumn) throws Exception{
         if(objs == null || objs.isEmpty()){
             return 0;
         }
         int updateNum = 0;
         // 自动生成对象的更新操作的SQL语句及其参数值
         for(int i = 0; i < objs.size(); i++){
             T obj = objs.get(i);
             updateNum += this.update(obj, keyColumn);
         }
         return updateNum;
     }

      /**
      * 批量插入对象
      * @param objs 待新增的实体对象列表
      * @param keyColumn 数据表主键列名称
      * @throws IllegalAccessException
      * @throws IllegalArgumentException
      */
     public  int batchInsert(List objs, String keyColumn) throws Exception {
         if(objs == null || objs.isEmpty()){
             return 0;
         }
         int updateNum = 0;
         // 自动生成对象的更新操作的SQL语句及其参数值
         for(int i = 0; i < objs.size(); i++){
             T obj = objs.get(i);
             updateNum += this.insert(obj, keyColumn);
         }
         return updateNum;
     }

     /**
      * 统计指定统计数量的SQL语句
      * @param sql 待执行的SQL语句
      * @param params SQL语句参数值
      * @return 返回记录总数
      * @throws Exception
      */
     public int getTotalRows(String sql, Object... params) throws Exception{
         String totalRowsSql = "select count(*) totalRows from ( "+sql+" )";
         this.showSQL(totalRowsSql);
         ResultSet rs = dbconn.queryForResultSet(totalRowsSql, params);
         while(rs.next()){
             return rs.getInt("totalRows");
         }
         return 0;
     }

     /**
      * 删除操作
      * @param sql 删除操作的SQL语句
      * @param params SQL语句中的参数值
      * @return 返回删除的记录数
      */
     public int delete(String sql, Object... params) throws Exception{
         this.showSQL(sql);
         return dbconn.execUpdate(sql, params);
     }

     /**
      * 获取下一个指定自增序列的值(MySql)
      * @param classType 对象类型
      * @param seqColName 自增字段名称
      * @return 返回指定表的主键自增序列的最新值
      */
     public  int getNextAutoIncrementVal(Class classType, String seqColName) throws Exception{
         StringBuffer sqlBuf = new StringBuffer();
         sqlBuf.append("select max(");
         sqlBuf.append(seqColName);
         sqlBuf.append(")+1 nextId from ");
         sqlBuf.append(TB_PREFIX);
         sqlBuf.append(this.toLowerCaseFirstOne(classType.getSimpleName()));
         this.showSQL(sqlBuf.toString());
         ResultSet rs = dbconn.queryForResultSet(sqlBuf.toString());
         if(rs.next()){
             return rs.getInt("nextId");
         }else{
             return 0;
         }
     }

     /**
      * 首字母转小写
      * @param str 待转换的字符创
      * @return 返回首字母小写后的字符串
      */
     public String toLowerCaseFirstOne(String str){
          if(Character.isLowerCase(str.charAt(0))){
               return str;
          }else{
              return (new StringBuilder()).append(Character.toLowerCase(str.charAt(0))).
                      append(str.substring(1)).toString();
          }
     }

     /**
      * 首字母转大写
      * @param str 待转换的字符串
      * @return 返回首字母大写的字符串
      */
     public String toUpperCaseFirstOne(String str){
          if(Character.isUpperCase(str.charAt(0))){
              return str;
          }else{
              return (new StringBuilder()).append(Character.toUpperCase(str.charAt(0))).
                      append(str.substring(1)).toString();
          }
     }

     /**
      * 打印SQL语句
      * @param sql
      */
     public void showSQL(String sql){
         System.out.println(sql);
     }

 }

        以上是根据自己的理解封装的一些常用DAO层操作，并已运用到部署上线的两个项目中，目前尚未报出BUG。但在效率方面，个人觉得还有很多地方需要优化的地方，比如说批量增删改操作，根据我个人PC机测试的结果，使用JDBC自带的批量操作，要比上述简单循环的操作速度要慢，但我还是觉得这部分的效率还有很大的提升空间，希望能有位IT大卡给我指点一二，不甚感激！















 















你可能感兴趣的:(Java)



Long类型前后端数据不一致
igotyback
前端
响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问

LocalDateTime 转 String
igotyback
java开发语言
importjava.time.LocalDateTime;importjava.time.format.DateTimeFormatter;publicclassMain{publicstaticvoidmain(String[]args){//获取当前时间LocalDateTimenow=LocalDateTime.now();//定义日期格式化器DateTimeFormatterformat

Linux下QT开发的动态库界面弹出操作（SDL2）
13jjyao
QT类qt开发语言sdl2linux
需求：操作系统为linux，开发框架为qt，做成需带界面的qt动态库，调用方为java等非qt程序难点：调用方为java等非qt程序，也就是说调用方肯定不带QApplication::exec()，缺少了这个，QTimer等事件和QT创建的窗口将不能弹出(包括opencv也是不能弹出)；这与qt调用本身qt库是有本质的区别的思路：1.调用方缺QApplication::exec()，那么我们在接口

DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理
STU学生网页设计
网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程

【华为OD机试真题2023B卷 JAVA&JS】We Are A Team
若博豆
java算法华为javascript
华为OD2023（B卷）机试题库全覆盖，刷题指南点这里WeAreATeam时间限制：1秒|内存限制：32768K|语言限制：不限题目描述：总共有n个人在机房，每个人有一个标号（1<=标号<=n），他们分成了多个团队，需要你根据收到的m条消息判定指定的两个人是否在一个团队中，具体的：1、消息构成为：abc，整数a、b分别代

关于城市旅游的HTML网页设计——(旅游风景云南 5页)HTML+CSS+JavaScript
二挡起步
web前端期末大作业javascripthtmlcss旅游风景
⛵源码获取文末联系✈Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业|游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作|HTML期末大学生网页设计作业，Web大学生网页HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScrip

HTML网页设计制作大作业（div+css） 云南我的家乡旅游景点 带文字滚动
二挡起步
web前端期末大作业web设计网页规划与设计htmlcssjavascriptdreamweaver前端
Web前端开发技术描述网页设计题材，DIV+CSS布局制作,HTML+CSS网页设计期末课程大作业游景点介绍|旅游风景区|家乡介绍|等网站的设计与制作HTML期末大学生网页设计作业HTML：结构CSS：样式在操作方面上运用了html5和css3，采用了div+css结构、表单、超链接、浮动、绝对定位、相对定位、字体样式、引用视频等基础知识JavaScript：做与用户的交互行为文章目录前端学习路线

node.js学习
小猿L
node.jsnode.js学习vim
node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行

Java 重写(Override)与重载(Overload)
叨唧唧的
Java重写(Override)与重载(Overload)重写(Override)重写是子类对父类的允许访问的方法的实现过程进行重新编写,返回值和形参都不能改变。即外壳不变，核心重写！重写的好处在于子类可以根据需要，定义特定于自己的行为。也就是说子类能够根据需要实现父类的方法。重写方法不能抛出新的检查异常或者比被重写方法申明更加宽泛的异常。例如：父类的一个方法申明了一个检查异常IOExceptio

简单了解 JVM
记得开心一点啊
jvm
目录♫什么是JVM♫JVM的运行流程♫JVM运行时数据区♪虚拟机栈♪本地方法栈♪堆♪程序计数器♪方法区/元数据区♫类加载的过程♫双亲委派模型♫垃圾回收机制♫什么是JVMJVM是JavaVirtualMachine的简称，意为Java虚拟机。虚拟机是指通过软件模拟的具有完整硬件功能的、运行在一个完全隔离的环境中的完整计算机系统（如：JVM、VMwave、VirtualBox）。JVM和其他两个虚拟机

1分钟解决 -bash: mvn: command not found，在Centos 7中安装Maven
Energet!c
开发语言
1分钟解决-bash:mvn:commandnotfound，在Centos7中安装Maven检查Java环境1下载Maven2解压Maven3配置环境变量4验证安装5常见问题与注意事项6总结检查Java环境Maven依赖Java环境，请确保系统已经安装了Java并配置了环境变量。可以通过以下命令检查：java-version如果未安装，请先安装Java。1下载Maven从官网下载：前往Apach

Java企业面试题3
马龙强_
java
1.break和continue的作用(智*图)break：用于完全退出一个循环（如for,while）或一个switch语句。当在循环体内遇到break语句时，程序会立即跳出当前循环体，继续执行循环之后的代码。continue：用于跳过当前循环体中剩余的部分，并开始下一次循环。如果是在for循环中使用continue，则会直接进行条件判断以决定是否执行下一轮循环。2.if分支语句和switch分

JVM、JRE和 JDK：理解Java开发的三大核心组件
Y雨何时停T
Javajava
Java是一门跨平台的编程语言，它的成功离不开背后强大的运行环境与开发工具的支持。在Java的生态中，JVM（Java虚拟机）、JRE（Java运行时环境）和JDK（Java开发工具包）是三个至关重要的核心组件。本文将探讨JVM、JDK和JRE的区别，帮助你更好地理解Java的运行机制。1.JVM：Java虚拟机（JavaVirtualMachine）什么是JVM？JVM，即Java虚拟机，是Ja

Java面试题精选：消息队列(二)
芒果不是芒
Java面试题精选javakafka
一、Kafka的特性1.消息持久化：消息存储在磁盘，所以消息不会丢失2.高吞吐量：可以轻松实现单机百万级别的并发3.扩展性：扩展性强，还是动态扩展4.多客户端支持：支持多种语言（Java、C、C++、GO、）5.KafkaStreams（一个天生的流处理）:在双十一或者销售大屏就会用到这种流处理。使用KafkaStreams可以快速的把销售额统计出来6.安全机制：Kafka进行生产或者消费的时候会

白骑士的Java教学基础篇 2.5 控制流语句
白骑士所长
Java教学java开发语言
欢迎继续学习Java编程的基础篇！在前面的章节中，我们了解了Java的变量、数据类型和运算符。接下来，我们将探讨Java中的控制流语句。控制流语句用于控制程序的执行顺序，使我们能够根据特定条件执行不同的代码块，或重复执行某段代码。这是编写复杂程序的基础。通过学习这一节内容，你将掌握如何使用条件语句和循环语句来编写更加灵活和高效的代码。条件语句条件语句用于根据条件的真假来执行不同的代码块。if语句‘

python语法——三目运算符
HappyRocking
pythonpython三目运算符
在java中，有三目运算符，如：intc=(a>b)?a:b表示c取两者中的较大值。但是在python，不能直接这样使用，估计是因为冒号在python有分行的关键作用。那么在python中，如何实现类似功能呢？可以使用ifelse语句，也是一行可以完成，格式为：aifbelsec表示如果b为True，则表达式等于a，否则等于c。如：c=(aif(a>b)elseb)同样是完成了取最大值的功能。

ArrayList 源码解析
程序猿进阶
Java基础ArrayListListjava面试性能优化架构设计idea
ArrayList是Java集合框架中的一个动态数组实现，提供了可变大小的数组功能。它继承自AbstractList并实现了List接口，是顺序容器，即元素存放的数据与放进去的顺序相同，允许放入null元素，底层通过数组实现。除该类未实现同步外，其余跟Vector大致相同。每个ArrayList都有一个容量capacity，表示底层数组的实际大小，容器内存储元素的个数不能多于当前容量。当向容器中添

Java爬虫框架（一）--架构设计
狼图腾-狼之传说
java框架java任务html解析器存储电子商务
一、架构图那里搜网络爬虫框架主要针对电子商务网站进行数据爬取，分析，存储，索引。爬虫：爬虫负责爬取，解析，处理电子商务网站的网页的内容数据库：存储商品信息索引：商品的全文搜索索引Task队列：需要爬取的网页列表Visited表：已经爬取过的网页列表爬虫监控平台：web平台可以启动，停止爬虫，管理爬虫，task队列，visited表。二、爬虫1.流程1)Scheduler启动爬虫器，TaskMast

Java：爬虫框架
dingcho
Javajava爬虫
一、ApacheNutch2【参考地址】Nutch是一个开源Java实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。Nutch致力于让每个人能很容易,同时花费很少就可以配置世界一流的Web搜索引擎.为了完成这一宏伟的目标,Nutch必须能够做到:每个月取几十亿网页为这些网页维护一个索引对索引文件进行每秒上千次的搜索提供高质量的搜索结果简单来说Nutch支持分

python怎么将png转为tif_png转tif
weixin_39977276
发国外的文章要求图片是tif，cmyk色彩空间的。大小尺寸还有要求。比如网上大神多，找到了一段代码，感谢！https://www.jianshu.com/p/ec2af4311f56https://github.com/KevinZc007/image2Tifimportjava.awt.image.BufferedImage;importjava.io.File;importjava.io.Fi

JavaScript 中，深拷贝（Deep Copy）和浅拷贝（Shallow Copy）
跳房子的前端
前端面试javascript开发语言ecmascript
在JavaScript中，深拷贝（DeepCopy）和浅拷贝（ShallowCopy）是用于复制对象或数组的两种不同方法。了解它们的区别和应用场景对于避免潜在的bugs和高效地处理数据非常重要。以下是对深拷贝和浅拷贝的详细解释，包括它们的概念、用途、优缺点以及实现方式。1.浅拷贝（ShallowCopy）概念定义：浅拷贝是指创建一个新的对象或数组，其中包含了原对象或数组的基本数据类型的值和对引用数

JAVA·一个简单的登录窗口
MortalTom
java开发语言学习
文章目录概要整体架构流程技术名词解释技术细节资源概要JavaSwing是Java基础类库的一部分，主要用于开发图形用户界面（GUI）程序整体架构流程新建项目，导入sql.jar包（链接放在了文末），编译项目并运行技术名词解释一、特点丰富的组件提供了多种可视化组件，如按钮（JButton）、文本框（JTextField）、标签（JLabel）、下拉列表（JComboBox）等，可以满足不同的界面设计

WebMagic：强大的Java爬虫框架解析与实战
Aaron_945
Javajava爬虫开发语言
文章目录引言官网链接WebMagic原理概述基础使用1.添加依赖2.编写PageProcessor高级使用1.自定义Pipeline2.分布式抓取优点结论引言在大数据时代，网络爬虫作为数据收集的重要工具，扮演着不可或缺的角色。Java作为一门广泛使用的编程语言，在爬虫开发领域也有其独特的优势。WebMagic是一个开源的Java爬虫框架，它提供了简单灵活的API，支持多线程、分布式抓取，以及丰富的

博客网站制作教程
2401_85194651
javamaven
首先就是技术框架：后端：Java+SpringBoot数据库：MySQL前端：Vue.js数据库连接：JPA(JavaPersistenceAPI)1.项目结构blog-app/├──backend/│├──src/main/java/com/example/blogapp/││├──BlogApplication.java││├──config/│││└──DatabaseConfig.java

00. 这里整理了最全的爬虫框架（Java + Python）
有一只柴犬
爬虫系列爬虫javapython
目录1、前言2、什么是网络爬虫3、常见的爬虫框架3.1、java框架3.1.1、WebMagic3.1.2、Jsoup3.1.3、HttpClient3.1.4、Crawler4j3.1.5、HtmlUnit3.1.6、Selenium3.2、Python框架3.2.1、Scrapy3.2.2、BeautifulSoup+Requests3.2.3、Selenium3.2.4、PyQuery3.2

JAVA学习笔记之23种设计模式学习
victorfreedom
Java技术设计模式androidjava常用设计模式
博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器

JavaScript `Map` 和 `WeakMap`详细解释
跳房子的前端
JavaScript原生方法javascript前端开发语言
在JavaScript中，Map和WeakMap都是用于存储键值对的数据结构，但它们有一些关键的不同之处。MapMap是一种可以存储任意类型的键值对的集合。它保持了键值对的插入顺序，并且可以通过键快速查找对应的值。Map提供了一些非常有用的方法和属性来操作这些数据对：set(key,value):将一个键值对添加到Map中。如果键已经存在，则更新其对应的值。get(key):获取指定键的值。如果键

切换淘宝最新npm镜像源是
hai40587
npm前端node.js
切换淘宝最新npm镜像源是一个相对简单的过程，但首先需要明确当前淘宝npm镜像源的状态和最新的镜像地址。由于网络环境和服务更新，镜像源的具体地址可能会发生变化，因此，我将基于当前可获取的信息，提供一个通用的切换步骤，并附上最新的镜像地址（截至回答时）。一、了解npm镜像源npm（NodePackageManager）是JavaScript的包管理器，用于安装、更新和管理项目依赖。由于npm官方仓库

【Java】已解决：java.util.concurrent.CompletionException
屿小夏
java开发语言
文章目录一、分析问题背景出现问题的场景代码片段二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决：java.util.concurrent.CompletionException一、分析问题背景在Java并发编程中，java.util.concurrent.CompletionException是一种常见的运行时异常，通常在使用CompletableFuture进行异步计算时出现

设计模式之建造者模式(通俗易懂--代码辅助理解【Java版】）
ok!ko
设计模式设计模式建造者模式java
文章目录设计模式概述1、建造者模式2、建造者模式使用场景3、优点4、缺点5、主要角色6、代码示例：1）实现要求2）UML图3)实现步骤：1）创建一个表示食物条目和食物包装的接口2）创建实现Packing接口的实体类3）创建实现Item接口的抽象类，该类提供了默认的功能4）创建扩展了Burger和ColdDrink的实体类5）创建一个Meal类，带有上面定义的Item对象6）创建一个MealBuil

mondb入手
木zi_鸣
mongodb
windows 启动mongodb  编写bat文件，
mongod --dbpath D:\software\MongoDBDATA
mongod --help  查询各种配置
配置在mongob
打开批处理，即可启动，27017原生端口，shell操作监控端口  扩展28017，web端操作端口
启动配置文件配置，
数据更灵活 

大型高并发高负载网站的系统架构
bijian1013
高并发负载均衡
        扩展Web应用程序
一.概念
        简单的来说，如果一个系统可扩展，那么你可以通过扩展来提供系统的性能。这代表着系统能够容纳更高的负载、更大的数据集，并且系统是可维护的。扩展和语言、某项具体的技术都是无关的。扩展可以分为两种：
        1.

DISPLAY变量和xhost(原创)
czmmiao
display
DISPLAY
在Linux/Unix类操作系统上, DISPLAY用来设置将图形显示到何处. 直接登陆图形界面或者登陆命令行界面后使用startx启动图形, DISPLAY环境变量将自动设置为:0:0, 此时可以打开终端, 输出图形程序的名称(比如xclock)来启动程序, 图形将显示在本地窗口上, 在终端上输入printenv查看当前环境变量, 输出结果中有如下内容:DISPLAY=:0.0

获取B/S客户端IP
周凡杨
java编程jspWeb浏览器
   最近想写个B/S架构的聊天系统，因为以前做过C/S架构的QQ聊天系统，所以对于Socket通信编程只是一个巩固。对于C/S架构的聊天系统，由于存在客户端Java应用，所以直接在代码中获取客户端的IP，应用的方法为：
   String ip = InetAddress.getLocalHost().getHostAddress();
然而对于WEB

浅谈类和对象
朱辉辉33
编程
    类是对一类事物的总称，对象是描述一个物体的特征，类是对象的抽象。简单来说，类是抽象的，不占用内存，对象是具体的，
占用存储空间。
    类是由属性和方法构成的，基本格式是public  class 类名{
//定义属性
private/public 数据类型 属性名；
//定义方法
publ

android activity与viewpager+fragment的生命周期问题
肆无忌惮_
viewpager
有一个Activity里面是ViewPager，ViewPager里面放了两个Fragment。
第一次进入这个Activity。开启了服务，并在onResume方法中绑定服务后，对Service进行了一定的初始化，其中调用了Fragment中的一个属性。
super.onResume();
bindService(intent, conn, BIND_AUTO_CREATE);


base64Encode对图片进行编码
843977358
base64图片encoder
/**
* 对图片进行base64encoder编码
*
* @author mrZhang
* @param path
* @return
*/
public static String encodeImage(String path) {
BASE64Encoder encoder = null;
byte[] b = null;
I

Request Header简介
aigo
servlet
当一个客户端(通常是浏览器)向Web服务器发送一个请求是，它要发送一个请求的命令行，一般是GET或POST命令，当发送POST命令时，它还必须向服务器发送一个叫“Content-Length”的请求头(Request   Header)   用以指明请求数据的长度，除了Content-Length之外，它还可以向服务器发送其它一些Headers，如：    

HttpClient4.3 创建SSL协议的HttpClient对象
alleni123
httpclient爬虫ssl
public class HttpClientUtils
{
public static CloseableHttpClient createSSLClientDefault(CookieStore cookies){
SSLContext sslContext=null;
try
{
sslContext=new SSLContextBuilder().l

java取反 -右移-左移-无符号右移的探讨
百合不是茶
位运算符 位移
取反：
在二进制中第一位，1表示符数，0表示正数
byte a = -1;
原码：10000001
反码：11111110
补码：11111111
//异或: 00000000
byte b = -2;
原码：10000010
反码：11111101
补码：11111110
//异或: 00000001


java多线程join的作用与用法
bijian1013
java多线程
        对于JAVA的join，JDK 是这样说的：join public final void join （long millis ）throws InterruptedException Waits at most millis milliseconds for this thread to die. A timeout of 0 means t

Java发送http请求(get 与post方法请求)
bijian1013
javaspring
PostRequest.java
package com.bijian.study;
import java.io.BufferedReader;
import java.io.DataOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.HttpURL

【Struts2二】struts.xml中package下的action配置项默认值
bit1129
struts.xml
在第一部份，定义了struts.xml文件，如下所示：
 
<!DOCTYPE struts PUBLIC
"-//Apache Software Foundation//DTD Struts Configuration 2.3//EN"
"http://struts.apache.org/dtds/struts

【Kafka十三】Kafka Simple Consumer
bit1129
simple
代码中关于Host和Port是割裂开的，这会导致单机环境下的伪分布式Kafka集群环境下，这个例子没法运行。
实际情况是需要将host和port绑定到一起，
 
package kafka.examples.lowlevel;
import kafka.api.FetchRequest;
import kafka.api.FetchRequestBuilder;
impo

nodejs学习api
ronin47
nodejs api
NodeJS基础 什么是NodeJS
JS是脚本语言，脚本语言都需要一个解析器才能运行。对于写在HTML页面里的JS，浏览器充当了解析器的角色。而对于需要独立运行的JS，NodeJS就是一个解析器。
每一种解析器都是一个运行环境，不但允许JS定义各种数据结构，进行各种计算，还允许JS使用运行环境提供的内置对象和方法做一些事情。例如运行在浏览器中的JS的用途是操作DOM，浏览器就提供了docum

java-64.寻找第N个丑数
bylijinnan
java

public class UglyNumber {
/**
* 64.查找第N个丑数
具体思路可参考 [url] http://zhedahht.blog.163.com/blog/static/2541117420094245366965/[/url]
*
题目：我们把只包含因子
2、3和5的数称作丑数（Ugly Number）。例如6、8都是丑数，但14

二维数组（矩阵）对角线输出
bylijinnan
二维数组

/**
二维数组 对角线输出 两个方向
例如对于数组：
{ 1, 2, 3, 4 },
{ 5, 6, 7, 8 },
{ 9, 10, 11, 12 },
{ 13, 14, 15, 16 },
slash方向输出：
1
5 2
9 6 3
13 10 7 4
14 11 8
15 12
16
backslash输出：
4
3

[JWFD开源工作流设计]工作流跳跃模式开发关键点(今日更新)
comsci
工作流
   既然是做开源软件的,我们的宗旨就是给大家分享设计和代码,那么现在我就用很简单扼要的语言来透露这个跳跃模式的设计原理
   大家如果用过JWFD的ARC-自动运行控制器,或者看过代码,应该知道在ARC算法模块中有一个函数叫做SAN(),这个函数就是ARC的核心控制器,要实现跳跃模式,在SAN函数中一定要对LN链表数据结构进行操作,首先写一段代码,把

redis常见使用
cuityang
redis常见使用
redis 通常被认为是一个数据结构服务器，主要是因为其有着丰富的数据结构 strings、map、 list、sets、 sorted sets
引入jar包 jedis-2.1.0.jar  (本文下方提供下载)
package redistest;
import redis.clients.jedis.Jedis;
public class Listtest

配置多个redis
dalan_123
redis
配置多个redis客户端
<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans"       xmlns:xsi=&quo

attrib命令
dcj3sjt126com
attr
 
attrib指令用于修改文件的属性.文件的常见属性有:只读.存档.隐藏和系统. 
  只读属性是指文件只可以做读的操作.不能对文件进行写的操作.就是文件的写保护. 
  存档属性是用来标记文件改动的.即在上一次备份后文件有所改动.一些备份软件在备份的时候会只去备份带有存档属性的文件. 


Yii使用公共函数
dcj3sjt126com
yii
在网站项目中，没必要把公用的函数写成一个工具类，有时候面向过程其实更方便。 在入口文件index.php里添加 require_once('protected/function.php'); 即可对其引用，成为公用的函数集合。 function.php如下：
  <?php /**   * This is the shortcut to D

linux 系统资源的查看（free、uname、uptime、netstat）
eksliang
netstatlinux unamelinux uptimelinux free
linux 系统资源的查看
转载请出自出处：http://eksliang.iteye.com/blog/2167081
 
http://eksliang.iteye.com 一、free查看内存的使用情况
语法如下：
 
free [-b][-k][-m][-g] [-t]
参数含义
-b:直接输入free时，显示的单位是kb我们可以使用b(bytes),m

JAVA的位操作符
greemranqq
位运算JAVA位移<<>>>
最近几种进制，加上各种位操作符，发现都比较模糊，不能完全掌握，这里就再熟悉熟悉。
 
1.按位操作符 ：
   按位操作符是用来操作基本数据类型中的单个bit,即二进制位，会对两个参数执行布尔代数运算，获得结果。
   与（&）运算：
   1&1 = 1, 1&0 = 0, 0&0 &

Web前段学习网站
ihuning
Web
 
Web前段学习网站
菜鸟学习：http://www.w3cschool.cc/
 
JQuery中文网：http://www.jquerycn.cn/
 
内存溢出：http://outofmemory.cn/#csdn.blog
 
http://www.icoolxue.com/
 
http://www.jikexue

强强联合：FluxBB 作者加盟 Flarum
justjavac
r
原文：FluxBB Joins Forces With Flarum作者：Toby Zerner译文：强强联合：FluxBB 作者加盟 Flarum译者：justjavac
FluxBB 是一个快速、轻量级论坛软件，它的开发者是一名德国的 PHP 天才 Franz Liedke。FluxBB 的下一个版本(2.0)将被完全重写，并已经开发了一段时间。FluxBB 看起来非常有前途的，

java统计在线人数（session存储信息的）
macroli
javaWeb
这篇日志是我写的第三次了 前两次都发布失败！郁闷极了！
 
由于在web开发中常常用到这一部分所以在此记录一下，呵呵，就到备忘录了！
我对于登录信息时使用session存储的，所以我这里是通过实现HttpSessionAttributeListener这个接口完成的。
1、实现接口类，在web.xml文件中配置监听类，从而可以使该类完成其工作。
public class Ses

bootstrp carousel初体验 快速构建图片播放
qiaolevip
每天进步一点点学习永无止境bootstrap纵观千象
img{
border: 1px solid white;
box-shadow: 2px 2px 12px #333;
_width: expression(this.width > 600 ? "600px" : this.width + "px");
_height: expression(this.width &

SparkSQL读取HBase数据，通过自定义外部数据源
superlxw1234
sparksparksqlsparksql读取hbasesparksql外部数据源
关键字：SparkSQL读取HBase、SparkSQL自定义外部数据源
 
 
前面文章介绍了SparSQL通过Hive操作HBase表。
 
SparkSQL从1.2开始支持自定义外部数据源(External DataSource)，这样就可以通过API接口来实现自己的外部数据源。这里基于Spark1.4.0，简单介绍SparkSQL自定义外部数据源，访

Spring Boot 1.3.0.M1发布
wiselyman
spring boot
    Spring Boot 1.3.0.M1于6.12日发布，现在可以从Spring milestone repository下载。这个版本是基于Spring Framework 4.2.0.RC1,并在Spring Boot 1.2之上提供了大量的新特性improvements and new features。主要包含以下：
 
1.提供一个新的sprin








按字母分类：
ABCDEFGHIJKLMNOPQRSTUVWXYZ其他






首页 -
关于我们 -
站内搜索 -
Sitemap -
侵权投诉

版权所有 IT知识库 CopyRight © 2000-2050 E-COM-NET.COM , All Rights Reserved.