基于JAVA和Oracle数据库实现的项目信息管理系统

WonderBoy

发布日期: 2018-11-05 15:14:59 浏览量: 3475
评分:
star star star star star star star star star star_border
*转载请注明来自write-bug.com

1 需求分析

1.1 背景

项目管理系统,是反映公司员工资料,项目负责部门和项目进度,设备采购软件系统,是管理项目的有效工具。

面向用户:对项目进度跟踪,公司人员信息管理和设备管理的公司。只能由公司内部查看数据库中的数据。要求使用本系统的用户管理系统的使用有所了解,知道基本的操作和使用过程的注意事项。

1.2 系统目标

系统对外部封闭,不允许外部人员访问公司项目管理系统中的数据库。能够安全的访问系统独立的数据库。程序实现数据库数据的直观显示,保证数据库的能够为公司提供较为方便和基础的项目管理服务,能够为公司管理层提供监督渠道。

数据分析:员工的基本信息,部门的基本信息,项目的基本信息,设备基本信息

1.3 功能分析

项目管理系统应该能够提供以下功能:管理员登陆、员工信息管理、部门信息管理、项目信息管理、设备信息管理。

  • 管理员登录:项目管理系统采用Oracle数据库连接的服务名,用户名和口令(密码)验证模式,进入项目管理系统前项目管理员必须在登陆界面输入验证信息方可进入项目管理系统的主界面进行相应的操作

  • 学生信息管理:学生信息管理包含五个模块:学生信息的浏览、添加、删除、查询、修改

  • 部门信息管理:包含一个模块:部门经理信息查询

  • 项目信息管理:包含两个模块:根据项目经理的姓名查询项目的完成情况、查询某个项目的设备购买情况

  • 设备信息管理:包含三个模块:设备费用查询、设备供应商查询、添加设备

1.4 性能需求分析

  • 系统易操作性:项目管理系统应该做到操作简单,界面友好,使得用户可以快速上手使用,不受到专业知识的限制

  • 系统可维护性:由于系统涉及的信息比较多,数据库中的数据需定期修改,系统可利用的空间及性能也随之下降,为了使系统更好地运转,用户可以对系统数据及一些简单的功能进行独立的维护及调整

2 概念设计

2.1 概念模型(E-R图)

2.2 数据字典

数据字典包括的项目有数据项、数据结构、数据流、数据存储、加工逻辑和外部实体。可使用一些符号来表示数据结构、数据流和数据存储的组成。

2.2.1 员工表

数据元素 数据类型 数据长度 数据描述
w_id VARCHAR2 4 员工编号
w_name VARCHAR2 16 员工姓名
sex CHAR 2 员工性别
age CHAR 20 员工年龄
contract_date DATE 合同日期
d_id VARCHAR2 4 部门编号
d_name VARCHAR2 12 部门名称
post VARCHAR2 6 员工职务

2.2.2 部门表

数据元素 数据类型 数据长度 数据描述
d_id VARCHAR2 4 部门编号
d_name VARCHAR2 12 部门名称
m_id VARCHAR2 4 部门经理编号
m_name VARCHAR2 8 部门经理姓名
w_num NUMBER 员工人数

2.2.3 项目表

数据元素 数据类型 数据长度 数据描述
p_id VARCHAR2 4 项目编号
p_name VARCHAR2 16 项目名称
d_id VARCHAR2 4 部门名称
w_id VARCHAR2 4 项目经理编号
fund FLOAT 126 项目经费
type VARCHAR2 4 项目类型
signing_time DATE 签订时间
complete_time DATE 应完成时间
check_time DATE 验收时间
remarks VARCHAR2 8 备注

2.2.4 设备表

数据元素 数据类型 数据长度 数据描述
e_id VARCHAR2 4 设备编号
e_name VARCHAR2 12 设备名称
fee FLOAT 设备费用
supplier VARCHAR2 12 供应商
p_id VARCHAR2 4 项目编号
remarks VARCHAR2 8 备注

