学步园

//Statement
			Class.forName("oracle.jdbc.driver.OracleDriver");
			conn = DriverManager.getConnection("jdbc:oracle:thin:@127.0.0.1:1521:ORCL10", "SCOTT", "yf123");
			stmt = conn.createStatement();// Statement创建时就是一个空的执行器
			/** 在execute或者executeQuery时执行死的sql语句 */
			/** 这只能是拼好的字符串,而不能动态的传参数,并且在数据库中每次肯定穿的是不同的sql语句，因此每次都要解析编译 */
			stmt.execute("insert into jdbc_users values (" + user.getId() + ",'" + user.getName() + "','" + user.getPasswd() + "')");

//PreparedStatement	
      Connection conn=null;
      PreparedStatement pstmt=null;
      Class.forName("oracle.jdbc.driver.OracleDriver");
      conn = DriverManager.getConnection("jdbc:oracle:thin:@127.0.0.1:1521:ORCL10", "SCOTT", "yf123");
      String sql="insert into jdbc_users values(?,?,?,?,?)";
      pstmt=conn.prepareStatement(sql);//PreparedStatement创建时就传过去一个sql语句,这样就可以预编译
      /**然后设置sql中好占位符的值,这里是动态的传参数*/
      pstmt.setInt(1, user.getId());
      pstmt.setString(2, user.getName());
      pstmt.setString(3, user.getPasswd());
      pstmt.setString(4, user.getPhone());
      pstmt.setString(5, user.getEmail());
      /**设置好后，就全封装到pstm里了,只要空执行就可以了*/
      pstmt.execute();

import java.sql.Connection;
import java.sql.DatabaseMetaData;
import java.sql.DriverManager;
import java.sql.SQLException;
import java.sql.Statement;
//TransactionTest
//http://blog.csdn.net/cxwen78/article/details/6875713
public class TransactionTest {

	// 数据库连接
	public static Connection getConnection() {
		Connection con = null;
		try {
			Class.forName("com.mysql.jdbc.Driver"); // 加载Mysql数据驱动
			con = DriverManager.getConnection("jdbc:mysql://localhost:3306/first_springmvc", "root", "123"); // 创建数据连接
		} catch (Exception e) {
			System.out.println("数据库连接失败");
		}
		return con;
	}

	// 判断数据库是否支持事务
	public static boolean judgeTransaction(Connection con) {
		try {
			// 获取数据库的元数据
			DatabaseMetaData md = con.getMetaData();
			// 获取事务处理支持情况
			return md.supportsTransactions();
		} catch (SQLException e) {
			e.printStackTrace();
		}
		return false;
	}

	// 将一组SQL语句放在一个事务里执行，要么全部执行通过，要么全部不执行
	public static void startTransaction(Connection con, String[] sqls) throws Exception {

		if (sqls == null) {
			return;
		}
		Statement sm = null;
		try {
			// 事务开始
			System.out.println("事务处理开始！");
			con.setAutoCommit(false); // 设置连接不自动提交，即用该连接进行的操作都不更新到数据库
			
			sm = con.createStatement(); 			
			for (int i = 0; i < sqls.length; i++) {
				sm.execute(sqls[i]);// 执行添加事物的语句
			}
			
			System.out.println("提交事务处理！");
			con.commit(); // 提交给数据库处理

			System.out.println("事务处理结束！");

		} catch (SQLException e) {
			try {
				System.out.println("事务执行失败，进行回滚！\n");
				con.rollback(); // 若前面某条语句出现异常时，进行回滚，取消前面执行的所有操作
			} catch (SQLException e1) {
				e1.printStackTrace();
			}
		} finally {
			sm.close();
		}
	}


	public static void main(String[] args) throws Exception {

		String[] arry = new String[4]; // 定义一组事物处理语句
		arry[0] = "delete from users where username='aaa'"; 
		arry[1] = "UPDATE users SET usernamecn='普通用户' where username='aaa'";//引发错误
		arry[2] = "INSERT INTO users (username,password) values ('ddd','ddd')";
		arry[3] = "select * from users";
		Connection con = null;
		try {

			con = getConnection(); // 获得数据库连接
			boolean judge = judgeTransaction(con); // 判断是否支持批处理
			System.out.print("支持事务处理吗？ ");
			System.out.println(judge ? "支持" : "不支持");
			if (judge) {
				startTransaction(con, arry); // 如果支持则开始执行事务
			}
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			con.close(); // 关闭数据库连接
		}
		
	}

}

