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;
}
}

原文地址：https://www.cnblogs.com/nwxayyf/p/10350603.html

时间： 2024-10-13 01:30:39

javaWeb_JDBC_面向对象编程在JDBC中的使用的相关文章

js面向对象编程：if中能够使用那些作为推断条件呢？

   在全部编程语言中if是最长用的推断之中的一个.但在js中究竟哪些东西能够在if中式作为推断表达式呢? 比如怎样几行,仅仅是少了一个括号.真假就全然不同.究竟表示什么含义呢 var obj={}; obj.Funtext=function(){}; if(obj.Funtext) { alert("true obj.Funtext;"); } else { alert("false obj.Funtext"); } obj.Funtext=function(){

js面向对象编程：if中可以使用那些作为判断条件呢？

作者来源http://www.2cto.com/kf/201407/314978.html搬运 在所有编程语言中if是最长用的判断之一,但在js中到底哪些东西可以在if中式作为判断表达式呢? 例如如何几行,只是少了一个括号,真假就完全不同,到底表示什么含义呢 ? 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 var obj={};  obj.Funtext=function(){};     if(obj.Funtext)    {      a

LY.JAVA面向对象编程.工具类中使用静态、说明书的制作过程

2018-07-08 获取数组中的最大值 某个数字在数组中第一次出现时的索引 制作说明书的过程 对工具类的使用 获取数组中的最大值 获取数字在数组中第一次出现的索引值 原文地址:https://www.cnblogs.com/twinkle-star/p/9279622.html

基于表的Lua原生支持面向对象编程在GUI中的使用示例

http://blog.csdn.net/cnjet/article/details/5974212 lua真的有很多神奇的用法,下面是一个基于表的形式实现的对于GUI的定义.支持事件响应等. 可以在线(http://www.lua.org/cgi-bin/demo)测试运行效果. [cpp] view plaincopy -- Canvas Canvas = { ["frame_msg.OFrame"] = { skin="Engine//Standard.OSkin1St

面向对象编程思想(前传)--你必须知道的javascript（转载）

原文地址:http://www.cnblogs.com/zhaopei/p/6623460.html阅读目录 什么是鸭子类型 javascript的面向对象 封装 继承 多态 原型 this指向 call apply band js中的闭包 什么是高阶函数 在写面向对象编程思想-设计模式中的js部分的时候发现很多基础知识不了解的话,是很难真正理解和读懂js面向对象的代码.为此,在这里先快速补上.然后继续我们的面向对象编程思想-设计模式. 什么是鸭子类型 javascript是一门典型的动态类型语

python学习之路-第七天-python面向对象编程简介

面向对象编程 在python中,同样是类和对象作为重要的组成部分. 而且在python中基本数据类型如int都是有封装类的,都有自己的方法,应该是和java里面的Integer类似吧 类包括域和方法:域也就是类或对象中的变量,方法就是类里面声明的函数 self关键字: 相当于java中的this,下面是个例子: #!/usr/bin/python # Filename: method.py class Person: def sayHi(self): print 'Hello, how are

Python 面向对象编程基础

活在当下的程序员应该都听过“面向对象编程”一词,也经常有人问能不能用一句话解释下什么是“面向对象编程”,我们先来看看比较正式的说法. 把一组数据结构和处理它们的方法组成对象(object),把相同行为的对象归纳为类(class),通过类的封装(encapsulation)隐藏内部细节,通过继承(inheritance)实现类的特化(specialization)和泛化(generalization),通过多态(polymorphism)实现基于对象类型的动态分派. 这样一说是不是更不明白了.所以

面向对象编程中的设计模式

面向对象编程中的设计模式 最近在复习(预习)软考,看到了设计模式这个知识点,打算小做总结一下~~ 设计模式分为三种类型,共23种.(红色标注常用的) 创建型模式:单例模式.抽象工厂模式.建造者模式.工厂模式.原型模式. 结构型模式:适配器模式.桥接模式.装饰模式.组合模式.外观模式.享元模式.代理模式. 行为型模式:模版方法模式.命令模式.迭代器模式.观察者模式.中介者模式.备忘录模式.解释器模式(Interpreter模式).状态模式.策略模式.职责链模式(责任链模式).访问者模式.

关于java中面向对象编程的一点点小感悟！！！

断断续续接触java已经有半年的时间,当然中间也有过很多事情,不得已而中断了java的学习.当初刚刚接触到java的时候,总是不能理解java的面向对象编程优点.平常生活中我们做事情的思维方式都是面向过程的,就拿最简单的我要上一个培训班来说: 第一步:当然得是网上.贴吧.朋友的口中来了解这个辅导班,以此来决定是否需要上这个辅导班. 第二步:当然就是当了解完成之后,对这个辅导班比较满意.自己就需要做准备来达到辅导班的要求,比如说学费.复习知识,准备参加辅导班规定的考试. 第三步:当然就是付诸实践,