jdbc

day21

sql.properties

UPDATE_CUSTOMER=UPDATE customers SET name = ? WHERE id = ?

c3p0-config.xml

<?xml version="1.0" encoding="UTF-8"?>
<c3p0-config>

	<named-config name="helloc3p0">
		
		<!-- 指定连接数据源的基本属性 -->
		<property name="user">root</property>
		<property name="password">1230</property>
		<property name="driverClass">com.mysql.jdbc.Driver</property>
		<property name="jdbcUrl">jdbc:mysql:///atguigu</property>
		
		<!-- 若数据库中连接数不足时, 一次向数据库服务器申请多少个连接 -->
		<property name="acquireIncrement">5</property>
		<!-- 初始化数据库连接池时连接的数量 -->
		<property name="initialPoolSize">5</property>
		<!-- 数据库连接池中的最小的数据库连接数 -->
		<property name="minPoolSize">5</property>
		<!-- 数据库连接池中的最大的数据库连接数 -->
		<property name="maxPoolSize">10</property>

		<!-- C3P0 数据库连接池可以维护的 Statement 的个数 -->
		<property name="maxStatements">20</property>
		<!-- 每个连接同时可以使用的 Statement 对象的个数 -->
		<property name="maxStatementsPerConnection">5</property>
	
	</named-config>
		
</c3p0-config>

dbcp.properties

username=root
password=1230
driverClassName=com.mysql.jdbc.Driver
url=jdbc:mysql:///atguigu

initialSize=10
maxActive=50
minIdle=5
maxWait=5000

jdbc.properties

driverClass=oracle.jdbc.driver.OracleDriver
jdbcUrl=jdbc:oracle:thin:@localhost:1521:orcl
user=scott
password=java

#driver=com.mysql.jdbc.Driver
#jdbcUrl=jdbc:mysql://localhost:3306/atguigu
#user=root
#password=1230

ReflectionUtils.java

package com.atguigu.jdbc;

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 {
   

	
	/**
	 * 通过反射, 获得定义 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) {
   
			System.out.println("不可能抛出的异常");
		} 
		
		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) {
   
			System.out.println("不可能抛出的异常");
		}
	}
	
	/**
	 * 直接读取对象的属性值, 忽略 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) {
   
			System.out.println("不可能抛出的异常");
		}
		
		return result;
	}
}

Customer.java

package com.atguigu.jdbc;

import java.sql.Date;

public class Customer {
   

	private Integer id;
	private String name;
	private String email;
	private Date birth;

	public Integer getId() {
   
		return id;
	}

	public void setId(Integer id) {
   
		this.id = id;
	}

	public String getCustomerName() {
   
		return name;
	}

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

	public String getEmail() {
   
		return email;
	}

	public void setEmail(String email) {
   
		this.email = email;
	}

	public Date getBirth() {
   
		return birth;
	}

	public void setBirth(Date birth) {
   
		this.birth = birth;
	}

	@Override
	public String toString() {
   
		return "Customer [id=" + id + ", name=" + name + ", email=" + email
				+ ", birth=" + birth + "]";
	}

	public Customer(Integer id, String name, String email, Date birth) {
   
		super();
		this.id = id;
		this.name = name;
		this.email = email;
		this.birth = birth;
	}
	
	public Customer() {
   
		// TODO Auto-generated constructor stub
	}

}

CustomerDao.java

package com.atguigu.jdbc;

public class CustomerDao 
	extends JdbcDaoImpl<Customer>{
   
	
}

CustomerDaoTest.java

package com.atguigu.jdbc;

import static org.junit.Assert.*;

import java.sql.Connection;

import org.junit.Test;

public class CustomerDaoTest {
   

	CustomerDao customerDao = new CustomerDao();
	
	@Test
	public void testBatch() {
   
		fail("Not yet implemented");
	}

	@Test
	public void testGetForValue() {
   
		fail("Not yet implemented");
	}

	@Test
	public void testGetForList() {
   
		fail("Not yet implemented");
	}

	@Test
	public void testGet()