java反射泛型通用dao，druid封装高可用jdbcutils

最新推荐文章于 2024-04-10 18:00:22 发布
最新推荐文章于 2024-04-10 18:00:22 发布
阅读量662 收藏
点赞数 1
分类专栏： JDBC
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38897274/article/details/82660096
版权

1、建三个注解，用于midel类上，Table(标注表名)，Id(标注数据库主键字段），Column(标注除主键其他字段)

package b.w.xqp.anno;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 标识数据库字段的名称
 * 
 * @author T
 * 
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Column {

    /**
     * 字段名称
     */
    String value();

    /**
     * 字段的类型
     * 
     * @return
     */
    Class<?> type() default String.class;

    /**
     * 字段的长度
     * 
     * @return
     */
    int length() default 0;

}

 

package b.w.xqp.anno;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 标识数据库字段的ID
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.FIELD)
public @interface Id {

    /**
     * ID的名称
     * 
     * @return
     */
    String value();

}

 

package b.w.xqp.anno;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;
 
/**
 * 数据库表的的名称
 */
@Retention(RetentionPolicy.RUNTIME)
@Target(ElementType.TYPE)
public @interface Table {
 
    /**
     * 表名
     */
    String value();
    
}

 

 

2、创建JdbcGenericDao接口，并创建通用方法

package b.w.xqp.dao.base;

import java.util.List;
import java.util.Map;

public interface JdbcGenericDao<T> {

    /**
     * 保存方法
     * 
     * @param t
     *            要保存的model模型
     * @throws Exception
     */
    public void save(T t) throws Exception;

    /**
     * 删除方法
     * 
     * @param id
     *            主键id
     * @param clazz
     *            删除模型的字节码文件
     * @throws Exception
     */
    public void delete(Object id, Class<T> clazz) throws Exception;

    /**
     * 修改方法
     * 
     * @param t
     *            model模型
     * @throws Exception
     */
    public void update(T t) throws Exception;

    /**
     * 
     * @param id
     * @param clazz
     * @return
     * @throws Exception
     */
    public T get(Object id, Class<T> clazz) throws Exception;

    /**
     * 根据条件查询
     * 
     * @param sqlWhereMap
     *            key：条件字段名 value：条件字段值
     * @param clazz
     * @return
     * @throws Exception
     */
    public List<T> findAllByConditions(Map<String, Object> sqlWhereMap,
            Class<T> clazz) throws Exception;

}
 

 

3、创建接口实现类JdbcGenericDaoImpl

package b.w.xqp.dao.base;

import java.beans.IntrospectionException;
import java.beans.PropertyDescriptor;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Timestamp;
import java.sql.Types;
import java.util.ArrayList;
import java.util.Date;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;

import b.w.xqp.anno.Column;
import b.w.xqp.anno.Id;
import b.w.xqp.anno.Table;
import b.w.xqp.util.JDBCUtils;

/**
 * 泛型DAO的JDBC实现
 * 
 * @author T
 * @version 1.0
 */
@SuppressWarnings("all")
public class JdbcGenericDaoImpl<T> implements JdbcGenericDao<T> {

    // 表的别名
    private static final String TABLE_ALIAS = "t";

    @Override
    public void save(T t) throws Exception {
        Connection connection = null;
        PreparedStatement ps = null;

        Class<?> clazz = t.getClass();
        // 获得表名
        String tableName = getTableName(clazz);
        // 获得字段
        StringBuilder fieldNames = new StringBuilder(); // 字段名
        List<Object> fieldValues = new ArrayList<Object>(); // 字段值
        StringBuilder placeholders = new StringBuilder(); // 占位符
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            PropertyDescriptor pd = new PropertyDescriptor(field.getName(),
                    t.getClass());

            // 判断字段值是否为空
            if (pd.getReadMethod().invoke(t) != null) {
                if (field.isAnnotationPresent(Id.class)) {
                    fieldNames.append(field.getAnnotation(Id.class).value())
                            .append(",");
                    fieldValues.add(pd.getReadMethod().invoke(t));
                } else if (field.isAnnotationPresent(Column.class)) {
                    fieldNames
                            .append(field.getAnnotation(Column.class).value())
                            .append(",");
                    fieldValues.add(pd.getReadMethod().invoke(t));
                }
                placeholders.append("?").append(",");
            }
        }
        // 删除最后一个逗号
        fieldNames.deleteCharAt(fieldNames.length() - 1);
        placeholders.deleteCharAt(placeholders.length() - 1);

