Spring jdbc基础类

最新推荐文章于 2024-07-20 23:59:39 发布
最新推荐文章于 2024-07-20 23:59:39 发布
阅读量87 收藏
点赞数
文章标签： java
原文链接：https://my.oschina.net/body/blog/896247
版权

为什么80%的码农都做不了架构师？>>>   hot3.png

package com.beans;

import java.io.Serializable;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;

import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.dao.DataAccessException;
import org.springframework.jdbc.core.BatchPreparedStatementSetter;
import org.springframework.jdbc.core.JdbcTemplate;
import org.springframework.jdbc.core.PreparedStatementCreator;
import org.springframework.jdbc.support.GeneratedKeyHolder;
import org.springframework.jdbc.support.KeyHolder;

@SuppressWarnings("serial")
public class PoJo implements Serializable { 
    
    private static final Logger logger = LoggerFactory.getLogger(PoJo.class);  

    JdbcTemplate jdbcTemplate;

    public JdbcTemplate getJdbcTemplate() {
        return jdbcTemplate;
    }

    public void setJdbcTemplate(JdbcTemplate jdbcTemplate) {
        this.jdbcTemplate = jdbcTemplate;
    }

    String _tableName() {
        return "base_teacher";
    }

    StringBuilder _SqlSave(Serializable entity) {
        StringBuilder _save = new StringBuilder();
        try {
            boolean flag_value = false;
            Field[] fields = entity.getClass().getDeclaredFields();
            for (Field field : fields) {
                if ("INSTANCE".equals(field.getName())) {
                    continue;
                }
                String getFn = "get" + field.getName().substring(0, 1).toUpperCase() + field.getName().substring(1);
                Method method = entity.getClass().getMethod(getFn);
                Object obj = method.invoke(entity);
                if (obj != null) {
                    flag_value = true;
                    _save.append(field.getName()).append(",");
                }
            }
            if (!flag_value)
                return _save;
            _save.insert(0, String.format("insert into %s (", _tableName()));
            _save.deleteCharAt(_save.length() - 1).append(")");
            // 拼接值
            _save.append("values").append("(");
            for (Field field : fields) {
                if ("INSTANCE".equals(field.getName())) {
                    continue;
                }
                String getFn = "get" + field.getName().substring(0, 1).toUpperCase() + field.getName().substring(1);
                Method method = entity.getClass().getMethod(getFn);
                Object obj = method.invoke(entity);
                if (obj != null) {
                    _save.append("?,");
                }
            }
            _save.deleteCharAt(_save.length() - 1).append(")");
        } catch (SecurityException e) {
            logger.info("异常信息{}",e);
        } catch (NoSuchMethodException e) {
            logger.info("异常信息{}",e);
        } catch (IllegalAccessException e) {
            logger.info("异常信息{}",e);
        } catch (IllegalArgumentException e) {
            logger.info("异常信息{}",e);
        } catch (InvocationTargetException e) {
            logger.info("异常信息{}",e);
        }
        return _save;
    }

    StringBuilder _SqlUpdate(Serializable entity) {
        StringBuilder _update = new StringBuilder();
        try {
            _update.append("update ").append(_tableName()).append(" set ");
            Field[] fields = entity.getClass().getDeclaredFields();
            for (Field field : fields) {
                if ("INSTANCE".equals(field.getName())) {
                    continue;
                }
                if ("id".equals(field.getName().toLowerCase())) {
                    continue;
                }
                String getFn = "get" + field.getName().substring(0, 1).toUpperCase() + field.getName().substring(1);
                Method method = entity.getClass().getMethod(getFn);
                Object obj = method.invoke(entity);
                if (obj != null) {
                    _update.append(field.getName()).append(" = ? ,");
                }
            }
            _update.deleteCharAt(_update.length() - 1).append(" where id = ?");

        } catch (SecurityException e) {
            logger.info("异常信息{}",e);
        } catch (NoSuchMethodException e) {
            logger.info("异常信息{}",e);
        } catch (IllegalAccessException e) {
            logger.info("异常信息{}",e);
        } catch (IllegalArgumentException e) {
            logger.info("异常信息{}",e);
        } catch (InvocationTargetException e) {
            logger.info("异常信息{}",e);
        }
        return _update;
    }

    StringBuilder _SqlDel(Serializable entity) {
        StringBuilder _del = new StringBuilder();
        try {
            _del.append("delete ").append(_tableName()).append(" where ");
            Field[] fields = entity.getClass().getDeclaredFields();
            for (Field field : fields) {
                if ("INSTANCE".equals(field.getName())) {
                    continue;
                }
                String getFn = "get" + field.getName().substring(0, 1).toUpperCase() + field.getName().substring(1);
                Method method = entity.getClass().getMethod(getFn);
                Object obj = method.invoke(entity);
                if (obj != null) {
                    _del.append(field.getName()).append("=? and ");
                }
            }
            _del.delete(_del.length() - 4,_del.length());
        } catch (SecurityException e) {
            logger.info("异常信息{}",e);
        } catch (NoSuchMethodException e) {
            logger.info("异常信息{}",e);
        } catch (IllegalAccessException e) {
            logger.info("异常信息{}",e);
        } catch (IllegalArgumentException e) {
            logger.info("异常信息{}",e);
        } catch (InvocationTargetException e) {
            logger.info("异常信息{}",e);
        }
        return _del;
    }

