javaWeb_JDBC_面向對象編程在JDBC中的使用
jdbc中加入對象操作
1.改變
之前的操作都是使用sql語句對數據庫中的表的字段進行一個操作，那個這一個改變的是對一個字段值的操作。那麽我們在實際的開發中，使用的
是對對象的操作，也就是一條記錄就是一個對象，字段就是這一個對象的對應屬性，那麽我們操作這一個對象的時候實際操作的是這一個數據庫
中的記錄。
2.操作步驟
(1).創建對象
創建的對象其實就是和數據庫表中的字段一一對應。
(2).創建數據庫表
根據實體對象(也即是學生對象)編寫數據庫表以及對應的字段。[實體對象與數據庫表之間的對應關系]
(3).創建數據庫操作的工具類
(4).實體操作類
實現對數據庫操作的增刪改查
(5).編寫測試類
3.代碼測試--實現學生對象的增刪查改[僅示例，代碼不可使用]
(1).註意事項1:
要能夠使用基本的sql語句實現基本的增刪改查(能夠在navicat上使用)
(2).代碼實現
//創建學生對象
public class Student {
//id
private int id;
//姓名
private String studentName;
//年齡
private int age;
//籍貫
private String nativePlace;
//無參
public Student(){}
//帶參
public Student(int id,String studentName,int age,String nativePalace){
this.id = id;
this.studentName = studentName;
this.age = age;
this.nativePlace = nativePalace;
}
@Override
public String toString() {
return "Student [id=" + id + ", studentName=" + studentName + ", age="
+ age + ", nativePlace=" + nativePlace + "]";
}
//省略getXxx()和setXxx()方法
}
//封裝了增刪改和數據庫連接以及釋放資源的工具類
public class JDBCTools {
/**
* 執行 SQL 的方法
*
* @param sql: insert, update 或 delete。 而不包含 select
*/
public static void update(String sql) {
Connection connection = null;
Statement statement = null;
try {
// 1. 獲取數據庫連接
connection = getConnection();
// 2. 調用 Connection 對象的 createStatement() 方法獲取 Statement 對象
statement = connection.createStatement();
// 4. 發送 SQL 語句: 調用 Statement 對象的 executeUpdate(sql) 方法
statement.executeUpdate(sql);
} catch (Exception e) {
e.printStackTrace();
} finally {
// 5. 關閉數據庫資源: 由裏向外關閉.
releaseDB(null, statement, connection);
}
}
/**
* 釋放數據庫資源的方法
*
* @param resultSet
* @param statement
* @param connection
*/
public static void releaseDB(ResultSet resultSet, Statement statement,
Connection connection) {
if (resultSet != null) {
try {
resultSet.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if (statement != null) {
try {
statement.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
if (connection != null) {
try {
connection.close();
} catch (SQLException e) {
e.printStackTrace();
}
}
}
/**
* 獲取數據庫連接的方法
*
*/
public static Connection getConnection() throws IOException,
ClassNotFoundException, SQLException {
// 0. 讀取 jdbc.properties
/**
* 1). 屬性文件對應 Java 中的 Properties 類 2). 可以使用類加載器加載 bin 目錄(類路徑下)的文件
*/
Properties properties = new Properties();
InputStream inStream = ReflectionUtils.class.getClassLoader()
.getResourceAsStream("jdbc.properties");
properties.load(inStream);
// 1. 準備獲取連接的 4 個字符串: user, password, jdbcUrl, driverClass
String user = properties.getProperty("user");
String password = properties.getProperty("password");
String jdbcUrl = properties.getProperty("jdbcUrl");
String driverClass = properties.getProperty("driverClass");
// 2. 加載驅動: Class.forName(driverClass)
Class.forName(driverClass);
// 3. 調用
// DriverManager.getConnection(jdbcUrl, user, password)
// 獲取數據庫連接
Connection connection = DriverManager.getConnection(jdbcUrl, user,password);
return connection;
}
}
//測試類
public class JDBCTest {
public static void main(String[] args) {
Student student = new Student();
student.setStudentName("張三");
student.setAge(12);
student.setNativePlace("唐朝");
//------------------
Student student1 = new Student();
student1.setStudentName("李四");
student1.setAge(15);
student1.setNativePlace("宋朝");
//添加
//JDBCTest.addNewStudent(student1);
//刪
//JDBCTest.deleteStudent(student);
//改
//JDBCTest.updateStudent(student1);
//查
Student queryStudent = JDBCTest.searchStudent();
System.out.println("查詢結果是:"+queryStudent);
}
public static Student searchStudent() {
//先定義一個基本sql
String sql = "SELECT * FROM student WHERE ";
@SuppressWarnings("resource")
Scanner scanner = new Scanner(System.in);
System.out.print("請輸入查詢名字:");
String getName = scanner.next();
sql = sql + "studentName = ‘" + getName + "‘";
System.out.println(sql);
Student student = getStudent(sql);
return student;
}
/**
* 根據傳入的 SQL 返回 Student 對象
* @param sql
* @return
*/
public static Student getStudent(String sql) {
Student stu = null;
Connection connection = null;
Statement statement = null;
ResultSet resultSet = null;
try {
connection = JDBCTools.getConnection();
statement = connection.createStatement();
resultSet = statement.executeQuery(sql);
if (resultSet.next()) {
stu = new Student(resultSet.getInt(1), resultSet.getString(2),
resultSet.getInt(3), resultSet.getString(4));
}
} catch (Exception e) {
e.printStackTrace();
} finally {
JDBCTools.releaseDB(resultSet, statement, connection);
}
return stu;
}
public static void updateStudent(Student st){
String sql = "Update student set studentName=‘"
+ st.getStudentName() +"‘,age= "
+ st.getAge() + ",nativePlace=‘"
+ st.getNativePlace() +"‘where studentName=‘"
+ st.getStudentName() + "‘";
System.out.println(sql);
JDBCTools.update(sql);
}
public static void deleteStudent(Student st){
String sql = "delete from student where studentName=‘"
+st.getStudentName()+"‘";
System.out.println(sql);
JDBCTools.update(sql);
}
public static void addNewStudent(Student student) {
// 1. 準備一條 SQL 語句:
String sql = "INSERT INTO student VALUES("
+ student.getId()
+ ",‘" + student.getStudentName()
+ "‘," + student.getAge() + ",‘"
+ student.getNativePlace()+"‘"
+ ")";
System.out.println(sql);
JDBCTools.update(sql);
}
}
//反射類
/**
* 反射的 Utils 函數集合
* 提供訪問私有變量, 獲取泛型類型 Class, 提取集合中元素屬性等 Utils 函數
* @author Administrator
*
*/
public class ReflectionUtils {
/**
* 通過反射, 獲得定義 Class 時聲明的父類的泛型參數的類型
* 如: public EmployeeDao extends BaseDao<Employee, String>
* @param clazz
* @param index
* @return
*/
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 (Class<T>) 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;
}
}
javaWeb_JDBC_面向對象編程在JDBC中的使用