jdbc的连接数据库，使用PreparedStatement实现增删改查等接口

首先是连接，关闭资源等数据库操作

将连接数据库，关闭资源封装在JDBCUtils里

package jdbc.utils;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;

public class JDBCUtils {
    //获取数据库连接函数
    public static Connection getConnection() throws Exception {
        Class clazz=Class.forName("com.microsoft.sqlserver.jdbc.SQLServerDriver");
        String url = "jdbc:sqlserver://localhost:1433;databaseName=EDUCATION";
        Connection con = DriverManager.getConnection(url,"sa","1");
        System.out.println("连接成功");
        return con;
    }
    //关闭连接和操作指针
    public static void closeResource(Connection con,PreparedStatement ps) {
        try {
            if(ps != null)
                ps.close();
        }
        catch(Exception ex) {
            ex.printStackTrace();
        }
        try {
            if(con != null)
                con.close();
        }
        catch(Exception ex) {
            ex.printStackTrace();
        }
    }

    //关闭连接，信使，结果集
    public static void closeResource(Connection con,PreparedStatement ps,ResultSet resultSet) {
        try {
            if(ps != null)
                ps.close();
        }
        catch(Exception ex) {
            ex.printStackTrace();
        }
        try {
            if(con != null)
                con.close();
        }
        catch(Exception ex) {
            ex.printStackTrace();
        }
        try {
            if(resultSet != null)
                resultSet.close();
        }
        catch(Exception ex) {
            ex.printStackTrace();
        }
    }
}

使用PreparedStatement对数据库进行单条的增删改等操作以及通用的操作

package jdbc_practice.preparedstatement.crud;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import jdbc.utils.JDBCUtils;;

/*
 * PreparedStatement代替Statement， 实现对数据库增删改
 * */

public class PreparedStatementUpdateTest {
    //增加class的一条记录
    public static void testAdd() {
        Connection con=null;
        PreparedStatement ps=null;
        try {
            con=JDBCUtils.getConnection();

            String sql="insert into class values(?,?)";
            ps=con.prepareStatement(sql);
            ps.setObject(1,"030103");
            ps.setObject(2, "物联网");
            ps.execute();
            System.out.println("增加成功");
        }
        catch(Exception ex) {
            ex.printStackTrace();
        }
        finally {
            JDBCUtils.closeResource(con, ps);
        }
    }
    //修改class的一条记录
    public static void testUpdate(){
        Connection con=null;
        PreparedStatement ps=null;
        try {
            con = JDBCUtils.getConnection();

            //建立信使ps，预编译sql语句
            String sql = "update class set cName = ? where classId = ?";
            ps = con.prepareStatement(sql);

            //填充占位符
            ps.setObject(1, "数媒");
            ps.setObject(2, "030100");

            //执行
            ps.execute();
            System.out.println("修改成功");
        }
        catch(Exception e) {
            e.printStackTrace();
        }
        finally {
            JDBCUtils.closeResource(con, ps);
        }
    }
    //删除class的一条记录
    public static void testDelete() {
        Connection con=null;
        PreparedStatement ps=null;
        try {
            con=JDBCUtils.getConnection();

            String sql="delete class where cName=?";
            ps=con.prepareStatement(sql);
            ps.setObject(1,"计科");
            ps.execute();
            System.out.println("删除成功");
        }
        catch(Exception ex) {
            ex.printStackTrace();
        }
        finally {
            JDBCUtils.closeResource(con, ps);
        }
    }

    //通用增删改，参数为预编译的sql，和可变形参args用来充当占位符
    public static void update(String sql,Object ...args) {
        Connection con = null;
        PreparedStatement ps=null;
        try {
            //1.获取连接
            con=JDBCUtils.getConnection();
            //2.预编译sql，返回ps实例
            ps=con.prepareStatement(sql);
            //填充占位符，sql中的占位符个数=args数组长度
            for(int i=0;i<args.length;i++) {
                ps.setObject(i+1, args[i]);
            }
            //4.执行
            ps.execute();

            System.out.println("执行成功 ");
        }
        catch (Exception ex) {
            ex.printStackTrace();
        }
        finally {
            //5.关闭资源
            JDBCUtils.closeResource(con, ps);
        }
    }