        // 拼接sql
        StringBuilder sql = new StringBuilder("");
        sql.append("insert into ").append(tableName).append(" (")
                .append(fieldNames.toString()).append(") values (")
                .append(placeholders).append(")");

        try {
            // 开启事务
            connection = JDBCUtils.getConnection();
            /** 设置不自动提交，以便于在出现异常的时候数据库回滚 **/
            JDBCUtils.startTransaction();
            ps = connection.prepareStatement(sql.toString());
            // 设置SQL参数占位符的值
            setParameter(fieldValues, ps, false);
            // 执行SQL
            ps.execute();
            // 提交事务
            JDBCUtils.commit();
        } catch (Exception e) {
            JDBCUtils.rollback();
            e.printStackTrace();
        } finally {
            // 关闭连接
            if (ps != null) {
                ps.close();
            }
            JDBCUtils.close();
        }
    }

    @Override
    public void delete(Object id, Class<T> clazz) throws Exception {
        Connection connection = null;
        PreparedStatement ps = null;
        // 获得表名
        String tableName = getTableName(clazz);
        // 获得ID字段名和值
        String idFieldName = "";
        boolean flag = false;
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            if (field.isAnnotationPresent(Id.class)) {
                idFieldName = field.getAnnotation(Id.class).value();
                flag = true;
                break;
            }
        }
        if (!flag) {
            throw new Exception(clazz.getName()
                    + " object not found id property.");
        }

        // 拼装sql
        String sql = "delete from " + tableName + " where " + idFieldName
                + "=?";
        try {
            connection = JDBCUtils.getConnection();
            // 开启事务
            JDBCUtils.startTransaction();
            ps = connection.prepareStatement(sql);
            ps.setObject(1, id);
            // 执行SQL
            ps.execute();
            // 提交事务
            JDBCUtils.commit();
        } catch (Exception e) {
            // 回滚事务
            JDBCUtils.rollback();
            e.printStackTrace();
        } finally {
            // 关闭连接
            if (ps != null) {
                ps.close();
            }
            JDBCUtils.close();
        }
    }

    @Override
    public void update(T t) throws Exception {
        Connection connection = null;
        PreparedStatement ps = null;
        Class<?> clazz = t.getClass();
        // 获得表名
        String tableName = getTableName(clazz);
        // 获得字段
        List<Object> fieldNames = new ArrayList<Object>(); // 字段名
        List<Object> fieldValues = new ArrayList<Object>(); // 字段值
        List<String> placeholders = new ArrayList<String>();// 占位符
        String idFieldName = "";
        Object idFieldValue = "";
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            PropertyDescriptor pd = new PropertyDescriptor(field.getName(),
                    t.getClass());
            if (pd.getReadMethod().invoke(t) != null) {
                if (field.isAnnotationPresent(Id.class)) {
                    idFieldName = field.getAnnotation(Id.class).value();
                    idFieldValue = pd.getReadMethod().invoke(t);
                } else if (field.isAnnotationPresent(Column.class)) {
                    fieldNames.add(field.getAnnotation(Column.class).value());
                    fieldValues.add(pd.getReadMethod().invoke(t));
                    placeholders.add("?");
                }
            }
        }
        // ID作为更新条件，放在集合中的最后一个元素
        fieldNames.add(idFieldName);
        fieldValues.add(idFieldValue);
        placeholders.add("?");

        // 拼接sql
        StringBuilder sql = new StringBuilder("");
        sql.append("update ").append(tableName).append(" set ");
        int index = fieldNames.size() - 1;
        for (int i = 0; i < index; i++) {
            sql.append(fieldNames.get(i)).append("=")
                    .append(placeholders.get(i)).append(",");
        }
        sql.deleteCharAt(sql.length() - 1).append(" where ")
                .append(fieldNames.get(index)).append("=").append("?");

        try {
            // 获取链接
            connection = JDBCUtils.getConnection();
            // 开启事务
            JDBCUtils.startTransaction();
            ps = connection.prepareStatement(sql.toString());
            // 设置SQL参数占位符的值
            setParameter(fieldValues, ps, false);
            // 执行SQL
            ps.execute();
            // 提交事务
            JDBCUtils.commit();
        } catch (Exception e) {
            // 回滚事务
            JDBCUtils.rollback();
            e.printStackTrace();
        } finally {
            // 关闭连接
            if (ps != null) {
                ps.close();
            }
            JDBCUtils.close();
        }
    }

    @Override
    public T get(Object id, Class<T> clazz) throws Exception {
        String idFieldName = "";
        Field[] fields = clazz.getDeclaredFields();
        boolean flag = false;
        for (Field field : fields) {
            if (field.isAnnotationPresent(Id.class)) {
                idFieldName = field.getAnnotation(Id.class).value();
                flag = true;
                break;
            }
        }

        if (!flag) {
            throw new Exception(clazz.getName()
                    + " object not found id property.");
        }

        // 拼装SQL
        Map<String, Object> sqlWhereMap = new HashMap<String, Object>();
        sqlWhereMap.put(TABLE_ALIAS + "." + idFieldName, id);

        List<T> list = findAllByConditions(sqlWhereMap, clazz);
        return list.size() > 0 ? list.get(0) : null;
    }

    @Override
    public List<T> findAllByConditions(Map<String, Object> sqlWhereMap,
            Class<T> clazz) throws Exception {
        List<T> list = new ArrayList<T>();
        String tableName = getTableName(clazz);
        String idFieldName = "";
        // 存储所有字段的信息
        // 通过反射获得要查询的字段
        StringBuffer fieldNames = new StringBuffer();
        Field[] fields = clazz.getDeclaredFields();
        for (Field field : fields) {
            String propertyName = field.getName();
            if (field.isAnnotationPresent(Id.class)) {
                idFieldName = field.getAnnotation(Id.class).value();
                fieldNames.append(TABLE_ALIAS + "." + idFieldName)
                        .append(" as ").append(propertyName).append(",");
            } else if (field.isAnnotationPresent(Column.class)) {
                fieldNames
                        .append(TABLE_ALIAS + "."
                                + field.getAnnotation(Column.class).value())
                        .append(" as ").append(propertyName).append(",");
            }
        }
        fieldNames.deleteCharAt(fieldNames.length() - 1);

        // 拼装SQL
        String sql = "select " + fieldNames + " from " + tableName + " "
                + TABLE_ALIAS;
        PreparedStatement ps = null;
        List<Object> values = null;
        ResultSet rs = null;
        if (sqlWhereMap != null) {
            List<Object> sqlWhereWithValues = getSqlWhereWithValues(sqlWhereMap);
            if (sqlWhereWithValues != null) {
                // 拼接SQL条件
                String sqlWhere = (String) sqlWhereWithValues.get(0);
                sql += sqlWhere;
                // 得到SQL条件中占位符的值
                values = (List<Object>) sqlWhereWithValues.get(1);
            }
        }

        // 设置参数占位符的值
        try {
            if (values != null) {
                ps = JDBCUtils.getConnection().prepareStatement(sql);
                setParameter(values, ps, true);
            } else {
                ps = JDBCUtils.getConnection().prepareStatement(sql);
            }

            // 开启事务
            JDBCUtils.startTransaction();
            // 执行SQL
            rs = ps.executeQuery();
            // 提交事务
            JDBCUtils.commit();
            while (rs.next()) {
                T t = clazz.newInstance();
                initObject(t, fields, rs);
                list.add(t);
            }
        } catch (Exception e) {
            // 回滚 事务
            JDBCUtils.rollback();
            e.printStackTrace();
        } finally {
            /* 关闭连接 */
            if (rs != null) {
                rs.close();
            }

            if (ps != null) {
                ps.close();
            }

            JDBCUtils.close();
        }
        return list;
    }

    /**
     * 根据结果集初始化对象
     */
    private void initObject(T t, Field[] fields, ResultSet rs)
            throws SQLException, IntrospectionException,
            IllegalAccessException, InvocationTargetException {
        for (Field field : fields) {
            String propertyName = field.getName();
            Object paramVal = null;
            Class<?> clazzField = field.getType();
            if (clazzField == String.class) {
                paramVal = rs.getString(propertyName);
            } else if (clazzField == short.class || clazzField == Short.class) {
                paramVal = rs.getShort(propertyName);
            } else if (clazzField == int.class || clazzField == Integer.class) {
                paramVal = rs.getInt(propertyName);
            } else if (clazzField == long.class || clazzField == Long.class) {
                paramVal = rs.getLong(propertyName);
            } else if (clazzField == float.class || clazzField == Float.class) {
                paramVal = rs.getFloat(propertyName);
            } else if (clazzField == double.class || clazzField == Double.class) {
                paramVal = rs.getDouble(propertyName);
            } else if (clazzField == boolean.class
                    || clazzField == Boolean.class) {
                paramVal = rs.getBoolean(propertyName);
            } else if (clazzField == byte.class || clazzField == Byte.class) {
                paramVal = rs.getByte(propertyName);
            } else if (clazzField == char.class
                    || clazzField == Character.class) {
                paramVal = rs.getCharacterStream(propertyName);
            } else if (clazzField == Date.class) {
                paramVal = rs.getTimestamp(propertyName);
            } else if (clazzField.isArray()) {
                paramVal = rs.getString(propertyName).split(","); // 以逗号分隔的字符串
            }
            PropertyDescriptor pd = new PropertyDescriptor(propertyName,
                    t.getClass());
            pd.getWriteMethod().invoke(t, paramVal);
        }
    }

    /**
     * 根据条件，返回sql条件和条件中占位符的值
     * 
     * @param sqlWhereMap
     *            key：字段名 value：字段值
     * @return 第一个元素为SQL条件，第二个元素为SQL条件中占位符的值
     */
    private List<Object> getSqlWhereWithValues(Map<String, Object> sqlWhereMap) {
        if (sqlWhereMap.size() < 1)
            return null;
        List<Object> list = new ArrayList<Object>();
        List<Object> fieldValues = new ArrayList<Object>();
        StringBuffer sqlWhere = new StringBuffer(" where ");
        Set<Entry<String, Object>> entrySets = sqlWhereMap.entrySet();
        for (Iterator<Entry<String, Object>> iteraotr = entrySets.iterator(); iteraotr
                .hasNext();) {
            Entry<String, Object> entrySet = iteraotr.next();
            fieldValues.add(entrySet.getValue());
            Object value = entrySet.getValue();
            if (value.getClass() == String.class) {
                sqlWhere.append(entrySet.getKey()).append(" like ").append("?")
                        .append(" and ");
            } else {
                sqlWhere.append(entrySet.getKey()).append("=").append("?")
                        .append(" and ");
            }
        }
        sqlWhere.delete(sqlWhere.lastIndexOf("and"), sqlWhere.length());
        list.add(sqlWhere.toString());
        list.add(fieldValues);
        return list;
    }

    /**
     * 获得表名
     */
    private String getTableName(Class<?> clazz) throws Exception {
        if (clazz.isAnnotationPresent(Table.class)) {
            Table table = clazz.getAnnotation(Table.class);
            return table.value();
        } else {
            throw new Exception(clazz.getName() + " is not Entity Annotation.");
        }
    }

    /**
     * 设置SQL参数占位符的值
     */
    private void setParameter(List<Object> values, PreparedStatement ps,
            boolean isSearch) throws SQLException {
        for (int i = 1; i <= values.size(); i++) {
            Object fieldValue = values.get(i - 1);
            Class<?> clazzValue = fieldValue.getClass();
            if (clazzValue == String.class) {
                if (isSearch)
                    ps.setString(i, "%" + (String) fieldValue + "%");
                else
                    ps.setString(i, (String) fieldValue);

            } else if (clazzValue == boolean.class
                    || clazzValue == Boolean.class) {
                ps.setBoolean(i, (Boolean) fieldValue);
            } else if (clazzValue == byte.class || clazzValue == Byte.class) {
                ps.setByte(i, (Byte) fieldValue);
            } else if (clazzValue == char.class
                    || clazzValue == Character.class) {
                ps.setObject(i, fieldValue, Types.CHAR);
            } else if (clazzValue == Date.class) {
                ps.setTimestamp(i, new Timestamp(((Date) fieldValue).getTime()));
            } else if (clazzValue.isArray()) {
                Object[] arrayValue = (Object[]) fieldValue;
                StringBuffer sb = new StringBuffer();
                for (int j = 0; j < arrayValue.length; j++) {
                    sb.append(arrayValue[j]).append("、");
                }
                ps.setString(i, sb.deleteCharAt(sb.length() - 1).toString());
            } else {
                ps.setObject(i, fieldValue, Types.NUMERIC);
            }
        }
    }
}

 

 