    StringBuilder _SqlWhere(Serializable entity) {
        StringBuilder _where = new StringBuilder();
        try {
            Field[] fields = entity.getClass().getDeclaredFields();
            for (Field field : fields) {
                if ("INSTANCE".equals(field.getName())) {
                    continue;
                }
                String getFn = "get" + field.getName().substring(0, 1).toUpperCase() + field.getName().substring(1);
                Method method = entity.getClass().getMethod(getFn);
                Object obj = method.invoke(entity);
                if (obj != null) {
                    _where.append(field.getName()).append("=? and ");
                }
            }
            if (_where.length() > 5) {
                _where.delete(_where.length() - 4,_where.length());
            }
        } catch (SecurityException e) {
            logger.info("异常信息{}",e);
        } catch (NoSuchMethodException e) {
            logger.info("异常信息{}",e);
        } catch (IllegalAccessException e) {
            logger.info("异常信息{}",e);
        } catch (IllegalArgumentException e) {
            logger.info("异常信息{}",e);
        } catch (InvocationTargetException e) {
            logger.info("异常信息{}",e);
        }
        return _where;
    }
    
    StringBuilder _SqlWhere(Map<String, Object> param) {
        StringBuilder _where = new StringBuilder();
        try {
            for(String key:param.keySet())
            {
                _where.append(key).append(" = ? and ");
            }
            if (_where.length() > 5) {
                _where.delete(_where.length() - 4,_where.length());
            }
        } catch (SecurityException e) {
            logger.info("异常信息{}",e);
        } 
        return _where;
    }

    Object[] _Values(Serializable entity) {
        try {
            List<Object> values = new LinkedList<Object>();
            Field[] fields = entity.getClass().getDeclaredFields();
            for (Field field : fields) {
                if ("INSTANCE".equals(field.getName())) {
                    continue;
                }
                String getFn = "get" + field.getName().substring(0, 1).toUpperCase() + field.getName().substring(1);
                Method method = entity.getClass().getMethod(getFn);
                Object obj = method.invoke(entity);
                if (obj != null) {
                    values.add(obj);
                }
            }
            return values.toArray();
        } catch (SecurityException e) {
            logger.info("异常信息{}",e);
        } catch (NoSuchMethodException e) {
            logger.info("异常信息{}",e);
        } catch (IllegalAccessException e) {
            logger.info("异常信息{}",e);
        } catch (IllegalArgumentException e) {
            logger.info("异常信息{}",e);
        } catch (InvocationTargetException e) {
            logger.info("异常信息{}",e);
        }
        return null;
    }
    
    List<Object> _LValues(Serializable entity) {
        List<Object> values = new LinkedList<Object>();
        try {
            Field[] fields = entity.getClass().getDeclaredFields();
            for (Field field : fields) {
                if ("INSTANCE".equals(field.getName())) {
                    continue;
                }
                String getFn = "get" + field.getName().substring(0, 1).toUpperCase() + field.getName().substring(1);
                Method method = entity.getClass().getMethod(getFn);
                Object obj = method.invoke(entity);
                if (obj != null) {
                    values.add(obj);
                }
            }
        } catch (SecurityException e) {
            logger.info("异常信息{}",e);
        } catch (NoSuchMethodException e) {
            logger.info("异常信息{}",e);
        } catch (IllegalAccessException e) {
            logger.info("异常信息{}",e);
        } catch (IllegalArgumentException e) {
            logger.info("异常信息{}",e);
        } catch (InvocationTargetException e) {
            logger.info("异常信息{}",e);
        }
        return values;
    }
    
    Object[] _Values(Map<String, Object> param) {
        try {
            List<Object> values = new LinkedList<Object>();
            for (String key : param.keySet()) {
                if ("INSTANCE".equals(key.toUpperCase())) {
                    continue;
                }
                values.add(param.get(key));
            }
            return values.toArray();
        } catch (SecurityException e) {
            logger.info("异常信息{}",e);
        }
        return null;
    }
    
    List<Object> _LValues(Map<String, Object> param) {
        List<Object> values = new LinkedList<Object>();
        try {
            for (String key : param.keySet()) {
                if ("INSTANCE".equals(key.toUpperCase())) {
                    continue;
                }
                values.add(param.get(key));
            }
        } catch (SecurityException e) {
            logger.info("异常信息{}",e);
        }
        return values;
    }

    void _setIValues(Serializable entity, PreparedStatement ps) {
        try {
            Field[] fields = entity.getClass().getDeclaredFields();
            int i = 1;
            for (Field field : fields) {
                if ("INSTANCE".equals(field.getName())) {
                    continue;
                }
                String getFn = "get" + field.getName().substring(0, 1).toUpperCase() + field.getName().substring(1);
                Method method = entity.getClass().getMethod(getFn);
                Object obj = method.invoke(entity);
                if (obj != null) {
                    try {
                        ps.setObject(i, obj);
                    } catch (SQLException e) {
                        logger.info("异常信息{}",e);
                        continue;
                    }
                    i++;
                }
            }
        } catch (SecurityException e) {
            logger.info("异常信息{}",e);
        } catch (NoSuchMethodException e) {
            logger.info("异常信息{}",e);
        } catch (IllegalAccessException e) {
            logger.info("异常信息{}",e);
        } catch (IllegalArgumentException e) {
            logger.info("异常信息{}",e);
        } catch (InvocationTargetException e) {
            logger.info("异常信息{}",e);
        }
    }
    
