总结基于mysql，oracle的jdbc对数据库的操作（增删查改，批量操作，事务）

最新推荐文章于 2022-10-30 17:51:31 发布
最新推荐文章于 2022-10-30 17:51:31 发布
阅读量1.3k 收藏 1
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shenbushen/article/details/51095784
版权

jdbc对数据库的操作对于java web来说是非常重要的，当然现在有很多操作数据库的框架供我们操作，但是究其根本，都是封装了jdbc的：所以我把它总结总结我的使用方法：

主要的几个对象：    PreparedStatement ps = conn.prepareStatement(sql);             查询使用：ResultSet rs = ps.executeQuery();    增删改使用：ps.executeUpdate()


我一般使用一个静态类（也可不静态）,来封装数据库的直接操作：

public class sqlDao {

 private static final String Driver = "com.mysql.jdbc.Driver";                    //驱动
 private static final String Url = "jdbc:mysql://localhost:3309/sshtext?useUnicode=true&characterEncoding=gbk";     //为了应对乱码加了后面的编码
 pvate static final String Username = "root";                                                                                                         //账号
 private static final String Password = "123456";                                                                                                //密码


private Connection conn = null;

public void connect() {                            //连接
 try {
  Class.forName(Driver);
  conn = (Connection) DriverManager.getConnection(Url, Username, Password);
  if (conn.isClosed()) {
   System.out.println("connect  not success");
   conn = null;
  }
 } catch (ClassNotFoundException e) {
  // TODO Auto-generated catch block
  e.printStackTrace();
 } catch (SQLException e) {
  // TODO Auto-generated catch block
  e.printStackTrace();
 }
}

public void closeConn() {                              //关闭
 try {
  if (conn != null && !conn.isClosed()) {
   conn.close();
  }
 } catch (SQLException e) {
  // TODO Auto-generated catch block
  e.printStackTrace();
 }
}


///华丽分界线/

增删查找：


///查找：

//类似登录，检测，查重，列出数据等等业务操作


 public String Login(AccountMessage account) {               //传入一个实体类
  boolean flag = false;
  // TODO MODIFY
  String temp = "";
  connect();
  try {
   String sql = "SELECT * FROM tb_user WHERE user_id = ? AND password = ?;";                   //定义sql语句，使用占位符
   PreparedStatement ps = conn.prepareStatement(sql);
   ps.setString(1, account.getUsername());                                                                                 //设置占位符的数据
   ps.setString(2, account.getPassword());
   ResultSet rs = ps.executeQuery();                                                                                         //执行查询
   if (rs != null && rs.next()) {                                                                                                      //若查询非空，且有数据
    flag = true;
    temp = rs.getString(2);                                                                                                           //通过rs.getString(index)的方式获取查询行列的数据
    temp = temp + ":";
    temp = temp + rs.getString(4);
    temp = temp + ":";
    temp = temp + rs.getString(5);
   }
  } catch (SQLException e) {
   e.printStackTrace();
  } finally {
   closeConn();
  }
  return temp;
 }



///增加：主要是注册啊,写进记录等

public boolean tieNeiRong(TieziMessage tiezi) {
  boolean flag = false;
  connect();
  String sql = "INSERT INTO tb_tie(tie_id,username,leibie, content, lujin, time) VALUES(?,?,?,?,?,?);";
  try {
   PreparedStatement ps = conn.prepareStatement(sql);
   ps.setString(1, tiezi.gettie_Id());
   ps.setString(2, tiezi.getUsername());
   ps.setString(3, tiezi.getleibie());
   ps.setString(4, tiezi.gettie_content());
   ps.setString(5, tiezi.getlujin());
   ps.setString(6, tiezi.gettime());
   if (ps.executeUpdate() == 1) {
    flag = true;
   }
  } catch (SQLException e) {
   // TODO Auto-generated catch block
   e.printStackTrace();
  }

  return flag;
 }


删除

public boolean Delete_tiezi(int tie_id) {
  connect();
  boolean flag = false;
   try {
    String sql ="delete  from tb_tie where tie_id ="+tie_id+";";                        //直接拼字符串
    PreparedStatement ps = conn.prepareStatement(sql);
  
    //ps.setInt(1, tie_id);                                                                                 //占位符
    
    if (ps.executeUpdate(sql)== 1) {
     flag = true;
    }
   } catch (SQLException e) {
    e.printStackTrace();
   } finally {
    closeConn();
   }
  
  
  return flag;
 }



//修改