2.3 数据流图

数据流图(Data Flow Diagram)是一种图形化技术,它描绘信息流和数据从输入到输出的过程中所经受的变换。根据数据流图,可以分析出程序所需的模块和模块之间的调用关系。

如下图所示,在项目管理系统,在用户界面捕捉用户的操作,接受事务后数据流流向不同的模块。

3 逻辑结构设计

3.1 关系描述

  • 员工与部门的关系:n:1一个员工只能属于一个部门,一个部门可以有多个员工

  • 部门与项目的关系:1:n一个部门可以负责多个项目,一个项目只能由一个部门负责

  • 员工与项目的关系:m:n一个员工可以实现多个项目,一个项目可以由多个员工实现

  • 员工与设备的关系:1:n一个员工可以采购多个设备,一个设备只能由一个员工采购

  • 项目与设备的关系:1:n一个项目可以使用多个设备,一个设备只能由一个部门使用

3.2 系统结构图

3.3 流程图

4 系统实施

4.1 建表语句

  1. /*==============================================================*/
  2. /* Table: "worker" */
  3. /*==============================================================*/
  4. create table "worker"
  5. (
  6. "w_id" VARCHAR2(4) not null,
  7. "w_name" VARCHAR2(8),
  8. "sex" CHAR(2),
  9. "age" CHAR(2),
  10. "contract_date" DATE,
  11. "post" VARCHAR2(8),
  12. "d_id" VARCHAR2(4),
  13. constraint PK_WORKER primary key ("w_id")
  14. );
  15. /*==============================================================*/
  16. /* Table: "department" */
  17. /*==============================================================*/
  18. create table "department"
  19. (
  20. "d_id" VARCHAR2(4) not null,
  21. "d_name" VARCHAR2(16),
  22. "m_id" VARCHAR2(4),
  23. constraint PK_DEPARTMENT primary key ("d_id")
  24. );
  25. /*==============================================================*/
  26. /* Table: "project" */
  27. /*==============================================================*/
  28. create table "project"
  29. (
  30. "p_id" VARCHAR2(4) not null,
  31. "p_name" VARCHAR2(16),
  32. "fund" FLOAT(126),
  33. "type" VARCHAR2(4),
  34. "signing_time" DATE,
  35. "complete_time" DATE,
  36. "check_time" DATE,
  37. "m_id" VARCHAR2(4),
  38. "remarks" VARCHAR2(256),
  39. constraint PK_PROJECT primary key ("p_id")
  40. );
  41. /*==============================================================*/
  42. /* Table: "equipment" */
  43. /*==============================================================*/
  44. create table "equipment"
  45. (
  46. "e_id" VARCHAR2(4) not null,
  47. "e_name" VARCHAR2(16),
  48. "fee" FLOAT(126),
  49. "supplier" VARCHAR2(16),
  50. "p_id" VARCHAR2(4),
  51. "remarks" VARCHAR2(256),
  52. constraint PK_EQUIPMENT primary key ("e_id")
  53. );

4.2 插入数据

4.2.1 worker表

  1. INSERT INTO "worker" VALUES ('1008', '马化腾', '男', '29', TO_DATE('20171229201245', 'YYYYMMDDHH24MISS'), '经理', '11');
  2. INSERT INTO "worker" VALUES ('1011', '雷军', '男', '21', TO_DATE('20171220085418', 'YYYYMMDDHH24MISS'), '职员', '11');
  3. INSERT INTO "worker" VALUES ('1006', '司马懿', '男', '56', TO_DATE('20171229202106', 'YYYYMMDDHH24MISS'), '职员', '13');
  4. INSERT INTO "worker" VALUES ('1005', '王超', '男', '38', TO_DATE('20171018161809', 'YYYYMMDDHH24MISS'), '经理', '14');
  5. INSERT INTO "worker" VALUES ('1001', '张三', '男', '26', TO_DATE('20171026143550', 'YYYYMMDDHH24MISS'), '职员', '11');
  6. INSERT INTO "worker" VALUES ('1002', '李四', '男', '25', TO_DATE('20171026143733', 'YYYYMMDDHH24MISS'), '职员', '12');
  7. INSERT INTO "worker" VALUES ('1003', '李玲', '女', '27', TO_DATE('20171026144030', 'YYYYMMDDHH24MISS'), '经理', '13');
  8. INSERT INTO "worker" VALUES ('1004', '王五', '男', '25', TO_DATE('20171026144412', 'YYYYMMDDHH24MISS'), '经理', '14');