    void _setUValues(Serializable entity, PreparedStatement ps) {
        try {
            Field[] fields = entity.getClass().getDeclaredFields();
            int i = 1;
            for (Field field : fields) {
                if ("INSTANCE".equals(field.getName())) {
                    continue;
                }
                if ("id".equals(field.getName().toLowerCase())) {
                    continue;
                }
                String getFn = "get" + field.getName().substring(0, 1).toUpperCase() + field.getName().substring(1);
                Method method = entity.getClass().getMethod(getFn);
                Object obj = method.invoke(entity);
                if (obj != null) {
                    try {
                        ps.setObject(i, obj);
                    } catch (SQLException e) {
                        logger.info("异常信息{}",e);
                        continue;
                    }
                    i++;
                }
            }
            Method method = entity.getClass().getMethod("getId");
            Object obj = method.invoke(entity);
            ps.setObject(i, obj);
        } catch (SecurityException e) {
            logger.info("异常信息{}",e);
        } catch (NoSuchMethodException e) {
            logger.info("异常信息{}",e);
        } catch (IllegalAccessException e) {
            logger.info("异常信息{}",e);
        } catch (IllegalArgumentException e) {
            logger.info("异常信息{}",e);
        } catch (InvocationTargetException e) {
            logger.info("异常信息{}",e);
        } catch (SQLException e) {
            logger.info("异常信息{}",e);
        }
    }

    List<Object[]> _ListValues(List<?> lst_vo) {
        List<Object[]> lst_orgs = new ArrayList<Object[]>();
        for (Object entity : lst_vo) {
            try {
                List<Object> values = new LinkedList<Object>();
                Field[] fields = entity.getClass().getDeclaredFields();
                for (Field field : fields) {
                    if ("INSTANCE".equals(field.getName())) {
                        continue;
                    }
                    String getFn = "get" + field.getName().substring(0, 1).toUpperCase() + field.getName().substring(1);
                    Method method = entity.getClass().getMethod(getFn);
                    Object obj = method.invoke(entity);
                    if (obj != null) {
                        values.add(obj);
                    }
                }
                lst_orgs.add(values.toArray());
            } catch (SecurityException e) {
                logger.info("异常信息{}",e);
            } catch (NoSuchMethodException e) {
                logger.info("异常信息{}",e);
            } catch (IllegalAccessException e) {
                logger.info("异常信息{}",e);
            } catch (IllegalArgumentException e) {
                logger.info("异常信息{}",e);
            } catch (InvocationTargetException e) {
                logger.info("异常信息{}",e);
            }
        }
        System.out.println(Arrays.toString(lst_orgs.toArray()));
        return lst_orgs;
    }

    Object[] _UpdateValues(Serializable entity) {
        try {
            List<Object> values = new LinkedList<Object>();
            Field[] fields = entity.getClass().getDeclaredFields();
            for (Field field : fields) {
                if ("INSTANCE".equals(field.getName())) {
                    continue;
                }
                if ("id".equals(field.getName().toLowerCase())) {
                    continue;
                }
                String getFn = "get" + field.getName().substring(0, 1).toUpperCase() + field.getName().substring(1);
                Method method = entity.getClass().getMethod(getFn);
                Object obj = method.invoke(entity);
                if (obj != null) {
                    values.add(obj);
                }
            }
            Method method = entity.getClass().getMethod("getId");
            Object obj = method.invoke(entity);
            values.add(obj);
            return values.toArray();
        } catch (SecurityException e) {
            logger.info("异常信息{}",e);
        } catch (NoSuchMethodException e) {
            logger.info("异常信息{}",e);
        } catch (IllegalAccessException e) {
            logger.info("异常信息{}",e);
        } catch (IllegalArgumentException e) {
            logger.info("异常信息{}",e);
        } catch (InvocationTargetException e) {
            logger.info("异常信息{}",e);
        }
        return null;
    }

    List<Object[]> _UpdateListValues(List<?> lst_vo) {
        List<Object[]> lst_orgs = new ArrayList<Object[]>();
        for (Object entity : lst_vo) {
            try {
                List<Object> values = new LinkedList<Object>();
                Field[] fields = entity.getClass().getDeclaredFields();
                for (Field field : fields) {
                    if ("INSTANCE".equals(field.getName())) {
                        continue;
                    }
                    if ("id".equals(field.getName().toLowerCase())) {
                        continue;
                    }
                    String getFn = "get" + field.getName().substring(0, 1).toUpperCase() + field.getName().substring(1);
                    Method method = entity.getClass().getMethod(getFn);
                    Object obj = method.invoke(entity);
                    if (obj != null) {
                        values.add(obj);
                    }
                }
                Method method = entity.getClass().getMethod("getId");
                Object obj = method.invoke(entity);
                values.add(obj);
                lst_orgs.add(values.toArray());
            } catch (SecurityException e) {
                logger.info("异常信息{}",e);
            } catch (NoSuchMethodException e) {
                logger.info("异常信息{}",e);
            } catch (IllegalAccessException e) {
                logger.info("异常信息{}",e);
            } catch (IllegalArgumentException e) {
                logger.info("异常信息{}",e);
            } catch (InvocationTargetException e) {
                logger.info("异常信息{}",e);
            }
        }
        return lst_orgs;
    }

