基于数据库，JDBC，DButils的练习：通用DAO练习
先贴代码：
首先是通用接口 DAO.java
package com.gome.day1;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;
public interface DAO<T> {
/**
* 获取总数
* @param conn
* @param sql
* @param clazz
* @param args
* @return
*/
public long getCount(Connection conn, String sql, Object ... args) throws SQLException;
/**
* 查询多个对象组成的 List
* @param conn
* @param sql
* @param clazz
* @param args
* @return
*/
public List<T> getList(Connection conn, String sql, Object ... args) throws SQLException;
/**
* 查询一个对象
* @param conn
* @param sql
* @param clazz
* @param args
* @return
*/
public T get(Connection conn, String sql, Object ... args) throws SQLException;
/**
* 增删改
* @param conn
* @param sql
* @param clazz
* @param args
* @return
*/
public int update(Connection conn, String sql, Object ... args) throws SQLException;
}
然后是实现类 JdbcImpl.java
package com.gome.day1;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;
import org.apache.commons.dbutils.QueryRunner;
import org.apache.commons.dbutils.handlers.BeanHandler;
import org.apache.commons.dbutils.handlers.BeanListHandler;
import org.apache.commons.dbutils.handlers.ScalarHandler;
public class JdbcImpl<T> implements DAO<T> {
private QueryRunner qr = new QueryRunner();
private Class clazz;
public JdbcImpl() {
//获取父类的泛型 ‘类型’
/*Type type = this.getClass().getGenericSuperclass();
ParameterizedType pt = (ParameterizedType) type;
Type[] types = pt.getActualTypeArguments();
clazz = (Class) types[0];*/
//这里使用啦ReflectionUtils工具类来获取父类的泛型 ‘类型’
clazz = ReflectionUtils.getSuperGenericType(this.getClass());
}
@Override
public long getCount(Connection conn, String sql, Object... args) throws SQLException {
return (long) qr.query(conn, sql, new ScalarHandler(), args);
}
@Override
public List<T> getList(Connection conn, String sql, Object... args) throws SQLException {
return qr.query(conn, sql, new BeanListHandler<T>(clazz), args);
}
@Override
public T get(Connection conn, String sql, Object... args) throws SQLException {
return qr.query(conn, sql, new BeanHandler<T>(clazz), args);
}
@Override
public int update(Connection conn, String sql, Object... args) throws SQLException {
return qr.update(conn, sql, args);
}
}
与数据库表中数据对应的meidianmenber11类和多态的处理子类Meidianmenber11DAO
Meidianmenber11.cpp文件
package com.gome.day1;
class Meidianmenber11DAO extends DAOjdbcImpl<Meidianmenber11> {
//获取父类的泛型 ‘类型’，本来写在这里，但是发现可以写在父类的构造器中，这样就更方便啦
/*Type type = this.getClass().getGenericSuperclass();
ParameterizedType pt = (ParameterizedType) type;
Type[] types = pt.getActualTypeArguments();
clazz = (Class) types[0];*/
}
public class Meidianmenber11 {
private int menber_id;
private String menber_name;
private double salary;
public int getMenber_id() {
return menber_id;
}
public void setMenber_id(int menber_id) {
this.menber_id = menber_id;
}
public String getMenber_name() {
return menber_name;
}
public void setMenber_name(String menber_name) {
this.menber_name = menber_name;
}
public double getSalary() {
return salary;
}
public void setSalary(double salary) {
this.salary = salary;
}
@Override
public String toString() {
return "Meidianmenber11 [menber_id=" + menber_id + ", menber_name="
+ menber_name + ", salary=" + salary + "]";
}
}
最后是测试类：DAOTest.java
package com.gome.day1;
import java.sql.Connection;
import java.sql.SQLException;
import java.util.List;
import org.junit.Test;
import com.mchange.v2.c3p0.ComboPooledDataSource;
public class DAOTest {
private ComboPooledDataSource ds = new ComboPooledDataSource("helloc3p0");
@Test
public void test1(){
Meidianmenber11DAO m11dao = new Meidianmenber11DAO();
Connection conn = null;
try {
conn = ds.getConnection();
String sql = "insert into customers(id, name, email, birth) values(?,?,?,?)";
int row = m11dao .update(conn, sql, 21, "周岩", "[email protected]", "1999-9-9");
System.out.println(row);
} catch (SQLException e) {
e.printStackTrace();
} finally {
conn .close();
}
}
@Test
public void test2(){
Meidianmenber11DAO m11dao = new Meidianmenber11DAO();
Connection conn = null;
try {
conn = ds.getConnection();
String sql = "select order_id orderId, order_name orderName, order_date orderDate from `order`";
List<Order> list = m11dao .getList(conn, sql);
for (Order order : list) {
System.out.println(order);
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
conn.close();
}
}
}
还有就是上面代码中用到的反射工具类 ReflectionUtils.java
package com.gome.day1;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
/**
* 反射的 Utils 函数集合
* 提供访问私有变量, 获取泛型类型 Class, 提取集合中元素属性等 Utils 函数
* @author Administrator
*
*/
public class ReflectionUtils {
/**
* 将反射时的 "检查异常" 转换为 "运行时异常"
* @return
*/
public static IllegalArgumentException convertToUncheckedException(Exception ex){
if(ex instanceof IllegalAccessException || ex instanceof IllegalArgumentException
|| ex instanceof NoSuchMethodException){
throw new IllegalArgumentException("反射异常", ex);
}else{
throw new IllegalArgumentException(ex);
}
}
/**
* 通过反射, 获得定义 Class 时声明的父类的泛型参数的类型
* 如: public EmployeeDao extends BaseDao<Employee, String>
* @param clazz
* @param index
* @return
*/
@SuppressWarnings("unchecked")
public static Class getSuperClassGenricType(Class clazz, int index){
Type genType = clazz.getGenericSuperclass();
if(!(genType instanceof ParameterizedType)){
return Object.class;
}
Type [] params = ((ParameterizedType)genType).getActualTypeArguments();
if(index >= params.length || index < 0){
return Object.class;
}
if(!(params[index] instanceof Class)){
return Object.class;
}
return (Class) params[index];
}
/**
* 通过反射, 获得 Class 定义中声明的父类的泛型参数类型
* 如: public EmployeeDao extends BaseDao<Employee, String>
* @param <T>
* @param clazz
* @return
*/
@SuppressWarnings("unchecked")
public static<T> Class<T> getSuperGenericType(Class clazz){
return getSuperClassGenricType(clazz, 0);
}
/**
* 循环向上转型, 获取对象的 DeclaredMethod
* @param object
* @param methodName
* @param parameterTypes
* @return
*/
public static Method getDeclaredMethod(Object object, String methodName, Class<?>[] parameterTypes){
for(Class<?> superClass = object.getClass(); superClass != Object.class; superClass = superClass.getSuperclass()){
try {
//superClass.getMethod(methodName, parameterTypes);
return superClass.getDeclaredMethod(methodName, parameterTypes);
} catch (NoSuchMethodException e) {
//Method 不在当前类定义, 继续向上转型
}
//..
}
return null;
}
/**
* 使 filed 变为可访问
* @param field
*/
public static void makeAccessible(Field field){
if(!Modifier.isPublic(field.getModifiers())){
field.setAccessible(true);
}
}
/**
* 循环向上转型, 获取对象的 DeclaredField
* @param object
* @param filedName
* @return
*/
public static Field getDeclaredField(Object object, String filedName){
for(Class<?> superClass = object.getClass(); superClass != Object.class; superClass = superClass.getSuperclass()){
try {
return superClass.getDeclaredField(filedName);
} catch (NoSuchFieldException e) {
//Field 不在当前类定义, 继续向上转型
}
}
return null;
}
/**
* 直接调用对象方法, 而忽略修饰符(private, protected)
* @param object
* @param methodName
* @param parameterTypes
* @param parameters
* @return
* @throws InvocationTargetException
* @throws IllegalArgumentException
*/
public static Object invokeMethod(Object object, String methodName, Class<?> [] parameterTypes,
Object [] parameters) throws InvocationTargetException{
Method method = getDeclaredMethod(object, methodName, parameterTypes);
if(method == null){
throw new IllegalArgumentException("Could not find method [" + methodName + "] on target [" + object + "]");
}
method.setAccessible(true);
try {
return method.invoke(object, parameters);
} catch(IllegalAccessException e) {}
return null;
}
/**
* 直接设置对象属性值, 忽略 private/protected 修饰符, 也不经过 setter
* @param object
* @param fieldName
* @param value
*/
public static void setFieldValue(Object object, String fieldName, Object value){
Field field = getDeclaredField(object, fieldName);
if (field == null)
throw new IllegalArgumentException("Could not find field [" + fieldName + "] on target [" + object + "]");
makeAccessible(field);
try {
field.set(object, value);
} catch (IllegalAccessException e) {}
}
/**
* 直接读取对象的属性值, 忽略 private/protected 修饰符, 也不经过 getter
* @param object
* @param fieldName
* @return
*/
public static Object getFieldValue(Object object, String fieldName){
Field field = getDeclaredField(object, fieldName);
if (field == null)
throw new IllegalArgumentException("Could not find field [" + fieldName + "] on target [" + object + "]");
makeAccessible(field);
Object result = null;
try {
result = field.get(object);
} catch (IllegalAccessException e) {}
return result;
}
}
项目添加的.jar文件与配置文件