4.2.2 department表

  1. INSERT INTO "department" VALUES ('11', '采购部', '1008');
  2. INSERT INTO "department" VALUES ('12', '销售部', '1002');
  3. INSERT INTO "department" VALUES ('13', '策划部', '1003');
  4. INSERT INTO "department" VALUES ('14', '人事部', '1004');

4.2.3 project表

  1. INSERT INTO "project" VALUES ('004', '跨海大桥', 300000000, '桥梁', TO_DATE('20160226150155', 'YYYYMMDDHH24MISS'), TO_DATE('20170326150206', 'YYYYMMDDHH24MISS'), TO_DATE('20171001150213', 'YYYYMMDDHH24MISS'), '1004', NULL);
  2. INSERT INTO "project" VALUES ('001', '京沪高速', 300000, '建筑', TO_DATE('20170901145036', 'YYYYMMDDHH24MISS'), TO_DATE('20171026145042', 'YYYYMMDDHH24MISS'), TO_DATE('20171027145048', 'YYYYMMDDHH24MISS'), '1005', NULL);
  3. INSERT INTO "project" VALUES ('002', '青藏铁路', 1500000, '建筑', TO_DATE('20170701145439', 'YYYYMMDDHH24MISS'), TO_DATE('20170901145459', 'YYYYMMDDHH24MISS'), TO_DATE('20171026145505', 'YYYYMMDDHH24MISS'), '1008', NULL);
  4. INSERT INTO "project" VALUES ('003', '鸟巢', 30000000, '工程', TO_DATE('20170801145900', 'YYYYMMDDHH24MISS'), TO_DATE('20170901145906', 'YYYYMMDDHH24MISS'), TO_DATE('20171004145911', 'YYYYMMDDHH24MISS'), '1003', NULL);

4.2.4 equipment表

  1. INSERT INTO "equipment" VALUES ('101', '挖掘机', 100000, '徐工', '001', NULL);
  2. INSERT INTO "equipment" VALUES ('102', '玻璃', 10000, '通用', '003', NULL);
  3. INSERT INTO "equipment" VALUES ('103', '铝合金', 20000, '上汽', '002', NULL);
  4. INSERT INTO "equipment" VALUES ('104', '液晶', 50000, '京东方', '004', NULL);
  5. INSERT INTO "equipment" VALUES ('105', '台式机', 100000, '清华同方', '003', '办公专用');
  6. INSERT INTO "equipment" VALUES ('108', 'A4纸', 200, '华润', '003', NULL);
  7. INSERT INTO "equipment" VALUES ('109', '键鼠套装', 1000, '达尔优', '003', NULL);

5 运行维护

转储:定期进行静态转储,动态转储,海量转储。

数据库中可能发生各种各样的故障,大致可以分为以下几类:

  • 事务故障的恢复策略主要是:
    反向扫描日志文件,查找该事物的更新操作;对该事物的更新操作执行逆操作;继续反向扫描日志文件,查找该事物的其他更新操作,并做同样处理;如此处理下去,直至读到此事物的开始标记,事物故障恢复就完成了。

  • 系统故障的恢复策略主要是:
    正向扫描日志文件,找出在故障发生前已经提交的事务,将其事务标识记入重做队列。同时找出故障发生时尚未完成的事务,将其事务标识记入撤消队列;对撤消队列的各个事务进行撤消处理;对重做队列的各个事务进行重做处理。

  • 介质故障的恢复策略主要是:
    装入最新的数据库后备副本,使数据库恢复到最近一次转储的一致性状态。装入相应的日志文件副本,重做已完成的事物。