5、创建jdbcutils类

package b.w.xqp.util;

import java.sql.Connection;
import java.sql.SQLException;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.alibaba.druid.pool.DruidDataSource;

/**
 * JDBC封装类
 * 
 * @author T
 * 
 */
@SuppressWarnings("all")
public class JDBCUtils {
    private static final Logger logger = LoggerFactory
            .getLogger(JDBCUtils.class);

    private static DruidDataSource dataSource = new DruidDataSource();
    // 声明线程共享变量
    public static ThreadLocal container = new ThreadLocal();
    // 配置说明,参考官方网址
    // http://blog.163.com/hongwei_benbear/blog/static/1183952912013518405588/
    static {
        dataSource
                .setUrl("jdbc:mysql://localhost:3306/testdianshang?useUnicode=true&characterEncoding=utf-8");
        dataSource.setUsername("root");// 用户名
        dataSource.setPassword("123456");// 密码
        dataSource.setInitialSize(2);
        dataSource.setMaxActive(20);
        dataSource.setMinIdle(0);
        dataSource.setMaxWait(60000);
        dataSource.setValidationQuery("SELECT 1");
        dataSource.setTestOnBorrow(false);
        dataSource.setTestWhileIdle(true);
        dataSource.setPoolPreparedStatements(false);
    }

