一：先看几个概念 ：

首先，自己参考了几篇文章，写的很不错，自己也借鉴一下，然后会在最后贴出自己在项目中使用到的存储过程，已经实现过程，大家可以做个对比，实现方法不同。http://www.cnblogs.com/liunanjava/p/4261242.html

过程和函数，它们被编译后 保存在数据库中 ，称为持久性存储模块（Persistent Stored Module，PSM），可以反复调用，运行速度快。 不同之处是函数必须指定返回类型 。

Java调用结构：

存储过程：{call <procedure-name>[(<arg1>,<arg2>, ...)]}
函数：{?= call <procedure-name>[(<arg1>,<arg2>, ...)]} 。

如果 要调用存储过程 ，则使用第一种语法，就是开头不带问号的语法，call 后面是过程名，
如果没有参数，可以省略小括号。
如果 要调用函数 ，则使用第二种语法，开头带有一个问号加等号， 实际上这个问号就是一个占位符，这个问号总是调用函数的第一个占位符 。其它部分与过程的语法相同。

二、CallableStatement 执行存储过程 ：

2.1、建立基类

1. package com.pb.emp.dao;
3. import java.sql.Connection;
4. import java.sql.DriverManager;
5. import java.sql.PreparedStatement;
6. import java.sql.ResultSet;
7. import java.sql.SQLException;
9. import com.pb.emp.untily.ConfigManager;
12. public class BaseDao {
13. protected Connection conn;
14. protected PreparedStatement ps;
15. protected ResultSet rs;
17. //建立连接
18. public boolean getConnection(){
19. String driver=ConfigManager.getInstance().getString( "jdbc.driver_class" );
20. String url=ConfigManager.getInstance().getString( "jdbc.connection.url" );
21. String username=ConfigManager.getInstance().getString( "jdbc.connection.username" );
22. String password=ConfigManager.getInstance().getString( "jdbc.connection.password" );
24. try {
25. Class.forName(driver);
26. conn=DriverManager.getConnection(url,username, password);
27. } catch (ClassNotFoundException e) {
28. // TODO Auto-generated catch block
29. e.printStackTrace();
30. return false ;
31. } catch (SQLException e) {
32. // TODO Auto-generated catch block
33. e.printStackTrace();
34. return false ;
35. }
36. return true ;
37. }
39. //增加，修改，删除
40. public int executeUpdate(String sql, Object[] params){
41. getConnection();
42. int updateRow= 0 ;
43. try {
44. ps=conn.prepareStatement(sql);
45. //填充占位符
46. for ( int i= 0 ;i<params.length;i++){
47. ps.setObject(i+ 1 , params[i]);
48. }
49. updateRow = ps.executeUpdate();
50. } catch (SQLException e) {
51. // TODO Auto-generated catch block
52. e.printStackTrace();
53. }
54. return updateRow;
55. }
56. //
57. //查询
58. public ResultSet executeSQL(String sql, Object[] params){
59. getConnection();
61. try {
62. ps=conn.prepareStatement(sql);
63. //填充占位符
64. for ( int i= 0 ;i<params.length;i++){
65. ps.setObject(i+ 1 , params[i]);
66. }
67. rs = ps.executeQuery();
68. } catch (SQLException e) {
69. // TODO Auto-generated catch block
70. e.printStackTrace();
71. }
72. return rs;
73. }
75. // 关闭资源
76. public boolean closeResource() {
77. if (rs!= null ){
78. try {
79. rs.close();
80. } catch (SQLException e) {
81. // TODO Auto-generated catch block
82. e.printStackTrace();
83. return false ;
84. }
85. }
86. if (ps!= null ){
87. try {
88. ps.close();
89. } catch (SQLException e) {
90. // TODO Auto-generated catch block
91. e.printStackTrace();
92. return false ;
93. }
94. }
96. if (conn!= null ){
97. try {
98. conn.close();
99. } catch (SQLException e) {
100. // TODO Auto-generated catch block
101. e.printStackTrace();
102. return false ;
103. }
104. }
105. return true ;
106. }
107. }