    Object[] _DelValues(Serializable entity) {
        try {
            List<Object> values = new LinkedList<Object>();
            Field[] fields = entity.getClass().getDeclaredFields();
            for (Field field : fields) {
                if ("INSTANCE".equals(field.getName())) {
                    continue;
                }
                String getFn = "get" + field.getName().substring(0, 1).toUpperCase() + field.getName().substring(1);
                Method method = entity.getClass().getMethod(getFn);
                Object obj = method.invoke(entity);
                if (obj != null) {
                    values.add(obj);
                }
            }
            return values.toArray();
        } catch (SecurityException e) {
            logger.info("异常信息{}",e);
        } catch (NoSuchMethodException e) {
            logger.info("异常信息{}",e);
        } catch (IllegalAccessException e) {
            logger.info("异常信息{}",e);
        } catch (IllegalArgumentException e) {
            logger.info("异常信息{}",e);
        } catch (InvocationTargetException e) {
            logger.info("异常信息{}",e);
        }
        return null;
    }

    public Map<String, Object> _queryMapOneBySql(String sql) {
        try {
            if (sql.indexOf("rownum") == -1) {
                if (sql.indexOf("where") == -1) {
                    sql += " where ";
                }
                sql += " rownum = 1 ";
            }
            logger.info("执行SQL[{}]",sql);
            return jdbcTemplate.queryForMap(sql);
        } catch (DataAccessException e) {
            logger.info("异常信息{}",e);
        }
        return new HashMap<>();
    }

    public List<Map<String, Object>> _queryMapListBySql(String sql) {
        try {
            logger.info("执行SQL[{}]",sql);
            return jdbcTemplate.queryForList(sql);
        } catch (DataAccessException e) {
            logger.info("异常信息{}",e);
        }
        return new ArrayList<>();
    }

    public List<Map<String, Object>> _queryPagingListMapBySql(String sql, int start, int end) {
        try {
            String pgSQL = "SELECT * FROM (SELECT a.*, ROWNUM rn FROM (%s) a WHERE ROWNUM <= %d) WHERE rn >= %d";
            pgSQL = String.format(pgSQL, sql, end, start);
            // Sql转大写使用
            logger.info("执行SQL[{}]",pgSQL.toUpperCase());
            return jdbcTemplate.queryForList(pgSQL.toUpperCase());
        } catch (DataAccessException e) {
            logger.info("异常信息{}",e);
        }
        return new ArrayList<>();
    }

    public int _statBySql(String sql) {
        try {
            String statSql = "SELECT count(*) FROM (%s) ";
            statSql = String.format(statSql, sql);
            // Sql转大写使用
            logger.info("执行SQL[{}]",statSql);
            return jdbcTemplate.queryForObject(statSql, Integer.class);
        } catch (DataAccessException e) {
            logger.info("异常信息{}",e);
        }
        return 0;
    }

    public <T> int Save() {
        try {
            logger.info("执行SQL[{}]",_SqlSave(this).toString());
            return jdbcTemplate.update(_SqlSave(this).toString(), _Values(this));
        } catch (DataAccessException e) {
            logger.info("异常信息{}",e);
        }
        return 0;
    }

    public <T> int[] Saves(final List<? extends Serializable> lst_vo) {
        try {
            BatchPreparedStatementSetter setter = new BatchPreparedStatementSetter() {
                public int getBatchSize() {
                    return lst_vo.size();
                }

                public void setValues(PreparedStatement ps, int i) {
                    try {
                        _setIValues(lst_vo.get(i), ps); 
                    } catch (Exception e) {
                        logger.info("异常信息{}",e);
                    }
                }
            };
            logger.info("执行SQL[{}]",_SqlSave(lst_vo.get(0)).toString());
            return jdbcTemplate.batchUpdate(_SqlSave(lst_vo.get(0)).toString(),setter);
        } catch (DataAccessException e) {
            logger.info("异常信息{}",e);
        }
        return null;
    }

    public <T> int Update() {
        try {
            logger.info("执行SQL[{}]",_SqlUpdate(this).toString());
            return jdbcTemplate.update(_SqlUpdate(this).toString(), _UpdateValues(this));
        } catch (DataAccessException e) {
            logger.info("异常信息{}",e);
        }
        return 0;
    }
    
    public <T> int Del() {
        try {
            logger.info("执行SQL[{}]",_SqlDel(this).toString());
            return jdbcTemplate.update(_SqlDel(this).toString(), _DelValues(this));
        } catch (DataAccessException e) {
            logger.info("异常信息{}",e);
        }
        return 0;
    }
    
    public <T> int[] BatDel(final List<? extends Serializable> lst_vo) {
        try {
            BatchPreparedStatementSetter setter = new BatchPreparedStatementSetter() {
                public int getBatchSize() {
                    return lst_vo.size();
                }

                public void setValues(PreparedStatement ps, int i) {
                    try {
                        _setIValues(lst_vo.get(i), ps); 
                    } catch (Exception e) {
                        logger.info("异常信息{}",e);
                    }
                }
            };
            logger.info("执行批量SQL[{}]",_SqlDel(lst_vo.get(0)).toString());
            return jdbcTemplate.batchUpdate(_SqlDel(lst_vo.get(0)).toString(),setter);
        } catch (DataAccessException e) {
            logger.info("异常信息{}",e);
        }
        return null;
    }
    