 public boolean UpdateMsg(String username, String nickname, String sex) {
  boolean flag = false;
  connect();
  try {
   String sql = "UPDATE tb_user SET username = ?, sex = ? WHERE user_id = ?";
   PreparedStatement ps = conn.prepareStatement(sql);
   ps.setString(1, nickname);
   ps.setString(2, sex);
   ps.setString(3, username);
   if (ps.executeUpdate() == 1) {
    flag = true;
   }
  } catch (SQLException e) {
   e.printStackTrace();
  } finally {
   closeConn();
  }

  return flag;
 }



会了简单增删改,还得会批量增删查改,这涉及到数据库事务的管理了，再批量增删查改时，如果是一条一条提交，然后在中间突然出现错误，后面的没有提交，这就会造成部分数据增删查改，部分没有执行，这肯定是不行的

//批量删除的例子：前台传来一条用户账号组成的字符串,我们把他转换成整形数组，然后整形数组传进来


public boolean deletebyuser_ids(int ids[]) throws SQLException     //出错回滚
{
 connect();
 
 try {
  conn.setAutoCommit(false);    //设置手动提交
  String sql="delete from user_role where user_id=?;";
  PreparedStatement ps =  (PreparedStatement) conn.prepareStatement(sql);
 for(int i=0;i<ids.length;i++)
 { 
  
   ps.setInt(1, ids[i]);
   ps.addBatch();
 }

//ps.addBatch("sql语句");             //添加静态的sql语句

  ps.executeBatch();
   try {
    conn.commit();     //手动 提交
   } catch (SQLException e1) {
    conn.rollback();         //出错回滚
    return false;
   }
  return true;
 
 }
 catch (SQLException e) {
  e.printStackTrace();
  return false;
 }
 finally
 {
  conn.setAutoCommit(true);   //最后设为主动提交
 }
 
 
}


//当然也可以使用拼接字符串的方式去执行批量删除

public boolean deleteall(int ids[])             //拼接字符串方式删除
{
 connect();
 String sql="delete from user_role where user_id in";
 try {
  String canshuc=");";
  String canshua="(";
  String canshub="";
  for(int i=0;i<ids.length;i++)
  {
   canshub+=ids[i]+",";
  }
  
  canshub=canshub.substring(0, canshub.length()-1);
  sql=sql+canshua+canshub+canshuc;
  
  PreparedStatement ps =  (PreparedStatement) conn.prepareStatement(sql);
  int a=ps.executeUpdate();
  
 } catch (SQLException e) {
  // TODO Auto-generated catch block
  
  e.printStackTrace();
  return false;
 }
return true;
  
}


}


/华丽分割线


使用例子：仅仅在需要用到的地方填上


sqlDao sdo=new sqlDao();              //创建对象
   boolean a=sdo.deletebyuser_id(user.getId());        //调用函数
   
   sdo.closeConn();                             //关闭连接




MYSQL总结完毕.


下面是jdbc对Oracle数据库的操作：需要oracle的jdbc操作包。

首先是连接数据库：

	 private static final String driverUrl = "oracle.jdbc.driver.OracleDriver";  
	  
	    private static final String url = "jdbc:oracle:thin:@127.0.0.1:1521:myfirst";  
	      
	    private static final String username = "XIAOHUA";  
	      
	    private static final String password = "123456";  
	      
	    public static Connection getConnection(){  
	        Connection connection = null;  
	        try {  
	            Class.forName(driverUrl);  
	            connection = DriverManager.getConnection(url, username, password);  
	            
	        } catch (ClassNotFoundException e) {  
	            e.printStackTrace();  
	        } catch (SQLException e) {  
	            e.printStackTrace();  
	        }  
	        return connection;  
	    }


然后是：基本的增删查改：

