MySql 数据库用java程序创建表以及存储过程
Java连接MySql数据库,并且实现插入、删除、更新、选择操作
天之火–Qutr的专栏君子终日乾乾,夕惕若,厉,无咎。
HomeJava连接MySql数据库,并且实现插入、删除、更新、选择操作!这是我最近写的一个连接MySql数据库的一个例子,主要实现了插入,删除,更新,选择操作,用的环境是j2sdk1.4.2_08,Eclipse3.1。
以前我的同事用Python 写了同样的类,非常的好用,支持了我们公司的大部分业务,现在我们慢慢改用Java了,所以我用Java重写了一遍。
一方面在今后的业务中能够用到,另一方面熟悉一下Java。
下面我把在Eclipse3.1下怎样配置数据库连接信息简单说一下。
1.启动Eclipse3.1。
2.建立一个Java project就叫DbConnect 吧,再在该Project下建立一个新类也叫DbConnect 吧。
3.右击DbConnect.java文件点import,选择Archive file然后选择你的mysql-connector-java-3.1.8-bin.jar文件,点Finish。
你会看到有好些文件被加载进来,OK这就是连接MySql所需的驱动信息。
如果到了这里你都成功的话那么恭喜你,你已经成功一半了!:)4.接下来把我下面的代码copy到你的Java文件中,修改相关的数据库连接信息运行一下。
OK?我说一下那个mysql-connector-java-3.1.8-bin.jar文件,其实这就是一个MySql的驱动,各数据库厂商提供了不同的适用于JDBC的驱动使得在Java中连接数据库非常简单。
这里我就不多说了,以后我会写篇专门介绍数据库驱动的文章。
关于MySql的驱动还有更新版本的,你需要到MySql的网站上去下载,这个网上到处都是,我就不多说了。
下面看程序,有些地方我写了详细的注释应该能看懂。
这个类是非常有特色的,在每个方法的传人参数和返回值不变的情况下,希望高手能提出改进意见。
多指教,谢谢!/*** 数据库连接、选择、更新、删除演示*///import java.sql.*;import java.sql.Connection;import java.sql.Statement;import java.sql.ResultSet;import java.sql.DriverManager;import java.util.*;public class DbConnect{/////////////////////////////////////////———–>>>数据成员and 构造函数private Connection dbconn;private Statement dbstate;private ResultSet dbresult;DbConnect(){dbconn = null;dbstate = null;dbresult = null;}/////////////////////////////////////////———–>>>类方法public void print(String str)//简化输出{System.out.println(str);}//end print(…)/*** 连接MySql数据库* @param host* @param port* @param dbaName* @param usName* @param psw* @return bool值,连接成功返回真,失败返回假*/public boolean dbConnection(String host, String port, String dbaName, String usName, String psw){String driverName = "com.mysql.jdbc.Driver";//"org.gjt.mm.mysql.Driver"两个驱动都可以用String dbHost = host;//数据库的一些信息String dbPort = port;String dbName = dbaName;String enCoding = "?useUnicode=true&characterEncoding=gb2312"; //解决MySql中文问题,要连续写不能空格String userName = usName;String Psw = psw;String url = "jdbc:mysql://" + dbHost + ":" + dbPort + "/" + dbName + enCoding;try{Class.forName(driverName).newInstance();dbconn = DriverManager.getConnection(url, userName, Psw);//getConnection(url, userName, Psw)从给的driver中选择合适的去连接数据库//return a connection to the URL}catch(Exception e){print("url = " + url); //发生错误时,将连接数据库信息打印出来print("userName = " + userName);print("Psw" + Psw);print("Exception: " + e.getMessage());//得到出错信息}if (dbconn != null)//dbconn != null 表示连接数据库成功,由异常保证!?return true;elsereturn false;}// end boolean dbConnection(…)/*** 对数据库表进行选择操作!* @param tableName 数据库表名* @param fieles 字段名* @param selCondition 选择条件* @return 一个含有map的List(列表)*/public ArrayList dbSelect(String tableName, ArrayList fields, String selCondition){ArrayList mapInList = new ArrayList();String selFields = "";for (int i = 0; i<fields.size(); ++i)selFields += fields.get(i) + ", ";String selFieldsTem = selFields.substring(0, selFields.length() – 2);//根据String的索引提取子串try{dbstate = dbconn.createStatement();String sql = "select " + selFieldsTem + " from " + tableName + selCondition;print("sql = " + sql);try{dbresult = dbstate.executeQuery(sql);}catch(Exception err){print("Sql = " + sql);print("Exception: " + err.getMessage());}while(dbresult.next()){Map selResult = new HashMap();selResult.put("message_type", dbresult.getString("message_type"));selResult.put("message_content",dbresult.getString("message_content"));mapInList.add(selResult);}}catch(Exception e){print("Exception: " + e.getMessage());}return mapInList;}//end String dbSelect(…)/*** 对数据库表中的记录进行删除操作* @param tableName* @param condition* @return bool值,表示删除成功或者失败。
mysql数据库建表代码
mysql数据库建表代码MySQL是一种开源的关系型数据库管理系统,它是最流行的数据库之一。
在MySQL中,建表是非常重要的一步,因为它决定了数据的存储方式和结构。
在本文中,我们将介绍如何使用MySQL建表。
我们需要创建一个数据库。
在MySQL中,可以使用以下命令创建一个名为“mydatabase”的数据库:CREATE DATABASE mydatabase;接下来,我们需要在该数据库中创建一个表。
表是由列和行组成的,每个列都有一个数据类型和一个名称。
在MySQL中,可以使用以下命令创建一个名为“mytable”的表:CREATE TABLE mytable (id INT NOT NULL AUTO_INCREMENT,name VARCHAR(50) NOT NULL,age INT NOT NULL,PRIMARY KEY (id));在上面的代码中,我们创建了一个包含三个列的表。
第一列是“id”,它是一个自增的整数,不允许为空。
第二列是“name”,它是一个最大长度为50的字符串,不允许为空。
第三列是“age”,它是一个整数,不允许为空。
最后,我们将“id”列设置为主键。
除了上面的基本数据类型外,MySQL还支持其他数据类型,如日期、时间、布尔值等。
在创建表时,可以根据需要选择适当的数据类型。
在创建表后,我们可以使用INSERT语句向表中添加数据。
例如,以下代码将向“mytable”表中添加一条记录:INSERT INTO mytable (name, age) VALUES ('John', 25);在上面的代码中,我们向“mytable”表中添加了一个名为“John”的人,他的年龄为25岁。
由于“id”列是自增的,因此不需要在INSERT语句中指定它的值。
我们可以使用SELECT语句从表中检索数据。
例如,以下代码将检索“mytable”表中所有人的姓名和年龄:SELECT name, age FROM mytable;在上面的代码中,我们使用SELECT语句选择了“name”和“age”列,并从“mytable”表中检索了所有记录。
Java中使用MyBatis Plus连接和操作MySQL数据库
Java中使用MyBatis Plus连接和操作MySQL数据库1. 简介近年来,Java语言以其跨平台特性和广泛的应用领域成为了全球最受欢迎的编程语言之一。
而MySQL作为一种强大的开源关系型数据库,也是Java开发者首选的数据库之一。
在Java中,我们可以使用MyBatis Plus来连接和操作MySQL数据库,提升开发效率和简化数据库操作。
2. MyBatis Plus简介MyBatis Plus是基于MyBatis的一款增强工具,旨在简化和提升MyBatis的使用体验。
它提供了一系列强大的功能,如代码生成器、分页插件、性能分析插件等,使得开发者能够更加便捷地开发和维护数据库相关的应用程序。
3. 连接MySQL数据库在使用MyBatis Plus连接MySQL数据库之前,我们需要先在项目中引入相关的依赖。
可以通过Maven或Gradle等构建工具来管理项目的依赖。
在pom.xml或build.gradle文件中添加相应的依赖项,然后进行构建操作。
在Java代码中,我们需要创建一个数据源并配置相关的数据库连接信息。
可以使用MySQL提供的JDBC驱动程序来管理数据库连接。
在MyBatis Plus中,我们可以使用com.mysql.cj.jdbc.Driver作为驱动类,指定数据库的URL、用户名和密码来建立连接。
4. 创建实体类在进行数据库操作之前,我们需要定义与数据库表对应的实体类。
在Java中,我们可以使用POJO(Plain Old Java Object)来表示实体类。
POJO是一种普通的Java对象,不继承任何特定的父类或实现任何特定的接口。
在MyBatis Plus中,实体类需要使用@Table注解来指定对应的数据库表名,使用@Column注解来指定字段名,以及指定主键等属性。
通过在实体类中定义与表对应的字段和属性,我们可以通过MyBatis Plus来进行数据库的增删改查操作。
preparedstatement创建表
preparedstatement创建表技术篇在Java语言中操作数据库是常见的需求,而建表是操作数据库最基本的步骤之一。
Java中,通过PreparedStatement可以很方便地创建、添加、更新表的结构。
下面我们详细介绍一下如何使用PreparedStatement 创建表。
第一步:连接数据库首先,我们需要连接到我们要创建表的数据库。
这一步可以通过JDBC API完成,例如:```java// 定义数据库连接信息String url = "jdbc:mysql://localhost:3306/test";String username = "root";String password = "123456";// 加载数据库驱动Class.forName("com.mysql.jdbc.Driver");// 建立数据库连接Connection connection = DriverManager.getConnection(url, username, password);```第二步:创建PreparedStatement对象将SQL语句传递给PreparedStatement对象,它会预解析SQL语句并缓存它,然后就可以调用PreparedStatement对象的方法来完成表的创建。
```java// SQL语句String sql = "CREATE TABLE IF NOT EXISTS user ("+ "id INT PRIMARY KEY AUTO_INCREMENT,"+ "username VARCHAR(50),"+ "password VARCHAR(50))";// 创建PreparedStatement对象PreparedStatement preparedStatement = connection.prepareStatement(sql);```第三步:执行SQL语句调用PreparedStatement对象的execute方法即可执行SQL语句:```javapreparedStatement.execute();```PreparedStatement还提供了executeQuery()和executeUpdate()方法,可以用来执行查询和更新操作。
java连接Mysql方法和示例
非本人资料,资料来自:/cxwen78/article/details/6863696这网址很多好的资料。
JDBC是Sun公司制定的一个可以用Java语言连接数据库的技术。
一、JDBC基础知识JDBC(Java Data Base Connectivity,java数据库连接)是一种用于执行SQL语句的Java API,可以为多种关系数据库提供统一访问,它由一组用Java语言编写的类和接口组成。
JDBC为数据库开发人员提供了一个标准的API,据此可以构建更高级的工具和接口,使数据库开发人员能够用纯Java API 编写数据库应用程序,并且可跨平台运行,并且不受数据库供应商的限制。
1、跨平台运行:这是继承了Java语言的“一次编译,到处运行”的特点;2、不受数据库供应商的限制:巧妙在于JDBC设有两种接口,一个是面向应用程序层,其作用是使得开发人员通过SQL调用数据库和处理结果,而不需要考虑数据库的提供商;另一个是驱动程序层,处理与具体驱动程序的交互,JDBC驱动程序可以利用JDBC API创建Java程序和数据源之间的桥梁。
应用程序只需要编写一次,便可以移到各种驱动程序上运行。
Sun提供了一个驱动管理器,数据库供应商——如MySQL、Oracle,提供的驱动程序满足驱动管理器的要求就可以被识别,就可以正常工作。
所以JDBC不受数据库供应商的限制。
JDBC API可以作为连接Java应用程序与各种关系数据库的纽带,在带来方便的同时也有负面影响,以下是JDBC的优、缺点。
优点如下:∙操作便捷:JDBC使得开发人员不需要再使用复杂的驱动器调用命令和函数;∙可移植性强:JDBC支持不同的关系数据库,所以可以使同一个应用程序支持多个数据库的访问,只要加载相应的驱动程序即可;∙通用性好:JDBC-ODBC桥接驱动器将JDBC函数换成ODBC;∙面向对象:可以将常用的JDBC数据库连接封装成一个类,在使用的时候直接调用即可。
mysql用来创建数据库对象的命令
MySQL是一种常用的关系型数据库管理系统,它提供了丰富的命令来创建数据库对象,包括数据库、表、视图、索引、存储过程等。
本文将详细介绍MySQL中用于创建数据库对象的命令,并通过事实举例进行说明。
一、创建数据库创建数据库是在MySQL中创建对象的第一步。
可以使用CREATE DATABASE命令来创建数据库,语法如下:CREATE DATABASE database_name;例如,我们要创建一个名为"mydb"的数据库,可以使用以下命令:CREATE DATABASE mydb;二、创建表在数据库中,表是用于存储数据的主要对象。
可以使用CREATE TABLE命令来创建表,语法如下:CREATE TABLE table_name (column1 datatype constraint,column2 datatype constraint,...);例如,我们要创建一个名为"customers"的表,其中包含id、name 和email三个字段,可以使用以下命令:CREATE TABLE customers (id INT PRIMARY KEY,name VARCHAR(50),email VARCHAR(100));三、创建视图视图是基于一个或多个表的查询结果集,可以像表一样使用。
可以使用CREATE VIEW命令来创建视图,语法如下:CREATE VIEW view_name ASSELECT column1, column2, ...FROM table_nameWHERE condition;例如,我们要创建一个名为"customer_view"的视图,显示"customers"表中名字以"S"开头的客户信息,可以使用以下命令:CREATE VIEW customer_view ASSELECT id, name, emailFROM customersWHERE name LIKE 'S%';四、创建索引索引是用于加快数据库查询速度的对象。
java中mysql临时表的写法
java中mysql临时表的写法在Java 中使用MySQL 临时表,你可以通过JDBC(Java Database Connectivity)连接到MySQL 数据库,然后使用SQL 语句执行创建临时表的操作。
以下是一个简单的示例:```javaimport java.sql.Connection;import java.sql.DriverManager;import java.sql.SQLException;import java.sql.Statement;public class CreateTemporaryTableExample {public static void main(String[] args) {// JDBC连接参数String url = "jdbc:mysql://localhost:3306/your_database";String user = "your_username";String password = "your_password";try (Connection connection = DriverManager.getConnection(url, user, password)) { // 创建Statement 对象Statement statement = connection.createStatement();// 创建临时表的SQL 语句String createTemporaryTableSQL = "CREATE TEMPORARY TABLE temp_table_name ("+ "id INT PRIMARY KEY,"+ "name VARCHAR(255)"+ ")";// 执行SQL 语句statement.executeUpdate(createTemporaryTableSQL);System.out.println("Temporary table created successfully!");} catch (SQLException e) {e.printStackTrace();}}}```请确保替换示例中的以下信息:-`jdbc:mysql://localhost:3306/your_database`:将`your_database` 替换为你的MySQL 数据库名称。
java mysql预处理语句
java mysql预处理语句Java与MySQL是常用的编程语言和数据库管理系统,它们的结合可以实现强大的数据处理和管理功能。
在Java中使用MySQL数据库时,可以使用预处理语句来执行SQL查询、插入、更新和删除操作。
预处理语句能够提高程序的执行效率和安全性,同时也使得代码更易于维护和调试。
下面将列举10个常用的Java MySQL预处理语句。
1. 查询操作:```javaString sql = "SELECT * FROM table_name WHERE column_name = ?";PreparedStatement stmt = conn.prepareStatement(sql);stmt.setString(1, value);ResultSet rs = stmt.executeQuery();```上述代码中,将查询语句中的条件值使用占位符"?"表示,然后通过`setString`方法设置占位符的具体值,最后使用`executeQuery`方法执行查询操作,返回查询结果集。
2. 插入操作:```javaString sql = "INSERT INTO table_name (column1, column2)VALUES (?, ?)";PreparedStatement stmt = conn.prepareStatement(sql);stmt.setString(1, value1);stmt.setString(2, value2);int rows = stmt.executeUpdate();```上述代码中,将插入语句中的列值使用占位符"?"表示,然后通过`setString`方法设置占位符的具体值,最后使用`executeUpdate`方法执行插入操作,并返回受影响的行数。
mysql 创建存储过程语法
mysql 创建存储过程语法MySQL是一个广泛使用的关系型数据库管理系统,它提供了存储过程功能,允许用户以程序的方式在数据库中定义和执行一段预先定义好的SQL语句集合,从而实现复杂的业务逻辑。
下面就来介绍一下MySQL创建存储过程的语法。
1. 创建存储过程的基本语法CREATE PROCEDURE procedure_name ([ IN | OUT | INOUT ] parameter_name data_type [, ... ])BEGINsql_statement;...END;其中,CREATE PROCEDURE是创建存储过程的关键字,procedure_name 是存储过程的名称,parameter_name是存储过程的参数名,data_type 是参数的数据类型(支持常用的数据类型,如CHAR、INT、VARCHAR 等),sql_statement是实际执行的SQL语句。
2. 存储过程的参数类型MySQL支持三种参数类型:IN、OUT和INOUT。
IN表示输入参数,接收存储过程调用者的参数值。
OUT表示输出参数,将存储过程的执行结果作为参数返回给调用者。
在存储过程中,必须显式地设置输出参数的初始值。
INOUT表示既是输入参数也是输出参数,即将存储过程的执行结果作为参数返回给调用者,同时还允许存储过程修改输入参数的值。
3. 存储过程的变量除了参数,存储过程还可以定义一些局部变量,在存储过程中用来存储临时数据或者控制语句执行流程。
DECLARE variable_name datatype [DEFAULT value];其中,DECLARE是定义局部变量的关键字,variable_name是变量名称,datatype是变量的数据类型,可以是数字、字符串等,DEFAULT用来为变量指定默认值,value为变量的默认值,可以省略。
4. 存储过程的流程控制在存储过程中,可以使用IF、WHILE、LOOP等控制语句来控制程序的执行流程。
java存储过程写法
java存储过程写法在Java中,可以通过JDBC(Java Database Connectivity)来调用和执行存储过程。
下面我将从多个角度来介绍Java中存储过程的写法。
1. 使用CallableStatement:在Java中,可以使用CallableStatement来调用存储过程。
首先,你需要获取数据库连接,然后创建一个CallableStatement对象,并设置存储过程的参数,最后执行存储过程。
例如:java.Connection conn = DriverManager.getConnection(url, username, password);CallableStatement cs = conn.prepareCall("{callyour_stored_procedure(?, ?)}");cs.setInt(1, parameter1);cs.setString(2, parameter2);cs.execute();2. 使用存储过程注解:一些持久层框架(如MyBatis)提供了注解的方式来调用存储过程。
你可以在Java方法上使用注解来指定要调用的存储过程的名称和参数。
例如(使用MyBatis的@Select注解):java.@Select("{call your_stored_procedure(#{parameter1, mode=IN, jdbcType=INTEGER}, #{parameter2, mode=IN, jdbcType=VARCHAR})}")。
void callStoredProcedure(int parameter1, Stringparameter2);3. 使用存储过程的ORM映射:一些ORM框架(如Hibernate)允许你将存储过程映射为Java方法,然后直接调用这些方法来执行存储过程。
mysql创建方法
mysql创建方法如何使用MySQL创建数据库和表MySQL是一种广泛使用的关系型数据库管理系统,它可以帮助用户存储和管理大量的数据。
在本文中,我们将介绍如何使用MySQL 创建数据库和表。
1. 创建数据库我们需要创建一个数据库来存储我们的数据。
在MySQL中,可以使用CREATE DATABASE语句来创建数据库。
语法如下:CREATE DATABASE database_name;其中,database_name是你想要创建的数据库的名称。
请确保数据库名称唯一,并且遵循命名规范。
2. 选择数据库创建数据库后,我们需要使用USE语句来选择要操作的数据库。
语法如下:USE database_name;通过这个语句,我们可以告诉MySQL我们要在哪个数据库中执行操作。
3. 创建表在选择数据库后,我们可以使用CREATE TABLE语句来创建表。
表是用来组织和存储数据的结构。
语法如下:CREATE TABLE table_name (column1 datatype,column2 datatype,column3 datatype,...);其中,table_name是你想要创建的表的名称。
column1,column2等是表的列名,datatype是列的数据类型。
你可以根据需要在表中定义多个列。
4. 定义列的数据类型在创建表时,我们需要为每个列定义适当的数据类型。
以下是一些常用的MySQL数据类型:- INT:用于存储整数值。
- VARCHAR:用于存储可变长度的字符串。
- CHAR:用于存储固定长度的字符串。
- DATE:用于存储日期值。
- FLOAT:用于存储浮点数值。
根据你的数据要求,选择合适的数据类型来定义列。
5. 定义列的约束除了数据类型,我们还可以为列定义约束。
约束是规定列的取值范围和行为的规则。
以下是一些常用的列约束:- PRIMARY KEY:用于唯一标识表中的行。
- NOT NULL:用于确保列中的值不为空。
mysql存储过程sql语句
mysql存储过程sql语句存储过程是一组预编译的SQL语句,可以在MySQL数据库中进行存储和重复调用。
下面是一个简单的存储过程示例,用于在数据库中创建一个新的表:sql.DELIMITER //。
CREATE PROCEDURE create_new_table()。
BEGIN.CREATE TABLE new_table (。
id INT AUTO_INCREMENT PRIMARY KEY,。
name VARCHAR(50)。
);END //。
DELIMITER ;在这个示例中,我们首先使用`DELIMITER`语句将语句结束符号改为`//`,然后使用`CREATE PROCEDURE`语句定义了一个名为`create_new_table`的存储过程。
在`BEGIN`和`END`之间是存储过程的主体,其中包含了要执行的SQL语句。
在这个例子中,我们使用`CREATE TABLE`语句创建了一个名为`new_table`的新表,该表包含一个自增的id列和一个名为name的列。
最后,我们使用`DELIMITER ;`将语句结束符号改回分号。
除了创建表,存储过程还可以执行各种其他操作,包括插入、更新、删除数据,以及执行复杂的查询和逻辑处理。
存储过程可以接受参数,并根据参数的不同执行不同的逻辑。
存储过程的灵活性和可重用性使其成为管理和执行复杂数据库操作的有力工具。
需要注意的是,存储过程的语法和用法可能会因不同的数据库系统而有所不同,上面的示例是针对MySQL数据库的存储过程语法。
如何在MySQL中创建和使用临时存储过程
如何在MySQL中创建和使用临时存储过程MySQL是一种广泛使用的关系型数据库管理系统,可以为用户提供高效、可靠的数据存储和管理。
在MySQL中,存储过程是一种事先编写好的SQL语句集合,可以在需要的时候被调用。
临时存储过程是存储在数据库服务器的内存中,仅在会话期间存在,会话结束后自动清除的存储过程。
本文将介绍如何在MySQL中创建和使用临时存储过程。
一、创建临时存储过程的语法在MySQL中,使用CREATE PROCEDURE语句可以创建存储过程。
其基本语法如下:CREATE PROCEDURE procedure_name ([parameter_list])[characteristic_list] routine_body其中,procedure_name是存储过程的名称,parameter_list是存储过程的输入参数列表,characteristic_list是存储过程的特性列表,routine_body是存储过程内部的SQL语句集合。
二、创建一个简单的临时存储过程下面以一个简单的示例来说明如何创建一个临时存储过程。
假设我们有一个名为Employee的表,其中包含员工的姓名和年龄两列。
我们需要创建一个临时存储过程,用于查询指定年龄以上的员工信息。
首先,我们可以使用以下语句创建一个名为get_employee的临时存储过程:CREATE PROCEDURE get_employee(IN min_age INT)BEGINSELECT * FROM Employee WHERE age >= min_age;END;在上述语句中,我们定义了一个输入参数min_age,然后使用SELECT语句查询满足条件的员工信息。
三、调用临时存储过程在创建临时存储过程后,我们可以使用CALL语句来调用它。
下面是调用get_employee存储过程的示例:CALL get_employee(30);在上述语句中,我们将30作为参数传递给get_employee存储过程,从而查询年龄大于等于30的员工信息。
java生成达梦数据库建表语句
一、介绍在现代软件开发中,数据库是必不可少的一部分,而创建数据库表是数据库设计的重要环节之一。
在使用Java语言开发软件的过程中,我们常常会使用到达梦数据库作为后台数据库。
本文将从Java语言生成达梦数据库建表语句展开讨论。
二、Java生成达梦数据库建表语句的方式1. 使用JDBCJava Database Connectivity(JDBC)是Java语言中用于与数据库进行交互的API。
通过JDBC,我们可以使用Java代码连接并操作数据库。
在使用JDBC生成达梦数据库建表语句时,我们可以通过以下步骤实现:1)导入数据库驱动2)建立数据库连接3)创建Statement对象4)执行SQL语句5)关闭数据库连接通过以上步骤,我们可以在Java中调用达梦数据库的API,生成数据库建表语句。
2. 使用ORM框架ORM(Object-Relational Mapping)是一种编程技术,它允许我们在Java中以面向对象的方式操作数据库。
在使用ORM框架生成达梦数据库建表语句时,我们可以通过以下步骤实现:1)选择合适的ORM框架,如Hibernate、MyBatis等2)创建实体类(Entity)3)配置映射关系4)进行数据库操作通过ORM框架,我们可以将Java中的实体类映射到达梦数据库中的表,从而生成数据库建表语句。
三、Java生成达梦数据库建表语句的示例代码以下是使用JDBC和ORM框架分别生成达梦数据库建表语句的示例代码:1. 使用JDBC```javaimport java.sql.Connection;import java.sql.DriverManager;import java.sql.SQLException;import java.sql.Statement;public class CreateDmTableWithJDBC {public static void main(String[] args) {String url = "jdbc:damm://localhost:5236/demo";String user = "username";String password = "password";String sql = "CREATE TABLE employee " +"(id INTEGER not NULL, " +" name VARCHAR(255), " +" age INTEGER, " +" PRIMARY KEY ( id ))";try (Connection conn = DriverManager.getConnection(url, user, password);Statement stmt = conn.createStatement()) {stmt.execute(sql);System.out.println("Table created successfully");} catch (SQLException e) {System.out.println(e.getMessage());}}}```2. 使用ORM框架(以Hibernate为例)```javaimport org.hibernate.Session;import org.hibernate.SessionFactory;import org.hibernate.cfg.Configuration;import.example.Employee;public class CreateDmTableWithHibernate {public static void main(String[] args) {Configuration config = newConfiguration().configure().addAnnotatedClass(Employee.class); SessionFactory sessionFactory =config.buildSessionFactory();Session session = sessionFactory.openSession();session.beginTransaction();session.getTransaction()mit();session.close();sessionFactory.close();}}```四、总结通过本文我们可以了解到,在Java语言中生成达梦数据库建表语句有多种方式,包括使用JDBC和ORM框架。
java根据实体类生成数据库表的方法
java根据实体类生成数据库表的方法根据实体类生成数据库表通常涉及到以下几个步骤:1. 定义实体类:首先,你需要定义一个或多个实体类,这些类通常对应于数据库中的表。
2. 使用ORM工具:你可以使用对象关系映射(ORM)工具,如Hibernate或MyBatis,来根据实体类生成数据库表。
这些工具可以根据实体类的属性和注解自动生成相应的数据库表结构。
3. 配置数据库连接:在开始之前,你需要配置数据库连接信息,包括数据库类型、URL、用户名和密码等。
4. 执行生成表的操作:你可以通过编写代码或运行相应的ORM工具命令来执行生成表的操作。
通常,ORM工具会提供一个命令或方法来根据实体类生成数据库表。
下面是一个简单的示例,演示如何使用Hibernate根据实体类生成数据库表:1. 定义实体类import ;import ;Entitypublic class User {Idprivate Long id;private String name;private String email;// getters and setters}```2. 配置数据库连接你需要配置``文件来指定数据库连接信息。
3. 执行生成表的操作使用以下命令或方法执行生成表的操作:import ;import ;public class GenerateTable {public static void main(String[] args) {Configuration configuration = new Configuration();(""); // 加载配置文件SchemaExport schemaExport = newSchemaExport(configuration);(";"); // 设置分隔符(""); // 输出文件名(true); // 设置输出格式化(true, false, false, false); // 执行生成表的操作}}```这将会根据实体类生成一个名为``的文件,其中包含了创建数据库表的SQL 语句。
mysql根据表字段创建对象的方法
mysql根据表字段创建对象的方法MySQL是一种关系型数据库管理系统,使用标准SQL查询语言,是最常用的数据库之一。
在MySQL中,可以通过表字段的定义来创建数据库对象。
首先,我们需要了解表字段的概念。
表字段是数据库表的组成部分,用于存储表中不同列的数据。
每个字段都有其自己的名称和数据类型,用于定义存储的数据的格式。
在MySQL中,常见的数据类型包括整数、浮点数、字符型、日期型等。
在MySQL中创建对象的方法主要包括创建表、创建存储过程、创建函数和创建视图。
1.创建表:通过定义表字段来创建表对象。
可以使用CREATE TABLE语句来创建表,通过指定字段名称和数据类型来定义表的各个字段。
例如,以下语句可以创建一个名为students的表,并定义了两个字段id和name:CREATE TABLE students (id INT(11),name VARCHAR(50));2.创建存储过程:存储过程是一组预定义的SQL语句集合,可以在需要时调用执行。
通过使用CREATE PROCEDURE语句来创建存储过程对象。
可以在存储过程中定义参数和变量,以及使用SQL语句操作数据库。
例如,以下语句创建了一个名为get_students的存储过程,用于查询学生表中的数据:CREATE PROCEDURE get_students()BEGINSELECT * FROM students;END;3.创建函数:函数是一段可重复使用的代码,用于执行特定的操作并返回结果。
在MySQL中,可以使用CREATE FUNCTION语句来创建函数对象。
函数可以包含输入参数和输出结果,并使用SQL语句对数据进行处理。
例如,以下语句创建了一个名为get_student_name的函数,用于根据学生ID查询学生姓名:CREATE FUNCTION get_student_name(student_id INT)RETURNS VARCHAR(50)BEGINDECLARE student_name VARCHAR(50);SELECT name INTO student_name FROM students WHERE id = student_id;RETURN student_name;END;4.创建视图:视图是虚拟表,它是基于一个或多个表的查询结果集。
Java中怎么创建表格-创建方式-创建操作
Java中怎么创建表格-创建方式-创建操作Java表格是最常用的数据统计组件之一,其形式是由多行和多列组成的二维表格,其创建方式有这些:1.使用数组创建;2.使用向量来创建表格。
以下是关于Java中怎么创建表格的具体介绍。
一、表格创建〔java〕x.swing.JTable类所创建的对象是一个表,可以使用以下两种方法来创建。
1. 使用数组创建使用JTable类的以下构造方法可以依据指定的列名数组和数据数组创建表格。
JTable(Object[][] rowData, Object[] columnNames)(1)rowData:封装表格数据的数组。
(2)columnNames:装表格列名的数组。
在使用表格时,通常会将其添加到滚动面板中,然后将滚动面板添加到相应的位置,实现表格的显示。
2. 使用向量来创建表格在JTable类中还提供了以下构造方法,使用指定的表格列名向量和表格数据向量创建表格。
JTable(Vector rowData, Vector columnNames)(1)rowData:封装表格数据的向量。
(2)columnNames:封装表格列名的向量。
二、定制表格一旦创建了表,就必须要做一些定义来适应特定的使用状况。
默认状况下,一个表格可以通过双击表格中的单元格进行编辑。
如果你不想提供这个功能,你可以通过重写JTable类的isCellEditable(int row, int column)方法来禁用它。
默认状况下,该方法返回boolean型值true,表示指定的单元格可以被编辑,如果返回false,则表示不能被编辑。
如果表格只有几列,通常不必须要表格列的可重新排列功能。
如果表格的列较多,就可以把一些重要的列移动到表格前几列的位置。
这样能确保对表格中重要信息的浏览。
表格列的移动可以通过javax.swing.table.JTableHeader类的setReorderingAllowed(boolean reorderingAllowed)方法来实现。
JAVA通过MyBatis调用MySql存储过程和函数
JAV A通过MyBatis调用MySql存储过程和函数1.引言无论是采用SPRING MVC框架开发WEB画面,还是开发需按一定时间间隔执行的批处理,都可能要调用数据库的存储过程或函数。
其间调用参数设置不正会浪费大量调试时间初学者甚至放弃使用存储过程。
本文记录了通过MyBatis调用MySql存储过程和函数的具体参数设置内容,供参考。
2.MySql存储过程例/*全公司员工下一年度带薪休假一发赋予处理*/CREATE DEFINER=`DBuser`@`%` PROCEDURE `paid_vacation_compute `( OUT p_返回值 INT(11) ,INOUT p_员工号 CHAR(3) ,p_操作者ID VARCHAR(3))PROC_START:BEGIN/* 变量声明 */DECLARE done INT; #异常退出控制变量DECLARE empNo CHAR(3); #员工号DECLARE dateHire date; #分公司就职日DECLARE workYears INT; #集团内工作年数DECLARE lastYearRemainDays FLOAT; #昨年残日数(允许以小时为单位休假)DECLARE nowYearleaveDays FLOAT; #今年休暇日数(允许以小时为单位休假)DECLARE elapseYear INT; #入集团经过年度数/* 游标声明 */#上年带薪休假数据DECLARE staffPaidVacationDaysCur CURSOR FORSELECT a.EMP_NO, #员工号a.DATE_HIRE, #入职日期a.WORK_YEARS, #工作年限b.REMAIN_DAYS # 上年带薪休假应休但未休残日数FROM T_EMPLOYEE AS a,T_PAID_VACATION AS bWHERE a. EMP_NO = b. EMP_NO/* 程序退出规定声明 */DECLARE CONTINUE HANDLER FOR NOT FOUND SET SET done = 1;DECLARE EXIT HANDLER FOR SQLWARNING SET done = 2;DECLARE CONTINUE HANDLER FOR SQLEXCEPTIONBEGINSET done = 3;ROLLBACK; #SQL异常回滚END;/* 1.输入参数妥当性检查 */IF (p_操作者 IS NULL OR p_操作者 = '') THENSET p_返回值 = 9;LEAVE PROC_START;END IF;SET done = 0;START TRANSACTION;loop_label:LOOP# 读入一条记录, 代入到各个变量中FETCH staffPaidVacationDaysCurINTO empNo, #员工号dateHire, #就职日workYears, #集团内工作年数lastYearRemainDays #昨年残日数;IF done = 1 THENLEAVE loop_label;END IF;/*根据集团内工作年限+分公司就职年限计算下一年度带薪天数*/ SET elapseYear = YEAR(current_timestamp)- Year(dateHire)+ workYears;IF elapseYear = 0 THENSET nowYearLeaveDays = 10;ELSEIF elapseYear = 1 THENSET nowYearLeaveDays = 11;ELSEIF elapseYear = 2 THENSET nowYearLeaveDays = 12;ELSEIF elapseYear = 3 THENSET nowYearLeaveDays = 14;ELSEIF elapseYear = 4 THENSET nowYearLeaveDays = 16;ELSEIF elapseYear = 5 THENSET nowYearLeaveDays = 18;ELSEIF elapseYear >= 6 THENSET nowYearLeaveDays = 20;END IF;SET done = 0;SET p_员工号= empNo;UPDATE T_PAID_VACATIONSETLAST_YEAR_REMAIN_DAYS = lastYearRemainDays,THIS_YEAR_BASE_DAYS = nowYearLeaveDays,UPDATE_DATETIME = current_timestamp,UPDATE_USER_ID = 'SYS',UPDATE_TERMINAL_ID = 'MANUAL'WHERE EMP_NO = CONVERT(empNo USING binary);IF done = 3 THENSET p_返回值 = 6;LEAVE PROC_START;END IF;END LOOP;COMMIT;END3.MySql函数例CREATE DEFINER=`DBuser`@`%` FUNCTION ` paid_vacation_compute `( p_员工号 CHAR(3) ,p_操作者ID VARCHAR(3))) RETURNS int(11)BEGIN/* 变量声明 */DECLARE done INT; #异常退出控制变量DECLARE empNo CHAR(3); #员工号DECLARE dateHire date; #分公司就职日DECLARE workYears INT; #集团内工作年数DECLARE lastYearRemainDays FLOAT; #昨年残日数(允许以小时为单位休假)DECLARE nowYearleaveDays FLOAT; #今年休暇日数(允许以小时为单位休假)DECLARE elapseYear INT; #入集团经过年度数/* 游标声明 */#上年带薪休假数据DECLARE staffPaidVacationDaysCur CURSOR FORSELECT a.EMP_NO, #员工号a.DATE_HIRE, #入职日期a.WORK_YEARS, #工作年限b.REMAIN_DAYS # 上年带薪休假应休但未休残日数FROM T_EMPLOYEE AS a,T_PAID_VACATION AS bWHERE a. EMP_NO = b. EMP_NO/* 程序退出规定声明 */DECLARE CONTINUE HANDLER FOR NOT FOUND SET SET done = 1;DECLARE EXIT HANDLER FOR SQLWARNING SET done = 2;DECLARE CONTINUE HANDLER FOR SQLEXCEPTIONBEGINSET done = 3;ROLLBACK; #SQL异常回滚END;/* 1.输入参数妥当性检查 */IF (p_操作者 IS NULL OR p_操作者 = '') THENRETURN 9;END IF;SET done = 0;START TRANSACTION;loop_label:LOOP# 读入一条记录, 代入到各个变量中FETCH staffPaidVacationDaysCurINTO empNo, #员工号dateHire, #就职日workYears, #集团内工作年数lastYearRemainDays #昨年残日数;IF done = 1 THENLEAVE loop_label;END IF;/*根据集团内工作年限+分公司就职年限计算下一年度带薪天数*/ SET elapseYear = YEAR(current_timestamp)- Year(dateHire)+ workYears;IF elapseYear = 0 THENSET nowYearLeaveDays = 10;ELSEIF elapseYear = 1 THENSET nowYearLeaveDays = 11;ELSEIF elapseYear = 2 THENSET nowYearLeaveDays = 12;ELSEIF elapseYear = 3 THENSET nowYearLeaveDays = 14;ELSEIF elapseYear = 4 THENSET nowYearLeaveDays = 16;ELSEIF elapseYear = 5 THENSET nowYearLeaveDays = 18;ELSEIF elapseYear >= 6 THENSET nowYearLeaveDays = 20;END IF;SET done = 0;SET p_员工号= empNo;UPDATE T_PAID_VACATIONSETLAST_YEAR_REMAIN_DAYS = lastYearRemainDays,THIS_YEAR_BASE_DAYS = nowYearLeaveDays,UPDATE_DATETIME = current_timestamp,UPDATE_USER_ID = 'SYS',UPDATE_TERMINAL_ID = 'MANUAL'WHERE EMP_NO = CONVERT(empNo USING binary);IF done = 3 THENRETURN 6;END IF;END LOOP;COMMIT;END4.MySql存储过程调用时的iBatis用Mapper例BaseInfoEditMapper.xml<?xml version="1.0"encoding="UTF-8"?><!DOCTYPE mapperPUBLIC"-////DTD Mapper 3.0//EN""/dtd/ibatis-3-mapper.dtd"><mapper namespace="com.xxx.web.mapper.base_info_edit"><select id="VacationProcedure"parameterType="VacationBean"statementType="CALLABLE"> { call paid_vacation_compute (#{ReturnValue,javaType=INTEGER, jdbcType=INTEGER, mode=OUT},#{StaffNumber,javaType=String, jdbcType=CHAR, mode=INOUT},#{HireDate,javaType=String, jdbcType=VARCHAR, mode=IN},#{OperateID,javaType=String, jdbcType=VARCHAR, mode=IN})}</select></mapper>5.MySql函数调用时的iBatis用Mapper例BaseInfoEditMapper.xml<?xml version="1.0"encoding="UTF-8"?><!DOCTYPE mapperPUBLIC"-////DTD Mapper 3.0//EN""/dtd/ibatis-3-mapper.dtd"><mapper namespace="com.xxx.web.mapper.base_info_edit"><select id="VacationProcedure"parameterType="VacationBean"statementType="CALLABLE"> { #{ReturnValue,javaType=INTEGER, jdbcType=INTEGER, mode=OUT} =call paid_vacation_compute (#{StaffNumber,javaType=String, jdbcType=CHAR, mode=IN},#{HireDate,javaType=String, jdbcType=VARCHAR, mode=IN},#{OperateID,javaType=String, jdbcType=VARCHAR, mode=IN} )} </select></mapper>6.JAVA调用例1(MySql存储过程和函数相同)package com.XXX.impl;import java.util.ArrayList;import java.util.List;import com.XXX.web.bean.VacationCreateBean;import com.XXX.web.dao.BaseInfoEditDAO;import com.XXX.web.util.BasicSqlSupport;public class BaseInfoEditDAOImpl extends BasicSqlSupport implements BaseInfoEditDAO { public boolean addBaseInfo(BaseInfoEditBean objUserInfo) throws Exception {boolean blnFlag=false;//成功FLAG;//全公司员工下一年度带薪休假一发赋予处理VacationCreateBean objVacationCreateBean = new VacationCreateBean();objVacationCreateBean.setStaffNumber(objUserInfo.getSTAFF_NUMBER());objVacationCreateBean.setHireDate(objUserInfo.getDATE_HIRE().toString());objVacationCreateBean.setOperateID(objUserInfo.getCREATE_USER_ID());objVacationCreateBean.setDhcWorkYearsShinKi(objUserInfo.getDHC_WORK_YEARS());String returnValue = (String)this.session.selectOne("com.XXX.web.mapper.base_info_edit.VacationProcedure", objVacationCreateBean);//System.out.println("staffNumber=" + objVacationCreateBean.getStaffNumber());//System.out.println("result=" + objVacationCreateBean.getReturnValue());//System.out.println("returnValue=" + returnValue);//追加結果の判断blnFlag=true;return blnFlag;}}7.処理DAO接口package com.XXX.web.dao;import java.util.List;import com.XXX.web.bean.BaseInfoEditBean;/*** 员工基本信息画面の処理DAO*/public interface BaseInfoEditDAO {public List<BaseInfoEditBean> selectAuthoriyList() throws Exception;public String selectStaffId() throws Exception;public int selectOpetateTimeNum(String strStaffNumber) throws Exception;public boolean addBaseInfo(BaseInfoEditBean objUserInfo) throws Exception;public boolean updateBaseInfo(BaseInfoEditBean objUserInfo) throws Exception;public BaseInfoEditBean searchBaseInfo(String strStaffNumber) throws Exception; }8.共同処理package com.XXX.web.util;import org.apache.ibatis.session.SqlSession;public class BasicSqlSupport{protected SqlSession session;public SqlSession getSession() {return session;}public void setSession(SqlSession session) {this.session = session;} }9. DAO与MAP间的交互BEANpackage com.XXX.web.bean;import java.io.Serializable;public class VacationCreateBean implements Serializable{private int ReturnValue;private String StaffNumber;private String HireDate;private String OperateID;private int WorkYearsShinKi;public int getReturnValue() {return ReturnValue;}public void setReturnValue(int returnValue) {ReturnValue = returnValue;}public String getStaffNumber() {return StaffNumber;}public void setStaffNumber(String staffNumber) {StaffNumber = staffNumber;}public String getHireDate() {return HireDate;}public void setHireDate(String hireDate) {HireDate = hireDate;}public String getOperateID() {return OperateID;}public void setOperateID(String operateID) {OperateID = operateID;}public int getDhcWorkYearsShinKi() {return dhcWorkYearsShinKi;}public void setDhcWorkYearsShinKi(int dhcWorkYearsShinKi) {this.dhcWorkYearsShinKi = dhcWorkYearsShinKi;}}10.通过MAIN函数进行调用package com.ohc.pms.batch;import java.io.FileInputStream;import java.io.IOException;import java.sql.CallableStatement;import java.sql.Connection;import java.sql.DriverManager;import java.sql.SQLException;import java.util.Properties;import org.apache.log4j.Logger;import org.apache.log4j.PropertyConfigurator;public class VacationCreate {/**JDBC驱动名 */static String jdbcDriver = "com.mysql.jdbc.Driver";/**DB URL */static String dbURL = "jdbc:mysql://172.999.999.35:3306/empdb";/** DB用户名 */static String user = "empuser";/**DB密码 */static String pass = "empuser123";/**日志输出 */static protected Logger log = Logger.getLogger(VacationCreate.class );public static void main(String[] args) {Connection conn = null;CallableStatement stmt = null;try{PropertyConfigurator.configure(System.getProperty("user.dir") + "\\" + "log4j.properties");("実行路径:" + System.getProperty("user.dir"));String fileName = "jdbc.properties"; // 属性文件名Properties conf = new Properties();try {conf.load(new FileInputStream(System.getProperty("user.dir") + "\\" + "jdbc.properties"));} catch (IOException e) {System.err.println("Cannot open " + fileName + ".");e.printStackTrace();System.exit(-1); // 程序終了}// 读入jdbcDriver = conf.getProperty("driver");dbURL = conf.getProperty("url");user = conf.getProperty("user");pass = conf.getProperty("password");//JDBC driver登録Class.forName("com.mysql.jdbc.Driver");("DB连接。
使用存储过程建表
使用存储过程建表
存储过程是一种能够对数据库进行操作的程序,它可以将多个SQL语句组合在一起,从而提高数据库的执行效率。
在数据库设计中,使用存储过程建表可以帮助开发人员更快速、更稳定地完成数据库的构建。
以下是使用存储过程建表的一些具体步骤:
1. 创建存储过程
在SQL Server中,使用CREATE PROCEDURE语句可以创建一个存储过程。
例如,可以创建一个名为sp_create_table的存储过程来辅助我们建立新的表格。
2. 编写存储过程的代码
在创建存储过程后,需要编写相应的代码,来实现创建新表的功能。
代码中需要定义表格的字段名、数据类型、长度、默认值、约束条件等信息。
3. 执行存储过程
在存储过程的代码编写完成后,可以使用EXECUTE语句来运行存储过程。
例如EXEC sp_create_table可以执行名为sp_create_table 的存储过程来创建新的表格。
4. 修改存储过程
当数据库需求发生改变时,需要对存储过程进行修改。
通过ALTER PROCEDURE语句可以修改存储过程的代码,从而达到更新数据表信息的目的。
需要注意的是,存储过程的使用需要按照数据库设计的规范进行操作。
例如,在定义数据类型时,需要尽可能避免使用过大的长度,避免浪费数据库资源。
此外,在创建表格时,需要考虑各个字段之间的关联关系,以及约束条件的设置,以确保数据的完整性和一致性。
总之,使用存储过程实现建表可以让数据库的操作更加高效、稳
定,也更容易管理。
当初期数据库设计结构复杂时,可以考虑使用存储过程来进行建表操作,提高开发效率,减轻维护和升级的难度。
mysql 存储过程写法
mysql 存储过程写法MySQL 存储过程的写法如下:1. 创建存储过程```CREATE PROCEDURE procedure_name (in parameter_type parameter_name, out parameter_type parameter_name, inout parameter_type parameter_name)BEGIN-- 存储过程体END;```其中,`parameter_type` 表示参数类型,`parameter_name` 表示参数名称。
`in` 表示输入参数,`out` 表示输出参数,`inout` 表示传入传出参数。
2. 编写存储过程体存储过程体是存储过程的主体部分,通过 SQL 语句实现所需的功能。
```BEGIN-- 声明变量DECLARE variable_name variable_type;-- 赋值SET variable_name = value;-- 条件判断IF condition THEN-- SQL 语句ELSE-- SQL 语句END IF;-- 循环语句WHILE condition DO-- SQL 语句END WHILE;-- 返回结果SELECT column_name INTO variable_name FROM table_name WHERE condition;END;```3. 调用存储过程调用存储过程,使用 `CALL` 关键字和存储过程名称。
```CALL procedure_name(parameter);```其中,`parameter` 是存储过程的参数,可根据需要传入相应的值。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
MySql 数据库用java程序创建表以及存储过程
1.同一般的数据库操作基本一样。
2.Statement.executeUpdate(String sql); 这个方法可以用来执行DDL语句,以及执行更新操作。
3.需要注意 CallableStatement 接口的用法。
用于执行 SQL 存储过程的接口。
JDBC API 提供了一个存储过程 SQL 转义语法,该语法允许对所有 RDBMS 使用标准方式调用存储过程。
此转义语法有一个包含结果参数的形式和一个不包含结果参数的形式。
如果使用结果参数,则必须将其注册为 OUT 型参数。
其他参数可用于输入、输出或同时用于二者。
参数是根据编号按顺序引用的,第一个参数的编号是 1。
{?= call <procedure-name>[<arg1>,<arg2>, ...]}
{call <procedure-name>[<arg1>,<arg2>, ...]}
IN 参数值是使用从 PreparedStatement 中继承的 set 方法设置的。
在执行存储过程之前,必须注册所有 OUT 参数的类型;它们的值是在执行后通过此类提供的 get 方法检索的。
4.需要注意存储过程调用的方法。
5.registerOutParameter 的使用方法。
void registerOutParameter(int parameterIndex, int sqlType) throws SQLException
按顺序位置 parameterIndex 将 OUT 参数注册为 JDBC 类型 sqlType。
所有 OUT 参数都必须在执行存储过程前注册。
由 sqlType 指定的 OUT 参数的JDBC 类型确定必须用于 get 方法来读取该参数值的 Java 类型。
如果预期返回给此输出参数的 JDBC 类型是取决于此特定数据库的,则 sqlType 应该是java.sql.Types.OTHER。
方法 getObject(int) 检索该值。
参数:
parameterIndex - 第一个参数是 1,第二个参数是 2,依此类推。
sqlType - java.sql.Types 定义的 JDBC 类型代码。
如果参数是 JDBC 类型NUMERIC 或 DECIMAL,则应使用接受标度值的那种。
下面是一个具体的程序实例:
/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package gui.database;
import java.sql.*;
import java.util.logging.Level;
import java.util.logging.Logger;
/**
*
* @author zhfdai
*/
public class DBManager {
public static void main(String[] args) {
final String DATABASE_NAME = "jdbc:mysql://localhost:3306/test"; final String USER_NAME = "root";
final String PASSWORD = "zhfdai";
Connection connection; //为数据库建立的连接
Statement statement; //将执行的SQL语句
CallableStatement callable; //将执行的SQL存储过程
try {
Class.forName("org.gjt.mm.mysql.Driver");
connection = DriverManager.getConnection(DATABASE_NAME, USER_NAME, PASSWORD);
statement = connection.createStatement();
/*
创建时,先检查该数据库中该项是否已经存在。
若存在,就删除。
*/
String checkTable = "DROP TABLE IF EXISTS test.teacher;"; statement.executeUpdate(checkTable);
String createTable = "Create table test.teacher(name varchar(20) not null primary key ,age int not null);";
statement.executeUpdate(createTable);
String checkProcedure1 = "DROP PROCEDURE IF EXISTS
test.queryall";
statement.executeUpdate(checkProcedure1);
String createProcedure1 = "CREATE PROCEDURE test.queryall() BEGIN SELECT * FROM test.teacher; END";
statement.executeUpdate(createProcedure1);
String checkProcedure2 = "DROP PROCEDURE IF EXISTS
test.queryCount";
statement.executeUpdate(checkProcedure2);
String createProcedure2 = "CREATE PROCEDURE
test.queryCount(OUT param INT) BEGIN SELECT COUNT(*) INTO param FROM test.teacher; END";
statement.executeUpdate(createProcedure2);
String query = "queryall";
callable = connection.prepareCall("{call " + query + "}"); ResultSet rs = callable.executeQuery();
System.out.println("Column :" +
rs.getMetaData().getColumnCount());
System.out.println("Table:" +
rs.getMetaData().getTableName(1));
String queryCount = "queryCount(?)";
callable = connection.prepareCall("{ call " + queryCount + " }");
callable.registerOutParameter(1,
Types.INTEGER); //设定参数的数据类型。
callable.executeQuery(); //获取参数所得值。
int rowCount = callable.getInt(1);
System.out.println("The number of rows is " + rowCount);
} catch (SQLException ex) {
Logger.getLogger(DBManager.class.getName()).log(Level.SEV ERE, null, ex);
} catch (ClassNotFoundException ex) {
Logger.getLogger(DBManager.class.getName()).log(Level.SEV ERE, null, ex);
}
}
}。