    public <T> int DelById(String id) {
        try {
            String sql = String.format("delete from %s where id = ? ",_tableName());
            logger.info("执行删除SQL[{}],参数id[{}]",sql,id);
            return jdbcTemplate.update(sql,id);
        } catch (DataAccessException e) {
            logger.info("异常信息{}",e);
        }
        return 0;
    }
    
    public <T> int DelById(int id) {
        try {
            String sql = String.format("delete from %s where id = ? ",_tableName());
            logger.info("执行删除SQL[{}],参数id[{}]",sql,id);
            return jdbcTemplate.update(sql,id);
        } catch (DataAccessException e) {
            logger.info("异常信息{}",e);
        }
        return 0;
    }
    
    public <T> int DelById(Integer id) {
        try {
            String sql = String.format("delete from %s where id = ? ",_tableName());
            logger.info("执行删除SQL[{}]",sql);
            return jdbcTemplate.update(sql,id);
        } catch (DataAccessException e) {
            logger.info("异常信息{}",e);
        }
        return 0;
    }

    public <T> int[] Update(final List<? extends Serializable> lst_vo) {
        try {
            BatchPreparedStatementSetter setter = new BatchPreparedStatementSetter() {
                public int getBatchSize() {
                    return lst_vo.size();
                }

                public void setValues(PreparedStatement ps, int i) {
                    try {
                        _setUValues(lst_vo.get(i), ps); 
                    } catch (Exception e) {
                        logger.info("异常信息{}",e);
                    }
                }
            };
            logger.info("执行SQL[{}]",_SqlUpdate(lst_vo.get(0)).toString());
            return jdbcTemplate.batchUpdate(_SqlUpdate(lst_vo.get(0)).toString(),setter);
        } catch (DataAccessException e) {
            logger.info("异常信息{}",e);
        }
        return null;
    }

    public <T> int SaveAutoKey_int() {
        return _saveAutoKey(this.getClass()).intValue();
    }

    public <T> long SaveAutoKey_long() {
        return _saveAutoKey(this.getClass()).longValue();
    }

    public <T> double SaveAutoKey_double() {
        return _saveAutoKey(this.getClass()).doubleValue();
    }

    public <T> float SaveAutoKey_float() {
        return _saveAutoKey(this.getClass()).floatValue();
    }

    public <T> Number _saveAutoKey(final Class<T> beanClass) {
        KeyHolder keyHolder = new GeneratedKeyHolder();
        try {
            jdbcTemplate.update(new PreparedStatementCreator() {
                public PreparedStatement createPreparedStatement(Connection conn) throws SQLException {
                    PreparedStatement ps = jdbcTemplate.getDataSource().getConnection()
                            .prepareStatement(_SqlSave(beanClass).toString());
                    _setIValues(beanClass, ps);
                    return ps;
                }
            }, keyHolder);
        } catch (DataAccessException e) {
            logger.info("异常信息{}",e);
        }
        return keyHolder.getKey();
    }
    
    public Map<String, Object> GetMapById(Object id){ 
        try {
            String sql = String.format("select * from %s where id=? and rownum = 1",_tableName());
            logger.info("执行SQL[{}]",sql);
            List<Map<String, Object>> results = jdbcTemplate.queryForList(sql,id);
            return (results == null || results.size() == 0) ?null:results.get(0);
        } catch (DataAccessException e) {
            logger.info("异常信息{}",e);
        }
        return null;
    }
    
    public Map<String, Object> GetMap(){ 
        try {
            String where = _SqlWhere(this).toString();
            String sql = "";
            List<Map<String, Object>> results = null;
            if(StringUtils.isNotBlank(where) && StringUtils.isNotEmpty(where)){
                sql = String.format("select * from %s where %s and rownum = 1",_tableName(),where);
                logger.info("执行SQL[{}]",sql);
                results = jdbcTemplate.queryForList(sql,_Values(this));
            }else{
                sql = String.format("select * from %s where rownum = 1",_tableName());
                logger.info("执行SQL[{}]",sql);
                results = jdbcTemplate.queryForList(sql);
            }
            return (results == null || results.size() == 0) ?null:results.get(0);
        } catch (DataAccessException e) {
            logger.info("异常信息{}",e);
        }
        return null;
    } 
    
    public Map<String, Object> GetMapByMap(Map<String, Object> param){ 
        try {
            String where = _SqlWhere(param).toString();
            String sql = "";
            List<Map<String, Object>> results = null;
            if(StringUtils.isBlank(where) || StringUtils.isEmpty(where)){
                sql = String.format("select * from %s where rownum = 1",_tableName());
                logger.info("执行SQL[{}]",sql);
                results = jdbcTemplate.queryForList(sql);
            }else{
                sql = String.format("select * from %s where %s and rownum = 1",_tableName(),_SqlWhere(param));
                logger.info("执行SQL[{}]",sql);
                results = jdbcTemplate.queryForList(sql,_Values(param));
            }
            return (results == null || results.size() == 0) ?null:results.get(0);
        } catch (DataAccessException e) {
            logger.info("异常信息{}",e);
        }
        return null;
    }
    