新增：

    //新增 
	    public static void main(String[] args) {  
	        Connection connection = Helsd.getConnection();  
	        String sql = "INSERT INTO T_ADD(RESOURCEID,NAME) VALUES(?,?)";
	        try {
	         PreparedStatement ps = connection.prepareStatement(sql);
	         ps.setString(1, "WENYSSSSssssssss");
	         ps.setString(2, "B");
	         if (ps.executeUpdate() == 1) {
	        	 System.out.println("新增成功："+connection);  
	         }
	    }  catch (Exception e) {
			System.out.print(e.getMessage());
		}
	       finally
	       {
	    	   try {
				connection.close();
			} catch (SQLException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
	       }
	    }


删除： 

   public static void main(String[] args) {  
	        Connection connection = Helsd.getConnection();  
	        try {

	       
	         String sqls = "delete from T_ADD where NAME=?";
	         PreparedStatement pss = connection.prepareStatement(sqls);
	         pss.setString(1, "B");
	         pss.execute();
	    }  catch (Exception e) {
			System.out.print(e.getMessage());
		}
	       finally
	       {
	    	   try {
				connection.close();
			} catch (SQLException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
	       }
	    }

查询： 

  public static void main(String[] args) {  
	        Connection connection = Helsd.getConnection();  
	        try {

	       
	         String sqls = "select * from T_ADD where NAME=?";
	         PreparedStatement pss = connection.prepareStatement(sqls);
	         pss.setString(1, "2");
	        ResultSet rs= pss.executeQuery();
	        while(rs.next())
            {
	        	System.out.print(rs.getString(1));
	        	System.out.print(rs.getString(2));
            }
	    }  catch (Exception e) {
			System.out.print(e.getMessage());
		}
	       finally
	       {
	    	   try {
				connection.close();
			} catch (SQLException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
	       }
	    }

改： 

  public static void main(String[] args) {  
	        Connection connection = Helsd.getConnection();  
	        try {

	       
	         String sqls = "update T_ADD set NAME =? WHERE RESOURCEID=?";
	         PreparedStatement pss = connection.prepareStatement(sqls);
	         pss.setString(1, "wenyan");
	         pss.setString(2,"w");
	       pss.execute();
	    }  catch (Exception e) {
			System.out.print(e.getMessage());
		}
	       finally
	       {
	    	   try {
				connection.close();
			} catch (SQLException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
	       }
	    }


存储过程：

存储过程语句：

第一种：只有IN参数的：

存储过程：

CREATE OR REPLACE 
PROCEDURE INSERTADD(RESOURCES IN VARCHAR2,NAMES IN VARCHAR2) AS
BEGIN
	INSERT INTO  T_ADD(RESOURCEID,NAME) VALUES(RESOURCES,NAMES);
END;

jdbc调用: 

public static void main(String[] args) {  
	        Connection connection = Helsd.getConnection();  
	        try {
	        CallableStatement cs = connection.prepareCall("{call insertadd(?,?)}");
         
            cs.setString(1, "资源1");
            cs.setString(2,"名称1");
             cs.execute(); //执行查询操作，并获取结果集
	    }  catch (Exception e) {
			System.out.print(e.getMessage());
		}
	       finally
	       {
	    	   try {
				connection.close();
			} catch (SQLException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
	       }
	    }



第二种：两个参数，第一个参数是传进来的RESOURCEID,第二个参数是输出，输出的是单个值

CREATE OR REPLACE 
PROCEDURE getname(RESOURCEIDS IN VARCHAR2, NAMES OUT VARCHAR2)
AS
BEGIN
select NAME INTO NAMES from T_ADD where RESOURCEID=RESOURCEIDS;
END;


代码调用： 

 public static void main(String[] args) {  
	        Connection connection = Helsd.getConnection();  
	        try {
	        CallableStatement cs = connection.prepareCall("{call getname(?,?)}");
         
            cs.setString(1, "w");                           
            cs.registerOutParameter(2,java.sql.Types.VARCHAR);
             cs.execute(); //执行查询操作，并获取结果集
	       String str= cs.getString(2);
	       System.out.print(str);
	    }  catch (Exception e) {
			System.out.print(e.getMessage());
		}
	       finally
	       {
	    	   try {
				connection.close();
			} catch (SQLException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
	       }
	    }

第三种：两种参数，输出的是表：通过先定义包，定义好类型CURSOR，程序拿到这个cursor装换成结果集拿出数据：

建包：

CREATE OR REPLACE 
PACKAGE AA AS 
TYPE TEST_CURSOR IS REF CURSOR; 
end;
建存储过程： 

CREATE OR REPLACE 
PROCEDURE GETLIST(p_name IN VARCHAR2,P_CUSER OUT AA.TEST_CURSOR) AS
BEGIN
OPEN P_CUSER FOR
SELECT * FROM T_ADD WHERE NAME=p_name;
END;

jdbc调用然后拿数据： 

	    public static void main(String[] args) {  
	        Connection connection = Helsd.getConnection();  
	        try {
	        CallableStatement cs = connection.prepareCall("{call getlist(?,?)}");
         
            cs.setString(1, "3");
            cs.registerOutParameter(2,OracleTypes.CURSOR);
             cs.execute(); //执行查询操作，并获取结果集
             ResultSet rs = (ResultSet) cs.getObject(2);  
             // 获取列名及类型  
             int colunmCount = rs.getMetaData().getColumnCount();  
             String[] colNameArr = new String[colunmCount];  
             String[] colTypeArr = new String[colunmCount];  
             for (int i = 0; i < colunmCount; i++) {  
                 colNameArr[i] = rs.getMetaData().getColumnName(i + 1);  
                 colTypeArr[i] = rs.getMetaData().getColumnTypeName(i + 1);  
                 System.out.print(colNameArr[i] + "(" + colTypeArr[i] + ")"  
                         + " | ");  
             }  
             System.out.println();  
             while (rs.next()) {  
                 StringBuffer sb = new StringBuffer();  
                 for (int i = 0; i < colunmCount; i++) {  
                     sb.append(rs.getString(i + 1) + " | ");  
                 }  
                 System.out.println(sb);  
             }  
             System.out.println("------- Test Proc Out is ResultSet end. ");  
	    }  catch (Exception e) {
			System.out.print(e.getMessage());
		}
	       finally
	       {
	    	   try {
				connection.close();
			} catch (SQLException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
	       }
	    }

第四种：输入输出 IN   OUT  输入输出都是它：

存储过程：

CREATE OR REPLACE 
PROCEDURE testinout(p_name IN OUT VARCHAR2) AS
BEGIN
	SELECT count(RESOURCEID) INTO p_name from T_ADD WHERE NAME=p_name;
END;

代码： 

   // 测试Oracle连接是否成功  
	    public static void main(String[] args) {  
	        Connection connection = Helsd.getConnection();  
	        try {
	        CallableStatement cs = connection.prepareCall("{call testinout(?)}");
         
            cs.setString(1, "3");
            cs.registerOutParameter(1,java.sql.Types.VARCHAR);
             cs.execute(); //执行查询操作，并获取结果集
	       String str= cs.getString(1);
	       
	       System.out.print(str);
	    }  catch (Exception e) {
			System.out.print(e.getMessage());
		}
	       finally
	       {
	    	   try {
				connection.close();
			} catch (SQLException e) {
				// TODO Auto-generated catch block
				e.printStackTrace();
			}
	       }
	    }














shenbushen
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Java使用JDBC连接任意类型数据库（mysql oracle。。）
hu8471479的专栏
07-08 1536
import java.io.InputStream; import java.sql.Connection; import java.sql.Date; import java.sql.Driver; import java.sql.DriverManager; import java.sql.ResultSet; import java.sql.SQLException; import jav
利用JDBC中处理批量更新oracle数据
走走停停，停停走走……
07-13 1324
JDBC课的时候，听到一节是讲在利用JDBC中处理批量更新oracle数据时候的特性，让我很为JDBC的特性感的兴奋，利用这个特性可以在批量更新数据的时候不同往常一样每次都需要传送完成的SQL语句到数据库中。其中示范代码如下: 1 import java.sql.*; 2 3 public class BatchUpdates 4 { 5   public static void m
认识JDBC以及JDBC连接数据库、增删改查操作
weixin_67224308的博客
10-30 846
什么是概念：Java数据库连接，（，简称JDBC）是Java语言中用来规范客户端程序如何来访问数据库的应用程序接口，提供了诸如查询和更新数据库中数据的方法。JDBC也是Sun的商标。我们通常说的JDBC是面向关系型数据库的。各数据库厂商根据JDBC的规范，实现自身数据库操作的功能代码，然后以jar包（数据库厂商提供的驱动包）的形式提供给开发人员使用，开发人员使用反射的机制创建这些具体实现类，按照JDBC的规范来完成数据库的操作。
android数据库 批量 事务 操作
vurtne_ye的专栏
03-24 6543
先说说多线程 数据库sqlite问题： 1：多线程 单例 SQLiteOpenHelper 可以同时读和写。 2.多线程 多个对象 SQLiteOpenHelper  不能同时读写（可以同时读）。
数据库之对表的增删改查
weixin_30299539的博客
01-11 163
ORM--对象关系映射创建表 from django.db import models<br> class Publisher(models.Model): name = models.CharField(max_length=30, verbose_name="名称") address = models.CharField("地址", max_leng...
Python操作mysql数据库实现增删查改功能的方法
09-09
本篇文章将详细讲解如何使用Python实现对MySQL数据库的增删查改（CRUD）操作。 首先，我们需要导入Python中的MySQL数据库连接库`MySQLdb`。`MySQLdb`是Python的一个MySQL接口，它允许我们通过Python代码连接到MySQL...
java jdbc连接mysql数据库实现增删改查操作
09-02
总结来说，JDBC是Java与数据库交互的标准接口，通过它可以实现对数据库的基本操作。在这个例子中，我们展示了如何使用JDBC连接MySQL数据库，创建一个简单的实体类，以及实现CRUD操作。虽然在实际项目中，开发者更...
JDBC工具类和Druid数据连接池实现数据库数据增删查改操作
最新发布
06-21
使用JDBC工具类和Druid数据连接池实现对数据库数据的增加，删除，查询，修改操作。先创建tb_brand数据库，创建Brand实现类，创建Brand的测试类完成下面操作，使用JDBC工具类操作步骤：完成MySQL的jar包加载，注册类...
labview对MySQL数据库的增删查改
09-29
通过labview对MySQL数据库进行基本操作，使用时需改成自己的数据源和数据表
Mybatis实现批量插入或修改数据（Oracle和MySQL）
diweikang的博客
05-16 5886
Mybatis本身是很灵活的，因为可以自己在XML文件中编写sql进行操作，那就可以一次性将插入到数据库中，这样只用向数据库提交一次，性能也可以提高不少。下面来看一个例子： 首先，在DataMapper.java 接口类中加入接口： void batchInsertUcfUserBatchImport(List<UcfUserBatchImport> ucfUserBatchIm...
使用jdbc进行多数据的批量插入数据库（Oracle）
明天你好
01-05 1万+
public boolean insertDetailed(List listDetailed){ long start = System.currentTimeMillis(); PreparedStatement pstmt=null; StringBuffer sql=new StringBuffer(); int result
jdbc批量查询oracle数据,jdbc 大批量更新 oracle数据库中的数据
weixin_33897367的博客
04-03 610
jdbc 大批量更新 oracle数据库中的数据我用的是PreparedStatement来发送提交，并且数据量非常庞大。一次需要执行8900多条更新语句，也就是Update语句。我试过分开，一部分一部分来执行提交，但还是一样的速度慢，而且越执行越慢。实在是没有什么好的办法了，请教各位高手。8900多条更新,会慢,那就是写法有问题!把SQL贴上来!// 执行更新语句，将值插入到历史表中。@Supp...
JDBC连接，支持 mysql Oracle sqlserver数据库，获取表结构（表名，备注，注释）
hfuningn的博客
03-02 1449
import java.sql.Connection; import java.sql.DatabaseMetaData; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; import java....
getElementById( ) 方法
m0_57835615的博客
05-28 6498
1.getElementById( )方法 getElementById() 方法返回带有指定 ID 的元素 语法格式：
java使用JDBC连接mysql并且进行批量增删改操作
菜的抠脚弟弟的专栏
09-11 6725
在处理百万级的数据时，经常需要对数据库中的数据进行增删改查操作，由于数据量大，进行Query的时候在效率上还是可以接受，但进行增删改的时候，如果采用一次一条记录操作，则效率大大的降低，因此，需要进行批量操作。        本文利用java在eclipse环境下连接mysql数据库进行批量操作。 操作原理很简单，主要利用Betch函数，进行批量操作。 Connection conn = Dr
Oracle中以insert values的形式同时插入多条记录
热门推荐
You can't stand me now
10-10 9万+
由于要做测试数据插oracle数据库，想到了mysql的多个values的形式，但是sql报错。oracle并不支持这种一个insert into 多个values的方法 INSERT INTO users(name, age) VALUES('ccc', 333), ('aaa', 222), ('bbb', 111); 但是有另一种写法，做个简单记录，跟mysql中的一个i...
mySql、oracle数据表的单表增删改查及多表关联查询
chengxc2016的博客
12-17 5835
在对oracle数据库进行操作的时候，我们往往会有这样的困惑：         1、新增数据时，按照mySql的写法为什么新增不了？         2、多个数据表，通过外键关联，如何通过一条sql语句把所有需要的表关联起来并且获取到我所需要的数据内容？        那么在下面，将详细讲解单表的增删改成及多表的关联查询该如何书写sql语句： 首先，我们要建立数据库的连接，在src

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值