    /** 获取链接 */
    public static Connection getConnection() {
        Connection conn = null;
        try {
            conn = dataSource.getConnection();
            logger.debug("{}：链接已经开始", Thread.currentThread().getName());
            container.set(conn);
        } catch (Exception e) {
            logger.error("获取链接失败{}", e);
        }
        return conn;
    }

    /*** 获取当前线程上的连接开启事务 */
    public static void startTransaction() {
        Connection conn = (Connection) container.get();// 首先获取当前线程的连接
        if (conn == null) {// 如果连接为空
            conn = getConnection();// 从连接池中获取连接
            container.set(conn);// 将此连接放在当前线程上
            logger.debug("{}：链接为空，重新获取链接", Thread.currentThread().getName());
        } else {
            try {
                conn.setAutoCommit(false);// 开启事务
                logger.debug("{}：开启事务", Thread.currentThread().getName());
            } catch (Exception e) {
                logger.error("开启事务失败{}", e);
            }
        }
    }

    /** 提交事务 */
    public static void commit() {
        try {
            Connection conn = (Connection) container.get();// 从当前线程上获取连接if(conn!=null){//如果连接为空,则不做处理
            if (null != conn) {
                conn.commit();// 提交事务
                logger.debug("{}：事务已经提交", Thread.currentThread().getName());
            }
        } catch (Exception e) {
            logger.error("事务提交失败{}", e);
        }
    }