    public List<Map<String, Object>> GetListMap(){ 
        try {
            String where = _SqlWhere(this).toString();
            String sql = "";
            List<Map<String, Object>> results = null;
            if(StringUtils.isBlank(where) || StringUtils.isEmpty(where)){
                sql = String.format("select * from %s ",_tableName());
                logger.info("执行SQL[{}]",sql);
                results = jdbcTemplate.queryForList(sql);
            }else{
                sql = String.format("select * from %s where %s ",_tableName(),_SqlWhere(this));
                logger.info("执行SQL[{}]",sql);
                results = jdbcTemplate.queryForList(sql,_Values(this));
            } 
            return (results != null && results.size() == 0) ?null:results;
        } catch (DataAccessException e) {
            logger.info("异常信息{}",e);
        }
        return null;
    } 
    
    public List<Map<String, Object>> GetListMap(int size){ 
        try {
            String where = _SqlWhere(this).toString();
            String sql = "";
            List<Map<String, Object>> results = null;
            if(StringUtils.isBlank(where) || StringUtils.isEmpty(where)){
                sql = String.format("select * from %s where rownum <= ?",_tableName());
                results = jdbcTemplate.queryForList(sql,size);
            }else{
                sql = String.format("select * from %s where %s ",_tableName(),_SqlWhere(this)+" and rownum <= ?");
                logger.info("执行SQL[{}]",sql);
                List<Object> args = new ArrayList<Object>();
                args.addAll(_LValues(this));
                args.add(size);
                results = jdbcTemplate.queryForList(sql,args.toArray());
            } 
            return (results != null && results.size() == 0) ?null:results;
        } catch (DataAccessException e) {
            logger.info("异常信息{}",e);
        }
        return null;
    } 
    
    public List<Map<String, Object>> GetListMap(Map<String, Object> param){ 
        try {
            String where = _SqlWhere(param).toString();
            String sql = "";
            List<Map<String, Object>> results = null;
            if(StringUtils.isBlank(where) || StringUtils.isEmpty(where)){
                sql = String.format("select * from %s ",_tableName());
                logger.info("执行SQL[{}]",sql);
                results = jdbcTemplate.queryForList(sql);
            }else{
                sql = String.format("select * from %s where %s ",_tableName(),_SqlWhere(param));
                logger.info("执行SQL[{}]",sql);
                results = jdbcTemplate.queryForList(sql,_Values(param));
            } 
            return (results != null && results.size() == 0) ?null:results;
        } catch (DataAccessException e) {
            logger.info("异常信息{}",e);
        }
        return null;
    }
    
    public List<Map<String, Object>> GetListMap(Map<String, Object> param,int size){ 
        try {
            String where = _SqlWhere(param).toString();
            String sql = "";
            List<Map<String, Object>> results = null;
            if(StringUtils.isBlank(where) || StringUtils.isEmpty(where)){
                sql = String.format("select * from %s where rownum <= ?",_tableName());
                logger.info("执行SQL[{}]",sql);
                results = jdbcTemplate.queryForList(sql,size);
            }else{
                sql = String.format("select * from %s where %s ",_tableName(),_SqlWhere(param).append(" and rownum <= ?"));
                logger.info("执行SQL[{}]",sql);
                List<Object> args = new ArrayList<Object>();
                args.addAll(_LValues(param));
                args.add(size);
                results = jdbcTemplate.queryForList(sql,args.toArray());
            } 
            return (results != null && results.size() == 0) ?null:results;
        } catch (DataAccessException e) {
            logger.info("异常信息{}",e);
        }
        return null;
    }
    
    public List<Map<String, Object>> pageListMap(int currentPage,int pageSize){ 
        if(currentPage <= 0) currentPage = 1;
        if(pageSize <= 0) pageSize = 5;
        int start = (currentPage-1)*pageSize;
        int end = currentPage*pageSize;
        
        String sql = String.format("select * from %s ",_tableName());
        String where = _SqlWhere(this).toString();
        if(StringUtils.isNotBlank(where) && StringUtils.isNotEmpty(where)){
            sql += " where "+where;
        }
        String pgSQL="SELECT * FROM (SELECT a.*, ROWNUM rn FROM (%s) a WHERE ROWNUM <= %d) WHERE rn >= %d";
        pgSQL = String.format(pgSQL, sql,end,start);
        logger.info("执行SQL[{}]",pgSQL);
        try {
            List<Map<String, Object>> results = null;
            if(StringUtils.isNotBlank(where) && StringUtils.isNotEmpty(where)){
                results = jdbcTemplate.queryForList(pgSQL.toUpperCase(),_Values(this));
            }else{
                results = jdbcTemplate.queryForList(pgSQL.toUpperCase());
            }
            return (results != null && results.size() == 0) ?null:results;
        } catch (DataAccessException e) {
            logger.info("异常信息{}",e);
        }
        return null;
    }
    
    public Integer pageListCount(){  
        String sql = String.format("select count(*) from %s ",_tableName());
        String where = _SqlWhere(this).toString();
        if(StringUtils.isNotBlank(where) && StringUtils.isNotEmpty(where)){
            sql += " where "+where;
        }
        logger.info("执行SQL[{}]",sql);
        try {
            if(StringUtils.isNotBlank(where) && StringUtils.isNotEmpty(where)){
                return jdbcTemplate.queryForObject(sql,_Values(this), Integer.class);
            }else{
                return jdbcTemplate.queryForObject(sql, Integer.class);
            }
        } catch (DataAccessException e) {
            logger.info("异常信息{}",e);
        }
        return 0;
    }
    