6 用户手册

6.1 安装及配置

本系统基于Java开发,要使用本系统在本机上必须安装有Java开发环境,数据库使用Oracle。

6.2 使用方法

登录界面

主界面

6.3 基本操作

运行程序之后首先进入登陆界面,在登录界面中输入服务名,用户名(数据库的用户名,比如SCOTT),密码。例如我的数据库的服务名是orcl,用户名是CHAN。经过正确的连接即可进入到程序的主界面。

如下图所示,应用程序界面包括 “切换卡 (用来切换页面)”,“显示区 (显示基本信息)”,“查询区 (用来进行数据查询)”,“控制按钮 (用来进行基本操作)”。

员工页面,点击打开表格可以查看所有员工的基本信息,关闭表格可以清空页面上的表格显示。

点击添加信息可以添加某个员工的信息:

点击修改可以修改某个员工的信息(注意:员工的编号在数据库中是唯一的,被修改的员工的编号在数据库中必须存在)

点击删除信息可以删除某个员工的信息(同样编号必须存在)

在部门页面可以通过部门名称查询部门经理的信息:

在项目页面

点击查询完成情况可以查询某项目经理(姓名)完成合同的情况

点击查询设备采购可以某个项目设备采购情况

在设备页面有一下几个查询:

7 附录

对客户端进行响应的逻辑处理函数大部分通过在客户端中调用数据库的存储过程完成。