    /*** 回滚事务 */
    public static void rollback() {
        try {
            Connection conn = (Connection) container.get();// 检查当前线程是否存在连接
            if (conn != null) {
                conn.rollback();// 回滚事务
                logger.debug("{}：事务已经回滚", Thread.currentThread().getName());
                container.remove();// 如果回滚了,就移除这个连接
                logger.debug("{}：移出当前链接", Thread.currentThread().getName());
            }
        } catch (Exception e) {
            logger.error("事务回滚失败{}", e);
        }
    }

    /*** 关闭连接 */
    public static void close() {
        try {
            Connection conn = (Connection) container.get();
            if (conn != null) {
                conn.close();
                logger.debug("{}：链接关闭", Thread.currentThread().getName());
            }
        } catch (SQLException e) {
            logger.error("链接关闭失败{}", e);
        } finally {
            try {
                container.remove();// 从当前线程移除连接切记
                logger.debug("{}：移出当前链接", Thread.currentThread().getName());
            } catch (Exception ex) {
                logger.error("移出链接失败{}", ex);
            }
        }
    }
}

 

5、测试使用

package b.w.xqp.pojo;

import java.util.Date;

import b.w.xqp.anno.Column;
import b.w.xqp.anno.Id;
import b.w.xqp.anno.Table;