    public Integer pageListCount(Map<String, Object> param){  
        String sql = String.format("select count(*) from %s ",_tableName());
        String where = _SqlWhere(param).toString();
        if(StringUtils.isNotBlank(where) && StringUtils.isNotEmpty(where)){
            sql += " where "+where;
        }
        logger.info("执行SQL[{}]",sql);
        try {
            if(StringUtils.isNotBlank(where) && StringUtils.isNotEmpty(where)){
                return jdbcTemplate.queryForObject(sql,_Values(param), Integer.class);
            }else{
                return jdbcTemplate.queryForObject(sql, Integer.class);
            }
        } catch (DataAccessException e) {
            logger.info("异常信息{}",e);
        }
        return 0;
    }
    
    public List<Map<String, Object>> pageListMap(Map<String, Object> param,int currentPage,int pageSize){ 
        if(currentPage <= 0) currentPage = 1;
        if(pageSize <= 0) pageSize = 5;
        int start = (currentPage-1)*pageSize;
        int end = currentPage*pageSize;
        
        String sql = String.format("select * from %s ",_tableName());
        String where = _SqlWhere(param).toString();
        if(StringUtils.isNotBlank(where) && StringUtils.isNotEmpty(where)){
            sql += " where "+where;
        }
        String pgSQL="SELECT * FROM (SELECT a.*, ROWNUM rn FROM (%s) a WHERE ROWNUM <= %d) WHERE rn >= %d";
        pgSQL = String.format(pgSQL, sql,end,start);
        logger.info("执行SQL[{}]",pgSQL);
        try {
            List<Map<String, Object>> results = null;
            if(StringUtils.isNotBlank(where) && StringUtils.isNotEmpty(where)){
                results = jdbcTemplate.queryForList(pgSQL.toUpperCase(),_Values(param));
            }else{
                results = jdbcTemplate.queryForList(pgSQL.toUpperCase());
            }
            return (results != null && results.size() == 0) ?null:results;
        } catch (DataAccessException e) {
            logger.info("异常信息{}",e);
        }
        return null;
    }

}
 

 

<dependencies>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>druid</artifactId>
            <version>1.0.29</version>
        </dependency>
        <dependency>
            <groupId>com.oracle</groupId>
            <artifactId>ojdbc6</artifactId>
            <version>11.2.0.4</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-jdbc</artifactId>
            <version>3.2.16.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-webmvc</artifactId>
            <version>3.2.16.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>3.2.16.RELEASE</version>
        </dependency>
        <dependency>
            <groupId>commons-lang</groupId>
            <artifactId>commons-lang</artifactId>
            <version>2.6</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.11</version>
            <scope>test</scope>
        </dependency>
        <!-- Logging -->
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.6.6</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>jcl-over-slf4j</artifactId>
            <version>1.6.6</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.6.6</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>3.0.1</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

转载于:https://my.oschina.net/body/blog/896247