//procedure 01:
//	DELIMITER $$
//
//	USE `test`$$
//
//	DROP PROCEDURE IF EXISTS `addlog`$$
//
//	CREATE PROCEDURE `addlog`(IN id VARCHAR(30), IN logId INT, IN msg VARCHAR(30), OUT sid INT )
//	BEGIN
//		INSERT INTO t_sys_log(id, LOG_ID, MSG) VALUES(id, logId,msg);
//		-- select last_insert_id() into sid;  
//		SELECT LOG_ID INTO sid FROM t_sys_log AS a WHERE a.id = id ;
//	   END$$
//
//	DELIMITER ;



//procedure 02:
//DELIMITER $$
//
//USE `test`$$
//
//DROP PROCEDURE IF EXISTS `listUser`$$
//
//CREATE PROCEDURE `listUser`(IN v INT, OUT a VARCHAR(255))
//BEGIN
//	SELECT username  FROM t_ums_user WHERE valid=v;
//	
//   END$$
//
//DELIMITER ;

/**
 * http://blog.csdn.net/cxwen78/article/details/6870959
 */
public class procedureTest {

	// 数据库连接
	public static Connection getConnection() {
		Connection conn = null;
		try {
			Class.forName("com.mysql.jdbc.Driver"); // 加载Mysql数据驱动
			conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/test?useUnicode=true&characterEncoding=utf8", "root", "123"); // 创建数据连接
		} catch (Exception e) {
			System.out.println("数据库连接失败");
		}
		return conn;
	}

	// 列出数据库中所有的存储过程名
	public static void getAllProName(Connection con) {
		try {
			DatabaseMetaData md = con.getMetaData(); // 获得数据库的元数据
			ResultSet resultSet = md.getProcedures(null, null, "%"); // 获得所有的存储过程的描述
			System.out.println("数据库现有的存储过程名为："); // 显示存储过程名，位于结果集的第三个字段

			while (resultSet.next()) {
				String procName = resultSet.getString(3);
				System.out.print(procName + "\n");
			}

			System.out.println();
		} catch (SQLException e) {
			e.printStackTrace();
		}
	}

	// 调用存储过程,传入int，out参数，输出int，string
	public static void call4InOut2IntString(Connection con) throws Exception {
		CallableStatement cstmt = null; // CallableStatement是Statement的子类
		System.out.println("开始执行存储过程");
		try {
			// 调用无参数的存储过程
			cstmt = con.prepareCall("{call addlog(?,?,?,?,?)}"); // 3个？号作占位符

			// 设置输入的参数值
			cstmt.setString(1, "1");
			cstmt.setInt(2, 111);
			cstmt.setString(3, "test_msg");
			cstmt.registerOutParameter(4, Types.INTEGER); // 注册输出参数类型
			cstmt.registerOutParameter(5, Types.VARCHAR); // 注册输出参数类型

			// 执行
			// int CallableStatement.executeUpdate: 存储过程不返回结果集。
			// ResultSet CallableStatement.executeQuery: 存储过程返回一个结果集。
			// Boolean CallableStatement.execute: 存储过程返回多个结果集。
			// int[] CallableStatement.executeBatch: 提交批处理命令到数据库执行。
			cstmt.execute();

			int out_1 = cstmt.getInt(4); // 获取输出的参数值
			String out_2 = cstmt.getString(5);
			System.out.println("logId:  " + out_1);
			System.out.println("msg:  " + out_2);

		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			cstmt.close();
		}
		System.out.println("存储过程执行结束");
	}

	public static void call4ExecuteQuery(Connection con) throws Exception {
		CallableStatement cstmt = null; // CallableStatement是Statement的子类
		System.out.println("开始执行存储过程");
		try {
			// 调用无参数的存储过程
			cstmt = con.prepareCall("{call listUser(?,?)}"); // 3个？号作占位符

			// 设置输入的参数值
			cstmt.setInt(1, 1);
			cstmt.registerOutParameter(2, Types.VARCHAR); // 注册输出参数类型

			// 执行
			// int CallableStatement.executeUpdate: 存储过程不返回结果集。
			// ResultSet CallableStatement.executeQuery: 存储过程返回一个结果集。
			// Boolean CallableStatement.execute: 存储过程返回多个结果集。
			// int[] CallableStatement.executeBatch: 提交批处理命令到数据库执行。
			ResultSet rs = cstmt.executeQuery();
			while (rs.next()) {
				System.out.println(rs.getString(1));
			}

		} catch (SQLException e) {
			e.printStackTrace();
		} finally {
			cstmt.close();
		}
		System.out.println("存储过程执行结束");
	}

	public static void main(String[] args) throws Exception {
		Connection conn = null;
		try {
			conn = getConnection(); // 获得数据库连接
			getAllProName(conn); // 列出数据库的所有存储过程名
			// call4InOut2IntString(conn); // 调用存储过程

			call4ExecuteQuery(conn);

		} catch (Exception e1) {
			throw e1;
		} finally {
			conn.close(); // 关闭数据库连接
		}
	}
}