/**
 * 图书
 */
@Table("t_book")
// 表名
public class Book {

    /**
     * 图书编号
     */
    @Id("t_isbn")
    private String isbn;

    /**
     * 书名
     */
    @Column("t_name")
    private String name;

    /**
     * 作者
     */
    @Column("t_author")
    private String author;

    /**
     * 出版社
     */
    @Column("t_publishing")
    private String publishing;

    /**
     * 出版时间
     */
    @Column(value = "t_pubdate")
    private Date pubdate;

    /**
     * 价格
     */
    @Column(value = "t_price")
    private String price;

    public String getIsbn() {
        return isbn;
    }

    public void setIsbn(String isbn) {
        this.isbn = isbn;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getAuthor() {
        return author;
    }

    public void setAuthor(String author) {
        this.author = author;
    }

    public String getPublishing() {
        return publishing;
    }

    public void setPublishing(String publishing) {
        this.publishing = publishing;
    }

    public Date getPubdate() {
        return pubdate;
    }

    public void setPubdate(Date pubdate) {
        this.pubdate = pubdate;
    }

    public String getPrice() {
        return price;
    }

    public void setPrice(String price) {
        this.price = price;
    }

    @Override
    public String toString() {
        return "书名: " + name + " 图书编号: " + isbn + " 作者: " + author + " 出版社: "
                + publishing + " 出版时间: " + pubdate + " 价格: " + price;
    }
}

 

package b.w.xqp.controller;

import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.junit.Test;

import b.w.xqp.dao.base.JdbcGenericDao;
import b.w.xqp.dao.base.JdbcGenericDaoImpl;
import b.w.xqp.pojo.Book;

public class JdbcGenericDaoTest {

    private static JdbcGenericDao<Book> bookDao = new JdbcGenericDaoImpl<Book>();

    @Test
    public void save() throws Exception {
        Book book = new Book();
        book.setAuthor("柳岩");
        book.setIsbn("11");
        book.setName("大的秘籍");
        book.setPrice("12.7");
        book.setPubdate(new Date());
        // book.setPublishing("上海出版社");
        bookDao.save(book);

    }