客户端程序逻辑处理的核心代码如下(界面代码在提交的工程中):

  1. import com.connectdb.ConnectDB;
  2. import oracle.jdbc.OracleTypes;
  3. import java.sql.*;
  4. import java.text.SimpleDateFormat;
  5. import java.util.Vector;
  6. import java.util.Date;
  7. public class ProjectFunction {
  8. /**
  9. * 添加员工信息
  10. * @param
  11. */
  12. public static boolean addWorker(String wId,String dId,String wName,String sex,String age,String date,String dName,String post){
  13. // 获取数据库连接Connection对象
  14. Connection conn = ConnectDB.getConnection();
  15. System.out.println(wId+dId+wName+sex+age+date+dName+post);
  16. try {
  17. CallableStatement c = conn.prepareCall("{call p_addworker(?,?,?,?,?,?,?)}");
  18. c.setString(1,wId);
  19. c.setString(2,wName);
  20. c.setString(3,sex);
  21. c.setString(4,age);
  22. System.out.println("传入的时间是 "+date);
  23. c.setString(5,date);
  24. c.setString(6,post);
  25. c.setString(7,dId);
  26. //c.setDate(6,Date.valueOf(date));
  27. //执行Oracle存储过程
  28. c.execute();
  29. } catch (Exception e) {
  30. e.printStackTrace();
  31. }finally{
  32. // 关闭数据库连接
  33. ConnectDB.closeConnection(conn);
  34. }
  35. return true;
  36. }
  37. /**
  38. * 删除员工信息
  39. * @param
  40. */
  41. public static void deleteWorker(String wId){
  42. // 获取数据库连接Connection对象
  43. Connection conn = ConnectDB.getConnection();
  44. try {
  45. CallableStatement c = conn.prepareCall("{call p_delworker(?)}");
  46. c.setString(1,wId);
  47. //执行Oracle存储过程
  48. c.execute();
  49. } catch (Exception e) {
  50. e.printStackTrace();
  51. }finally{
  52. // 关闭数据库连接
  53. ConnectDB.closeConnection(conn);
  54. }
  55. }
  56. /**
  57. * 查询员工信息
  58. * @param
  59. */
  60. public static Vector<Vector<String>> queryWorker(String sql){
  61. // 获取数据库连接Connection对象
  62. Connection conn = ConnectDB.getConnection();
  63. ResultSet rs=null;
  64. Vector<Vector<String>> list=new Vector<Vector<String>>();
  65. int i=0;
  66. try {
  67. Statement st = conn.createStatement();
  68. rs = st.executeQuery(sql);
  69. System.out.println("执行查询");
  70. // 判断结果集是否有效
  71. while(rs.next()){
  72. // 数据库存在,返回结果集
  73. System.out.println(rs.getString("w_id"));
  74. System.out.println(rs.getString("w_name"));
  75. System.out.println(rs.getString("sex"));
  76. System.out.println(rs.getString("post"));
  77. Vector<String> result=new Vector<String>();
  78. result.add(rs.getString("w_id"));
  79. result.add(rs.getString("w_name"));
  80. result.add(rs.getString("sex"));
  81. result.add(rs.getString("d_name"));
  82. result.add(rs.getString("post"));
  83. result.add(rs.getDate("contract_date").toString());
  84. list.add(i,result);
  85. i++;
  86. }
  87. // 释放此 ResultSet 对象的数据库和 JDBC 资源
  88. rs.close();
  89. // 释放此 PreparedStatement 对象的数据库和 JDBC 资源
  90. st.close();
  91. } catch (Exception e) {
  92. e.printStackTrace();
  93. }finally{
  94. // 关闭数据库连接
  95. ConnectDB.closeConnection(conn);
  96. }
  97. return list;
  98. }
  99. /**
  100. * 修改员工信息
  101. * @param
  102. */
  103. public static boolean updateWorker(String wId,String dId,String wName,String sex,String age,String date,String dName,String post){
  104. // 获取数据库连接Connection对象
  105. Connection conn = ConnectDB.getConnection();
  106. System.out.println(wId+dId+wName+sex+age+date+dName+post);
  107. try {
  108. CallableStatement c = conn.prepareCall("{call p_updateworker(?,?,?,?,?,?,?)}");
  109. c.setString(1,wId);
  110. c.setString(2,wName);
  111. c.setString(3,sex);
  112. c.setString(4,age);
  113. System.out.println("传入的时间是 "+date);
  114. c.setString(5,date);
  115. c.setString(6,post);
  116. c.setString(7,dId);
  117. //c.setDate(6,Date.valueOf(date));
  118. //执行Oracle存储过程
  119. c.execute();
  120. } catch (Exception e) {
  121. e.printStackTrace();
  122. }finally{
  123. // 关闭数据库连接
  124. ConnectDB.closeConnection(conn);
  125. }
  126. return true;
  127. }
  128. /**
  129. * 获取员工列表
  130. * @param
  131. */
  132. public static Vector<Vector<String>> getWorkerList(){
  133. // 获取数据库连接Connection对象
  134. Connection conn = ConnectDB.getConnection();
  135. ResultSet rs=null;
  136. Vector<Vector<String>> list=new Vector<Vector<String>>();
  137. int i=0;
  138. try {
  139. Statement st = conn.createStatement();
  140. String sql="SELECT * FROM \"worker\"";
  141. rs = st.executeQuery(sql);
  142. // 判断结果集是否有效
  143. while(rs.next()){
  144. // 数据库存在,返回结果集
  145. Vector<String> result=new Vector<String>();
  146. result.add(rs.getString("w_id"));
  147. result.add(rs.getString("w_name"));
  148. result.add(rs.getString("sex"));
  149. result.add(rs.getString("post"));
  150. result.add(rs.getDate("contract_date").toString());
  151. result.add(rs.getString("d_id"));
  152. list.add(i,result);
  153. i++;
  154. }
  155. System.out.println("长度 "+list.size());
  156. rs.close();
  157. // 释放此 PreparedStatement 对象的数据库和 JDBC 资源
  158. st.close();
  159. } catch (Exception e) {
  160. e.printStackTrace();
  161. }finally{
  162. // 关闭数据库连接
  163. ConnectDB.closeConnection(conn);
  164. }
  165. return list;
  166. }
  167. /**
  168. * 查询部门经理
  169. * @param
  170. */
  171. public static Vector<String> queryManager(String dName){
  172. // 获取数据库连接Connection对象
  173. Connection conn = ConnectDB.getConnection();
  174. String wId="",wName="",sex="",age="",post="",contractTime="";
  175. Vector<String> list=new Vector<String>();
  176. try {
  177. CallableStatement c = conn.prepareCall("{call P_FDMANAGER(?,?,?,?,?,?,?)}");
  178. c.setString(1,dName);
  179. c.registerOutParameter(2, OracleTypes.VARCHAR);
  180. c.registerOutParameter(3,OracleTypes.VARCHAR);
  181. c.registerOutParameter(4,OracleTypes.CHAR);
  182. c.registerOutParameter(5,OracleTypes.CHAR);
  183. c.registerOutParameter(6,OracleTypes.DATE);
  184. c.registerOutParameter(7,OracleTypes.VARCHAR);
  185. //执行Oracle存储过程
  186. c.execute();
  187. wId=c.getString(2);
  188. wName=c.getString(3);
  189. sex=c.getString(4);
  190. age=c.getString(5);
  191. contractTime=c.getDate(6).toString();
  192. post=c.getString(7);
  193. System.out.println("执行查询");
  194. list.add(wId);
  195. list.add(wName);
  196. list.add(sex);
  197. list.add(age);
  198. list.add(contractTime);
  199. list.add(post);
  200. } catch (Exception e) {
  201. e.printStackTrace();
  202. }finally{
  203. // 关闭数据库连接
  204. ConnectDB.closeConnection(conn);
  205. }
  206. return list;
  207. }
  208. /**
  209. * 查询项目设备采购信息
  210. * @param
  211. */
  212. public static Vector<String> getEqubyPro(String pName){
  213. Vector<String> result=new Vector<String>();
  214. // 获取数据库连接Connection对象
  215. Connection conn = ConnectDB.getConnection();
  216. String eNmae="",eSupplier="";
  217. float eFee;
  218. try {
  219. CallableStatement c = conn.prepareCall("{call P_GETEBYP(?,?,?,?)}");
  220. c.setString(1,pName);
  221. c.registerOutParameter(2, OracleTypes.VARCHAR);
  222. c.registerOutParameter(3,OracleTypes.FLOAT);
  223. c.registerOutParameter(4,OracleTypes.VARCHAR);
  224. //执行Oracle存储过程
  225. c.execute();
  226. eNmae=c.getString(2);
  227. eFee=c.getFloat(3);
  228. eSupplier=c.getString(4);
  229. result.add(eNmae);
  230. result.add(String.valueOf(eFee));
  231. result.add(eSupplier);
  232. System.out.println("查询设备 "+eNmae+eFee+eSupplier);
  233. } catch (Exception e) {
  234. e.printStackTrace();
  235. }finally{
  236. // 关闭数据库连接
  237. ConnectDB.closeConnection(conn);
  238. }
  239. return result;
  240. }
  241. /**
  242. * 查询设备采购费用信息
  243. * @param
  244. */
  245. public static float getEquFee(String eName){
  246. // 获取数据库连接Connection对象
  247. Connection conn = ConnectDB.getConnection();
  248. float eFee=0;
  249. try {
  250. CallableStatement c = conn.prepareCall("{call P_GETEFEE(?,?)}");
  251. c.setString(1,eName);
  252. c.registerOutParameter(2,OracleTypes.FLOAT);
  253. //执行Oracle存储过程
  254. c.execute();
  255. eFee=c.getFloat(2);
  256. System.out.println("查询设备 "+eName+eFee+"----");
  257. } catch (Exception e) {
  258. e.printStackTrace();
  259. }finally{
  260. // 关闭数据库连接
  261. ConnectDB.closeConnection(conn);
  262. }
  263. return eFee;
  264. }
  265. /**
  266. * 添加设备
  267. * @param
  268. */
  269. public static void addEqu(String eId,String eName,float fee,String supplier,String remarks,String pId){
  270. // 获取数据库连接Connection对象
  271. Connection conn = ConnectDB.getConnection();
  272. System.out.println(eId+eName+fee+supplier+remarks+pId);
  273. try {
  274. CallableStatement c = conn.prepareCall("{call p_addequ(?,?,?,?,?,?)}");
  275. c.setString(1,eId);
  276. c.setString(2,eName);
  277. c.setFloat(3,fee);
  278. c.setString(4,supplier);
  279. c.setString(5,pId);
  280. c.setString(6,remarks);
  281. //执行Oracle存储过程
  282. c.execute();
  283. } catch (Exception e) {
  284. e.printStackTrace();
  285. }finally{
  286. // 关闭数据库连接
  287. ConnectDB.closeConnection(conn);
  288. }
  289. }
  290. /**
  291. * 查询设备供应商信息
  292. * @param
  293. */
  294. public static String getEquSup(String eName){
  295. // 获取数据库连接Connection对象
  296. Connection conn = ConnectDB.getConnection();
  297. String eSupplier="";
  298. try {
  299. CallableStatement c = conn.prepareCall("{call P_GETESUP(?,?)}");
  300. c.setString(1,eName);
  301. c.registerOutParameter(2,OracleTypes.VARCHAR);
  302. //执行Oracle存储过程
  303. c.execute();
  304. eSupplier=c.getString(2);
  305. System.out.println("查询设备 "+eName+eSupplier);
  306. } catch (Exception e) {
  307. e.printStackTrace();
  308. }finally{
  309. // 关闭数据库连接
  310. ConnectDB.closeConnection(conn);
  311. }
  312. return eSupplier;
  313. }
  314. /**
  315. * 查询项目员工信息
  316. * @param
  317. */
  318. public static void getWerbyPro(String pName){
  319. // 获取数据库连接Connection对象
  320. Connection conn = ConnectDB.getConnection();
  321. String wNmae="",wId="";
  322. float eFee;
  323. try {
  324. CallableStatement c = conn.prepareCall("{call P_GETEBYP(?,?,?,?)}");
  325. c.setString(1,pName);
  326. c.registerOutParameter(2, OracleTypes.VARCHAR);
  327. c.registerOutParameter(3,OracleTypes.FLOAT);
  328. c.registerOutParameter(4,OracleTypes.VARCHAR);
  329. //执行Oracle存储过程
  330. c.execute();
  331. wNmae=c.getString(2);
  332. wId=c.getString(4);
  333. } catch (Exception e) {
  334. e.printStackTrace();
  335. }finally{
  336. // 关闭数据库连接
  337. ConnectDB.closeConnection(conn);
  338. }
  339. }
  340. /**
  341. * 查询项目完成情况
  342. * @param
  343. */
  344. public static Vector<String> queryComplete(String ManagerName){
  345. Vector<String> result=new Vector<String>();
  346. // 获取数据库连接Connection对象
  347. Connection conn = ConnectDB.getConnection();
  348. String date1="",date2="",pName="",isComplete="";
  349. try {
  350. CallableStatement c = conn.prepareCall("{call P_ISFINISHED(?,?,?,?)}");
  351. c.setString(1,ManagerName);
  352. c.registerOutParameter(2, OracleTypes.DATE);
  353. c.registerOutParameter(3, OracleTypes.DATE);
  354. c.registerOutParameter(4, OracleTypes.VARCHAR);
  355. //执行Oracle存储过程
  356. c.execute();
  357. date1=c.getString(2).toString();
  358. date2=c.getString(3).toString();
  359. pName=c.getString(4);
  360. System.out.println("签订时间是:"+date2);
  361. System.out.println("应完成时间是:"+date1);
  362. //pName=c.getString(4);
  363. Date date;
  364. date=c.getDate(2);
  365. System.out.println("应完成时间是 "+date1);
  366. System.out.println("时间格式 "+date);
  367. Date now = new Date();
  368. SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");//可以方便地修改日期格式
  369. String hehe = dateFormat.format( now );
  370. System.out.println(hehe);
  371. if(date1.compareTo(hehe)<0){
  372. isComplete="已完成";
  373. System.out.println("已经完成");
  374. } else {
  375. isComplete="未完成";
  376. }
  377. result.add(pName);
  378. result.add(date2);
  379. result.add(date1);
  380. result.add(isComplete);
  381. } catch (Exception e) {
  382. e.printStackTrace();
  383. }finally{
  384. // 关闭数据库连接
  385. ConnectDB.closeConnection(conn);
  386. }
  387. return result;
  388. }
  389. }