package com.pb.emp.dao; import java.sql.Connection; import java.sql.DriverManager; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; import com.pb.emp.untily.ConfigManager; public class BaseDao { protected Connection conn; protected PreparedStatement ps; protected ResultSet rs; //建立连接 public boolean getConnection(){ String driver=ConfigManager.getInstance().getString("jdbc.driver_class"); String url=ConfigManager.getInstance().getString("jdbc.connection.url"); String username=ConfigManager.getInstance().getString("jdbc.connection.username"); String password=ConfigManager.getInstance().getString("jdbc.connection.password"); try { Class.forName(driver); conn=DriverManager.getConnection(url,username, password); } catch (ClassNotFoundException e) { // TODO Auto-generated catch block e.printStackTrace(); return false; } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); return false; } return true; } //增加，修改，删除 public int executeUpdate(String sql, Object[] params){ getConnection(); int updateRow=0; try { ps=conn.prepareStatement(sql); //填充占位符 for(int i=0;i<params.length;i++){ ps.setObject(i+1, params[i]); } updateRow = ps.executeUpdate(); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); } return updateRow; } // //查询 public ResultSet executeSQL(String sql, Object[] params){ getConnection(); try { ps=conn.prepareStatement(sql); //填充占位符 for(int i=0;i<params.length;i++){ ps.setObject(i+1, params[i]); } rs = ps.executeQuery(); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); } return rs; } // 关闭资源 public boolean closeResource() { if(rs!=null){ try { rs.close(); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); return false; } } if(ps!=null){ try { ps.close(); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); return false; } } if(conn!=null){ try { conn.close(); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); return false; } } return true; } }

2.2、 执行不带参但是有返回值的存储过程

下面建立存储过程

1. --查询emp表记录数
2. CREATE OR REPLACE PROCEDURE getEmpCount(v_count OUT NUMBER)
3. AS
4. BEGIN
5. SELECT COUNT (*) INTO v_count FROM emp;
6. END ;

--查询emp表记录数 CREATE OR REPLACE PROCEDURE getEmpCount(v_count OUT NUMBER) AS BEGIN SELECT COUNT(*) INTO v_count FROM emp; END;

1. //执行不带参但是有返回值的存储过程获取emp表总记录数
2. public int getTotalCountProc(){
3. //定义一个变量来接收结果
4. int totalCount= 0 ;
5. //声明CallableStatement对象
6. CallableStatement proc= null ;
7. String sql= "{call getEmpCount(?)}" ;
9. try {
10. //建立连接
11. getConnection();
12. //CallableStatement对象
13. proc=conn.prepareCall(sql);
14. //将数据库对象数据类型注册为java中的类型
15. proc.registerOutParameter( 1 , Types.INTEGER);
16. //执行
17. proc.execute();
18. //接收返回值
19. totalCount=proc.getInt( 1 );
20. } catch (SQLException e) {
21. // TODO Auto-generated catch block
22. e.printStackTrace();
23. }
25. return totalCount;
26. }

//执行不带参但是有返回值的存储过程获取emp表总记录数 public int getTotalCountProc(){ //定义一个变量来接收结果 int totalCount=0; //声明CallableStatement对象 CallableStatement proc=null; String sql="{call getEmpCount(?)}"; try { //建立连接 getConnection(); //CallableStatement对象 proc=conn.prepareCall(sql); //将数据库对象数据类型注册为java中的类型 proc.registerOutParameter(1, Types.INTEGER); //执行 proc.execute(); //接收返回值 totalCount=proc.getInt(1); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); } return totalCount; }

2.3、执行带参带返回值的存储过程

1. --根据部门编号和姓名查询人数
2. CREATE OR REPLACE PROCEDURE getEmpCount(v_deptno  NUMBER, v_ename VARCHAR2,v_count OUT NUMBER)
3. AS
4. BEGIN
5. SELECT COUNT (*) INTO v_count FROM emp
6. WHERE ename LIKE '%' ||v_ename|| '%' AND deptno=v_deptno;
7. END ;

--根据部门编号和姓名查询人数 CREATE OR REPLACE PROCEDURE getEmpCount(v_deptno NUMBER, v_ename VARCHAR2,v_count OUT NUMBER) AS BEGIN SELECT COUNT(*) INTO v_count FROM emp WHERE ename LIKE '%'||v_ename||'%' AND deptno=v_deptno; END;

1. //执行带参带返回值的存储过程
2. public int getTotalCountProc1( int deptno,String ename){
3. //定义一个变量来接收结果
4. int totalCount= 0 ;
5. //声明CallableStatement对象
6. CallableStatement proc= null ;
7. String sql= "{call getEmpCount(?,?,?)}" ;
8. //建立连接
9. getConnection();
10. //CallableStatement对象
11. try {
12. proc=conn.prepareCall(sql);
13. //设置占位符
14. //Object [] params={deptno,ename};
15. //只设置输入参数即可
16. proc.setInt( 1 , deptno);
17. proc.setString( 2 , ename);
18. //proc.setInt(3, totalCount);
19. 将数据库对象数据类型注册为java中的类型，将输出参数转换
20. proc.registerOutParameter( 3 , Types.INTEGER);
21. //执行
22. proc.execute();
23. //获取结果
24. totalCount=proc.getInt( 3 );
25. } catch (SQLException e) {
26. // TODO Auto-generated catch block
27. e.printStackTrace();
28. } finally {
29. this .closeResource();
30. if (proc!= null ){
31. try {
32. proc.close();
33. } catch (SQLException e) {
34. // TODO Auto-generated catch block
35. e.printStackTrace();
36. }
37. }
38. }
40. return totalCount;
42. }

//执行带参带返回值的存储过程 public int getTotalCountProc1(int deptno,String ename){ //定义一个变量来接收结果 int totalCount=0; //声明CallableStatement对象 CallableStatement proc=null; String sql="{call getEmpCount(?,?,?)}"; //建立连接 getConnection(); //CallableStatement对象 try { proc=conn.prepareCall(sql); //设置占位符 //Object [] params={deptno,ename}; //只设置输入参数即可 proc.setInt(1, deptno); proc.setString(2, ename); //proc.setInt(3, totalCount); 将数据库对象数据类型注册为java中的类型，将输出参数转换 proc.registerOutParameter(3, Types.INTEGER); //执行 proc.execute(); //获取结果 totalCount=proc.getInt(3); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); }finally{ this.closeResource(); if(proc!=null){ try { proc.close(); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } return totalCount; }

2.4、执行返回值为游标的存储过程

1. --查询员工所有信息
2. CREATE OR REPLACE PROCEDURE emp_cur(emp_cur OUT SYS_REFCURSOR)
3. AS
4. BEGIN
5. OPEN emp_cur FOR SELECT * FROM emp;
6. END ;

--查询员工所有信息 CREATE OR REPLACE PROCEDURE emp_cur(emp_cur OUT SYS_REFCURSOR) AS BEGIN OPEN emp_cur FOR SELECT * FROM emp; END;

1. //执行返回值为游标的存储过程 游标名emp_cur
2. public List<emp> getempProc1(){
3. List<emp> emplist= new ArrayList<emp>();
4. String sql= "{call emp_cur(?) }" ;
5. //声明CallableStatement对象
6. CallableStatement proc= null ;
7. //建立连接
8. getConnection();
10. try {
11. //执行
12. proc=conn.prepareCall(sql);
13. //注册类型为数据库游标类型
14. proc.registerOutParameter( 1 , oracle.jdbc.OracleTypes.CURSOR);
15. //接收结果集
16. proc.execute();
17. //获取结果第一个对象
18. rs=(ResultSet) proc.getObject( 1 );
19. while (rs.next()){
20. int empno=rs.getInt( "empno" );
21. String ename=rs.getString( "ename" );
22. String job=rs.getString( "job" );
23. int mgr=rs.getInt( "mgr" );
24. Date hiredate=rs.getDate( "hiredate" );
25. double sal=rs.getDouble( "sal" );
26. double comm=rs.getDouble( "comm" );
27. int deptno=rs.getInt( "deptno" );
28. //声明Emp对象
29. Emp emp= new Emp();
30. //将得到的值添加到对象中
31. emp.setEmpno(empno);
32. emp.setEname(ename);
33. emp.setJob(job);
34. emp.setMgr(mgr);
35. emp.setHiredate(hiredate);
36. emp.setSal(sal);
37. emp.setComm(comm);
38. emp.setDeptno(deptno);
39. //将对象添加到集合
40. emplist.add(emp);
41. }
42. } catch (SQLException e) {
43. // TODO Auto-generated catch block
44. e.printStackTrace();
45. } finally {
46. this .closeResource();
47. if (proc!= null ){
48. try {
49. proc.close();
50. } catch (SQLException e) {
51. // TODO Auto-generated catch block
52. e.printStackTrace();
53. }
54. }
55. }
59. return emplist;
61. }</emp></emp></emp>

//执行返回值为游标的存储过程 游标名emp_cur public List<emp> getempProc1(){ List<emp> emplist=new ArrayList<emp>(); String sql="{call emp_cur(?) }"; //声明CallableStatement对象 CallableStatement proc=null; //建立连接 getConnection(); try { //执行 proc=conn.prepareCall(sql); //注册类型为数据库游标类型 proc.registerOutParameter(1, oracle.jdbc.OracleTypes.CURSOR); //接收结果集 proc.execute(); //获取结果第一个对象 rs=(ResultSet) proc.getObject(1); while(rs.next()){ int empno=rs.getInt("empno"); String ename=rs.getString("ename"); String job=rs.getString("job"); int mgr=rs.getInt("mgr"); Date hiredate=rs.getDate("hiredate"); double sal=rs.getDouble("sal"); double comm=rs.getDouble("comm"); int deptno=rs.getInt("deptno"); //声明Emp对象 Emp emp=new Emp(); //将得到的值添加到对象中 emp.setEmpno(empno); emp.setEname(ename); emp.setJob(job); emp.setMgr(mgr); emp.setHiredate(hiredate); emp.setSal(sal); emp.setComm(comm); emp.setDeptno(deptno); //将对象添加到集合 emplist.add(emp); } } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); }finally{ this.closeResource(); if(proc!=null){ try { proc.close(); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); } } } return emplist; }</emp></emp></emp>

以上看出，需要将输出的参数，和结果注册，输入的参数不要注册,

但输入参数需要设置占位符 。

三、执行函数 。

3.1 、函数功能为根据雇员id 返回姓名

[sql] view plain print

1. CREATE OR REPLACE FUNCTION getename(v_empno NUMBER)
2. RETURN VARCHAR2
3. AS
4. v_ename VARCHAR2(20);
6. BEGIN
7. SELECT ename INTO v_ename FROM emp WHERE empno=v_empno;
8. RETURN v_ename;
9. END ;

CREATE OR REPLACE FUNCTION getename(v_empno NUMBER) RETURN VARCHAR2 AS v_ename VARCHAR2(20); BEGIN SELECT ename INTO v_ename FROM emp WHERE empno=v_empno; RETURN v_ename; END;

1. public void getenamefun( int empno){
2. //sql
3. String ename= "" ;
4. String sql= "{?=call getename(?)}" ; //注意和存储过程的区别
5. CallableStatement fun= null ;
6. getConnection();
7. try {
8. fun=conn.prepareCall(sql);
9. fun.setInt( 2 , empno);
10. fun.registerOutParameter( 1 , Types.VARCHAR);
11. fun.execute();
12. ename=fun.getString( 1 );
13. System.out.println(ename);
14. } catch (SQLException e) {
15. // TODO Auto-generated catch block
16. e.printStackTrace();
17. }
19. }

public void getenamefun(int empno){ //sql String ename=""; String sql="{?=call getename(?)}";//注意和存储过程的区别 CallableStatement fun=null; getConnection(); try { fun=conn.prepareCall(sql); fun.setInt(2, empno); fun.registerOutParameter(1, Types.VARCHAR); fun.execute(); ename=fun.getString(1); System.out.println(ename); } catch (SQLException e) { // TODO Auto-generated catch block e.printStackTrace(); } } 其它的方法与过程一样，只是多了个返回值类型。

------------------------------------------------------------------

四：接下来说下自己项目中的，直接看代码。

创建储存过程的代码基本一样，只是Java调用存储过程的时候，跟上边调用的方法不同，大家可以自行理解：

4.1:更新订单状态，返回状态值

1. DELIMITER $$ -------------先定义语句的结束符号
3. USE `zhangzi_tester`$$
5. DROP PROCEDURE IF EXISTS `pay_orderState`$$
7. CREATE PROCEDURE `pay_orderState`(
8. IN serNumbner VARCHAR (32),
9. IN itemId VARCHAR (32),
10. IN captions INT ,
11. IN cfcaPayTime VARCHAR (32),
12. IN payDate VARCHAR (30),
13. OUT state VARCHAR (2))
14. BEGIN
15. DECLARE maxMoney INT DEFAULT 0;
16. DECLARE countMoney INT DEFAULT 0;
17. DECLARE caps INT DEFAULT 0;
18. START TRANSACTION ; -- 配置事务
19. SELECT IFNULL(max_finance_money,0) INTO maxMoney FROM t_item_info WHERE id = itemId;
20. SELECT IFNULL( SUM (capital),0) INTO countMoney FROM t_order_info WHERE fk_item_id = itemId AND pay_status = '01' ;
21. IF maxMoney >= captions+countMoney THEN -- 判断有没有超募
22. IF  maxMoney = countMoney+captions THEN
23. UPDATE t_item_info SET full_flag= '01' WHERE id= itemId;
24. END IF;
25. UPDATE t_order_info SET pay_status = '01' ,order_complete_date = cfcaPayTime, pay_date= payDate WHERE serial_number = serNumbner; -- 没有超募
26. SET state = '1' ; -- 未超募 返回1
27. ELSE
28. UPDATE t_order_info SET pay_status = '03' ,order_complete_date = cfcaPayTime, pay_date=  payDate WHERE serial_number = serNumbner; -- 没有超募
29. SET state = '3' ; -- 已超募 返回3
30. END IF;
31. COMMIT ; -- 事务结束提交
32. END $$
34. DELIMITER ; ---改成默认的分号;

DELIMITER $$ -------------先定义语句的结束符号 USE `zhangzi_tester`$$ DROP PROCEDURE IF EXISTS `pay_orderState`$$ CREATE PROCEDURE `pay_orderState`( IN serNumbner VARCHAR (32), IN itemId VARCHAR (32), IN captions INT, IN cfcaPayTime VARCHAR(32), IN payDate VARCHAR(30), OUT state VARCHAR (2)) BEGIN DECLARE maxMoney INT DEFAULT 0; DECLARE countMoney INT DEFAULT 0; DECLARE caps INT DEFAULT 0; START TRANSACTION;-- 配置事务 SELECT IFNULL(max_finance_money,0) INTO maxMoney FROM t_item_info WHERE id = itemId; SELECT IFNULL(SUM(capital),0) INTO countMoney FROM t_order_info WHERE fk_item_id = itemId AND pay_status = '01'; IF maxMoney >= captions+countMoney THEN -- 判断有没有超募 IF maxMoney = countMoney+captions THEN UPDATE t_item_info SET full_flag='01' WHERE id= itemId; END IF; UPDATE t_order_info SET pay_status = '01',order_complete_date = cfcaPayTime, pay_date= payDate WHERE serial_number = serNumbner; -- 没有超募 SET state ='1'; -- 未超募 返回1 ELSE UPDATE t_order_info SET pay_status = '03',order_complete_date = cfcaPayTime, pay_date= payDate WHERE serial_number = serNumbner; -- 没有超募 SET state ='3'; -- 已超募 返回3 END IF; COMMIT; -- 事务结束提交 END$$ DELIMITER ;---改成默认的分号;

4.2：Java调用存储过程代码

1. /*
2. * 订单支付完成调用存储过程接口，修改订单支付状态
3. */
4. @SuppressWarnings ( "unchecked" )
5. public String orderState( final String serNumbner, final String itemId, final int captions, final String bankNotificationTime){
6. String param2Value= null ;
7. try {
8. param2Value = (String)jdbc.execute(
9. new CallableStatementCreator() {
10. public CallableStatement createCallableStatement(Connection con) throws SQLException {
11. String storedProc = "{call pay_orderState(?,?,?,?,?,?)}" ; // 调用的sql
12. CallableStatement cs = con.prepareCall(storedProc);
13. cs.setString( 1 , serNumbner);
14. cs.setString( 2 , itemId);
15. cs.setInt( 3 , captions);
16. cs.setString( 4 , bankNotificationTime);
17. cs.setString( 5 ,DateTimeUtils.getNowTime());
18. cs.registerOutParameter( 6 , Types.VARCHAR);
19. return cs;
20. }
21. }, new CallableStatementCallback() {
22. public Object doInCallableStatement(CallableStatement cs) throws SQLException,DataAccessException{
23. cs.execute();
24. return cs.getString( 6 ); // 获取输出参数的值
25. }
26. });
27. } catch (Exception ex){
28. throw new RuntimeException(ex);
29. }
30. return param2Value;
31. }

/* * 订单支付完成调用存储过程接口，修改订单支付状态 */ @SuppressWarnings("unchecked") public String orderState(final String serNumbner,final String itemId,final int captions,final String bankNotificationTime){ String param2Value=null; try{ param2Value = (String)jdbc.execute( new CallableStatementCreator() { public CallableStatement createCallableStatement(Connection con) throws SQLException { String storedProc = "{call pay_orderState(?,?,?,?,?,?)}";// 调用的sql CallableStatement cs = con.prepareCall(storedProc); cs.setString(1, serNumbner); cs.setString(2, itemId); cs.setInt(3, captions); cs.setString(4, bankNotificationTime); cs.setString(5,DateTimeUtils.getNowTime()); cs.registerOutParameter(6, Types.VARCHAR); return cs; } }, new CallableStatementCallback() { public Object doInCallableStatement(CallableStatement cs) throws SQLException,DataAccessException{ cs.execute(); return cs.getString(6);// 获取输出参数的值 } }); }catch(Exception ex){ throw new RuntimeException(ex); } return param2Value; }

4.3：再附上两段代码，有关Java调用储存过程的

1. < bean id = "jdbcTemplate" class = "org.springframework.jdbc.core.JdbcTemplate" >
2. < property name = "dataSource" ref = "dataSource" >
3. </ property > </ bean >

<bean id="jdbcTemplate" class="org.springframework.jdbc.core.JdbcTemplate"> <property name="dataSource" ref="dataSource"> </property></bean>

4.4:最后一张图片--mysql执行储存过程

下面这个和我的很相似，不用自己写了，就用他的吧！

最近做了一个需求，需要批量更新 数据库 表，但是因为涉及到的数据较多(千万条)，如果直接用sql更新，估计会把pl/sql弄垮

sql如下：update online_product set online_flag = '0' where status = 'ON'

所以，写了一个存储过程，以备忘：

1. declare
2. cursor product_id_list is
3. select product_id from online_product where status = 'ON' ;
4. commit_count number := 0;
5. total_count number := 0;
6. begin
7. for pid in product_id_list loop
8. total_count := total_count + 1;
9. commit_count := commit_count + 1;
10. update online_product setonline_flag = '0'
11. where status = 'ON'
12. and product_id = pid.product_id;
13. if commit_count > 1000 then
14. commit ;
15. commit_count := 0;
16. end if;
17. end loop;
18. commit ;
19. dbms_output.put_line( 'Total Count:' || total_count);
20. end ;

什么是 存储过程 简单的说，就是一组SQL语句集，功能强大，可以实现一些比较复杂的逻辑功能，类似于 JAVA 语言 中 的方法； ps: 存储过程 跟触发器有点类似，都是一组SQL集，但是 存储过程 是主动调用的，且功能比触发器更加强大，触发器是某件事触发后自动调用； 有哪些特性 有输入输出参数，可以声明变量，有if/else, case,while等控制语句，通过编写 存储过程 ，可以实现复杂的逻辑功能； 函数 的普遍特性：模块化，封装， 代码 复用； 速度快，只有首次 执行 需经过编译和优化步骤，后续被调用可以直接 执行 ，省去以上步骤； MySQL 存储过程 的创建 CREATE PROCEDURE sp_name ([ 在 存储过程 中 常看到declare定义的变量和@set定义的变量。简单的来说，declare定义的类似是局部变量，@set定义的类似全局变量。 1、declare定义的变量类似 java 类 中 的局部变量，仅在类 中 生效。即只在 存储过程 中 的begin和end之间生效。 2、@set定义的变量，叫做会话变量，也叫用户定义变量，在整个会话 中 都起作用(比如某个应用的一个连接过程 中 )，即这个变量可以在被调用的 存储过程 或者 代码 之间共享数据。如何理解呢？可以看下面这个简单例子，很好理解。  （1）先 执行 下面脚本，创建一个 存储过程 ，分别有declare形式的变量和@set形式的变量 DROP PROCEDURE 在 Java 中 ，你可以使用 函数 来 执行 特定的任务。 函数 是 Java 程序 中 的一个模块，它封装了一组指令，这些指令可以在需要时被调用。这是 Java 中 定义和使用 函数 的基本步骤。请记住，在 Java 中 ， 函数 必须在类 中 定义。上面的 函数 接收两个整数作为参数，并返回它们的和。 1. 什么是 函数 ？ 首先看一下数据类型——————– 数据类型介绍文章 基本数据类型：数值(number)、字符串(string)、布尔(Boolean)、null、undefined 复杂数据类型:对象（object)、构造 函数 (function)、数组(array)等 复杂数据类型又叫引用数据类型 函数 是一个复杂数据类型，分别存储在栈里面的地址和存储在堆里面的数据 函数 的概念 对于 js 来说， 函数 就是把任意一段 代码 放在一个 盒子 里面 在我想要让这段 代码 执行 的时候，直接 执行 这个 盒子 里面的 代码 就行 java script权威指南解释： 函数 （function）: 函数 是带有名称（na 如果想要 执行 存储过程 ，我们应该使用 CallableStatement 接口。CallableStatement 接口继承自PreparedStatement 接口。所以CallableStatement 接口包含有Statement 接口和PreparedStatement 接口定义的全部方法，但是并不是所有的方法我们都要使用，主要使用的方法有这样几个： 执行 SQL 语句，如果第一个结果是 ResultSet 对象，则返回 true；如果第一个结果是更新计数或者没有结果，则返回 false。 存储 函数 与 存储过程 一、 存储过程 1.理解2.参数的分类3. 存储过程 的使用创建使用二、存储 函数 的使用创建使用三、对比存储 函数 和 存储过程 四、 存储过程 与 函数 的查看,修改,删除查看修改删除五.、关于 存储过程 使用的争议6.1 优点6.2 缺点阿里开发规范 一、 存储过程 含义： 存储过程 的英文是 Stored Procedure。它的思想很简单，就是一组经过预先编译的 SQL 语句的封装。 ** 执行 过程：** 存储过程 预先存储在 MySQL 服务器上，需要 执行 的时候，客户端只需要向服务器端发出调用 存储过程 的命令，服 存储过程 和存储 函数 1 存储过程 和 函数 概述2 创建 存储过程 3 调用 存储过程 4 查看 存储过程 5 删除 存储过程 6 语法6.1 变量6.2 if条件判断6.3 传递参数6.4 case结构6.5 while循环6.6 repeat结构6.7 loop语句6.8 leave语句6.9 游标/光标7 存储 函数 1 存储过程 和 函数 概述 存储过程 和 函数 是 事先经过编译并存储在数据库 中 的一段 SQL 语句的集合，调... set @studentNameTest='理想';SELECT * FROM student_test WHERE student_sex = '男';SELECT * FROM student_test WHERE student_sex = '女';1.概念： 存储过程 （Stored Procedure）就是一段存储在数据库 中 执行 某种功能的PL/SQL程序。跟 java 中 的方法相类似，而且都需要调用，一次编译永久有效。过程主要的操作是：增删改查。##创建一个 存储过程 。 import java .sql.CallableStatement; import java .sql.Connection; import java .sql.DriverManager; import java .sql.PreparedStatement; import java .sql.ResultSet; import java .sql.ResultSetMetaData; import ja... 存储过程 是用户定义的SQL语句序列的集合，涉及特定表或其他对象的任务。用户可以调用 存储过程 。 函数 通常是数据库定义的方法。它接受参数并返回某种类型的值，并且不涉及特定的用户表（如果是自定义 函数 ，则可能涉及用户表）。 存储过程 和 函数 的区别 1、 函数 必须有一个且必须只有一个返回值，并且还要制定返回值的数值类型。 存储过程 可以有返回值，也可以没有返回值，甚至可以有多个返回值，所有返回值...    ---------------不带输出参数的---------------------------------- create procedure getsum @n int =0&lt;--此处为参数--&gt; declare @sum int&lt;--定义变量--&gt; declare @i int set @...