    @Test
    public void delete() throws Exception {
        bookDao.delete("5", Book.class);
    }

    @Test
    public void update() throws Exception {
        Book book = new Book();
        book.setIsbn("10");
        book.setPublishing("上海出版社");
        bookDao.update(book);
    }

    @Test
    public void testGet() throws Exception {
        System.out.println("\n-------------测试查询一条记录--------------------");
        Book book = bookDao.get("4", Book.class);
        System.out.println(book);
    }

    @Test
    public void testStudentFindAll2() throws Exception {
        System.out
                .println("\n-------------更新、删除前,测试根据条件查询所有记录--------------------");
        Map<String, Object> sqlWhereMap = new HashMap<String, Object>();
        // sqlWhereMap.put("t_isbn", "9787111213826");
        // sqlWhereMap.put("t_name", "Java");
        sqlWhereMap.put("t_publishing", "上海出版社");
        // sqlWhereMap.put("t_pubdate", new Date(new
        // SimpleDateFormat("yyyy-MM-dd HH:mm:ss").parse("2007-01-01 12:06:00").getTime()));
        List<Book> books = bookDao.findAllByConditions(null, Book.class);
        for (Book book : books) {
            System.out.println(book);
        }
    }
}
 

 

x-tang
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
22-05-12 西安 jdbc(02) druid连接池、自己封装的jdbc工具类MyQueryRunner、DButils
m0_56799642的博客
05-14 567
数据库连接池： 连接对象的缓冲区。负责申请，分配管理，释放连接的操作 数据库连接池：javaX.sql.DataSource接口，具体的实现是开源组织。开源万岁！ 用了连接池，我们面对的是连接池,close（）放回到连接池，不再是关闭连接 数据库连接池技术 DBCP 数据库连接池 C3P0 数据库连接池 DRUID 阿里【德鲁伊连接池，用的最多】集DBCP 、C3P0 、Proxool 优点于一身的数据库连接池 创建德鲁伊连接池方式1：不使用properties文件 @T
基于Druid的JDBCUtils类
qq_50230792的博客
03-04 279
基于Druid的JDBCUtils类编写，以及简单的使用。
将JDBCUtils工具类改成Druid实现
最新发布
weixin_43866613的博客
04-10 101
将JDBCUtils工具类改成Druid实现。
Druid工具类的封装v2.0
chengstudying的博客
03-31 94
1.0版本的工具类，不能确保一个线程中的所有方法获取的连接都是同一个，2.0版本基于这一缺点做了改进，工具类改进代码如下。
DruidJDBCUtil工具类(Driuid和JDBC)
Ciao's blog
02-11 228
DruidJDBCUtil工具类(Driuid和JDBC)
druid工具类的封装
qq_57196379的博客
10-09 480
durid封装工具类
Java 中利用泛型和反射机制抽象DAO的实例
08-30
主要介绍了Java 中利用泛型和反射机制抽象DAO的实例的相关资料,需要的朋友可以参考下
java 基于泛型与反射的通用 DAO
11-10
java的基于泛型+反射的通用DAO例子，原创，没事写着玩的，请多指教哈。。。
反射处理java泛型
12-22
它提供了便捷的访问泛型对象类型(java.reflect.Type)的反射方法。 　本文假设你已经了解java反射知识，并能熟练的应用。如果还不了解java反射知识，那么你可以先移步到Oracel反射课程，这可能是你开始学习反射的好...
Java-Java反射与泛型教程
11-13
Java 反射与泛型教程 资源为视频教程资源 希望对你的 Java 学习有所帮助。
深入分析JAVA 反射和泛型
08-19
主要介绍了JAVA 反射和泛型的的相关资料，文中讲解非常细致，代码帮助大家更好的理解和学习，感兴趣的朋友可以了解下
JDBC Template的使用
weixin_43167662的博客
09-16 225
1. 数据库连接池 2. Spring JDBC : JDBC Template ## 数据库连接池 1. 概念：其实就是一个容器(集合)，存放数据库连接的容器。 当系统初始化好后，容器被创建，容器中会申请一些连接对象，当用户来访问数据库时，从容器中获取连接对象，用户访问完之后，会将连接对象归还给容器。 2. 好处： 1. 节约资源 2. 用户访问高效 3. 实现： 1. 标准接口：DataSou...
Druid连接池的使用以及封装CURD方法
qq_36427906的博客
11-16 600
使用德鲁伊连接池之前需要三个jar包 链接: https://pan.baidu.com/s/1iVMoSvpDKZ6qOrWIfCv_PA 提取码: z5hx 复制这段内容后打开百度网盘手机App，操作更方便哦 配置文件db.properties druid.url=jdbc:mysql://localhost:3306/ttt druid.username=root druid.passw...
通过 druid 和 dbutils 封装 数据库操作
时光·漫步的博客
04-21 1126
package com.hq.db; import com.alibaba.druid.pool.DruidDataSource; import com.hq.db.annotation.Column; import com.hq.db.annotation.Exclude; import com.hq.db.annotation.Table; import org.apache.common...
Druid连接池工具类，连接多个不同数据库需求
weixin_30838921的博客
06-08 1503
1.需要连接一系列的数据库 2.数据库会动态改变，比如新增和删除数据库 代码如下： package com.chinaoly.utils; import com.alibaba.druid.pool.DruidDataSource; import com.alibaba.druid.pool.DruidDataSourceFactory; import com.chinaoly...
Druid 连接池 JDBCUtils 工具类的使用
weixin_34314962的博客
03-29 1637
Druid工具介绍 它不仅仅是一个数据库连接池，它还包含一个ProxyDriver，一系列内置的JDBC组件库，一个SQL Parser。 支持所有JDBC兼容的数据库，包括Oracle、MySQL、Derby、Postgresql、SQL Server、H2等等。 Druid针对oracle和mysql做了特别优化，比如Oracle的PS Cache内存占用优化，MySql的ping检测优化。...
封装JdbcUtil工具类，实现自动封装为实体类
srg1011的博客
07-14 1573
根据今天所学，自己写的JdbcUtil工具类。 其中update操作包含增删改，使用事务处理 查询操作分为两种： 1、需要传入sql语句（使用预编译，用？占位）、参数、需要包装的实体类的class路径；返回实体类的list（可以为单个） 2、传入sql、参数。适用于查询基本数据类型组成的list （可以为单个） jdbcUtil.java代码： import java.io.Inpu...
java通过反射机制来创建Dao层通用查询方法
deng着你的博客
04-21 2457
    反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意方法和属性；这种动态获取信息以及动态调用对象方法的功能称为java语言的反射机制。那我们该如何使用呢？我们首先得运用java中的Class类，Class是一个类，一个描述类的类（也就是描述类本身），封装了描述方法的Method，描述字段的Filed，描述构造器的Constructo...
Java之Druid连接池
qq_43336579的博客
11-14 437
使用Druid连接数据库 1.导入核心jar包 druid-1.0.9.jar — DruidDataSource 2.在src目录执行核心配置文件 druid里面内置的属性名字,等号前面的名字不能更改 driverClassName=com.mysql.jdbc.Driver url=jdbc:mysql://localhost:3306/mydb_02 username=root password=123456 连接池的默认配置信息 initialSize=5 初始化连接数量5 maxActive
java 泛型及反射
02-01
泛型和反射在Java中都是非常重要的特性。泛型可以帮助我们编写更加通用和安全的代码，而反射则可以在程序运行时动态地操作对象。两者结合使用可以在某些情况下达到非常灵活的效果。 需要注意的是，泛型和反射虽然在...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值