8 总结

8.1 遇到的问题

Oracle数据库与之前接触过的数据库SQL语句有些不一样,除了常用的增删查改与其他主关系型数据库相似,其他的语句还是有一些区别的。在实习中经常因为在SQL语句中少个双引号或者将双引号写成单引号而出错,所以在刚开始写存储过程中用了不少时间。可见Oracle数据库对语法的要求比较严格。

8.2 存在的问题

  • 在这次实习中,我发现自己的数据库设计能力还稍有不足,对项目管理系统的几个表的设计不是很合理,表中有些字段的类型和长度可能与实际应用不相符。在进行数据库设计时应该考虑实际项目中的应用,这样才能设计出满足实际需求的数据库管理系统。

  • 客户端程序中的程序设计时没有很好地采用架构来实现。使用三层逻辑架构时没有做到完全的层次分离,在表现层中还存在一些业务逻辑层的代码。数据库中每个表都应该用一个类来封装,然后对类中的成员变量也就是数据库表中的每个字段分别设置set()和get()方法。

  • 程序尚存在一些已知和未知的BUG,反映出自己在程序设计时对问题的考虑不够全面,对于在实际中可能存在的情况没完全把握。

8.3 收获

  • 通过完成数据库课程设计,加深了我对数据库理论知识和在实际应用方面的认识,在实践中发现了自己在数据库设计和程序设计上的不足,对于提高自己的编程能力很有帮助。实习中的数据库设计部分可以巩固在实用数据库中的知识,让我学会在实际场景中更好地使用数据库。

  • 这次实习让我学习了在项目中经常使用到的主流关系型数据库Oracle,掌握Oracle的特征和基本使用方法。在项目中使用Oracle可以实现对SQL语句的封装,不仅提高程序的执行效率还提高了数据的安全性。当对数据库进行复杂操作时(如对多个表进行 Update, Insert, Query, Delete 时),可将此复杂操作用存储过程封装起来与数据库提供的事务处理结合一起使用。这些操作,如果用程序来完成,就变成了一条条的 SQL 语句,可能要多次连接数据库。而换成存储,只需要连接一次数据库就可以了。

上传的附件 cloud_download 基于JAVA和Oracle数据库实现的项目信息管理系统.7z ( 2.77mb, 567次下载 )
error_outline 下载需要13点积分

keyboard_arrow_left上一篇 : 基于java的多人聊天程序课程设计 基于C++实现的语法分析之LL(1)分析法实现 : 下一篇keyboard_arrow_right



WonderBoy
2018-11-05 15:15:39
使用JAVA和Oracle数据库实现的项目信息管理系统
冯亮
2019-04-08 10:52:28
数据库用的挺6 啊 就是长度不够 ‘ ’
渣渣赵
2019-12-05 19:33:31
博主厉害!感谢分享
我是你爸爸
2020-06-26 10:58:17
博主那个里面少了少了二个文件然后用不了

发送私信

过往的青春,诉写白纸般的纯真

6
文章数
10
评论数
最近文章
eject