    //对上述三种操作进行测试
    public static void main(String []args) {
        String sql="insert into class values(?,?)";
        String s1,s2;
        s1="030104";
        s2="计创";
        update(sql,s1,s2);

        sql="delete from class where cName=?";
        s1="计创";
        update(sql,s1);

        sql="update class set cName=? where classId=?";
        s1="计创";
        s2="030102";
        update(sql,s1,s2);
    }
}

使用PreparedStatement对表进行通用查询操作，即查询字段args是个可变参数

package jdbc_practice.preparedstatement.crud;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;

import java.lang.reflect.Field;

import jdbc.utils.*;
import bean.Class;

public class ClassforQuery {
    //对表的通用查询操作：即查询字段是个可变参数
    public static Class queryForClass(String sql,Object...args) {
        Connection con = null;
        PreparedStatement ps=null;
        ResultSet res = null;
        try {
            con=JDBCUtils.getConnection();
            ps=con.prepareStatement(sql);
            for(int i=0;i<args.length;i++) {
                ps.setObject(i+1, args[i]);
            }

            res=ps.executeQuery();
            //获取结果集的元数据 ，元数据指的是每个列的列名，String name = "Tom",String 和name是修饰Tom的元数据
            ResultSetMetaData rsmd = res.getMetaData();
            //通过rsmd来获取结果集中的列数
            int col = rsmd.getColumnCount();
            if(res.next()) {
                Class clazz = new Class();
                //处理一行数据中的每一个列
                for(int i=0;i<col;i++) {
                    //获取每个列的属性值
                    Object value = res.getObject(i+1);
                    //获取每个列的列名
                    String colName = rsmd.getColumnName(i+1);
                    //给clazz对象的colName属性，赋值为value：通过反射
                    Field field = Class.class.getDeclaredField(colName);//先拿到属性名为colName的属性
                    field.setAccessible(true);//将属性设置为可访问
                    field.set(clazz, value);//修改该对象的该属性值为value
                }
                System.out.println("执行成功");
                return clazz;
            }
        }
        catch(Exception ex) {
            ex.printStackTrace();
        }
        finally {//finally块在return执行之后，return返回之前执行
            JDBCUtils.closeResource(con, ps, res);
        }
        return null;
    }

    public static void main(String []args) {
        String sql = "select classId,cName from class where classId = ?";
        String arg1 = "030100",arg2 = "";
        Class clazz = queryForClass(sql,arg1);
        System.out.println(clazz);
    }
}

对单表查询的升级，解决了数据库表的列名和java类名不同的情况

package jdbc_practice.preparedstatement.crud;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;

import bean.Student;
import jdbc.utils.JDBCUtils;
import java.lang.reflect.Field;

public class StudentForQuery {
    public static Student queryForStudent(String sql,Object...args) {
        Connection con = null;
        PreparedStatement ps = null;
        ResultSet res = null;
        try {
            con=JDBCUtils.getConnection();
            ps=con.prepareStatement(sql);
            for(int i=0;i<args.length;i++) {
                ps.setObject(i+1, args[i]);
            }
            //获得数据集和元数据集
            res = ps.executeQuery();
            ResultSetMetaData rsmd = res.getMetaData();
            int col = rsmd.getColumnCount();

            if(res.next()) {
                Student stu = new Student();
                for(int i=0;i<col;i++) {
                    Object value = res.getObject(i+1);          //要获得的数据值
                    String colLabel = rsmd.getColumnLabel(i+1);    //要获得的元数据名称

                    Field field = Student.class.getDeclaredField(colLabel);//这里要用Label以解决数据库表类名称和类属性名不同的情况
                    field.setAccessible(true);
                    field.set(stu,value);
                }

                System.out.println("执行成功");
                return stu;
            }

        }
        catch(Exception ex) {
            ex.printStackTrace();
        }
        finally {
            JDBCUtils.closeResource(con, ps, res);
        }

        return null;
    }