weixin_33932129
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java-泛型
weixin_45196232的博客
03-29 104
规定好某个位置的类型1、规定集合容器的元素类型2、成员变量的类型3、规定方法的参数的类型4、规定方法的返回值的类型public class 类名 < E1 , E2 , E3 > {//类中的成员变量，方法的参数和返回类型，局部变量都可以使用泛型 }
Spring-mvc的jdbc
任伟、
02-24 224
spring对JDBC等数据库访问技术编写DAO提供以下几个重要支持 1、Spring对DAO异常提供了统一处理     spring提供了DataAccessException类。 2、Spring对DAO编写提供了支持的抽象类     spring提供了一套抽象的DAO类，还有一些方法，     jsbcTemplate封装常用JDBC方法     HibernateTempl
Spring jdbc 异常基类
yangmeijing的博客
11-04 873
使用JDBC API时，很多操作都要声明抛出java.sql.SQLException异常，通常情况下是要制定异常处理策略。 而Spring的JDBC模块为我们提供了一套异常处理机制，这套异常系统的基类是DataAccessException，它是RuntimeException的一种类型，那么就不用强制去捕捉异常了
[会写代码的健身爱好者成长史]之spring-security
DreamStat的博客
02-11 1100
1.什么是spring-security? spring-security是spring家族推出的一个安全校验权限框架，一般中大型项目都会采用这个框架 2.准备工作 2.1 添加依赖 <!--redis --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spri
Android之SQLite数据库操作
Francis-ChinaFeng
07-08 1466
前些日子，搞了个Android项目，接触到了SQLite数据库 个人感觉有点麻烦： 1、数据库字段的修改，需要修改实体类，DAO类的字段的增加、修改、删除 2、传统的JDBC思想，体力劳动，十分浪费程序员的精力 3、程序耦合性太高，不够灵活 怎样才能将SQLite的DAO类使用的如同Hibernate一样简单呢？ Android的本身提供了SQLiteOpenHelper类、SQLit
泛型<T>的类型获取
零度的博客专栏
01-11 1万+
T.getClass()或者T.class都是非法的，因为T是泛型变量。由于一个类的类型是什么,是在编译期处理的，故不能在运行时直接在Base里得到T的实际类型。 /** *@author zhangwenchao *@version * 可以在service层直接调用,也可以在DAO层扩展调用 */ public class BaseDaoImpl implements BaseDa
spring中的jdbcTemplate
ManuMAX的博客
12-09 122
它是spring框架中提供的一个对象，是对原始jdbcAPI对象的简单封装。spring框架为我们提供了很多的操作模板类：操作关系型数据的：操作nosql数据库的：操作消息队列的：注意：需要导入两个JAR包：spring-jdbc-5.0.2.RELEASE.jar、spring-tx-5.0.2.RELEASE.jar。
Spring JDBC常用Jar包
11-20
4. **spring-jdbc-3.2.3.RELEASE.jar**: 这是Spring JDBC模块的实现，提供了对JDBC的抽象，包括DataSource的管理、JdbcTemplate、SimpleJdbcInsert、SimpleJdbcCall等工具类。这些工具类简化了SQL的执行，避免了大量...
SpringJDBC.rar_SpringJDBC_spring jdbc
09-24
通过这个SpringJDBC.rar的案例，初学者可以学习到如何配置DataSource，如何创建JdbcTemplate实例，以及如何编写和执行SQL语句。同时，实践中还可以了解到如何将Spring JDBC整合到Spring Boot项目中，以及如何处理...
springjdbc.rar_SpringJDBC_spring jdbc
09-20
`JdbcTemplate`是Spring JDBC提供的一个关键类，它提供了大量的模板方法来执行SQL查询、更新和存储过程。使用`JdbcTemplate`测试数据库操作通常涉及以下步骤： 1. **配置数据源**：首先，你需要在Spring的配置文件...
spring jdbc.zip
06-10
JdbcTemplate是Spring JDBC的核心类，它是对JDBC的简单而强大的封装。它提供了大量的方法，用于执行SQL查询、更新、存储过程等，这些方法能够自动处理资源的关闭、异常处理以及结果集的映射。例如，我们可以通过以下...
spring jdbc相关包版本5.1.3
01-11
1. **spring-core-5.1.3.RELEASE.jar**：这是Spring框架的核心库，包含基础类如`ApplicationContext`，`BeanFactory`等，以及IoC（Inversion of Control，控制反转）和AOP（Aspect Oriented Programming，面向切面...
BaseDAO开发及获取泛型的传输数据类型（Class<T>）实例讲解
前尘叆夢
05-17 4735
一般在涉及DAO开发时，常用到的增删改查方法会封装到一个基类（BaseDAO），对于各个数据表的基本维护业务都需要用到增删改查等方法。 若对每张表都编写一套增删改差方法未必有些麻烦，并且不符合编码的基本准则。一般，我们可以将这些功能的所公用的部分封装为一个对象，或者是类，此类是所有DAO的 基类，可以称为：BaseDAO。 由于此类接收到不同的操作对象，故需泛型的支持。 下面，我通过以下实
java public t t_java中泛型public <T> void rev(T []ar)问题
weixin_42628941的博客
02-16 427
展开全部首先 基本内建类型(byte int short int long float double boolean)不能作为模板类、模板函数的模板参数，这是Java语言的一个缺陷(至少我62616964757a686964616fe4b893e5b19e31333332643265这么认为).也就说不能将int[] ar; 传入 void rev(T[] a){}解决:将public voi...
关于RedisTemplate里存取Long类型
l3349331的博客
03-12 1万+
redis里存long类型,会自动转成int类型,取的过程中不能强转成long类型,否则将会类型转换异常,本人处理的时候封装了一个工具类. public &amp;lt;T&amp;gt; T getObject(String key, Class&amp;lt;T&amp;gt; clazz) { Object valueObj = redisTemplate.opsForValue().get(ke...
java网站建设6-封装Springjdbc的通用基类
攀岩者
01-11 1541
package oa.common.dao; import java.util.List; import oa.common.model.PageModel; import org.springframework.jdbc.core.BeanPropertyRowMapper; import org.springframework.jdbc.core.RowMapper; import or
Spring JDBC-使用Spring JDBC访问数据库
热门推荐
小工匠
09-28 2万+
概述 使用Spring JDBC 基本的数据操作 更改数据 返回数据库表的自增主键值 批量更改数据 查询数据 使用RowCallbackHandler处理结果集 使用RowMapperT处理结果集 RowCallbackHandler和RowMapperT的比较 查询单值数据 调用存储过程3种方式 示例源码概述Spring JDBC是Spring所提供的持久层技术，它的主要目的降低JDBC API的
在eclipse中导入本地的jar包配置Junit环境步骤（包含Junit中的方法一直标红的解决方法）
最新发布
weixin_70987470的博客
07-20 200
从本地导入Junit
Promise 详解（原理篇）
山重水复疑无路，柳暗花明又一村。
07-20 344
Promise 是一种异步编程的解决方案。在异步操作中，callback 会导致回调地狱的问题，Promise 解决了这个问题。一个 Promise对象有以下三种状态:pending：初始状态，既不是成功，也不是失败状态。：意味着操作成功完成。rejected：意味着操作失败。当 new Promise() 被实例化后，即表示 Promise 进入 pending 初始化状态，准备就绪，等待运行。
手写定制Spring JDBC框架解析与实现简介
基于Spring JDBC手写定制自己的ORM框架是一项...通过这个任务，我们可以更好地理解Java JDBC的操作原理，掌握ORM框架的实现逻辑，为学习MyBatis等框架打下坚实的基础。这对于提高我们的开发能力和技术水平非常有帮助。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值