    public static void main(String[]args) {
        String sql = "select stuId as studentId,stuName as studentName from student where stuName = ?";
        String arg = "李军";
        Student stu = queryForStudent(sql,arg);
        System.out.println(stu);
    }
}

使用PreparedStatement实现对不同表的通用的返回一个对象的查询操作

以及使用ArrayList返回对不同表的通用的返回多个对象的查询操作

package jdbc_practice.preparedstatement.crud;

import java.lang.reflect.*;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.util.ArrayList;
import java.util.List;

import bean.Student;
import jdbc.utils.JDBCUtils;

public class PreparedStatementQueryTest {
    //使用PreparedStatement实现对不同表的通用的返回一个对象的查询操作
    //使用泛型机制，参数里先传入一个类的类型
    public static <T> T getInstance(Class<T> clazz,String sql,Object...args) {
        Connection con = null;
        PreparedStatement ps = null;
        ResultSet res = null;
        try {
            con=JDBCUtils.getConnection();
            ps=con.prepareStatement(sql);
            for(int i=0;i<args.length;i++) {
                ps.setObject(i+1, args[i]);
            }

            //获得数据集和元数据集
            res = ps.executeQuery();
            ResultSetMetaData rsmd = res.getMetaData();
            int col = rsmd.getColumnCount();

            if(res.next()) {
                T t = clazz.newInstance();
                for(int i=0;i<col;i++) {
                    Object value = res.getObject(i+1);          //要获得的数据值
                    String colLabel = rsmd.getColumnLabel(i+1);    //要获得的元数据名称

                    //通过反射给t对象指定的colName属性赋值为value
                    Field field = clazz.getDeclaredField(colLabel);
                    field.setAccessible(true);
                    field.set(t,value);
                }

                System.out.println("执行成功");
                return t;
            }

        }
        catch(Exception ex) {
            ex.printStackTrace();
        }
        finally {
            JDBCUtils.closeResource(con, ps, res);
        }

        return null;
    }

    //返回对不同表的通用的返回多个对象的查询操作
    public static <T> ArrayList<T> getForList(Class<T> clazz,String sql,Object...args){
        Connection con = null;
        PreparedStatement ps = null;
        ResultSet res = null;
        try {
            con=JDBCUtils.getConnection();
            ps=con.prepareStatement(sql);
            for(int i=0;i<args.length;i++) {
                ps.setObject(i+1, args[i]);
            }

            //获得数据集和元数据集
            res = ps.executeQuery();
            ResultSetMetaData rsmd = res.getMetaData();
            int col = rsmd.getColumnCount();

            ArrayList<T> list = new ArrayList<T>();
            while(res.next()) {
                T t = clazz.newInstance();
                for(int i=0;i<col;i++) {
                    Object value = res.getObject(i+1);          //要获得的数据值
                    String colLabel = rsmd.getColumnLabel(i+1);    //要获得的元数据名称

                    //通过反射给t对象指定的colName属性赋值为value
                    Field field = clazz.getDeclaredField(colLabel);
                    field.setAccessible(true);
                    field.set(t,value);
                }

                list.add(t);
            }
            System.out.println("执行成功");
            return list;
        }
        catch(Exception ex) {
            ex.printStackTrace();
        }
        finally {
            JDBCUtils.closeResource(con, ps, res);
        }

        return null;
    }

    public static void main(String []args) {
        String sql = "select stuName as studentName,stuId as studentId from student where stuId = ?";
        String arg = "101";

        Student stu = getInstance(Student.class,sql,arg);
        System.out.println(stu);

        sql = "select stuId as studentId,stuName as studentName from student where stuId > ?";
        arg = "0";
        ArrayList<Student> list = getForList(Student.class, sql, arg);
        list.forEach(System.out::println);

    }
}

原文地址：https://www.cnblogs.com/zsben991126/p/11846262.html

时间： 2024-08-14 05:55:42

jdbc的连接数据库，使用PreparedStatement实现增删改查等接口的相关文章

PHP连接数据库实现对网页内容增删改查

例子: $db = new MySQLi("localhost","root","","mydb"); !mysqli_connect_error() or die ("连接失败!"); $sql="select * from Info,Nation where Info.Nation=Nation.Code"; $result = $db->query($sql); if($re

myeclipse中JDBC连接mysql和简单的增删改查

废话不多说,直接上操作图,操作起来理解会更彻底 1.myeclipse中项目结构,先在web-inf-lib下导入jar包,注意Web App Libraries这个目录,下面会有用到的地方 2.连接语句 package utils; import java.sql.Connection;import java.sql.DriverManager;import java.sql.PreparedStatement;import java.sql.ResultSet;import java.sql

用JDBC连接 数据库 进行简单的增删改查

JDBC为java的基础.用jdbc实现对数据库的增删改查的功能是程序员的基本要求.本例以mysql为例,首先要使用本例需要添加mysql-connector-java-5.1.7-bin.jar包.专门用来加载jdbc的驱动.如果数据库为oracle,相应的jar包换为ojdbc6.jar. 通过下面的代码可以练习一下,掌握jdbc的使用方法,自己可以对程序进行相应的扩展,可以试试oracle数据库,也可以试试MongoDB,还可以试试redis等. package jdbc; import

使用DbUtils实现增删改查——ResultSetHandler 接口的实现类

在上一篇文章中<使用DbUtils实现增删改查>,发现运行runner.query()这行代码时.须要自己去处理查询到的结果集,比較麻烦.这行代码的原型是: public Object query(Connection conn, String sql, ResultSetHandler<T> rsh, Object... params) 当中ResultSetHandler是一个接口,实际上.万能的Apache已经为我们提供了众多好用的实现类,如今举比例如以下: public c

JDBC之Java连接mysql实现增删改查

使用软件:mysql.eclipse 链接步骤: 1.注册驱动 2.创建一个连接对象 3.写sql语句 4.执行sql语句并返回一个结果或者结果集 5.关闭链接(一般就是connection.statement.setresult)这三个连接对象,关闭顺序一般是(setresult    --->  statement  -->  setresult  ) 一.直接连接方法:(这种方法就是讲sql语句和结果所有的步骤写在一起) 不建议使用该方法 1 public static void mai

3月9日 连接数据库（简单的增删改查）

1.增加: //增加    private void button2_Click(object sender, EventArgs e)    {         string uname=textBox2.Text;        string upass=textBox1.Text; SqlConnection conn = new SqlConnection("server=.;database=data1220;user=sa;pwd=sa");        conn.Ope

使用JDBC分别利用Statement和PreparedStatement来对MySQL数据库进行简单的增删改查以及SQL注入的原理

一.MySQL数据库的下载及安装 https://www.mysql.com/ 点击DOWNLOADS,拉到页面底部,找到MySQL Community(GPL)Downloads,点击 选择下图中的MySQL Community Server 选择想要的版本进行下载 之后的步骤,因为本人已经安装过MySQL数据库,而卸载重装会比较麻烦,卸载不干净会导致新的装不上,所以可以参考下面的博客,因为官网的改动,前面的部分已经与该博客不符,按照本人在上面的介绍寻找即可 https://blog.csdn

Statement与 PreparedStatement(增删改查)区别及代码

1.Statement与 PreparedStatement的区别 (1)数据库在执行 sql 语句的时候如果使用 PreparedStatement 语句会有一点优势:因为数据库会对 preparedStatement 语句进行预编译,下次执行相同的 sql 语句时,数据库端不会再进行预编译了,而直接用数据库的缓冲区,提高数据访问的效率 (2)使用 Statement 对象.在对数据库只执行一次性存取的时侯,用 Statement 对象进行处理.PreparedStatement 对象的开销比

SSH中增删改查的封装实现

我们在使用SSH的时候,比如说User.Admin等实体对象,都有共同的增删改查方法,那么我们如何实现哪,看下边的例图: 这种类型的结构图,大家在开中可能会经常行的用到,例如下边这个项目实例: 其中: (1)BaseDao是增删改查的接口定义,是一个父接口,下边的UserDao和RoleDao都会继承该接口: (2)BaseDaoImpl是增删改查接口的实现类,是一个父类,下边的UserDaoImpl和RoleDaoImpl都继承了该接口: (3)UserDao和RoleDao就是他们自己的方法