精华内容
下载资源
问答
  • 由于许多重要原因,Java语言在实时系统中的使用并不广泛。 这些包括Java语言设计固有的不确定性性能影响,例如动态类加载,以及Java Runtime Environment(JRE)本身,例如垃圾收集器和本机代码编译。 Java实时规范...

    由于许多重要原因,Java语言在实时系统中的使用并不广泛。 这些包括Java语言设计固有的不确定性性能影响,例如动态类加载,以及Java Runtime Environment(JRE)本身,例如垃圾收集器和本机代码编译。 Java实时规范(RTSJ)是一个开放规范,它扩展了Java语言,从而为使用该语言构建实时系统提供了更广泛的机会(请参阅参考资料 )。 实现RTSJ需要在操作系统,JRE和Java类库(JCL)中提供支持。 本文探讨了使用Java语言实现实时系统所面临的挑战,并介绍了解决这些挑战的开发套件和运行时环境。 本系列的后续文章将更深入地介绍本文介绍的概念和技术。

    实时需求

    实时 (RT)是一个广义术语,用于描述具有实际时序要求的应用程序。 例如,缓慢的用户界面不能满足一般用户的通用RT要求。 这种类型的应用程序通常被称为软 RT应用程序。 相同的要求可能更明确地表述为“应用程序响应鼠标单击的时间不应超过0.1秒”。 如果不满足要求,那就是软失败:应用程序可以继续运行,并且用户尽管不满意,仍然可以使用它。 相反,必须严格满足实际时序要求的应用程序通常称为硬 RT应用程序。 例如,不得因为任何原因而延迟控制飞机舵的应用程序,因为结果可能是灾难性的。 成为RT应用程序意味着什么在很大程度上取决于应用程序对错过的时序要求形式的故障的容忍度。

    RT要求的另一个关键方面是响应时间。 对于编写硬或软RT应用程序的程序员来说,了解响应时间约束至关重要。 满足硬1微秒响应所需的技术与满足硬100毫秒响应所需的技术明显不同。 实际上,要使响应时间低于几十微秒,就需要结合使用定制的硬件和软件,可能没有或只有非常薄的操作系统层。

    最后,健壮的RT应用程序的设计人员通常需要一定数量的确定性性能特征,才能设计出满足响应时间要求的应用程序。 不可预测的性能影响大到足以影响系统满足应用程序响应时间要求的能力,这使得很难正确构建该应用程序,甚至无法实现。 大多数RT执行环境的设计人员都致力于降低不确定性的性能影响,以满足最广泛的RT应用程序的响应时间需求。

    RT Java应用程序面临的挑战

    在通用操作系统上的通用JVM上运行的标准Java应用程序只能希望满足数百毫秒级别的软RT要求。 该语言的几个基本方面负责:线程管理,类加载,即时(JIT)编译器活动和垃圾回收(GC)。 应用程序设计人员可以缓解其中的某些问题,但是只有通过大量工作才能解决。

    线程管理

    标准Java不保证线程调度或线程优先级。 必须在定义好的时间内响应事件的应用程序无法确保不会在高优先级线程之前安排另一个低优先级线程。 作为补偿,程序员需要将一个应用程序划分为一组应用程序,然后操作系统可以以不同的优先级运行这些应用程序。 这种划分将增加这些事件的开销,并使事件之间的通信更具挑战性。

    类加载

    符合Java的JVM必须延迟类的加载,直到程序首次引用它为止。 加载类可能要花费可变的时间,具体取决于从中加载类的介质(磁盘或其他)的速度,类的大小以及类加载器本身所引起的开销。 加载类的延迟通常可以高达10毫秒。 如果需要加载数十个或数百个类,则加载时间本身可能会导致严重的延迟,并且可能会导致意外的延迟。 可以使用仔细的应用程序设计来在应用程序启动时加载所有类,但这必须手动完成,因为Java语言规范不允许JVM尽早执行此步骤。

    垃圾收集

    GC对应用程序开发的好处(包括指针安全性,避免泄漏以及使开发人员无需编写自定义内存管理工具)已得到了充分的证明。 但是,对于使用Java语言的RT硬编程人员来说,GC是造成挫败感的另一个原因。 当Java堆耗尽到无法满足分配请求的程度时,垃圾收集就会自动发生。 应用程序本身也可以触发收集。

    一方面,对于Java程序员来说,GC是一件了不起的事情。 需要用诸如C和C ++之类的语言显式管理内存而引入的错误是一些最难诊断的问题。 在部署应用程序时证明没有此类错误也是一项基本挑战。 Java编程模型的主要优势之一是JVM(而不是应用程序)执行内存管理,从而减轻了应用程序程序员的负担。

    另一方面,传统的垃圾收集器有时会引入较长的延迟,而这对于应用程序程序员而言实际上是无法预测的。 几百毫秒的延迟并不罕见。 在应用程序级别解决此问题的唯一方法是通过创建一组可重复使用的对象来防止GC,从而确保Java堆内存永远不会耗尽。 换句话说,程序员通过自己显式管理内存来丢弃托管内存的好处,从而解决了该问题。 实际上,这种方法通常会失败,因为它阻止程序员使用JDK和其他类供应商提供的许多类库,这些类库可能会创建许多临时对象,这些对象最终会填满堆。

    汇编

    将Java代码编译为本地代码会给类加载带来类似的问题。 大多数现代JVM最初都会解释Java方法,而对于那些经常执行的方法,后来会编译为本地代码。 延迟的编译可导致快速启动,并减少在应用程序执行期间执行的编译量。 但是,使用解释后的代码执行任务并使用编译后的代码执行任务可能会花费大量时间。 对于硬RT应用程序,无法预测何时将进行编译会引入过多的不确定性,从而无法有效地计划应用程序的活动。 与类加载一样,可以通过使用Compiler类在应用程序启动时以编程方式编译方法来缓解此问题,但是维护这样的方法列表既繁琐又容易出错。

    Java实时规范

    创建RTSJ是为了解决Java语言的某些局限性,从而阻止了其在RT执行环境中的广泛使用。 RTSJ解决了几个有问题的领域,包括调度,内存管理,线程,同步,时间,时钟和异步事件处理。

    排程

    RT系统需要严格控制线程的调度方式,并确保确定性地调度线程:也就是说,在给定相同条件的情况下,以相同的方式调度线程。 尽管JCL定义了线程优先级的概念,但是不需要传统的JVM来强制执行优先级。 同样,非RT Java实现通常使用具有不可预测的调度顺序的循环抢占式调度方法。 使用RTSJ,RT线程需要真正的优先级和具有优先级继承的固定优先级抢占式调度程序。 这种调度方法可确保最高优先级的活动线程将始终处于执行状态,并且将继续执行,直到其自愿释放CPU或被更高优先级的线程抢占为止。 优先级继承可确保在较高优先级的线程需要较低优先级的线程持有的资源时避免优先级倒置 。 优先级反转是RT系统的一个重要问题,我们将在RTLinux®中对其进行更详细的描述。

    内存管理

    尽管某些RT系统可以容忍垃圾收集器导致的延迟,但是在许多情况下,这些延迟是不可接受的。 为了支持不能容忍GC中断的任务,RTSJ定义了不朽和范围内存区域来补充标准Java堆。 如果垃圾收集器需要释放堆中的内存,则这些区域允许任务使用内存而无需阻塞。 分配给不朽内存区域的对象可被所有线程访问,并且永远不会被收集。 由于永生内存从未被收集,因此它是有限的资源,必须谨慎使用。 范围存储区可以在程序员的控制下创建和销毁。 每个范围存储区都分配有最大大小,可用于对象分配。 为了确保对象之间引用的完整性,RTSJ定义了一些规则,这些规则管理一个内存区域(堆,不朽或作用域)中的对象如何引用其他内存区域中的对象。 更多规则定义了范围存储器中的对象何时完成以及何时可以重用存储区域。 由于这些复杂性,不朽内存和作用域内存的建议使用仅限于不能容忍GC暂停的组件。

    线程数

    RTSJ增加了对两个新线程类的支持,它们为执行具有RT行为的任务提供了基础: RealtimeThreadNoHeapRealtimeThread (NHRT)。 这些类为优先级,定期行为,可以在超过最后期限时触发的处理程序提供最后期限以及使用堆以外的内存区域提供支持。 NHRT无法访问堆,因此与其他类型的线程不同,NHRT大部分不会被GC中断或抢占。 RT系统通常将具有高优先级的NHRT用于具有最严格的延迟要求的任务,将RealtimeThread s用于具有可被垃圾收集器容纳的延迟要求的任务,并将常规Java线程用于其他所有任务。 由于NHRT无法访问堆,因此使用这些线程需要高度注意。 例如,甚至必须仔细管理标准JCL中容器类的使用,以使容器类不会在堆上无意间创建临时或内部对象。

    同步化

    必须在RT系统中仔细管理同步,以防止高优先级的线程等待较低优先级的线程。 RTSJ包括优先级继承支持,以在发生同步时对其进行管理,并且它使线程能够通过无等待的读写队列进行通信而无需同步。

    时间和时钟

    RT系统需要比标准Java代码所提供的时钟更高分辨率的时钟。 新的HighResolutionTimeClock类封装了这些时间服务。

    异步事件处理

    RT系统通常管理和响应异步事件。 RTSJ包括对由许多来源触发的异步事件的支持,这些来源包括计时器,操作系统信号,错过的期限以及其他应用程序定义的事件。

    IBM WebSphere实时

    实施RTSJ需要基础操作系统以及JRE组件的广泛支持。 的IBM®WebSphere®实时,于2006年8月发布(见相关信息 ),包括完全遵守RTSJ以及旨在改进RT系统运行时的行为和促进工作中的应用设计人员必须做到创建RT系统的多项新技术。 图1显示了WebSphere Real Time组件的简化表示:

    图1. WebSphere Real Time概述
    WebSphere Real Time概述

    WebSphere Real Time基于IBM的跨平台J9技术。 应用于Linux操作系统的开源RT补丁提供了支持RT行为(尤其是RTSJ强制要求的行为)所需的基本RT服务。 显着增强的GC技术支持1毫秒的暂停时间。 JIT编译可用于较软的RT场景,在这些场景中无需进行更高优先级的工作即可进行编译。 还引入了一种新的提前 (AOT)编译技术(图1中未显示),以在不适合JIT编译的系统中提供更高的RT性能。 以下各节介绍了每种技术。 本系列的后续文章将提供有关每种技术如何工作的更多详细信息。

    RT Linux

    WebSphere Real Time在定制的完全开源的Linux版本上运行。 进行了几处更改以创建RT Java环境。 这些更改提供了完全可抢占的内核,线程中断处理程序,高分辨率计时器,优先级继承和健壮的互斥体。

    完全可抢占的内核

    RT Java线程是通过固定优先级调度(也称为静态优先级调度)和先进先出调度策略实现的。 标准的Linux内核提供了软RT行为,尽管对于高优先级的线程等待先于低优先级的线程等待的时间没有保证的上限,但是时间大约可以是数十微秒。 在RT Linux中,几乎所有内核活动都被抢占,从而减少了优先级较低的线程被抢占所需的时间,并允许更高优先级的线程运行。 其余无法抢占的关键部分简短且确定性地执行。 RT调度延迟已提高了三个数量级,现在大约可以在数十微秒内测量。

    线程中断处理程序可减少延迟

    几乎所有中断处理程序都转换为在进程上下文中运行的内核线程。 延迟时间更短且更具确定性,因为处理程序成为用户可配置的可调度实体,可以像其他任何进程一样抢占优先级。

    高分辨率计时器

    高分辨率时间和计时器可提高分辨率和准确性。 RT Java使用这些功能进行高分辨率的睡眠和定时等待。 Linux高分辨率计时器是使用高精度的64位数据类型实现的。 与传统的Linux不同,时间和计时器取决于低分辨率的系统时钟,这限制了计时器事件的粒度,RT Linux使用独立可编程的高分辨率计时器事件,这些事件可以在几微秒内到期。

    优先继承

    优先级继承是一种用于避免经典优先级反转问题的技术。 优先级反转的最简单示例之一,如图2的顶部图所示,涉及三个线程:一个高(H),一个中(M)和一个低(L)优先级线程。 想象一下,H和M最初处于Hibernate状态,等待事件被触发,L处于活动状态并保持锁定。 如果H醒来处理事件,它将抢占L并开始执行。 考虑一下如果H在由L持有的锁上阻塞时会发生什么。由于H在L释放锁之前无法取得进展,因此H阻塞并且L重新开始执行。 如果现在由事件触发M,则M将抢占L并执行所需的时间。 这种情况称为优先级反转,因为即使H的优先级高于M,M也会饿死H。

    图2.优先级倒置和优先级继承的示例
    优先级倒置和优先级继承的示例

    RT Linux通过称为优先级继承 (也称为优先级借出 )的策略防止优先级倒置,如图2的底部示意图所示。 当H在由L持有的锁上阻塞时,H将其优先级赋予L,从而保证没有比H优先级低的任务可以在释放H所需的锁之前抢占L。一旦释放该锁,L的优先级就会还原达到其原始值,以便H可以在不等待L的情况下取得进展。应用程序设计人员仍应努力避免出现以下情况:较高优先级的线程需要较低优先级的线程持有的资源,但是这种优先级继承机制提高了鲁棒性这样可以防止优先级倒置。

    健壮的互斥锁和rt-mutexes

    Linux pthread互斥锁受快速用户空间互斥锁(称为futexes)支持。 Futex可以优化时间来获得不受争议的锁,而无需依赖内核。 只有有争议的锁才需要内核干预。 健壮的互斥锁解决了在持有锁的应用程序崩溃后正确清理锁的问题。 同样,rt-mutexes将优先级继承协议扩展到健壮的互斥体,这使RT JVM可以通过pthread库依赖于优先级继承行为。

    确定性垃圾收集

    给定提供RT行为基础的RT操作系统(例如RT Linux),可以构建JVM的其他主要部分来展现RT行为。 GC是JVM中不确定性行为的较大来源之一,但是可以通过精心设计和依赖RT Linux的特性来缓解这种不确定性。

    GC的不确定性影响会暂停RT应用程序在特定期限内完成任务的能力(请参阅垃圾回收 )。 大多数GC实施都会干扰RT应用程序的延迟目标,以至于只有规模较大且时序要求宽松的任务才可以依靠GC技术。 RTSJ针对此问题的解决方案是通过不朽和作用域内存区域以及NHRT引入程序员管理的内存分配,但是这种解决方案可能会使Java应用程序设计人员感到头疼。

    WebSphere Real Time使程序员可以根据需要依赖RTSJ内存区域,但是建议仅将这种方法用于延迟要求非常严格的任务。 对于能够忍受1毫秒量级的GC暂停时间的任务,IBM创建了确定性GC技术,该技术可使程序员从自动内存管理的编程简便性中受益, 并以可预测的性能管理任务。

    IBM的确定性GC技术基于两个简单的前提:

    • 没有单个GC暂停会超过某个最大上限。
    • 通过控制该时间段内的暂停次数,GC将不超过任何给定时间窗口的某个百分比。

    考虑到这两个前提来管理GC活动会极大地提高应用程序实现其RT目标的可能性。

    节拍器GC

    WebSphere Real Time使用Metronome GC在JVM中实现确定性的低暂停时间GC行为(请参阅参考资料 )。 Metronome GC使用基于时间的调度方法,该方法将收集器和应用程序交错(在GC中被称为mutator,因为从垃圾收集器的角度来看,该应用程序用于随时间更改活动对象的图)按照固定的时间表。

    根据时间而不是分配速率进行调度的原因是,在应用程序执行期间分配通常不均匀。 通过完成GC工作作为对分配的一种征税,可能会导致GC暂停的分布不均匀,从而降低了GC行为的确定性水平。 通过使用基于时间的计划,节拍器GC可以实现一致的,确定的,有限制的暂停时间。 此外,由于不需要对现有代码进行语言扩展或修改,常规Java应用程序可以透明地使用Metronome,并受益于其确定性特征。

    节拍器将时间分为一系列离散的量子,大约500微秒,但长度不超过1毫秒,用于GC工作或应用工作。 尽管量子非常短,但是如果几个量子专用于GC工作,则应用程序仍会经历更长的暂停时间,这可能会危及RT截止日期。 为了更好地支持RT期限,Metronome分配了专用于GC工作的量子,因此应用程序应获得最少的时间百分比。 该百分比称为利用率 ,是用户提供的参数。 在任何时间间隔内,分配给应用程序的量子数量应不少于指定的利用率。 默认情况下,利用率为70%:在任何10毫秒的时间窗口中,至少7毫秒将专门用于应用程序。

    用户可以在程序启动时设置利用率。 图3显示了较长时间的应用程序利用率示例。 请注意,与垃圾收集器处于活动状态的时间量子相对应的周期性骤降。 在图3所示的整个时间窗口中,应用程序利用率保持等于或高于指定的70%(0.7)。

    图3.样本利用率图
    样品利用率图

    图4展示了节拍器技术在GC暂停时间方面的确定性。 只有一小部分的暂停时间超过500微秒。

    图4. GC暂停时间直方图
    GC暂停时间直方图

    为了使单个GC暂停时间较短,Metronome使用堆中的写屏障以及相关的元结构来跟踪活动对象和可能死掉的对象。 跟踪活动对象需要一系列GC数量来确定哪些对象应保持活动状态以及应回收哪些对象。 由于此跟踪工作与程序执行交织在一起,因此GC可能无法跟踪应用程序可以通过执行加载和存储“隐藏”的某些对象。

    隐藏活动对象不一定是恶意应用程序代码的结果。 这是更常见的原因,因为应用程序不了解垃圾收集器的活动。 为确保收集器不会遗漏任何对象,GC和VM通过跟踪对象之间的链接来协作,这些链接是通过应用程序执行的存储操作创建和断开的。 在应用程序执行存储操作之前执行的写屏障会执行此跟踪。 如果此存储可能导致隐藏活动对象,则写屏障的目的仅仅是记录对象如何链接在一起的更改。 这些写障碍代表了性能和内存占用开销,它们平衡了确定性行为的需求。

    对于许多GC策略,大对象的分配可能会很麻烦。 在许多情况下,堆过于分散,无法容纳单个大对象(例如数组)。 因此,它必须引起长时间的停顿才能对堆进行碎片整理或压缩,以将许多较小的可用内存区域合并为较大的可用内存区域,以满足较大的分配请求。 节拍器对数组使用了新的两级对象模型,称为arraylets 。 Arraylet将大型阵列分解为较小的部分,以使大型阵列分配更容易满足,而无需对堆进行碎片整理。 arraylet对象的第一层称为spine ,包含指向该数组较小的块(称为leaves)的指针的列表。 每个叶子的大小相同,这简化了查找数组中任何特定元素的计算,并且使收集器更容易找到合适的可用空间来分配每个叶子。 将数组分解为较小的不连续块可以使数组分配到堆中通常会出现的许多较小的可用区域中,而无需进行压缩。

    与传统的STW垃圾收集器实现不同,传统的STW垃圾收集器实现具有GC周期的概念来表示垃圾收集的开始和结束,而Metronome在应用程序的整个生命周期中将GC作为连续过程执行。 在应用程序的生命周期内保证了应用程序的利用率,在不需要大量GC工作的情况下,其利用率可能高于最低利用率。 当收集器找到可用内存以返回到应用程序时,可用内存会上下波动。

    RT的本机代码编译

    大多数现代JVM结合使用解释和编译代码执行。 为了消除解释的高性能成本,JIT编译器选择了频繁执行的代码以直接转换为CPU的本机指令。 Java语言的动态特性通常会导致该编译器在程序执行时运行,而不是在程序运行之前发生的步骤运行(例如C ++或Fortran之类的语言)。 JIT编译器可以选择要编译的代码,因此可以通过提高代码的性能来弥补编译所花费的时间。 除了这种动态编译行为之外,传统的JIT编译器还采用了各种推测性优化,这些优化利用了正在运行的程序的动态特性,这些特性可能在一个特定程序执行期间的某一时刻是正确的,但在执行期间可能不会保持正确。 如果以后关于此特性的假设变为假,则可以“取消”这种优化。

    在传统的非RT环境中,在程序执行时编译代码效果很好,因为编译器的操作对应用程序的性能几乎是透明的。 但是,在RT环境中,JIT编译器引入了不可预测的运行时行为,这对最坏情况的执行时间分析造成了严重破坏。 但是,在这种环境下,编译后代码的性能优势仍然很重要,因为它可以使更复杂的任务在较短的时间内完成。

    WebSphere Real Time引入了两个解决方案,以在不同的权衡点上平衡这两个需求。 第一个解决方案是采用以较低的非RT优先级运行的JIT编译器,该编译器已被修改为执行较少的主动式投机优化。 以非RT优先级进行操作可以使操作系统保证编译器永远不会干扰RT任务的执行。 尽管如此,代码性能会随时间变化的事实是不确定的影响,这使得该解决方案更适合于较软的RT环境而不是较硬的RT环境。

    对于较硬的RT环境,WebSphere Real Time引入了针对应用程序的AOT编译。 可以通过简单的命令行将存储在JAR文件中的Java类文件预编译为Java eXEcutable(JXE)文件。 通过在应用程序类路径上指定这些JXE文件而不是原始JAR文件,可以调用应用程序,以便执行AOT编译的代码-而不是解释字节码或由JIT编译器编译本机代码。 在第一个WebSphere Real Time版本中,使用AOT代码意味着不存在JIT编译器,这具有两个主要优点:较低的内存消耗,并且JIT编译线程或标识频繁执行代码的采样线程均无动态性能影响。

    图5显示了当使用AOT代码时Java代码如何在WebSphere Real Time中执行:

    图5.如何使用AOT代码
    如何使用AOT代码

    从图5的左上方开始,开发人员像在任何Java开发项目中一样,将Java源代码编译为类文件。 将类文件捆绑到JAR文件中,然后使用jxeinajar工具对其进行AOT编译。 该工具可以编译JAR文件中所有类中的所有方法,也可以基于程序的基于JIT的示例执行生成的输出有选择地编译某些方法,该示例基于JIT的程序执行确定了最重要的编译方法。 jxeinajar工具将方法编译到JAR文件中,并构造一个JXE文件,其中包含原始JAR文件的内容和AOT编译器生成的本机代码。 执行程序时,JXE文件可以直接替换JAR文件。 如果使用-Xnojit选项调用JVM,则将加载类路径上JXE文件中AOT编译的代码(根据Java语言的规则)。 在程序执行期间,将解释从JAR文件加载的方法或从JXE文件加载的未编译方法。 从JXE加载的已编译方法将作为本机代码执行。 在图5中,还需要-Xrealtime命令行选项来指定应调用RT VM。 此命令行选项仅在WebSphere Real Time中可用。

    AOT代码的缺点

    尽管AOT代码可以实现更具确定性的性能,但它也有一些缺点。 用于存储AOT代码的JXE通常比保存类文件的JAR文件大得多,因为本机代码通常不如存储在类文件中的字节码那么密集。 本机代码执行还需要各种补充数据,以描述如何将代码绑定到JVM中以及如何捕获异常,例如,以便可以执行代码。 第二个缺点是,尽管AOT编译的代码比解释的代码要快,但它比JIT的编译的代码要慢得多。 Finally, the time to transition between an interpreted method and a compiled method, or vice versa, is higher than the time to call an interpreted method from another interpreted method or to call a compiled method from a compiled method. In a JVM with an active JIT compiler, this cost is eventually eliminated by compiling "around the edges" of the compiled code until the number of transitions is too small to impact performance. In a JVM with AOT-compiled code but no JIT compiler, the number of transitions is determined by the set of methods that were compiled into the JXEs. For this reason, we typically recommend AOT compiling the entire application as well as the Java library classes on which the application depends. Expanding the number of compiled methods, as we mentioned above, has a footprint impact although the benefit to performance is usually more critical than the footprint increase.

    The reason AOT code is generally slower than JIT code is because of the nature of the Java language itself. The Java language requires that classes be resolved the first time the executing program references them. By compiling before the program executes, the AOT compiler must be conservative about classes, fields, and methods referenced by the code it compiles. AOT-compiled code is often slower than JIT-compiled code because the JIT has the advantage that it is performing compilation after the executing program has resolved many of these references. However, the JIT compiler must also carefully balance the time it takes to compile a program because that time adds to the program's execution time. For this reason, JIT compilers do not compile all code with the same degree of optimization. The AOT compiler does not have this limitation, so it can afford to apply more-aggressive compilation techniques that sometimes yield better performance than JIT-compiled code. Moreover, more methods can be AOT compiled than a JIT compiler might decide to compile, which can also result in better performance with AOT compilation than JIT compilation. Nonetheless, the common case is that AOT-compiled code is slower than JIT-compiled code.

    To avoid nondeterministic performance effects, neither the JIT compiler nor the AOT compiler provided in WebSphere Real Time applies the aggressively speculative optimizations generally applied by modern JIT compilers. These optimizations are generally performed because they can produce substantial performance improvements, but they are not appropriate in a RT system. Furthermore, supporting the various aspects of the RTSJ and the Metronome garbage collector introduces some overheads into compiled code that traditional compilers need not perform. For these reasons, code compiled for RT environments is typically slower than the code compiled for non-RT environments.

    未来发展方向

    More can be done to make an RT Java environment faster, in terms of both predictable performance and raw throughput. We see two key areas of advancement that must occur for the Java language to succeed in the RT application space:

    • Provide RT technology to users who want better predictability while running on traditional operating systems.
    • Make it much easier to use this technology.

    Toward soft RT

    Many features of WebSphere Real Time are useful to programmers targeting a traditional operating system. Incremental GC and priority-based threads would clearly be useful in many applications, even if hard RT guarantees could not be met and only soft RT performance could be provided. An application server providing predictable performance without unpredictable GC delays, for example, is an attractive idea to many developers. Similarly, enabling applications to run high-priority Java health-monitoring threads with reasonable scheduling targets would simplify Java server development.

    Making RT easier

    Simply bringing the advantages of using the Java language to the process of creating RT systems is a tremendous benefit to developers. But there's always room for improvement, and we are constantly evaluating new features that could simplify RT programming even further. You can go to our IBM alphaWorks site to try out our expedited real-time threads research technology that lets developers manage extremely high-frequency events with very little tolerance for variance or delay (see Related topics ). The tooling achieves highly deterministic behaviour by preloading, preinitializing, and precompiling the code to handle events and then running the code independently of the garbage collector with fewer and less onerous restrictions than the NHRTs in the RTSJ. You'll also find tooling called TuningFork, which traces paths from the operating system through the JVM and into applications, making it easier to perform detailed performance analysis.


    翻译自: https://www.ibm.com/developerworks/java/library/j-rtj1/index.html

    展开全文
  • Java学习总结之Java IO系统(一)

    千次阅读 2020-05-04 15:55:31
    java.io 包几乎包含了所有操作输入、输出需要的类。所有这些流类代表了输入源和输出目标。java.io 包中的流支持很多种格式,比如:基本类型、对象、本地化字符集等等。一个流可以理解为一个数据的序列。输入流表示从...

    概述

    java.io 包几乎包含了所有操作输入、输出需要的类。所有这些流类代表了输入源和输出目标。java.io 包中的流支持很多种格式,比如:基本类型、对象、本地化字符集等等。一个流可以理解为一个数据的序列。输入流表示从一个源读取数据,输出流表示向一个目标写数据。Java 为 I/O 提供了强大的而灵活的支持,使其更广泛地应用到文件传输和网络编程中。

    Java 的 I/O 大概可以分成以下几类:

    • 磁盘操作:File
    • 字节操作:InputStream 和 OutputStream
    • 字符操作:Reader 和 Writer
    • 对象操作:Serializable
    • 网络操作:Socket
    • 新的输入/输出:NIO

    File

    Java中IO操作有相应步骤,以文件操作为例,主要操作流程如下:
    1.使用File类打开一个文件
    2.通过字节流或字符流的子类,指定输出的位置
    3.进行读/写操作
    4.关闭输入/输出

    那么我们先来介绍一下File类
    Java文件类在java.io包中,它以抽象的方式代表文件名和目录路径名。该类主要用于获取文件和目录的属性,文件和目录的创建、查找、删除、重命名等,但不能进行文件的读写操作
    File对象代表磁盘中实际存在的文件和目录。通过以下构造方法创建一个File对象。

    通过给定的父抽象路径名子路径名字符串创建一个新的File实例。
    File(File parent, String child)

    通过将给定路径名字符串转换成抽象路径名来创建一个新 File 实例。
    File(String pathname)

    根据 parent 路径名字符串和 child 路径名字符串创建一个新 File 实例。
    File(String parent, String child)

    通过将给定的 file: URI 转换成一个抽象路径名来创建一个新的 File 实例。
    File(URI uri)

    注意: 
    1.在各个操作系统中,路径的分隔符是不一样的,例如:Windows中使用反斜杠:"\",Linux|Unix中使用正斜杠:"/"。在使用反斜杠时要写成"\\"的形式,因为反斜杠要进行转义。如果要让Java保持可移植性,应该使用File类的静态常量File.pathSeparator。
    2.构建一个File实例并不会在机器上创建一个文件。不管文件是否存在,都可以创建任意文件名的File实例。可以调用File实例上的exists()方法来判断这个文件是否存在。通过后续的学习我们会知道,当把一个输出流绑定到一个不存在的File实例上时,会自动在机器上创建该文件,如果文件已经存在,把输出流绑定到该文件上则会覆盖该文件,但这些都不是在创建File实例时进行的。

    创建File对象成功后,可以使用以下列表中的方法操作文件。

    File1.png

     

    File2.png

    File3.png

    File4.png

    下面给出一个使用File类的实例:

    import java.io.File;
    public class DirList {
       public static void main(String args[]) {
          String dirname = "/java";
          File f1 = new File(dirname);
          if (f1.isDirectory()) {
             System.out.println( "Directory of " + dirname);
             String s[] = f1.list();
             for (int i=0; i < s.length; i++) {
                File f = new File(dirname + "/" + s[i]);
                if (f.isDirectory()) {
                   System.out.println(s[i] + " is a directory");
                } else {
                   System.out.println(s[i] + " is a file");
                }
             }
          } else {
             System.out.println(dirname + " is not a directory");
        }
      }
    }
    

    小贴士:lastModified()方法返回的是从时间戳(1970年1月1日0时0分0秒)到当前的毫秒数,返回值类型是long,可以用Date类对它进行包装使其更易读。

    Java中的目录

    创建目录: 
    File类中有两个方法可以用来创建文件夹:

    • mkdir( )方法创建一个文件夹,成功则返回true,失败则返回false。失败表明File对象指定的路径已经存在,或者由于整个路径还不存在,该文件夹不能被创建。
    • mkdirs()方法创建一个文件夹和它的所有父文件夹。
      下面的例子创建 "/tmp/user/java/bin"文件夹:
    import java.io.File;
     
    public class CreateDir {
      public static void main(String args[]) {
        String dirname = "/tmp/user/java/bin";
        File d = new File(dirname);
        // 现在创建目录
        d.mkdirs();
      }
    }
    

    mkdirs是递归创建文件夹,允许在创建某文件夹时其父文件夹不存在,从而一同创建;mkdir必须满足路径上的父文件夹全都存在 
    注意: Java 在 UNIX 和 Windows 自动按约定分辨文件路径分隔符。如果你在 Windows 版本的 Java 中使用分隔符 (/) ,路径依然能够被正确解析。
    读取目录: 
    一个目录其实就是一个 File 对象,它包含其他文件和文件夹。
    如果创建一个 File 对象并且它是一个目录,那么调用 isDirectory() 方法会返回 true。
    可以通过调用该对象上的 list() 方法,来提取它包含的文件和文件夹的列表。
    下面展示的例子说明如何使用 list() 方法来检查一个文件夹中包含的内容:

    import java.io.File;
     
    public class DirList {
      public static void main(String args[]) {
        String dirname = "/tmp";
        File f1 = new File(dirname);
        if (f1.isDirectory()) {
          System.out.println( "目录 " + dirname);
          String s[] = f1.list();
          for (int i=0; i < s.length; i++) {
            File f = new File(dirname + "/" + s[i]);
            if (f.isDirectory()) {
              System.out.println(s[i] + " 是一个目录");
            } else {
              System.out.println(s[i] + " 是一个文件");
            }
          }
        } else {
          System.out.println(dirname + " 不是一个目录");
        }
      }
    }
    

    删除目录或文件: 
    删除文件可以使用 java.io.File.delete() 方法。
    以下代码会删除目录/tmp/java/,即便目录不为空。
    测试目录结构:

    /tmp/java/
    |-- 1.log
    |-- test
    

    deleteFolder是一个递归函数,类似于DFS思想

    import java.io.File;
     
    public class DeleteFileDemo {
      public static void main(String args[]) {
          // 这里修改为自己的测试目录
        File folder = new File("/tmp/java/");
        deleteFolder(folder);
      }
     
      //删除文件及目录
      public static void deleteFolder(File folder) {
        File[] files = folder.listFiles();
            if(files!=null) { 
                for(File f: files) {
                    if(f.isDirectory()) {
                        deleteFolder(f);
                    } else {
                        f.delete();
                    }
                }
            }
            folder.delete();
        }
    }
    

    RandomAccessFile

    RandomAccessFile不同于File,它提供了对文件内容的访问,可以读写文件且支持随机访问文件的任意位置
    RandomAccessFile读写用到文件指针,它的初始位置为0,可以用getFilePointer()方法获取文件指针的位置。下面是RandomAccessFile常用的方法。

    RandomAccessFile.png

    public int read(int x) throws IOException 方法只读取一个字节,也就是x的低八位。

    
    import java.io.File ;
    import java.io.RandomAccessFile ;
    public class RandomAccessFileDemo01{
        // 所有的异常直接抛出,程序中不再进行处理
        public static void main(String args[]) throws Exception{
            File f = new File("d:" + File.separator + "test.txt") ; // 指定要操作的文件
            RandomAccessFile rdf = null ;       // 声明RandomAccessFile类的对象
            rdf = new RandomAccessFile(f,"rw") ;// 读写模式,如果文件不存在,会自动创建
            String name = null ;
            int age = 0 ;
            name = "zhangsan" ;         // 字符串长度为8
            age = 30 ;                  // 数字的长度为4
            rdf.writeBytes(name) ;      // 将姓名写入文件之中
            rdf.writeInt(age) ;         // 将年龄写入文件之中
            name = "lisi    " ;         // 字符串长度为8
            age = 31 ;                  // 数字的长度为4
            rdf.writeBytes(name) ;      // 将姓名写入文件之中
            rdf.writeInt(age) ;         // 将年龄写入文件之中
            name = "wangwu  " ;         // 字符串长度为8
            age = 32 ;                  // 数字的长度为4
            rdf.writeBytes(name) ;      // 将姓名写入文件之中
            rdf.writeInt(age) ;         // 将年龄写入文件之中
            rdf.close() ;               // 关闭
        }
    };
    

    写完之后,开始读取数据。写的时候可以将一个字符串写入,读的时候需要一个个的以字节的形式读取出来。

    
    import java.io.File ;
    import java.io.RandomAccessFile ;
    public class RandomAccessFileDemo02{
        // 所有的异常直接抛出,程序中不再进行处理
        public static void main(String args[]) throws Exception{
            File f = new File("d:" + File.separator + "test.txt") ; // 指定要操作的文件
            RandomAccessFile rdf = null ;       // 声明RandomAccessFile类的对象
            rdf = new RandomAccessFile(f,"r") ;// 以只读的方式打开文件
            String name = null ;
            int age = 0 ;
            byte b[] = new byte[8] ;    // 开辟byte数组
            // 读取第二个人的信息,意味着要空出第一个人的信息
            rdf.skipBytes(12) ;     // 跳过第一个人的信息
            for(int i=0;i<b.length;i++){
                b[i] = rdf.readByte() ; // 读取一个字节
            }
            name = new String(b) ;  // 将读取出来的byte数组变为字符串
            age = rdf.readInt() ;   // 读取数字
            System.out.println("第二个人的信息 --> 姓名:" + name + ";年龄:" + age) ;
            // 读取第一个人的信息
            rdf.seek(0) ;   // 指针回到文件的开头
            for(int i=0;i<b.length;i++){
                b[i] = rdf.readByte() ; // 读取一个字节
            }
            name = new String(b) ;  // 将读取出来的byte数组变为字符串
            age = rdf.readInt() ;   // 读取数字
            System.out.println("第一个人的信息 --> 姓名:" + name + ";年龄:" + age) ;
            rdf.skipBytes(12) ; // 跳过第二个人的信息
            for(int i=0;i<b.length;i++){
                b[i] = rdf.readByte() ; // 读取一个字节
            }
            name = new String(b) ;  // 将读取出来的byte数组变为字符串
            age = rdf.readInt() ;   // 读取数字
            System.out.println("第三个人的信息 --> 姓名:" + name + ";年龄:" + age) ;
            rdf.close() ;               // 关闭
        }
    };
    

    结果如下:

    result.png

     

    在Java程序中所有的数据都是以的方式进行传输或保存的,程序需要数据的时候要使用输入流读取数据,而当程序需要将一些数据保存起来的时候,就要使用输出流完成。程序中的输入输出都是以流的形式保存的,流中保存的实际上全都是字节文件。流涉及的领域很广:标准输入输出,文件的操作,网络上的数据流,字符串流,对象流,zip文件流等等。

    Stream.png

     

    流具有方向性,至于是输入流还是输出流则是一个相对的概念,一般以程序为参考,如果数据的流向是程序至设备,我们成为输出流,反之我们称为输入流。
    可以将流想象成一个“水流管道”,水流就在这管道中形成了,自然就出现了方向的概念。

    Information.jpg

     

    先上一个Java IO流类层次图,如前所述,一个流被定义为一个数据序列。输入流用于从源读取数据,输出流用于向目标写数据:

    JavaIO流类层次图.png

     

    是不是被吓到了?没关系,我们将通过一个个例子来学习这些功能。

    IO流分类

    1.按操作数据类型分:字符流和字节流

    编码与解码:编码就是把字符转换为字节,而解码是把字节重新组合成字符。
    如果编码和解码过程使用不同的编码方式那么就出现了乱码。

    • GBK 编码中,中文字符占 2 个字节,英文字符占 1 个字节;
    • UTF-8 编码中,中文字符占 3 个字节,英文字符占 1 个字节;
    • UTF-16be 编码中,中文字符和英文字符都占 2 个字节。

    UTF-16be 中的 be 指的是 Big Endian,也就是大端。相应地也有 UTF-16le,le 指的是 Little Endian,也就是小端。
    Java 使用双字节编码 UTF-16be,这不是指 Java 只支持这一种编码方式,而是说 char 这种类型使用 UTF-16be 进行编码。char 类型占 16 位,也就是两个字节,Java 使用这种双字节编码是为了让一个中文或者一个英文都能使用一个 char 来存储。

    字符流:Java中的字符流处理的最基本的单元是2字节的Unicode码元(char),它通常用来处理文本数据,如字符、字符数组或字符串等。所谓Unicode码元,也就是一个Unicode代码单元,范围是0x0000~0xFFFF。在以上范围内的每个数字都与一个字符相对应,Java中的String类型默认就把字符以Unicode规则编码而后存储在内存中。然而与存储在内存中不同,存储在磁盘上的数据通常有着各种各样的编码方式。使用不同的编码方式,相同的字符会有不同的二进制表示。实际上字符流是这样工作的:

    • 输出字符流:把要写入文件的字符序列(实际上是Unicode码元序列)转为指定编码方式下的字节序列,然后再写入到文件中。
    • 输入字符流:把要读取的字节序列按指定编码方式解码为相应字符序列(实际上是Unicode码元序列从)从而可以存在内存中。

    也就是说,所有的文件在硬盘或在传输时都是以字节的方式进行的,包括图片等都是按字节的方式存储的,而字符是只有在内存中才会形成。

    字节流:Java中的字节流处理的最基本单位为单个字节(byte),它通常用来处理二进制数据,如果要得到字节对应的字符需要强制类型转换。

    两者比较: 
    1.字符流是由Java虚拟机将字节转化为2个字节的Unicode字符为单位的字符而成的,所以它对多国语言支持性较好,如果要操作中文数据等,用字符流。
    2.字符流只用来处理文本数据,字节流还可以用来处理媒体数据,如视频、音频、图片等。
    3.字符流的两个抽象基类为Reader和Writer,字节流的两个抽象基类为InputStream和OutputStream。它们的具体子类名以基类名为后缀进行扩展。
    4.字节流在操作的时候不会用到缓冲区(内存),是直接对文件本身操作的,而字符流在操作的时候使用缓冲区。

    Compare.jpg

     

    以向一个文件输出"Hello world!"为例,我们分别使用字节流和字符流进行输出,且在使用完之后都不关闭流。

    使用字节流不关闭执行:

    import java.io.File;
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.OutputStream;
    
    
    public class IOPractice {
    
        public static void main(String[] args) throws IOException {
            // 第1步:使用File类找到一个文件    
                 File f = new File("/home/xiejunyu/"+
                 "桌面/text.txt");   
            // 第2步:通过子类实例化父类对象     
                 OutputStream out = new FileOutputStream(f); 
            // 通过对象多态性进行实例化    
            // 第3步:进行写操作    
                 String str = "Hello World!";      
            // 准备一个字符串    
                 byte b[] = str.getBytes();          
            // 字符串转byte数组    
                 out.write(b);                      
            // 将内容输出    
             // 第4步:关闭输出流    
                // out.close();                  
            // 此时没有关闭    
                    }    
    }
    

    1.png

    此时没有关闭字节流操作,但是文件中也依然存在了输出的内容,证明字节流是直接操作文件本身的。

    使用字符流不关闭执行:

    import java.io.File;
    import java.io.FileWriter;
    import java.io.IOException;
    import java.io.Writer;
    
    
    public class IOPractice {
    
        public static void main(String[] args) throws IOException {
             // 第1步:使用File类找到一个文件    
            File f = new File("/home/xiejunyu/桌面/test.txt");
            // 第2步:通过子类实例化父类对象            
            Writer  out = new FileWriter(f);            
            // 第3步:进行写操作    
            String str = "Hello World!";      
            // 准备一个字符串    
            out.write(str);                    
            // 将内容输出    
            // 第4步:关闭输出流    
            // out.close();
            // 此时没有关闭    
        }    
    }
    

    2.png

    程序运行后会发现文件中没有任何内容,这是因为字符流操作时使用了缓冲区,而在关闭字符流时会强制性地将缓冲区中的内容进行输出,但是如果程序没有关闭字符流,缓冲区中的内容是无法输出的,所以得出结论:字符流使用了缓冲区,而字节流没有使用缓冲区。如果想让缓冲区中的内容输出,要么关闭流强制刷新缓冲区,要么调用flush方法冲刷缓冲区。可以简单地把缓冲区理解为一段特殊的内存。某些情况下,如果一个程序频繁地操作一个资源(如文件或数据库),则性能会很低,此时为了提升性能,就可以将一部分数据暂时读入到内存的一块区域之中,以后直接从此区域中读取数据即可,因为读取内存速度会比较快,这样可以提升程序的性能。
    在字符流的操作中,所有的字符都是在内存中形成的,在输出前会将所有的内容暂时保存在内存之中,所以使用了缓冲区暂存数据。

    建议: 
    1.虽然不关闭字节流不影响数据的输出,且后续JVM会自动回收这部分内存,但还是建议在使用完任何流对象之后关闭流。
    2.使用流对象都要声明或抛出IOException
    3.在创建一个文件时,如果目录下有同名文件将被覆盖
    4.在写文件时,如果文件不存在,会在创建输出流对象并绑定文件时自动创建文件,不必使用File的exists方法提前检测
    4.在读取文件时,必须使用File的exists方法提前检测来保证该文件已存在,否则抛出FileNotFoundException

    2.按流向分:输入流和输出流

    输入流:程序从输入流读取数据源。数据源包括外界(键盘、文件、网络等),即是将数据源读入到程序的通信通道。输入流主要包括两个抽象基类:InputStream(字节输入流)和Reader(字符输入流)及其扩展的具体子类。
    输出流:程序向输出流写入数据。将程序中的数据输出到外界(显示器、打印机、文件、网络等)的通信通道。输出流主要包括两个抽象基类:OutputStream(字节输出流)和Writer(字符输出流)及其扩展的具体子类。

    3.按功能分:节点流和处理流

    按照流是否直接与特定的地方(如磁盘、内存、设备等)相连,分为节点流和处理流两类。
    节点流:程序用于直接操作目标设备所对应的类叫节点流。(低级流)
    处理流:程序通过一个间接流类去调用节点流类,以达到更加灵活方便地读写各种类型的数据,这个间接流类就是处理流。处理流可以看成是对已存在的流进行连接和封装的流。(高级流)

    注意:在使用到处理流对流进行连接和封装时,读写完毕只需关闭处理流,不用关闭节点流。处理流关闭的时候,会调用其处理的节点流的关闭方法。如果将节点流关闭以后再关闭处理流,会抛出IO异常。

    (1) 节点流

    节点流.png

    • File 文件流。对文件进行读、写操作:FileReader、FileWriter、FileInputStream、FileOutputStream。
    • Memory 流。
      向内存数组读写数据: CharArrayReader与 CharArrayWriter、ByteArrayInputStream与ByteArrayOutputStream。
      向内存字符串读写数据:StringReader、StringWriter、StringBufferInputStream。
    • Pipe管道流:实现管道的输入和输出(进程间通信): PipedReader与PipedWriter、PipedInputStream与PipedOutputStream。

    节点流示意图.png

    (1) 处理流

    处理流.png

    • Buffering缓冲流:在读入或写出时,对数据进行缓存,以减少I/O的次数:BufferedReader与BufferedWriter、BufferedInputStream与BufferedOutputStream。
    • Filtering 滤流:在数据进行读或写时进行过滤:FilterReader与FilterWriter、FilterInputStream与FilterOutputStream。
    • Converting between Bytes and Characters 转换流:按照一定的编码/解码标准将字节流转换为字符流,或进行反向转换(Stream到Reader):InputStreamReader、OutputStreamWriter。
    • Object Serialization 对象流 :ObjectInputStream、ObjectOutputStream。
    • DataConversion数据流:按基本数据类型读、写(处理的数据是Java的基本类型):DataInputStream、DataOutputStream 。
    • Counting计数流:在读入数据时对行记数 :LineNumberReader、LineNumberInputStream。
    • Peeking Ahead预读流: 通过缓存机制,进行预读 :PushbackReader、PushbackInputStream。
    • Printing打印流: 包含方便的打印方法 :PrintWriter、PrintStream。

    处理流示意图.png

    读取控制台输入

    在Java中,从控制台输入有三种方法:

    1.使用标准输入流对象System.in

    System.in是System中内置的InputStream类对象,它的read方法一次只读入一个字节数据,返回0 ~ 255的一个byte值,一般用来读取一个字符,需要强制类型转换为char类型,而我们通常要取得一个字符串或一组数字,故这种方法不常用。下面给出这种方法的一个例子:

    public class CharTest{
    public static void main(String[] args) {
             try{   
             System.out.print("Enter a Char:");   
             char i = (char)System.in.read();   
             System.out.println("Yout Enter Char is:" + i);           }   
             catch(IOException e){   
                e.printStackTrace();   
             }   
        }
    }
    

    使用这种方法必须提供try-catch块或者在main方法首部声明IOException异常,因为System.in是一个流对象

    2.使用Scanner类

    Scanner类功能十分强大,可以读入字符串、整数、浮点数、布尔类型值等等。下面是例子:

    public class ScannerTest{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);   
        System.out.println("ScannerTest, Please Enter Name:");   
        String name = sc.nextLine();  //读取字符串型输入   
        System.out.println("ScannerTest, Please Enter Age:");   
        int age = sc.nextInt();    //读取整型输入   
        System.out.println("ScannerTest, Please Enter Salary:");   
        float salary = sc.nextFloat(); //读取float型输入   
        System.out.println("Your Information is as below:");   
        System.out.println("Name:" + name +"\n" + "Age:"+age 
        + "\n"+"Salary:"+salary);   
        }
     }   
    

    注意: 
    1.用nextXXX()读入XXX类型的数据,XXX可以是除了char外的所有基本数据类型,还可以是BigInteger或BigDecimal,其中凡是整型类型的数据还可以指定radix(进制),可以用next()和nextLine()读取一个字符串或一行字符
    2.next()和nextLine()的区别:
    next()

    • 一定要读取到有效字符后才可以结束输入。
    • 对输入有效字符之前遇到的空白,next() 方法会自动将其去掉。
    • 只有输入有效字符后才将其后面输入的空白作为分隔符或者结束符。
    • next() 不能得到带有空格的字符串,除非用useDelimeter方法修改分隔符。

    nextLine()

    • 以Enter为结束符,也就是说 nextLine()方法返回的是输入回车之前的所有字符。
    • 可以获得空白。

    3.可以用循环配合hasNextXXX方法判断输入是否继续
    4.Scanner类没有直接提供读取一个字符的方法,如果要读取一个字符,有三种方法,一是读入一个字符串后取字符串的第一个字符,二是使用System.in的read方法,三是使用字符流读入

    更多Scanner的用法之前已经在Java学习总结之Java基本程序设计结构中总结过了,不再赘述。

    3.使用BufferedReader对象

    可以把 System.in 包装在一个 BufferedReader 对象中来创建一个字符流
    下面是创建 BufferedReader 的基本语法:

    BufferedReader br = new BufferedReader(new 
                          InputStreamReader(System.in));
    

    其中,System.in是一个InputStream对象(字节流),使用InputStreamReader作为桥梁,将字节流转换为字符流,然后再使用BufferedReader进行进一步包装。
    BufferedReader 对象创建后,我们便可以使用 read() 方法从控制台读取一个字符(读入一个用0~65535之间的整数表示的字符,需要强制类型转换为char类型,如果已到达流末尾,则返回 -1),或者用 readLine() 方法读取一个字符串。下面是例子:

    public static void main(String[] args){
    //必须要处理java.io.IOException异常
      BufferedReader br = new BufferedReader(new InputStreamReader
      (System.in ));
      //java.io.InputStreamReader继承了Reader类
      String read = null;
      System.out.print("输入数据:");
      try {
       read = br.readLine();
      } catch (IOException e) {
       e.printStackTrace();
      }
      System.out.println("输入数据:"+read);
     }
    

    下面的程序示范了用 read() 方法从控制台不断读取字符直到用户输入 "q"。

    // 使用 BufferedReader 在控制台读取字符
     
    import java.io.*;
     
    public class BRRead {
      public static void main(String args[]) throws IOException
      {
        char c;
        // 使用 System.in 创建 BufferedReader 
        BufferedReader br = new BufferedReader(new 
                           InputStreamReader(System.in));
        System.out.println("输入字符, 按下 'q' 键退出。");
        // 读取字符
        do {
           c = (char) br.read();
           System.out.println(c);
        } while(c != 'q');
      }
    }
    

    下面的程序读取和显示字符行直到你输入了单词"end"。

    // 使用 BufferedReader 在控制台读取字符
    import java.io.*;
    public class BRReadLines {
      public static void main(String args[]) throws IOException
      {
        // 使用 System.in 创建 BufferedReader 
        BufferedReader br = new BufferedReader(new
                                InputStreamReader(System.in));
        String str;
        System.out.println("Enter lines of text.");
        System.out.println("Enter 'end' to quit.");
        do {
           str = br.readLine();
           System.out.println(str);
        } while(!str.equals("end"));
      }
    }
    

    在ACM等算法竞赛中,我们常常也会使用Java,在输入数据时有以下几点注意: 
    1.hasXXX等价于C++中读到文件末尾(EOF)
    2.使用BufferedReader输入会比Scanner输入快十倍左右!

    控制台输出

    控制台的输出由 print() 和 println() 完成。这些方法都由类 PrintStream 定义,System.out 是该类的一个对象。
    PrintStream 继承了 OutputStream类,并且实现了方法 write()。这样,write() 也可以用来往控制台写操作。
    PrintStream 定义 write() 的最简单格式如下所示:
    void write(int byteval)该方法将 byteval 的低八位字节写到流中,即System.out的write方法一次只能写一个字节(类比System.in的read方法一次只能读取一个字节)。
    下面的例子用 write() 把字符 "A" 和紧跟着的换行符输出到屏幕:

    import java.io.*;
     
    // 演示 System.out.write().
    public class WriteDemo {
       public static void main(String args[]) {
          int b; 
          b = 'A';//向上类型转换
          System.out.write(b);
          System.out.write('\n');
       }
    }
    

    注意:write() 方法不经常使用,因为 print() 和 println() 方法用起来更为方便。

    字节流(OutputStream、InputStream)

    字节流主要是操作byte类型的数据,以byte数组为准,主要操作类是OutputStream、InputStream。
    由于文件读写最为常见,我们先讨论两个重要的字节流 FileInputStream(文件输入流) 和 FileOutputStream(文件输出流),分别是抽象类InputStream和OutputStream的具体子类:

    FileInputStream 
    该流用于从文件读取数据,它的对象可以用关键字 new 来创建。
    有多种构造方法可用来创建对象。
    可以使用字符串类型的文件名来创建一个输入流对象来读取文件:

    InputStream f = new FileInputStream("C:/java/hello");
    

    也可以使用一个文件对象来创建一个输入流对象来读取文件。我们首先得使用 File() 方法来创建一个文件对象:

    File f = new File("C:/java/hello");
    InputStream in = new FileInputStream(f);
    

    创建了InputStream对象,就可以使用下面的方法来读取流或者进行其他的流操作。

     

    InputStream.png

    下面是一个例子:

    public static void main(String[] args) throws IOException{
        InputStream f  = new FileInputStream
        ("/home/xiejunyu/桌面/test.txt");
        int c = 0;
        while((c =  f.read()) != -1) 
        //这里也可以先用available方法得到可读的字节数
        System.out.println((char)c);
    }
    

    当我们需要创建一个byte[]来保存读取的字节时,如果数组太小,无法完整读入数据,如果太大又会造成内存浪费。可以使用File类的length方法得到文件的数据字节数,从而有效确定byte数组的大小。

    public static void main(String[] args) {
            // 创建一个FileInputStream对象
            try {
                FileInputStream fis = new FileInputStream("/home/xiejunyu/桌面/test.txt");
                byte[] b=new byte[100];
                fis.read(b,0,5); 
                /*把字节从文件读入b数组,从b数组的0位置开始存放,
                读取5个字节*/
                System.out.println(new String(b));
                fis.close();
            } catch (FileNotFoundException e) {
                e.printStackTrace();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    

    注意: 每调用一次read方法,当前读取在文件中的位置就会向后移动一个字节或者移动byte[]的长度(read的两个重载方法),已经到文件末尾会返回-1,可以通过read方法返回-1判断是否读到文件末尾,也可以使用available方法返回下一次可以不受阻塞读取的字节数来读取。FileInputStream不支持mark和reset方法进行重复读取。BufferedInputStream支持此操作。

    FileOutputStream 
    该类用来创建一个文件并向文件中写数据。
    如果该流在打开文件进行输出前,目标文件不存在,那么该流会创建该文件。 
    有两个构造方法可以用来创建 FileOutputStream 对象。
    使用字符串类型的文件名来创建一个输出流对象:

    OutputStream f = new FileOutputStream("C:/java/hello")
    

    也可以使用一个文件对象来创建一个输出流来写文件。我们首先得使用File()方法来创建一个文件对象:

    File f = new File("C:/java/hello");
    OutputStream f = new FileOutputStream(f);
    

    之前的所有操作中,如果重新执行程序,则肯定会覆盖文件中的已有内容,那么此时就可以通过FileOutputStream向文件中追加内容,FileOutputStream的另外一个构造方法:

    public FileOutputStream(File file,boolean append) 
    

    在构造方法中,如果将append的值设置为true,则表示在文件的末尾追加内容。程序代码如下:

    File f = new File("C:/java/hello");
    OutputStream f = new FileOutputStream(f,true);
    

    创建OutputStream 对象完成后,就可以使用下面的方法来写入流或者进行其他的流操作。

    FileOutputStream.png

     

    当有一个字符串时,可以用getBytes方法转为byte数组用于字节流的输出。

    下面是一个演示 InputStream 和 OutputStream 用法的例子:

    import java.io.*;
     
    public class FileStreamTest{
      public static void main(String args[]){
        try{
          byte bWrite[] = "ABC".getBytes();
          OutputStream os = new FileOutputStream("/home/xiejunyu/桌面/test.txt");
          for(int x=0; x < bWrite.length ; x++){
          os.write(bWrite[x] ); // writes the bytes
        }
        os.close();
     
        InputStream is = new FileInputStream("/home/xiejunyu/桌面/test.txt");
        int size = is.available();
     
        for(int i=0; i< size; i++){
          System.out.print((char)is.read() + "  ");
        }
          is.close();
        }catch(IOException e){
          System.out.print("Exception");
        }  
      }
    }
    

    上面的程序首先创建文件test.txt,并把给定的数字以二进制形式写进该文件,同时输出到控制台上。
    以上代码由于是二进制写入,可能存在乱码,你可以使用以下代码实例来解决乱码问题:

    import java.io.*;
     
    public class fileStreamTest2{
      public static void main(String[] args) throws IOException {
        
        File f = new File("a.txt");
        FileOutputStream fop = new FileOutputStream(f);
        // 构建FileOutputStream对象,文件不存在会自动新建;如果存在会覆盖原文件
        
        OutputStreamWriter writer = new OutputStreamWriter(fop, "UTF-8");
        // 构建OutputStreamWriter对象,参数可以指定编码,默认为操作系统默认编码,windows上是gbk
        
        writer.append("中文输入");
        // 写入到缓冲区
        
        writer.append("\r\n");
        //换行
        
        writer.append("English");
        // 刷新缓冲区,写入到文件,如果下面已经没有写入的内容了,直接close也会写入
        
        writer.close();
        //关闭写入流,同时会把缓冲区内容写入文件,所以上面的注释掉
        
        fop.close();
        // 关闭输出流,释放系统资源
     
        FileInputStream fip = new FileInputStream(f);
        // 构建FileInputStream对象
        
        InputStreamReader reader = new InputStreamReader(fip, "UTF-8");
        // 构建InputStreamReader对象,编码与写入相同
     
        StringBuffer sb = new StringBuffer();
        while (reader.ready()) {
          sb.append((char) reader.read());
          // 转成char加到StringBuffer对象中
        }
        System.out.println(sb.toString());
        reader.close();
        // 关闭读取流
        
        fip.close();
        // 关闭输入流,释放系统资源
     
      }
    }
    

    以上例子证明:在对多国语言的支持上,字符流表现更优,此时应使用字符流而不是字节流。

    还可以用InputStream和OutputStream配合进行文件的复制,即读取原件数据,写入副本文件。
    复制有两种实现方式:
    实现一:将源文件中的内容全部读取进来,之后一次性的写入到目标文件
    实现二:边读边写

    在实际开发中建议使用边读边写的方式,代码如下:

    public static void main(String[] args) {
            // 文件拷贝
            try {
                FileInputStream fis=new FileInputStream("happy.gif");
                FileOutputStream fos=new FileOutputStream("happycopy.gif");
                int n=0;
                byte[] b=new byte[1024];
                while((n=fis.read(b))!=-1){ 
                /*循环读取,每次1024个字节,最后一次可能不满1024。
                后面的字节覆盖前面的字节,不必担心数组溢出。*/
                    fos.write(b,0,n); //n是实际读取到的字节数,如果写fos.write(b),会造成最后一次数组未满的情况也写1024个字节,从而造成副本比原件略大
                }
                fis.close();
                fos.close();
            } catch (FileNotFoundException e) {
                // TODO Auto-generated catch block
                e.printStackTrace();
            }catch(IOException e){
                e.printStackTrace();
            }
        }
    

    实际上边读边写也分为三种方式:
    1.批量拷贝(循环读取,每次读入一个byte数组)
    2.缓冲拷贝(使用缓冲流)
    3.批量+缓冲拷贝(循环批量读取到字节数组中,然后使用缓冲输出流写入到文件)

    第三种方式是最快的。

    注意:InputStream的int read()方法读取一个字节,并用这个字节填充整型的低八位并返回,OutputStream的void write(int x)写入x的低八位,如果要写入一个int,需要移位并写4次。读写基本数据类型建议使用DataInputStream和DataOutputStream。小编推荐一个学Java的学习社区【 戳我立即加入 】,无论你是大牛还是小白,是想转行还是想入行都可以来了解一起进步一起学习!裙内有开发工具,很多干货和技术资料分享!

    展开全文
  • Java-订餐系统

    千次阅读 多人点赞 2020-03-05 14:19:03
    数据库设计 1、要求 (1)绘制所建数据库的E-R模型图 ...所设计数据库是订餐系统数据库。 (1)E-R模型 goods表: Id,goodsName,price,goodsDesc,imageLink user表: Id,userName,password,email,rank ...

    源代码(点击此处下载)


    数据库设计


    1、要求
    (1)绘制所建数据库的E-R模型图
    (2)表(实体表和关联表)结构的设计
    (3)录入数据的表(每个表5条记录即可)
    (4)说明组内分工

    2、设计内容
    所设计数据库是订餐系统数据库。

    • List 1

    此次试验设计的是一款点餐系统,系统主要分为 Admin 和 User 两大部分。
    Admin 部分主要可以进行查看订单、对点餐系统的维护管理、添加套餐组合与修改管理员信息操作。
    User 部分进行的是用户的操作,新用户可以通过系统注册用户个人信息,注册成功的用户可以通过点餐系统进行用户信息的修改、点餐、个人订单信息的查询操作。

    • List 2

    这套系统是为了方便餐厅管理和用户点餐而设计的。我们通过使用 Mysql 设计了系统所需的表,
    运用 Navicat 从 Mysql 数据库中调用相关数据,通过 JDBC 连接。
    运用 myeclipse 中的 JAVA 可视化界面开发插件 Matisse 开发 UI 界面。

    • List 3

    Java 点餐系统中一共四个包:dbconnection、dao、model 和 view。
    作用分别为连接数据库;对数据库中的数据进行处理;获取数据库数据以及给用户展示界面并提示用户进行相应的操作。
    在进行实际应用操作情景中,根据用户输入的登陆信息,系统会判断使用者是管理员还是普通用户(管理员的信息中 id 系统后台默认的以分辨,登陆界面中注册时没有权限注册管理员,全部为用户id),view 中的类将根据用户的触发项进行相应的页面转跳操作,view 中不同的类会根据用户的操作同
    时调用其对应 dao 和 model 包中的类进行操作。

    (1)E-R模型

    ER
    goods表:
    Id,goodsName,price,goodsDesc,imageLink

    user表:
    Id,userName,password,email,rank

    order_info表:
    orderId,orderStatus,orderNum,orderTotalMoney,userName

    order_goods表:
    Id,orderld,goodsTotalPrice,goodsId,goodsPrice,goodsNum,goodsName

    (2)所有表的设计视图

    goods表包含id,goodsName,price,goodsDesc,imageLink
    其中id为主键。

    CREATE TABLE `goods` (
      `id` int(10) NOT NULL AUTO_INCREMENT,
      `goodsName` varchar(100) DEFAULT NULL,
      `price` float DEFAULT NULL,
      `goodsDesc` varchar(200) DEFAULT NULL,
      `imageLink` varchar(500) DEFAULT NULL,
      PRIMARY KEY (`id`));
    insert  into `goods`(`id`,`goodsName`,`price`,`goodsDesc`,`imageLink`) 
    values (3,'宫保鸡丁',21,'宫保鸡丁哦','E:\java\eclipse\'),
    (5,'青椒肉丝',22,'青椒肉丝不好吃','E:\java\eclipse\'),
    (8,'麻婆豆腐',2,'香辣丝滑','E:\java\eclipse\’),
    (9,'鱼香肉丝',9,'四川风味','E:\java\eclipse\'),
    (10,'回锅肉',12,NULL,NULL),
    (11,'热狗肠',32,'说的','E:\java\eclipse\');
    

    在这里插入图片描述

    user表包含id,userName,password,email,rank
    其中id为主键。

    CREATE TABLE `user` (
    `id` int(10) NOT NULL AUTO_INCREMENT,
    `userName` varchar(100) DEFAULT NULL,
    `password` varchar(50) DEFAULT NULL,
    `email` varchar(200) DEFAULT NULL,
    `rank` int(1) DEFAULT '0',
    PRIMARY KEY (`id`));
    insert  into `user`(`id`,`userName`,`password`,`email`,`rank`) 
    values
    (1,'admin','123',NULL,1),
    (8,'aaa','123','ad@1.com',0),
    (9,'admin1','123',NULL,0);
    

    在这里插入图片描述

    order_info表包含orderId,orderStatus,orderNum,orderTotalMoney,userName
    其主键为orderId。

    CREATE TABLE `order_info` (
    `orderId` varchar(50) NOT NULL,`orderStatus` int(10) DEFAULT NULL,
    `orderNum` int(10) DEFAULT NULL,`orderTotalMoney` float DEFAULT NULL,
    `userName` varchar(100) DEFAULT NULL,PRIMARY KEY (`orderId`));
    insert into
    `order_info`(`orderId`,`orderStatus`,`orderNum`,`orderTotalMoney`,`userName`) 
    values ('20130708001514',3,1,12,'admin1'),
    ('20130708021437',1,1,12,'admin1'),('20130708110510',2,2,31,'aaa'),
    ('20130708110513',3,2,44,'aaa'),('20130708115503',1,1,2,'admin1'),
    ('20130708115508',4,2,44,'admin1'),('20130708115512',3,1,22,'admin1'),
    ('20130708121456',4,1,9,'admin1');
    

    在这里插入图片描述

    order_goods表包含id,orderld,goodsTotalPrice,goodsId,goodsPrice,goodsNum,goodsName
    其中主键为id。

    CREATE TABLE `order_goods` (
    `id` int(10) NOT NULL AUTO_INCREMENT,
      `orderId` varchar(50) DEFAULT NULL,
      `goodsTotalPrice` float DEFAULT NULL,
      `goodsId` int(10) DEFAULT NULL,
      `goodsPrice` float DEFAULT NULL,
      `goodsNum` int(10) DEFAULT NULL,
      `goodsName` varchar(100) DEFAULT NULL,
      PRIMARY KEY (`id`),
    
       KEY `FK_order_goods_2` (`orderId`),
       KEY `FK_order_goods_1` (`goodsId`),
    
        CONSTRAINT `FK_order_goods_1` FOREIGN KEY
     (`goodsId`) REFERENCES `goods` (`id`),
        CONSTRAINT `FK_order_goods_2` FOREIGN KEY
     (`orderId`) REFERENCES `order_info` (`orderId`)
    );
    
    Insert into
    `order_goods`(`id`,`orderId`,`goodsTotalPrice`,`goodsId`,`goodsPrice`,`goodsNum`,`goodsName`) 
    values (23,'20130708001514',12,10,12,1,'回锅肉'),
    (28,'20130708021437',12,10,12,1,'回锅肉'),
    (31,'20130708110510',22,5,22,1,'青椒肉丝'),
    (32,'20130708110510',9,9,9,1,'鱼香肉丝'),
    (33,'20130708110513',12,10,12,1,'回锅肉'),
    (34,'20130708110513',32,11,32,1,'热狗肠'),
    (39,'20130708115503',2,8,2,1,'麻婆豆腐'),
    (40,'20130708115508',12,10,12,1,'回锅肉'),
    (41,'20130708115508',32,11,32,1,'热狗肠'),
    (42,'20130708115512',22,5,22,1,'青椒肉丝'),
    (43,'20130708121456',9,9,9,1,'鱼香肉丝'); 
    

    在这里插入图片描述

    Java 程序设计部分

    sut.rj.dao
    dao

    GoodsDao

    package sut.rj.dao;
    
    import java.sql.Connection;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    import sut.rj.model.Goods;
    import sut.rj.dbconnection.StringUtil;
    
    @SuppressWarnings("unused")
    public class GoodsDao {
    	public int GoodsAdd(Connection con,Goods goods) throws Exception{
    		String sql="insert into goods values(null,?,?,?,?)";
    		PreparedStatement pstmt=con.prepareStatement(sql);
    		pstmt.setString(1, goods.getGoodsName());
    		pstmt.setFloat(2, goods.getPrice());
    		pstmt.setString(3, goods.getGoodsDesc());
    		pstmt.setString(4, goods.getImageLink());
    		return pstmt.executeUpdate();
    	}
    	
    public ResultSet goodsList(Connection con,Goods goods) throws Exception{	
    		StringBuffer sb=new StringBuffer("select * from `goods`");
    		if(StringUtil.isNotEmpty(goods.getGoodsName())){
    			sb.append(" and goodsName like '%"+goods.getGoodsName()+"%'");
    		}
    		if((goods.getPrice1()!=0)&&(goods.getPrice()==0) ){//低价格有,高价格无
    			sb.append(" and price>="+goods.getPrice1());
    		}else if(goods.getPrice()>goods.getPrice1()){//中间价格
    			sb.append(" and price between "+goods.getPrice1()+" and "+goods.getPrice());
    		}
    		else if((goods.getPrice()!=0)){//高价格有,低价格无或者和高价格一样
    			sb.append(" and price<="+goods.getPrice());
    		}
    		if(goods.getId()!=0){
    			sb.append(" and id="+goods.getId());
    		}
    		//System.out.println(sb.toString().replaceFirst("and", "where"));
    		PreparedStatement pstmt=con.prepareStatement(sb.toString().replaceFirst("and", "where"));
    		return pstmt.executeQuery();
    	}
    	
    public int goodsDelete(Connection con,String id) throws Exception{
    		String sql="delete from goods where id=?";
    		PreparedStatement pstmt=con.prepareStatement(sql);
    		pstmt.setString(1, id);
    		return pstmt.executeUpdate();
    	}
    	
    public int goodsModify(Connection con,Goods goods) throws Exception{
    		String sql="update goods set goodsName=?,goodsDesc=?,price=?,imageLink=? where id=?";
    		PreparedStatement pstmt=con.prepareStatement(sql);
    		pstmt.setString(1, goods.getGoodsName());
    		pstmt.setString(2, goods.getGoodsDesc());
    		pstmt.setFloat(3, goods.getPrice());
    		pstmt.setString(4, goods.getImageLink());
    		pstmt.setInt(5, goods.getId());
    		return pstmt.executeUpdate();
    	}}
    

    OrderDao

    package sut.rj.dao;
    
    import java.sql.Connection;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    
    import sut.rj.model.Order;
    import sut.rj.dbconnection.StringUtil;
    
    @SuppressWarnings("unused")
    public class OrderDao {
    	public int order_goodsAdd(Connection con ,Order order) throws Exception{
    		String sql="insert into `order_goods` values(null,?,?,?,?,?,?)";
    		PreparedStatement pstmt=con.prepareStatement(sql);
    		pstmt.setString(1, order.getOrderId());
    		pstmt.setFloat(2, order.getGoodsTotalPrice());		
    		pstmt.setInt(3, order.getGoodsId());
    		pstmt.setFloat(4, order.getGoodsPrice());
    		pstmt.setInt(5, order.getGoodsNum());
    		pstmt.setString(6, order.getGoodsName());
    		return pstmt.executeUpdate();
    	}
    	
    public int order_infoAdd(Connection con ,Order order) throws Exception{
    		String sql="insert into `order_info` values(?,?,?,?,?)";
    		PreparedStatement pstmt=con.prepareStatement(sql);
    		pstmt.setString(1, order.getOrderId());
    		pstmt.setInt(2, order.getOrderStatus());
    		pstmt.setInt(3, order.getOrderNum());		
    		pstmt.setFloat(4, order.getOrderTotalMoney());
    		pstmt.setString(5, order.getUserName());
    
    		return pstmt.executeUpdate();
    	}
    
    public ResultSet orderList(Connection con,Order order) throws Exception{	
    		StringBuffer sb=new StringBuffer("select * from `order_info`");
    		if(StringUtil.isNotEmpty(order.getOrderId())){
    			sb.append(" and orderId like '%"+order.getOrderId()+"%'");
    		}
    		if(StringUtil.isNotEmpty(order.getUserName())){
    			sb.append(" and userName like '%"+order.getUserName()+"%'");
    		}
    		PreparedStatement pstmt=con.prepareStatement(sb.toString().replaceFirst("and", "where"));
    		return pstmt.executeQuery();
    	}
    	
    public ResultSet orderGoodsList(Connection con,Order order) throws Exception{	
    		StringBuffer sb=new StringBuffer("select * from `order_goods`");
    		if(StringUtil.isNotEmpty(order.getOrderId())){
    			sb.append(" and orderId like '%"+order.getOrderId()+"%'");
    		}
    		PreparedStatement pstmt=con.prepareStatement(sb.toString().replaceFirst("and", "where"));
    		return pstmt.executeQuery();
    	}
    	
    public int orderStatusModify(Connection con,Order order) throws Exception{
    		String sql="update order_info set orderStatus=? where orderId=?";
    		PreparedStatement pstmt=con.prepareStatement(sql);
    		pstmt.setInt(1, order.getOrderStatus());
    		pstmt.setString(2, order.getOrderId());
    		return pstmt.executeUpdate();
    	}//同时删除order_goods和irder_info两张表里的有关orderId的数据 删除顺序要保证主外键关联顺序,不可以互换顺序
    	
    	public int deleteOrder(Connection con,Order order) throws Exception{
    			String sql="delete from order_goods where orderId=?";
    			PreparedStatement pstmt1=con.prepareStatement(sql);
    			pstmt1.setString(1, order.getOrderId());
    			pstmt1.executeUpdate();
    			sql="delete from order_info where orderId=?";
    			PreparedStatement pstmt2=con.prepareStatement(sql);
    			pstmt2.setString(1, order.getOrderId());
    			return pstmt2.executeUpdate();}}
    

    UserDao

    package sut.rj.dao;
    
    import java.sql.Connection;
    import java.sql.PreparedStatement;
    import java.sql.ResultSet;
    import java.sql.SQLException;
    
    import sut.rj.model.User;
    import sut.rj.dbconnection.StringUtil;
    
    @SuppressWarnings("unused")
    public class UserDao {
    
    	/**
    	 * 登陆验证
    	 * @param con
    	 * @param user
    	 * @return
    	 * @throws Exception
    	 */
    public User login(Connection con,User user) throws Exception{
    		User resultUser = null;
    		String sql="select *from user where userName=? and password=?";
    		PreparedStatement pstmt=con.prepareStatement(sql);
    		pstmt.setString(1, user.getUserName());
    		pstmt.setString(2, user.getPassword());
    		ResultSet rs=pstmt.executeQuery();
    		if(rs.next()){
    			resultUser = new User();
    			resultUser.setUserName(rs.getString("userName"));
    			resultUser.setPassword(rs.getString("password"));
    			resultUser.setRank(rs.getInt("rank"));
    			resultUser.setId(rs.getInt("id"));
    		}
    		return resultUser;
    	}
    
    public int userAdd(Connection con,User user) throws Exception{
    		String sql="insert into `user` values(null,?,?,?,?)";
    		PreparedStatement pstmt=con.prepareStatement(sql);
    		pstmt.setString(1, user.getUserName());
    		pstmt.setString(2, user.getPassword());
    		pstmt.setString(3, user.getEmail());
    		pstmt.setInt(4, user.getRank());
    		return pstmt.executeUpdate();
    	}
    
    public boolean isUserExist(Connection con,User user) throws Exception{
    		String sql="select *from user where userName=?";
    		PreparedStatement pstmt=con.prepareStatement(sql);
    		pstmt.setString(1, user.getUserName());
    		ResultSet rs =pstmt.executeQuery();
    		return rs.next();
    	}
    	
    public int userModify(Connection con,User user) throws Exception{
    		String sql="update `user` set userName=?,password=?,email=? where id=?";
    		PreparedStatement pstmt=con.prepareStatement(sql);
    		pstmt.setString(1, user.getUserName());
    		pstmt.setString(2, user.getPassword());
    		pstmt.setString(3, user.getEmail());
    		pstmt.setInt(4, user.getId());;
    		return pstmt.executeUpdate();}}
    

    sut.rj.dbconnection
    dbconnection
    DbUtil

    package sut.rj.dbconnection;
    
    import java.sql.Connection;
    import java.sql.DriverManager;
    
    public class DbUtil {
    	private String dbUrl="jdbc:mysql://localhost:3306/db_food?useUnicode=true&characterEncoding=utf8";
    	private String dbUserName="root";
    	private String dbPassword="admin123";
    	private String jdbcName="com.mysql.jdbc.Driver";
    
    public Connection getCon() throws Exception{
    		Class.forName(jdbcName);
    		Connection con=DriverManager.getConnection(dbUrl,dbUserName,dbPassword);
    		return con;
    	}
    	
    public void closeCon(Connection con) throws Exception{
    		if(con!=null){
    			con.close();
    		}
    	}
    
    public static void main(String[] args) {
    		DbUtil dbUtil=new DbUtil();
    		try {
    			dbUtil.getCon();
    			System.out.println("数据库连接成功");
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    			System.out.println("数据库连接失败");}	}}
    

    StringUtil

    package sut.rj.dbconnection;
    
    import java.util.regex.Matcher;
    import java.util.regex.Pattern;
    
    public class StringUtil {
    	public static boolean isEmpty(String str){
    		if("".equals(str)||str==null){
    			return true;
    		}else{
    			return false;
    		}
    	}
    	
    public static boolean isNotEmpty(String str){
    		if(!"".equals(str)&&str!=null){
    			return true;
    		}else{
    			return false;
    		}
    	}
        /**  
         * 验证邮箱地址是否正确  
         * @param email  
         * @return  
         */  
    public static boolean checkEmail(String email){  
         boolean flag = false;  
         try{  
          String check = "^([a-z0-9A-Z]+[-|\\.]?)+[a-z0-9A-Z]@([a-z0-9A-Z]+(-[a-z0-9A-Z]+)?\\.)+[a-zA-Z]{2,}$";  
          Pattern regex = Pattern.compile(check);  
          Matcher matcher = regex.matcher(email);  
          flag = matcher.matches();  
         }catch(Exception e){  
          flag = false;  
         }  
           
         return flag;  
        } 
    
        /**  
         * 验证手机号码  
         * @param mobiles  
         * @return  [0-9]{5,9}  
         */  
    public static boolean isMobileNO(String mobiles){  
         boolean flag = false;  
         try{  
          Pattern p = Pattern.compile("^((13[0-9])|(15[^4,\\D])|(18[0,5-9]))\\d{8}$");  
          Matcher m = p.matcher(mobiles);  
          flag = m.matches();  
         }catch(Exception e){  
          flag = false;  
         }  
         return flag;  
        }  
          
      //浮点型判断
        public static boolean isNum(String str){	
        	return str.matches("^[-+]?(([0-9]+)([.]([0-9]+))?|([.]([0-9]+))?)$");}}
    

    sut.rj.model
    model
    Goods

    package sut.rj.model;
    
    public class Goods {
    	private int id;
    	private String goodsName;
    	private String goodsDesc;
    	private float price;//查询价格低高价格
    	private float price1;//查询价格高价格
    	private String imageLink;
    	
    public Goods() {
    		super();
    		// TODO Auto-generated constructor stub
    	}
    	
    public Goods(int id, String goodsName, String goodsDesc, float price,
    			String imageLink) {
    		super();
    		this.id = id;
    		this.goodsName = goodsName;
    		this.goodsDesc = goodsDesc;
    		this.price = price;
    		this.imageLink = imageLink;
    	}
    
    public Goods(String goodsName, String goodsDesc, float price,
    			String imageLink) {
    		super();
    		this.goodsName = goodsName;
    		this.goodsDesc = goodsDesc;
    		this.price = price;
    		this.imageLink = imageLink;
    	}
    
    	public int getId() {
    		return id;
    	}
    	public void setId(int id) {
    		this.id = id;
    	}
    	public String getGoodsName() {
    		return goodsName;
    	}
    	public void setGoodsName(String goodsName) {
    		this.goodsName = goodsName;
    	}
    	public String getGoodsDesc() {
    		return goodsDesc;
    	}
    	public void setGoodsDesc(String goodsDesc) {
    		this.goodsDesc = goodsDesc;
    	}
    	public float getPrice() {
    		return price;
    	}
    	public void setPrice(float price) {
    		this.price = price;
    	}
    	public float getPrice1() {
    		return price1;
    	}
    	public void setPrice1(float price1) {
    		this.price1 = price1;
    	}
    	public String getImageLink() {
    		return imageLink;
    	}
    	public void setImageLink(String imageLink) {
    		this.imageLink = imageLink;}}
    

    Order

    package sut.rj.model;
    
    public class Order {
    
    	private int id;
    	private String orderId;
    	private float goodsTotalPrice;
    	private int goodsId;
    	private float goodsPrice;
    	private int goodsNum;
    	private String goodsName;
    	private int orderStatus;//订单状态 0 未处理(可以取消)1 已接受烹饪中 2 已送达已付款 3 已付款已完成 4已取消
    	private int orderNum;
    	private float orderTotalMoney;
    	private String userName;
    	
    public Order() {
    		super();
    		// TODO Auto-generated constructor stub
    	}
    public Order(String orderId, int orderStatus, int orderNum,
    			float orderTotalMoney, String userName) {
    		super();
    		this.orderId = orderId;
    		this.orderStatus = orderStatus;
    		this.orderNum = orderNum;
    		this.orderTotalMoney = orderTotalMoney;
    		this.userName = userName;
    	}
    public Order(String orderId, float goodsTotalPrice, int goodsId,
    			float goodsPrice, int goodsNum, String goodsName) {
    		super();
    		this.orderId = orderId;
    		this.goodsTotalPrice = goodsTotalPrice;
    		this.goodsId = goodsId;
    		this.goodsPrice = goodsPrice;
    		this.goodsNum = goodsNum;
    		this.goodsName = goodsName;
    	}
    	public int getId() {
    		return id;
    	}
    	public void setId(int id) {
    		this.id = id;
    	}
    	public String getOrderId() {
    		return orderId;
    	}
    	public void setOrderId(String orderId) {
    		this.orderId = orderId;
    	}
    	public float getGoodsTotalPrice() {
    		return goodsTotalPrice;
    	}
    	public void setGoodsTotalPrice(float goodsTotalPrice) {
    		this.goodsTotalPrice = goodsTotalPrice;
    	}
    	public int getGoodsId() {
    		return goodsId;
    	}
    	public void setGoodsId(int goodsId) {
    		this.goodsId = goodsId;
    	}
    	public float getGoodsPrice() {
    		return goodsPrice;
    	}
    	public void setGoodsPrice(float goodsPrice) {
    		this.goodsPrice = goodsPrice;
    	}
    	public int getGoodsNum() {
    		return goodsNum;
    	}
    	public void setGoodsNum(int goodsNum) {
    		this.goodsNum = goodsNum;
    	}
    	public String getGoodsName() {
    		return goodsName;
    	}
    	public void setGoodsName(String goodsName) {
    		this.goodsName = goodsName;
    	}
    	public int getOrderStatus() {
    		return orderStatus;
    	}
    	public void setOrderStatus(int orderStatus) {
    		this.orderStatus = orderStatus;
    	}
    	public int getOrderNum() {
    		return orderNum;
    	}
    	public void setOrderNum(int orderNum) {
    		this.orderNum = orderNum;
    	}
    	public float getOrderTotalMoney() {
    		return orderTotalMoney;
    	}
    	public void setOrderTotalMoney(float orderTotalMoney) {
    		this.orderTotalMoney = orderTotalMoney;
    	}
    	public String getUserName() {
    		return userName;
    	}
    	public void setUserName(String userName) {
    		this.userName = userName;}}
    

    User

    package sut.rj.model;
    
    public class User {
    	private int id;
    	private String userName;
    	private String password;
    	private String email;
    	private int rank;
    	
    public User() {
    		super();
    		// TODO Auto-generated constructor stub
    	}
    public User(String userName, String password, String email) {
    		super();
    		this.userName = userName;
    		this.password = password;
    		this.email = email;
    	}
    
    public User(String userName, String password) {
    		super();
    		this.userName = userName;
    		this.password = password;
    	}
    	public int getId() {
    		return id;
    	}
    	public void setId(int id) {
    		this.id = id;
    	}
    	public String getUserName() {
    		return userName;
    	}
    	public void setUserName(String userName) {
    		this.userName = userName;
    	}
    	public String getPassword() {
    		return password;
    	}
    	public void setPassword(String password) {
    		this.password = password;
    	}
    	public String getEmail() {
    		return email;
    	}
    	public void setEmail(String email) {
    		this.email = email;
    	}
    	public int getRank() {
    		return rank;
    	}
    	public void setRank(int rank) {
    		this.rank = rank;}}
    

    *sut.rj.view *
    view

    运用 JAVA可视化界面开发插件Matisse

    src文件夹上点击右键–>New–>Other弹出如下界面:
    myeclipse
    选择MyEclipse–>Swing–>Mattise Form弹出如下界面
    Matisse
    填入包名和类名后选中JFrame,在右侧的Mattise Palette中展开Swing文件夹就会看到Swing中的组件,如下图:
    free

    AccountModifyInterFrm

    package sut.rj.view;
    
    import java.sql.Connection;
    import javax.swing.*;
    
    import sut.rj.dao.UserDao;
    import sut.rj.model.User;
    import sut.rj.dbconnection.DbUtil;
    import sut.rj.dbconnection.StringUtil;
    
    public class AccountModifyInterFrm extends javax.swing.JInternalFrame {
    	//GEN-BEGIN:variables
    	// Variables declaration - do not modify
    	private javax.swing.JLabel jLabel1;
    	private javax.swing.JLabel jLabel2;
    	private javax.swing.JLabel jLabel3;
    	private javax.swing.JLabel jLabel4;
    	private javax.swing.JButton jb_modify;
    	private javax.swing.JButton jb_reset;
    	private javax.swing.JPasswordField newPasswordConfirmTxt;
    	private javax.swing.JPasswordField newPasswordTxt;
    	private javax.swing.JPasswordField oldPasswordTxt;
    	private javax.swing.JTextField userNameTxt;
    	// End of variables declaration//GEN-END:variables
    	private static final long serialVersionUID = 1L;
    	//实现序列化,serialVersionUID 用来表明实现序列化类的不同版本间的兼容性
    	DbUtil dbUtil = new DbUtil();
    	UserDao userDao = new UserDao();
    
    	/** Creates new form AccountModify */
    	public AccountModifyInterFrm() {
    		initComponents();
    		this.setLocation(320, 100);
    		this.userNameTxt.setText(LogOnFrm.s_currentUser.getUserName());
    	}
    
    	/** This method is called from within the constructor to
    	 * initialize the form.
    	 * WARNING: Do NOT modify this code. The content of this method is
    	 * always regenerated by the Form Editor.
    	 *初始化表单.
         *警告:不要修改此代码。这种方法的内容是
         *总是由表单编辑器重新生成. **/
    	//GEN-BEGIN:initComponents
    	// <editor-fold defaultstate="collapsed" desc="Generated Code">
    	private void initComponents() {
    
    		jLabel1 = new javax.swing.JLabel();
    		jLabel2 = new javax.swing.JLabel();
    		jLabel3 = new javax.swing.JLabel();
    		jLabel4 = new javax.swing.JLabel();
    		jb_modify = new javax.swing.JButton();
    		jb_reset = new javax.swing.JButton();
    		userNameTxt = new javax.swing.JTextField();
    		oldPasswordTxt = new javax.swing.JPasswordField();
    		newPasswordTxt = new javax.swing.JPasswordField();
    		newPasswordConfirmTxt = new javax.swing.JPasswordField();
    
    		setClosable(true);
    		setIconifiable(true);
    		setTitle("\u8d26\u6237\u4fe1\u606f\u4fee\u6539");
    
    		jLabel1.setIcon(new javax.swing.ImageIcon(getClass().getResource(
    				"/images/userName.png"))); // NOI18N
    		jLabel1.setText("\u7528\u6237\u540d\uff1a");
    		jLabel2.setIcon(new javax.swing.ImageIcon(getClass().getResource(
    				"/images/password.png"))); // NOI18N
    		jLabel2.setText("\u65e7\u5bc6\u7801\uff1a");
    		jLabel3.setIcon(new javax.swing.ImageIcon(getClass().getResource(
    				"/images/new_password.png"))); // NOI18N
    		jLabel3.setText("\u65b0\u5bc6\u7801\uff1a");
    		jLabel4.setText("\u65b0\u5bc6\u7801\u786e\u8ba4\uff1a");
    		jb_modify.setIcon(new javax.swing.ImageIcon(getClass().getResource(
    				"/images/edit.png"))); // NOI18N
    		jb_modify.setText("\u786e\u8ba4\u4fee\u6539");
    		jb_modify.addActionListener(new java.awt.event.ActionListener() {
    			public void actionPerformed(java.awt.event.ActionEvent evt) {
    				jb_modifyActionPerformed(evt);		}});
    
    		jb_reset.setIcon(new javax.swing.ImageIcon(getClass().getResource(
    				"/images/reset.png"))); // NOI18N
    		jb_reset.setText("\u91cd\u7f6e");
    		jb_reset.addActionListener(new java.awt.event.ActionListener() {
    			public void actionPerformed(java.awt.event.ActionEvent evt) {
    				jb_resetActionPerformed(evt);
    			}
    		});
    
    		userNameTxt.setEnabled(false);
    
    		javax.swing.GroupLayout layout = new javax.swing.GroupLayout(
    				getContentPane());
    		getContentPane().setLayout(layout);
    		layout
    				.setHorizontalGroup(layout
    						.createParallelGroup(
    								javax.swing.GroupLayout.Alignment.LEADING)
    						.addGroup(
    								layout
    										.createSequentialGroup()
    										.addGroup(
    												layout
    														.createParallelGroup(
    																javax.swing.GroupLayout.Alignment.LEADING,
    																false)
    														.addGroup(
    																layout
    																		.createSequentialGroup()
    																		.addGap(
    																				37,
    																				37,
    																				37)
    																		.addGroup(
    																				layout
    																						.createParallelGroup(
    																								javax.swing.GroupLayout.Alignment.TRAILING)
    																						.addComponent(
    																								jLabel1)
    																						.addComponent(
    																								jLabel2)
    																						.addComponent(
    																								jLabel3)
    																						.addComponent(
    																								jLabel4))
    																		.addGap(
    																				35,
    																				35,
    																				35)
    																		.addGroup(
    																				layout
    																						.createParallelGroup(
    																								javax.swing.GroupLayout.Alignment.TRAILING,
    																								false)
    																						.addComponent(
    																								newPasswordConfirmTxt,
    																								javax.swing.GroupLayout.Alignment.LEADING)
    																						.addComponent(
    																								newPasswordTxt,
    																								javax.swing.GroupLayout.Alignment.LEADING)
    																						.addComponent(
    																								oldPasswordTxt,
    																								javax.swing.GroupLayout.Alignment.LEADING)
    																						.addComponent(
    																								userNameTxt,
    																								javax.swing.GroupLayout.Alignment.LEADING,
    																								javax.swing.GroupLayout.DEFAULT_SIZE,
    																								127,
    																								Short.MAX_VALUE)))
    														.addGroup(
    																layout
    																		.createSequentialGroup()
    																		.addGap(
    																				47,
    																				47,
    																				47)
    																		.addComponent(
    																				jb_modify)
    																		.addGap(
    																				18,
    																				18,
    																				18)
    																		.addComponent(
    																				jb_reset,
    																				javax.swing.GroupLayout.DEFAULT_SIZE,
    																				javax.swing.GroupLayout.DEFAULT_SIZE,
    																				Short.MAX_VALUE)))
    										.addContainerGap(65, Short.MAX_VALUE)));
    		layout
    				.setVerticalGroup(layout
    						.createParallelGroup(
    								javax.swing.GroupLayout.Alignment.LEADING)
    						.addGroup(
    								javax.swing.GroupLayout.Alignment.TRAILING,
    								layout
    										.createSequentialGroup()
    										.addGap(41, 41, 41)
    										.addGroup(
    												layout
    														.createParallelGroup(
    																javax.swing.GroupLayout.Alignment.BASELINE)
    														.addComponent(jLabel1)
    														.addComponent(
    																userNameTxt,
    																javax.swing.GroupLayout.PREFERRED_SIZE,
    																javax.swing.GroupLayout.DEFAULT_SIZE,
    																javax.swing.GroupLayout.PREFERRED_SIZE))
    										.addGap(18, 18, 18)
    										.addGroup(
    												layout
    														.createParallelGroup(
    																javax.swing.GroupLayout.Alignment.BASELINE)
    														.addComponent(jLabel2)
    														.addComponent(
    																oldPasswordTxt,
    																javax.swing.GroupLayout.PREFERRED_SIZE,
    																javax.swing.GroupLayout.DEFAULT_SIZE,
    																javax.swing.GroupLayout.PREFERRED_SIZE))
    										.addGap(18, 18, 18)
    										.addGroup(
    												layout
    														.createParallelGroup(
    																javax.swing.GroupLayout.Alignment.BASELINE)
    														.addComponent(jLabel3)
    														.addComponent(
    																newPasswordTxt,
    																javax.swing.GroupLayout.PREFERRED_SIZE,
    																javax.swing.GroupLayout.DEFAULT_SIZE,
    																javax.swing.GroupLayout.PREFERRED_SIZE))
    										.addGap(12, 12, 12)
    										.addGroup(
    												layout
    														.createParallelGroup(
    																javax.swing.GroupLayout.Alignment.BASELINE)
    														.addComponent(jLabel4)
    														.addComponent(
    																newPasswordConfirmTxt,
    																javax.swing.GroupLayout.PREFERRED_SIZE,
    																javax.swing.GroupLayout.DEFAULT_SIZE,
    																javax.swing.GroupLayout.PREFERRED_SIZE))
    										.addGap(30, 30, 30)
    										.addGroup(
    												layout
    														.createParallelGroup(
    																javax.swing.GroupLayout.Alignment.BASELINE)
    														.addComponent(jb_modify)
    														.addComponent(jb_reset))
    										.addGap(40, 40, 40)));
    
    		pack();
    	}// </editor-fold>
    	//GEN-END:initComponents
    
    	private void jb_modifyActionPerformed(java.awt.event.ActionEvent evt) {
    		String oldPassword = new String(this.oldPasswordTxt.getPassword());
    		String newPassword1 = new String(this.newPasswordTxt.getPassword());
    		String newPassword2 = new String(this.newPasswordConfirmTxt
    				.getPassword());
    		if (StringUtil.isEmpty(oldPassword)) {
    			JOptionPane.showMessageDialog(null, "旧密码不能为空!");
    			return;
    		}
    		if (StringUtil.isEmpty(newPassword1)
    				|| StringUtil.isEmpty(newPassword2)) {
    			JOptionPane.showMessageDialog(null, "新密码不能为空!");
    			return;
    		}
    		if (!newPassword1.equals(newPassword2)) {
    			JOptionPane.showMessageDialog(null, "两次输入的密码不一致!");
    			return;
    		}
    		User user = null;
    		Connection con = null;
    		try {
    			con = dbUtil.getCon();
    			user = new User(LogOnFrm.s_currentUser.getUserName(), oldPassword);
    			if (userDao.login(con, user) != null) {
    				user.setPassword(newPassword1);
    				user.setId(LogOnFrm.s_currentUser.getId());
    				int modifyNum = userDao.userModify(con, user);
    				if (1 == modifyNum) {
    					JOptionPane.showMessageDialog(null, "修改成功!");
    					this.oldPasswordTxt.setText("");
    					this.newPasswordTxt.setText("");
    					this.newPasswordConfirmTxt.setText("");
    				} else {
    					JOptionPane.showMessageDialog(null, "修改失败,请重新输入");
    				}
    			} else {
    				JOptionPane.showMessageDialog(null, "旧密码错误!请重新输入");
    			}
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} finally {
    			try {
    				dbUtil.closeCon(con);
    			} catch (Exception e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}}}
    	private void jb_resetActionPerformed(java.awt.event.ActionEvent evt) {
    		this.oldPasswordTxt.setText("");
    		this.newPasswordTxt.setText("");
    		this.newPasswordConfirmTxt.setText("");}}
    

    AdminFrm

    package sut.rj.view;
    
    import javax.swing.*;
    
    public class AdminFrm extends javax.swing.JFrame {
    	//GEN-BEGIN:variables
    	// Variables declaration - do not modify
    	private javax.swing.JMenu jMenu1;
    	private javax.swing.JMenu jMenu3;
    	private javax.swing.JMenu jMenu4;
    	private javax.swing.JMenuBar jMenuBar1;
    	private javax.swing.JMenuItem jmiDealOrder;
    	private javax.swing.JMenuItem jmiExit;
    	private javax.swing.JMenuItem jmiGoodsAdd;
    	private javax.swing.JMenuItem jmiGoodsManage;
    	private javax.swing.JMenuItem jmiModify;
    	private javax.swing.JDesktopPane table;
    	// End of variables declaration//GEN-END:variables
    	private static final long serialVersionUID = 1L;
    	//实现序列化,serialVersionUID 用来表明实现序列化类的不同版本间的兼容性
    
    	/** Creates new form AdminFrm */
    	public AdminFrm() {
    		initComponents();
    		//设置最大化
    		this.setExtendedState(JFrame.MAXIMIZED_BOTH);
    	}
    
    	/** This method is called from within the constructor to
    	 * initialize the form.
    	 * WARNING: Do NOT modify this code. The content of this method is
    	 * always regenerated by the Form Editor.
    	 * 初始化表单.
         * 警告:不要修改此代码。这种方法的内容是
         * 总是由表单编辑器重新生成. 
    	 */
    	//GEN-BEGIN:initComponents
    	// <editor-fold defaultstate="collapsed" desc="Generated Code">
    	private void initComponents() {
    
    		table = new javax.swing.JDesktopPane();
    		jMenuBar1 = new javax.swing.JMenuBar();
    		jMenu1 = new javax.swing.JMenu();
    		jmiGoodsAdd = new javax.swing.JMenuItem();
    		jmiGoodsManage = new javax.swing.JMenuItem();
    		jMenu3 = new javax.swing.JMenu();
    		jmiDealOrder = new javax.swing.JMenuItem();
    		jMenu4 = new javax.swing.JMenu();
    		jmiModify = new javax.swing.JMenuItem();
    		jmiExit = new javax.swing.JMenuItem();
    
    		setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
    		setTitle("\u70b9\u9910\u7cfb\u7edf\u7ba1\u7406\u4e3b\u754c\u9762");
    		jMenu1.setIcon(new javax.swing.ImageIcon(getClass().getResource(
    				"/images/base.png"))); // NOI18N
    		jMenu1.setText("\u5957\u9910\u4fe1\u606f\u7ba1\u7406");
    
    		jmiGoodsAdd.setIcon(new javax.swing.ImageIcon(getClass().getResource(
    				"/images/add.png"))); // NOI18N
    		jmiGoodsAdd.setText("\u65b0\u589e\u5957\u9910");
    		jmiGoodsAdd.addActionListener(new java.awt.event.ActionListener() {
    			public void actionPerformed(java.awt.event.ActionEvent evt) {
    				jmiGoodsAddActionPerformed(evt);
    			}	});
    		jMenu1.add(jmiGoodsAdd);
    		jmiGoodsManage.setIcon(new javax.swing.ImageIcon(getClass()
    				.getResource("/images/edit.png"))); // NOI18N
    		jmiGoodsManage.setText("\u5957\u9910\u7ef4\u62a4");
    		jmiGoodsManage.addActionListener(new java.awt.event.ActionListener() {
    			public void actionPerformed(java.awt.event.ActionEvent evt) {
    				jmiGoodsManageActionPerformed(evt);	}});
    		jMenu1.add(jmiGoodsManage);
    		jMenuBar1.add(jMenu1);
    		jMenu3.setIcon(new javax.swing.ImageIcon(getClass().getResource(
    				"/images/bookManager.png"))); // NOI18N
    		jMenu3.setText("\u8ba2\u5355\u7ba1\u7406");
    
    		jmiDealOrder.setIcon(new javax.swing.ImageIcon(getClass().getResource(
    				"/images/order2.png"))); // NOI18N
    		jmiDealOrder.setText("\u8ba2\u5355\u5904\u7406");
    		jmiDealOrder.addActionListener(new java.awt.event.ActionListener() {
    			public void actionPerformed(java.awt.event.ActionEvent evt) {
    				jmiDealOrderActionPerformed(evt);
    			}});
    		jMenu3.add(jmiDealOrder);
    		jMenuBar1.add(jMenu3);
    		jMenu4.setIcon(new javax.swing.ImageIcon(getClass().getResource(
    				"/images/about.png"))); // NOI18N
    		jMenu4.setText("\u5176\u4ed6");
    		jmiModify.setIcon(new javax.swing.ImageIcon(getClass().getResource(
    				"/images/modify.png"))); // NOI18N
    		jmiModify.setText("\u4fee\u6539\u5bc6\u7801");
    		jmiModify.addActionListener(new java.awt.event.ActionListener() {
    			public void actionPerformed(java.awt.event.ActionEvent evt) {
    				jmiModifyActionPerformed(evt);
    			}});
    		jMenu4.add(jmiModify);
    
    		jmiExit.setIcon(new javax.swing.ImageIcon(getClass().getResource(
    				"/images/exit.png"))); // NOI18N
    		jmiExit.setText("\u9000\u51fa\u7cfb\u7edf");
    		jmiExit.addActionListener(new java.awt.event.ActionListener() {
    			public void actionPerformed(java.awt.event.ActionEvent evt) {
    				jmiExitActionPerformed(evt);
    			}});
    		jMenu4.add(jmiExit);
    		jMenuBar1.add(jMenu4);
    		setJMenuBar(jMenuBar1);
    		javax.swing.GroupLayout layout = new javax.swing.GroupLayout(
    				getContentPane());
    		getContentPane().setLayout(layout);
    		layout.setHorizontalGroup(layout.createParallelGroup(
    				javax.swing.GroupLayout.Alignment.LEADING).addComponent(table,
    				javax.swing.GroupLayout.DEFAULT_SIZE, 400, Short.MAX_VALUE));
    		layout.setVerticalGroup(layout.createParallelGroup(
    				javax.swing.GroupLayout.Alignment.LEADING).addComponent(table,
    				javax.swing.GroupLayout.DEFAULT_SIZE, 337, Short.MAX_VALUE));
    		pack();
    	}// </editor-fold>
    	//GEN-END:initComponents
    
    	//订单处理操作
    	private void jmiDealOrderActionPerformed(java.awt.event.ActionEvent evt) {
    		DealOrderInterFrm dealOrderInterFrm = new DealOrderInterFrm();
    		dealOrderInterFrm.setVisible(true);
    		this.table.add(dealOrderInterFrm);
    	}
    	//修改用户信息操作
    	void jmiModifyActionPerformed(java.awt.event.ActionEvent evt) {
    		AccountModifyInterFrm accountModify = new AccountModifyInterFrm();
    		accountModify.setVisible(true);
    		this.table.add(accountModify);
    	}
    	//套餐维护管理
    	private void jmiGoodsManageActionPerformed(java.awt.event.ActionEvent evt) {
    		GoodsManageInterFrm goodsManageInterFrm = new GoodsManageInterFrm();
    		goodsManageInterFrm.setVisible(true);
    		this.table.add(goodsManageInterFrm);
    	}
    	//套餐添加
    	private void jmiGoodsAddActionPerformed(java.awt.event.ActionEvent evt) {
    		GoodsAddInterFrm goodsAddInterFrm = new GoodsAddInterFrm();
    		goodsAddInterFrm.setVisible(true);
    		this.table.add(goodsAddInterFrm);
    	}
    	//退出系统
    	private void jmiExitActionPerformed(java.awt.event.ActionEvent evt) {
    		int result = JOptionPane.showConfirmDialog(null, "是否退出点餐系统?");
    		//System.out.println(result);
    		if (result == 0)
    			this.dispose();}
    
    	/**
    	 * @param args the command line arguments
    	 */
    	public static void main(String args[]) {
    		java.awt.EventQueue.invokeLater(new Runnable() {
    			public void run() {
    				new AdminFrm().setVisible(true);}});}}
    

    CheckOrderInterFrm

    package sut.rj.view;
    
    import java.sql.Connection;
    import java.sql.ResultSet;
    import java.util.Vector;
    
    import javax.swing.*;
    import javax.swing.table.DefaultTableModel;
    
    import sut.rj.dao.GoodsDao;
    import sut.rj.dao.OrderDao;
    import sut.rj.model.Goods;
    import sut.rj.model.Order;
    import sut.rj.dbconnection.DbUtil;
    import sut.rj.dbconnection.StringUtil;
    
    /**
     *
     * @author  __USER__
     */
    public class CheckOrderInterFrm extends javax.swing.JInternalFrame {
    
    	//GEN-BEGIN:variables
    	// Variables declaration - do not modify
    	private javax.swing.JTable cartTable;
    	private javax.swing.JLabel iamgeLb;
    	private javax.swing.JLabel jLabel1;
    	private javax.swing.JLabel jLabel2;
    	private javax.swing.JLabel jLabel3;
    	private javax.swing.JLabel jLabel4;
    	private javax.swing.JLabel jLabel5;
    	private javax.swing.JPanel jPanel2;
    	private javax.swing.JScrollPane jScrollPane1;
    	private javax.swing.JScrollPane jScrollPane2;
    	private javax.swing.JButton jb_search;
    	private javax.swing.JButton jb_status;
    	private javax.swing.JTextField orderIdTxt;
    	private javax.swing.JTextField orderStatusTxt;
    	private javax.swing.JTable orderTable;
    	private javax.swing.JTextField totalMoneyTxt;
    	private javax.swing.JTextField totalNumTxt;
    	private javax.swing.JTextField userNameTxt;
    	// End of variables declaration//GEN-END:variables
    
    	
    	private static final long serialVersionUID = 1L;
    	//实现序列化,serialVersionUID 用来表明实现序列化类的不同版本间的兼容性
    	@SuppressWarnings("unused")
    	private static final JTable j_orderTable = null;
    	DbUtil dbUtil = new DbUtil();
    	OrderDao orderDao = new OrderDao();
    	GoodsDao goodsDao = new GoodsDao();
    
    	/** Creates new form checkOrderInterFrm */
    	public CheckOrderInterFrm() {
    		initComponents();
    		this.setLocation(320, 100);
    		this.userNameTxt.setText(LogOnFrm.s_currentUser.getUserName());
    	}
    
    	//GEN-BEGIN:initComponents
    	// <editor-fold defaultstate="collapsed" desc="Generated Code">
    	private void initComponents() {
    
    		jScrollPane2 = new javax.swing.JScrollPane();
    		cartTable = new javax.swing.JTable();
    		jLabel2 = new javax.swing.JLabel();
    		totalNumTxt = new javax.swing.JTextField();
    		totalMoneyTxt = new javax.swing.JTextField();
    		jLabel1 = new javax.swing.JLabel();
    		jLabel3 = new javax.swing.JLabel();
    		orderStatusTxt = new javax.swing.JTextField();
    		jb_status = new javax.swing.JButton();
    		jLabel4 = new javax.swing.JLabel();
    		userNameTxt = new javax.swing.JTextField();
    		jLabel5 = new javax.swing.JLabel();
    		orderIdTxt = new javax.swing.JTextField();
    		jb_search = new javax.swing.JButton();
    		jScrollPane1 = new javax.swing.JScrollPane();
    		orderTable = new javax.swing.JTable();
    		jPanel2 = new javax.swing.JPanel();
    		iamgeLb = new javax.swing.JLabel();
    		setClosable(true);
    		setIconifiable(true);
    		setTitle("\u67e5\u770b\u8ba2\u5355");
    
    		cartTable.setModel(new javax.swing.table.DefaultTableModel(
    				new Object[][] {}, new String[] { "套餐编号", "套餐名称", "套餐数量", "套餐单价", "套餐金额" }) {
    					private static final long serialVersionUID = 1L;
    			boolean[] canEdit = new boolean[] { false, false, false, false,
    					false };
    			public boolean isCellEditable(int rowIndex, int columnIndex) {
    				return canEdit[columnIndex];		}});
    		cartTable.addMouseListener(new java.awt.event.MouseAdapter() {
    			public void mousePressed(java.awt.event.MouseEvent evt) {
    				cartTableMousePressed(evt);		}		});
    		jScrollPane2.setViewportView(cartTable);
    		jLabel2.setText("\u603b\u6570\u91cf\uff1a");
    		totalNumTxt.setEditable(false);
    		totalMoneyTxt.setEditable(false);
    		jLabel1.setText("\u603b\u91d1\u989d\uff1a");
    		jLabel3.setText("\u8ba2\u5355\u72b6\u6001\uff1a");
    		orderStatusTxt.setEditable(false);
    		jb_status.setText("\u53d6\u6d88\u8ba2\u5355");
    		jb_status.setFocusPainted(false);
    		jb_status.addActionListener(new java.awt.event.ActionListener() {
    			public void actionPerformed(java.awt.event.ActionEvent evt) {
    				jb_statusActionPerformed(evt);
    			}
    		});
    		jLabel4.setText("\u70b9\u9910\u4eba\uff1a");
    		userNameTxt.setEditable(false);
    		jLabel5.setText("\u8ba2\u5355\u53f7\uff1a");
    		jb_search.setIcon(new javax.swing.ImageIcon(getClass().getResource(
    				"/images/1.png"))); // NOI18N
    		jb_search.setText("\u8ba2\u5355\u67e5\u8be2");
    		jb_search.addActionListener(new java.awt.event.ActionListener() {
    			public void actionPerformed(java.awt.event.ActionEvent evt) {
    				jb_searchActionPerformed(evt);
    			}});
    		orderTable.setModel(new javax.swing.table.DefaultTableModel(
    				new Object[][] {
    
    				}, new String[] { "订单编号", "订单商品数量", "订单总金额", "订单状态" }) {
    			private static final long serialVersionUID = 1L;
    			boolean[] canEdit = new boolean[] { false, false, false, false };
    
    			public boolean isCellEditable(int rowIndex, int columnIndex) {
    				return canEdit[columnIndex];
    			}
    		});
    		orderTable.addMouseListener(new java.awt.event.MouseAdapter() {
    			public void mousePressed(java.awt.event.MouseEvent evt) {
    				orderTableMousePressed(evt);
    			}
    		});
    		jScrollPane1.setViewportView(orderTable);
    
    		jPanel2.setBorder(javax.swing.BorderFactory
    				.createTitledBorder("\u5957\u9910\u56fe\u7247"));
    
    		javax.swing.GroupLayout jPanel2Layout = new javax.swing.GroupLayout(
    				jPanel2);
    		jPanel2.setLayout(jPanel2Layout);
    		jPanel2Layout.setHorizontalGroup(jPanel2Layout.createParallelGroup(
    				javax.swing.GroupLayout.Alignment.LEADING).addComponent(
    				iamgeLb, javax.swing.GroupLayout.DEFAULT_SIZE, 72,
    				Short.MAX_VALUE));
    		jPanel2Layout.setVerticalGroup(jPanel2Layout.createParallelGroup(
    				javax.swing.GroupLayout.Alignment.LEADING).addComponent(
    				iamgeLb, javax.swing.GroupLayout.DEFAULT_SIZE, 65,
    				Short.MAX_VALUE));
    
    		javax.swing.GroupLayout layout = new javax.swing.GroupLayout(
    				getContentPane());
    		getContentPane().setLayout(layout);
    		layout
    				.setHorizontalGroup(layout
    						.createParallelGroup(
    								javax.swing.GroupLayout.Alignment.LEADING)
    						.addGroup(
    								layout
    										.createSequentialGroup()
    										.addGroup(
    												layout
    														.createParallelGroup(
    																javax.swing.GroupLayout.Alignment.LEADING,
    																false)
    														.addGroup(
    																layout
    																		.createSequentialGroup()
    																		.addGap(
    																				79,
    																				79,
    																				79)
    																		.addComponent(
    																				jLabel5)
    																		.addGap(
    																				36,
    																				36,
    																				36)
    																		.addComponent(
    																				orderIdTxt,
    																				javax.swing.GroupLayout.PREFERRED_SIZE,
    																				92,
    																				javax.swing.GroupLayout.PREFERRED_SIZE)
    																		.addPreferredGap(
    																				javax.swing.LayoutStyle.ComponentPlacement.RELATED,
    																				javax.swing.GroupLayout.DEFAULT_SIZE,
    																				Short.MAX_VALUE)
    																		.addComponent(
    																				jb_search))
    														.addGroup(
    																layout
    																		.createSequentialGroup()
    																		.addGap(
    																				29,
    																				29,
    																				29)
    																		.addComponent(
    																				jScrollPane1,
    																				javax.swing.GroupLayout.PREFERRED_SIZE,
    																				367,
    																				javax.swing.GroupLayout.PREFERRED_SIZE)))
    										.addGap(35, 35, 35)
    										.addGroup(
    												layout
    														.createParallelGroup(
    																javax.swing.GroupLayout.Alignment.LEADING)
    														.addGroup(
    																javax.swing.GroupLayout.Alignment.TRAILING,
    																layout
    																		.createSequentialGroup()
    																		.addComponent(
    																				jLabel4)
    																		.addPreferredGap(
    																				javax.swing.LayoutStyle.ComponentPlacement.RELATED)
    																		.addComponent(
    																				userNameTxt,
    																				javax.swing.GroupLayout.PREFERRED_SIZE,
    																				87,
    																				javax.swing.GroupLayout.PREFERRED_SIZE)
    																		.addGap(
    																				35,
    																				35,
    																				35))
    														.addComponent(
    																jScrollPane2,
    																javax.swing.GroupLayout.Alignment.TRAILING,
    																javax.swing.GroupLayout.PREFERRED_SIZE,
    																510,
    																javax.swing.GroupLayout.PREFERRED_SIZE)
    														.addGroup(
    																javax.swing.GroupLayout.Alignment.TRAILING,
    																layout
    																		.createSequentialGroup()
    																		.addGroup(
    																				layout
    																						.createParallelGroup(
    																								javax.swing.GroupLayout.Alignment.LEADING)
    																						.addGroup(
    																								layout
    																										.createSequentialGroup()
    																										.addComponent(
    																												jLabel3)
    																										.addPreferredGap(
    																												javax.swing.LayoutStyle.ComponentPlacement.RELATED)
    																										.addComponent(
    																												orderStatusTxt,
    																												javax.swing.GroupLayout.DEFAULT_SIZE,
    																												177,
    																												Short.MAX_VALUE)
    																										.addPreferredGap(
    																												javax.swing.LayoutStyle.ComponentPlacement.RELATED)
    																										.addComponent(
    																												jLabel2)
    																										.addPreferredGap(
    																												javax.swing.LayoutStyle.ComponentPlacement.RELATED)
    																										.addComponent(
    																												totalNumTxt,
    																												javax.swing.GroupLayout.PREFERRED_SIZE,
    																												76,
    																												javax.swing.GroupLayout.PREFERRED_SIZE)
    																										.addPreferredGap(
    																												javax.swing.LayoutStyle.ComponentPlacement.RELATED))
    																						.addGroup(
    																								layout
    																										.createSequentialGroup()
    																										.addComponent(
    																												jb_status)
    																										.addGap(
    																												297,
    																												297,
    																												297)))
    																		.addGroup(
    																				layout
    																						.createParallelGroup(
    																								javax.swing.GroupLayout.Alignment.TRAILING)
    																						.addGroup(
    																								layout
    																										.createSequentialGroup()
    																										.addComponent(
    																												jLabel1)
    																										.addPreferredGap(
    																												javax.swing.LayoutStyle.ComponentPlacement.RELATED)
    																										.addComponent(
    																												totalMoneyTxt,
    																												javax.swing.GroupLayout.PREFERRED_SIZE,
    																												81,
    																												javax.swing.GroupLayout.PREFERRED_SIZE))
    																						.addComponent(
    																								jPanel2,
    																								javax.swing.GroupLayout.PREFERRED_SIZE,
    																								javax.swing.GroupLayout.DEFAULT_SIZE,
    																								javax.swing.GroupLayout.PREFERRED_SIZE))))
    										.addContainerGap(23, Short.MAX_VALUE)));
    		layout
    				.setVerticalGroup(layout
    						.createParallelGroup(
    								javax.swing.GroupLayout.Alignment.LEADING)
    						.addGroup(
    								layout
    										.createSequentialGroup()
    										.addGroup(
    												layout
    														.createParallelGroup(
    																javax.swing.GroupLayout.Alignment.LEADING)
    														.addGroup(
    																layout
    																		.createSequentialGroup()
    																		.addContainerGap()
    																		.addGroup(
    																				layout
    																						.createParallelGroup(
    																								javax.swing.GroupLayout.Alignment.BASELINE)
    																						.addComponent(
    																								jLabel4)
    																						.addComponent(
    																								userNameTxt,
    																								javax.swing.GroupLayout.PREFERRED_SIZE,
    																								javax.swing.GroupLayout.DEFAULT_SIZE,
    																								javax.swing.GroupLayout.PREFERRED_SIZE)))
    														.addGroup(
    																layout
    																		.createSequentialGroup()
    																		.addGap(
    																				18,
    																				18,
    																				18)
    																		.addGroup(
    																				layout
    																						.createParallelGroup(
    																								javax.swing.GroupLayout.Alignment.BASELINE)
    																						.addComponent(
    																								orderIdTxt,
    																								javax.swing.GroupLayout.PREFERRED_SIZE,
    																								javax.swing.GroupLayout.DEFAULT_SIZE,
    																								javax.swing.GroupLayout.PREFERRED_SIZE)
    																						.addComponent(
    																								jLabel5)
    																						.addComponent(
    																								jb_search))))
    										.addGap(23, 23, 23)
    										.addGroup(
    												layout
    														.createParallelGroup(
    																javax.swing.GroupLayout.Alignment.LEADING)
    														.addGroup(
    																layout
    																		.createSequentialGroup()
    																		.addComponent(
    																				jScrollPane2,
    																				javax.swing.GroupLayout.PREFERRED_SIZE,
    																				169,
    																				javax.swing.GroupLayout.PREFERRED_SIZE)
    																		.addGap(
    																				38,
    																				38,
    																				38)
    																		.addGroup(
    																				layout
    																						.createParallelGroup(
    																								javax.swing.GroupLayout.Alignment.BASELINE)
    																						.addComponent(
    																								jLabel3)
    																						.addComponent(
    																								totalMoneyTxt,
    																								javax.swing.GroupLayout.PREFERRED_SIZE,
    																								javax.swing.GroupLayout.DEFAULT_SIZE,
    																								javax.swing.GroupLayout.PREFERRED_SIZE)
    																						.addComponent(
    																								jLabel1)
    																						.addComponent(
    																								totalNumTxt,
    																								javax.swing.GroupLayout.PREFERRED_SIZE,
    																								javax.swing.GroupLayout.DEFAULT_SIZE,
    																								javax.swing.GroupLayout.PREFERRED_SIZE)
    																						.addComponent(
    																								jLabel2)
    																						.addComponent(
    																								orderStatusTxt,
    																								javax.swing.GroupLayout.PREFERRED_SIZE,
    																								javax.swing.GroupLayout.DEFAULT_SIZE,
    																								javax.swing.GroupLayout.PREFERRED_SIZE))
    																		.addPreferredGap(
    																				javax.swing.LayoutStyle.ComponentPlacement.RELATED)
    																		.addGroup(
    																				layout
    																						.createParallelGroup(
    																								javax.swing.GroupLayout.Alignment.LEADING)
    																						.addComponent(
    																								jb_status)
    																						.addComponent(
    																								jPanel2,
    																								javax.swing.GroupLayout.PREFERRED_SIZE,
    																								javax.swing.GroupLayout.DEFAULT_SIZE,
    																								javax.swing.GroupLayout.PREFERRED_SIZE)))
    														.addComponent(
    																jScrollPane1,
    																javax.swing.GroupLayout.PREFERRED_SIZE,
    																199,
    																javax.swing.GroupLayout.PREFERRED_SIZE))
    										.addContainerGap(52, Short.MAX_VALUE)));
    
    		pack();
    	}// </editor-fold>
    	//GEN-END:initComponents
    	//填充ordertable
    	@SuppressWarnings("unchecked")
    	private void fillOrderTable() {
    		String orderId = this.orderIdTxt.getText();
    		String userName = this.userNameTxt.getText();
    		Order order = new Order();
    		order.setOrderId(orderId);
    		order.setUserName(userName);
    		DefaultTableModel dtm = (DefaultTableModel) orderTable.getModel();
    		dtm.setRowCount(0);
    		Connection con = null;
    		try {
    			con = dbUtil.getCon();
    			ResultSet rs = orderDao.orderList(con, order);
    			while (rs.next()) {
    				Vector v = new Vector();
    				v.add(rs.getString("orderId"));
    				v.add(rs.getInt("orderNum"));
    				v.add(rs.getFloat("orderTotalMoney"));
    				int status = rs.getInt("orderStatus");
    				switch (status) {
    				case 0:
    					v.add("未处理");
    					break;
    				case 1:
    					v.add("烹饪中");
    					break;
    				case 2:
    					v.add("已送达");
    					break;
    				case 3:
    					v.add("已付款");
    					break;
    				case 4:
    					v.add("已取消");
    					break;
    				}
    				dtm.addRow(v);
    			}
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} finally {
    			try {
    				dbUtil.closeCon(con);
    			} catch (Exception e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();			}		}}
    	//点击购物车表显示图片
    	private void cartTableMousePressed(java.awt.event.MouseEvent evt) {
    		String picturePath = null;
    		//获取选中的行
    		int row = cartTable.getSelectedRow();
    		int goodsId = Integer.parseInt((String) cartTable.getValueAt(row, 0));
    		Goods goods = new Goods();
    		goods.setId(goodsId);
    		Connection con = null;
    		try {
    			con = dbUtil.getCon();
    			ResultSet rs = goodsDao.goodsList(con, goods);
    			while (rs.next()) {
    				picturePath = rs.getString("imageLink");
    			}
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} finally {
    			try {
    				dbUtil.closeCon(con);
    			} catch (Exception e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}}
    		if (StringUtil.isNotEmpty(picturePath)) {
    			Icon icon = new ImageIcon(picturePath);
    			this.iamgeLb.setIcon(icon);
    		} else {
    			this.iamgeLb.setIcon(null);	}}
    	//取消订单操作
    	private void jb_statusActionPerformed(java.awt.event.ActionEvent evt) {
    		//获取选中的行,如果为选中,row默认为-1
    		int row = orderTable.getSelectedRow();//
    		if (row < 0) {
    			JOptionPane.showMessageDialog(null, "请选择一个订单");
    			return;
    		}
    		//获取订单编号
    		String orderId = (String) orderTable.getValueAt(row, 0);
    		Order order = new Order();
    		order.setOrderId(orderId);
    		order.setOrderStatus(4);//取消订单
    		try {
    			Connection con = dbUtil.getCon();
    			int modifyNum = orderDao.orderStatusModify(con, order);
    			if (modifyNum == 1) {
    				JOptionPane.showMessageDialog(null, "取消成功!");
    				this.orderStatusTxt.setText("已取消");
    				this.jb_status.setEnabled(false);
    				fillOrderTable();
    			} else {
    				JOptionPane.showMessageDialog(null, "取消订单失败!");
    			}
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		}}
    	//点击订单table	
    	@SuppressWarnings("unchecked")
    	private void orderTableMousePressed(java.awt.event.MouseEvent evt) {
    		//获取选中的行
    		int row = orderTable.getSelectedRow();
    		String orderId = (String) orderTable.getValueAt(row, 0);
    		this.totalNumTxt.setText(orderTable.getValueAt(row, 1) + "");//把int,float型转化为string
    		this.totalMoneyTxt.setText(orderTable.getValueAt(row, 2) + "");
    		String orderStatus = (String) orderTable.getValueAt(row, 3);
    		this.orderStatusTxt.setText(orderStatus);
    		this.iamgeLb.setIcon(null);
    		//修改取消订单按钮状态
    		if (!orderStatus.equals("未处理")) {
    			jb_status.setEnabled(false);
    		} else {
    			jb_status.setEnabled(true);
    		}
    		Order order = new Order();
    		order.setOrderId(orderId);
    		DefaultTableModel dtm = (DefaultTableModel) cartTable.getModel();
    		dtm.setRowCount(0);
    		Connection con = null;
    		try {
    			con = dbUtil.getCon();
    			ResultSet rs = orderDao.orderGoodsList(con, order);
    			while (rs.next()) {
    				Vector v = new Vector();
    				v.add(rs.getString("goodsId"));
    				v.add(rs.getString("goodsName"));
    				v.add(rs.getInt("goodsNum"));
    				v.add(rs.getFloat("goodsPrice"));
    				v.add(rs.getFloat("goodsTotalPrice"));
    				dtm.addRow(v);
    			}
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} finally {
    			try {
    				dbUtil.closeCon(con);
    			} catch (Exception e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}}}
    	//点击查询订单
    	private void jb_searchActionPerformed(java.awt.event.ActionEvent evt) {
    		fillOrderTable();}}
    

    DealOrderInterFrm

    package sut.rj.view;
    
    import java.sql.Connection;
    import java.sql.ResultSet;
    import java.util.Vector;
    
    import javax.swing.*;
    import javax.swing.table.DefaultTableModel;
    
    import sut.rj.dao.GoodsDao;
    import sut.rj.dao.OrderDao;
    import sut.rj.model.Goods;
    import sut.rj.model.Order;
    import sut.rj.dbconnection.DbUtil;
    import sut.rj.dbconnection.StringUtil;
    
    public class DealOrderInterFrm extends javax.swing.JInternalFrame {
    	//GEN-BEGIN:variables
    	// Variables declaration - do not modify
    	private javax.swing.ButtonGroup buttonGroup1;
    	private javax.swing.JTable cartTable;
    	private javax.swing.JLabel iamgeLb;
    	private javax.swing.JButton jButton1;
    	private javax.swing.JLabel jLabel1;
    	private javax.swing.JLabel jLabel2;
    	private javax.swing.JLabel jLabel3;
    	private javax.swing.JLabel jLabel4;
    	private javax.swing.JLabel jLabel5;
    	private javax.swing.JPanel jPanel2;
    	private javax.swing.JScrollPane jScrollPane1;
    	private javax.swing.JScrollPane jScrollPane2;
    	private javax.swing.JButton jb_search;
    	private javax.swing.JButton jb_status;
    	private javax.swing.JRadioButton jrb_1;
    	private javax.swing.JRadioButton jrb_2;
    	private javax.swing.JRadioButton jrb_3;
    	private javax.swing.JRadioButton jrb_4;
    	private javax.swing.JTextField orderIdTxt;
    	private javax.swing.JTextField orderStatusTxt;
    	private javax.swing.JTable orderTable;
    	private javax.swing.JTextField totalMoneyTxt;
    	private javax.swing.JTextField totalNumTxt;
    	private javax.swing.JTextField userNameTxt;
    	// End of variables declaration//GEN-END:variables
    
    	private static final long serialVersionUID = 1L;
    	//实现序列化,serialVersionUID 用来表明实现序列化类的不同版本间的兼容性
    	@SuppressWarnings("unused")
    	private static final JTable j_orderTable = null;
    	DbUtil dbUtil = new DbUtil();
    	OrderDao orderDao = new OrderDao();
    	GoodsDao goodsDao = new GoodsDao();
    
    	/** Creates new form checkOrderInterFrm */
    	public DealOrderInterFrm() {
    		initComponents();
    		this.setLocation(320, 100);}
    
    	//GEN-BEGIN:initComponents
    	// <editor-fold defaultstate="collapsed" desc="Generated Code">
    	private void initComponents() {
    
    		buttonGroup1 = new javax.swing.ButtonGroup();
    		jScrollPane2 = new javax.swing.JScrollPane();
    		cartTable = new javax.swing.JTable();
    		jLabel2 = new javax.swing.JLabel();
    		totalNumTxt = new javax.swing.JTextField();
    		totalMoneyTxt = new javax.swing.JTextField();
    		jLabel1 = new javax.swing.JLabel();
    		jLabel3 = new javax.swing.JLabel();
    		orderStatusTxt = new javax.swing.JTextField();
    		jLabel4 = new javax.swing.JLabel();
    		userNameTxt = new javax.swing.JTextField();
    		jLabel5 = new javax.swing.JLabel();
    		orderIdTxt = new javax.swing.JTextField();
    		jb_search = new javax.swing.JButton();
    		jScrollPane1 = new javax.swing.JScrollPane();
    		orderTable = new javax.swing.JTable();
    		jPanel2 = new javax.swing.JPanel();
    		iamgeLb = new javax.swing.JLabel();
    		jrb_1 = new javax.swing.JRadioButton();
    		jrb_2 = new javax.swing.JRadioButton();
    		jrb_3 = new javax.swing.JRadioButton();
    		jrb_4 = new javax.swing.JRadioButton();
    		jButton1 = new javax.swing.JButton();
    		jb_status = new javax.swing.JButton();
    
    		setClosable(true);
    		setIconifiable(true);
    		setTitle("\u67e5\u770b\u8ba2\u5355");
    		cartTable.setModel(new javax.swing.table.DefaultTableModel(
    				new Object[][] {
    				}, new String[] { "套餐编号", "套餐名称", "套餐数量", "套餐单价", "套餐金额" }) {
    					private static final long serialVersionUID = 1L;
    			boolean[] canEdit = new boolean[] { false, false, false, false,
    					false };
    			public boolean isCellEditable(int rowIndex, int columnIndex) {
    				return canEdit[columnIndex];			}});
    		cartTable.addMouseListener(new java.awt.event.MouseAdapter() {
    			public void mousePressed(java.awt.event.MouseEvent evt) {
    				cartTableMousePressed(evt);	}});
    		jScrollPane2.setViewportView(cartTable);
    		jLabel2.setText("\u603b\u6570\u91cf\uff1a");
    		totalNumTxt.setEditable(false);
    		totalMoneyTxt.setEditable(false);
    		jLabel1.setText("\u603b\u91d1\u989d\uff1a");
    		jLabel3.setText("\u8ba2\u5355\u72b6\u6001\uff1a");
    		orderStatusTxt.setEditable(false);
    		jLabel4.setText("\u70b9\u9910\u4eba\uff1a");
    		userNameTxt.setEditable(false);
    		jLabel5.setText("\u8ba2\u5355\u53f7\uff1a");
    		jb_search.setIcon(new javax.swing.ImageIcon(getClass().getResource(
    				"/images/search.png"))); // NOI18N
    		jb_search.setText("\u8ba2\u5355\u67e5\u8be2");
    		jb_search.addActionListener(new java.awt.event.ActionListener() {
    			public void actionPerformed(java.awt.event.ActionEvent evt) {
    				jb_searchActionPerformed(evt);	}	});
    		orderTable.setModel(new javax.swing.table.DefaultTableModel(
    				new Object[][] {
    				}, new String[] { "订单编号", "商品总数量", "总金额", "点餐人", "订单状态" }) {
    					private static final long serialVersionUID = 1L;
    			boolean[] canEdit = new boolean[] { false, false, false, false,
    					false };
    			public boolean isCellEditable(int rowIndex, int columnIndex) {
    				return canEdit[columnIndex];
    			}
    		});
    		orderTable.addMouseListener(new java.awt.event.MouseAdapter() {
    			public void mousePressed(java.awt.event.MouseEvent evt) {
    				orderTableMousePressed(evt);
    			}
    		});
    		jScrollPane1.setViewportView(orderTable);
    		jPanel2.setBorder(javax.swing.BorderFactory
    				.createTitledBorder("\u5957\u9910\u56fe\u7247"));
    		javax.swing.GroupLayout jPanel2Layout = new javax.swing.GroupLayout(
    				jPanel2);
    		jPanel2.setLayout(jPanel2Layout);
    		jPanel2Layout.setHorizontalGroup(jPanel2Layout.createParallelGroup(
    				javax.swing.GroupLayout.Alignment.LEADING).addComponent(
    				iamgeLb, javax.swing.GroupLayout.DEFAULT_SIZE, 72,
    				Short.MAX_VALUE));
    		jPanel2Layout.setVerticalGroup(jPanel2Layout.createParallelGroup(
    				javax.swing.GroupLayout.Alignment.LEADING).addComponent(
    				iamgeLb, javax.swing.GroupLayout.DEFAULT_SIZE, 65,
    				Short.MAX_VALUE));
    		buttonGroup1.add(jrb_1);
    		jrb_1.setText("\u786e\u8ba4\u8ba2\u5355");
    		buttonGroup1.add(jrb_2);
    		jrb_2.setText("\u53bb\u9001\u9910");
    		buttonGroup1.add(jrb_3);
    		jrb_3.setText("\u5df2\u5b8c\u6210");
    		buttonGroup1.add(jrb_4);
    		jrb_4.setText("\u5220\u9664\u8ba2\u5355");
    		jButton1.setIcon(new javax.swing.ImageIcon(getClass().getResource(
    				"/images/1.png"))); // NOI18N
    		jButton1.setText("\u63d0\u4ea4");
    		jButton1.addActionListener(new java.awt.event.ActionListener() {
    			public void actionPerformed(java.awt.event.ActionEvent evt) {
    				jButton1ActionPerformed(evt);
    			}
    		});
    
    		jb_status.setIcon(new javax.swing.ImageIcon(getClass().getResource(
    				"/images/reset.png"))); // NOI18N
    		jb_status.setText("\u53d6\u6d88\u8ba2\u5355");
    		jb_status.setFocusPainted(false);
    		jb_status.addActionListener(new java.awt.event.ActionListener() {
    			public void actionPerformed(java.awt.event.ActionEvent evt) {
    				jb_statusActionPerformed(evt);
    			}
    		});
    
    		javax.swing.GroupLayout layout = new javax.swing.GroupLayout(
    				getContentPane());
    		getContentPane().setLayout(layout);
    		layout
    				.setHorizontalGroup(layout
    						.createParallelGroup(
    								javax.swing.GroupLayout.Alignment.LEADING)
    						.addGroup(
    								layout
    										.createSequentialGroup()
    										.addGroup(
    												layout
    														.createParallelGroup(
    																javax.swing.GroupLayout.Alignment.LEADING)
    														.addGroup(
    																layout
    																		.createSequentialGroup()
    																		.addGap(
    																				79,
    																				79,
    																				79)
    																		.addComponent(
    																				jLabel5)
    																		.addGap(
    																				36,
    																				36,
    																				36)
    																		.addComponent(
    																				orderIdTxt,
    																				javax.swing.GroupLayout.PREFERRED_SIZE,
    																				92,
    																				javax.swing.GroupLayout.PREFERRED_SIZE)
    																		.addPreferredGap(
    																				javax.swing.LayoutStyle.ComponentPlacement.RELATED,
    																				11,
    																				Short.MAX_VALUE)
    																		.addComponent(
    																				jb_search)
    																		.addGap(
    																				107,
    																				107,
    																				107))
    														.addGroup(
    																layout
    																		.createSequentialGroup()
    																		.addContainerGap()
    																		.addComponent(
    																				jScrollPane1,
    																				javax.swing.GroupLayout.PREFERRED_SIZE,
    																				423,
    																				javax.swing.GroupLayout.PREFERRED_SIZE)
    																		.addPreferredGap(
    																				javax.swing.LayoutStyle.ComponentPlacement.RELATED)))
    										.addGroup(
    												layout
    														.createParallelGroup(
    																javax.swing.GroupLayout.Alignment.TRAILING)
    														.addGroup(
    																layout
    																		.createParallelGroup(
    																				javax.swing.GroupLayout.Alignment.LEADING)
    																		.addGroup(
    																				javax.swing.GroupLayout.Alignment.TRAILING,
    																				layout
    																						.createSequentialGroup()
    																						.addComponent(
    																								jLabel4)
    																						.addPreferredGap(
    																								javax.swing.LayoutStyle.ComponentPlacement.RELATED)
    																						.addComponent(
    																								userNameTxt,
    																								javax.swing.GroupLayout.PREFERRED_SIZE,
    																								87,
    																								javax.swing.GroupLayout.PREFERRED_SIZE)
    																						.addGap(
    																								35,
    																								35,
    																								35))
    																		.addGroup(
    																				javax.swing.GroupLayout.Alignment.TRAILING,
    																				layout
    																						.createSequentialGroup()
    																						.addGroup(
    																								layout
    																										.createParallelGroup(
    																												javax.swing.GroupLayout.Alignment.LEADING)
    																										.addGroup(
    																												layout
    																														.createSequentialGroup()
    																														.addComponent(
    																																jLabel3)
    																														.addPreferredGap(
    																																javax.swing.LayoutStyle.ComponentPlacement.RELATED)
    																														.addComponent(
    																																orderStatusTxt,
    																																javax.swing.GroupLayout.DEFAULT_SIZE,
    																																177,
    																																Short.MAX_VALUE)
    																														.addPreferredGap(
    																																javax.swing.LayoutStyle.ComponentPlacement.RELATED)
    																														.addComponent(
    																																jLabel2)
    																														.addPreferredGap(
    																																javax.swing.LayoutStyle.ComponentPlacement.RELATED)
    																														.addComponent(
    																																totalNumTxt,
    																																javax.swing.GroupLayout.PREFERRED_SIZE,
    																																76,
    																																javax.swing.GroupLayout.PREFERRED_SIZE))
    																										.addGroup(
    																												layout
    																														.createSequentialGroup()
    																														.addGroup(
    																																layout
    																																		.createParallelGroup(
    																																				javax.swing.GroupLayout.Alignment.LEADING)
    																																		.addComponent(
    																																				jrb_1)
    																																		.addComponent(
    																																				jrb_3))
    																														.addGap(
    																																12,
    																																12,
    																																12)
    																														.addGroup(
    																																layout
    																																		.createParallelGroup(
    																																				javax.swing.GroupLayout.Alignment.LEADING)
    																																		.addComponent(
    																																				jrb_2)
    																																		.addComponent(
    																																				jrb_4))
    																														.addPreferredGap(
    																																javax.swing.LayoutStyle.ComponentPlacement.RELATED)
    																														.addComponent(
    																																jButton1))
    																										.addComponent(
    																												jb_status))
    																						.addPreferredGap(
    																								javax.swing.LayoutStyle.ComponentPlacement.RELATED)
    																						.addGroup(
    																								layout
    																										.createParallelGroup(
    																												javax.swing.GroupLayout.Alignment.TRAILING)
    																										.addGroup(
    																												layout
    																														.createSequentialGroup()
    																														.addComponent(
    																																jLabel1)
    																														.addPreferredGap(
    																																javax.swing.LayoutStyle.ComponentPlacement.RELATED)
    																														.addComponent(
    																																totalMoneyTxt,
    																																javax.swing.GroupLayout.PREFERRED_SIZE,
    																																81,
    																																javax.swing.GroupLayout.PREFERRED_SIZE))
    																										.addComponent(
    																												jPanel2,
    																												javax.swing.GroupLayout.PREFERRED_SIZE,
    																												javax.swing.GroupLayout.DEFAULT_SIZE,
    																												javax.swing.GroupLayout.PREFERRED_SIZE))))
    														.addGroup(
    																layout
    																		.createSequentialGroup()
    																		.addPreferredGap(
    																				javax.swing.LayoutStyle.ComponentPlacement.RELATED)
    																		.addComponent(
    																				jScrollPane2,
    																				javax.swing.GroupLayout.PREFERRED_SIZE,
    																				510,
    																				javax.swing.GroupLayout.PREFERRED_SIZE)))
    										.addContainerGap()));
    		layout
    				.setVerticalGroup(layout
    						.createParallelGroup(
    								javax.swing.GroupLayout.Alignment.LEADING)
    						.addGroup(
    								layout
    										.createSequentialGroup()
    										.addGroup(
    												layout
    														.createParallelGroup(
    																javax.swing.GroupLayout.Alignment.LEADING)
    														.addGroup(
    																layout
    																		.createSequentialGroup()
    																		.addGap(
    																				18,
    																				18,
    																				18)
    																		.addGroup(
    																				layout
    																						.createParallelGroup(
    																								javax.swing.GroupLayout.Alignment.BASELINE)
    																						.addComponent(
    																								orderIdTxt,
    																								javax.swing.GroupLayout.PREFERRED_SIZE,
    																								javax.swing.GroupLayout.DEFAULT_SIZE,
    																								javax.swing.GroupLayout.PREFERRED_SIZE)
    																						.addComponent(
    																								jLabel5)
    																						.addComponent(
    																								jb_search)))
    														.addGroup(
    																layout
    																		.createSequentialGroup()
    																		.addContainerGap()
    																		.addGroup(
    																				layout
    																						.createParallelGroup(
    																								javax.swing.GroupLayout.Alignment.BASELINE)
    																						.addComponent(
    																								jLabel4)
    																						.addComponent(
    																								userNameTxt,
    																								javax.swing.GroupLayout.PREFERRED_SIZE,
    																								javax.swing.GroupLayout.DEFAULT_SIZE,
    																								javax.swing.GroupLayout.PREFERRED_SIZE))))
    										.addGap(23, 23, 23)
    										.addGroup(
    												layout
    														.createParallelGroup(
    																javax.swing.GroupLayout.Alignment.LEADING)
    														.addGroup(
    																layout
    																		.createSequentialGroup()
    																		.addComponent(
    																				jScrollPane2,
    																				javax.swing.GroupLayout.PREFERRED_SIZE,
    																				169,
    																				javax.swing.GroupLayout.PREFERRED_SIZE)
    																		.addGap(
    																				28,
    																				28,
    																				28)
    																		.addGroup(
    																				layout
    																						.createParallelGroup(
    																								javax.swing.GroupLayout.Alignment.BASELINE)
    																						.addComponent(
    																								jLabel3)
    																						.addComponent(
    																								totalMoneyTxt,
    																								javax.swing.GroupLayout.PREFERRED_SIZE,
    																								javax.swing.GroupLayout.DEFAULT_SIZE,
    																								javax.swing.GroupLayout.PREFERRED_SIZE)
    																						.addComponent(
    																								jLabel1)
    																						.addComponent(
    																								totalNumTxt,
    																								javax.swing.GroupLayout.PREFERRED_SIZE,
    																								javax.swing.GroupLayout.DEFAULT_SIZE,
    																								javax.swing.GroupLayout.PREFERRED_SIZE)
    																						.addComponent(
    																								jLabel2)
    																						.addComponent(
    																								orderStatusTxt,
    																								javax.swing.GroupLayout.PREFERRED_SIZE,
    																								javax.swing.GroupLayout.DEFAULT_SIZE,
    																								javax.swing.GroupLayout.PREFERRED_SIZE))
    																		.addPreferredGap(
    																				javax.swing.LayoutStyle.ComponentPlacement.RELATED)
    																		.addGroup(
    																				layout
    																						.createParallelGroup(
    																								javax.swing.GroupLayout.Alignment.TRAILING)
    																						.addComponent(
    																								jPanel2,
    																								javax.swing.GroupLayout.PREFERRED_SIZE,
    																								javax.swing.GroupLayout.DEFAULT_SIZE,
    																								javax.swing.GroupLayout.PREFERRED_SIZE)
    																						.addGroup(
    																								layout
    																										.createSequentialGroup()
    																										.addComponent(
    																												jb_status)
    																										.addGap(
    																												13,
    																												13,
    																												13)
    																										.addGroup(
    																												layout
    																														.createParallelGroup(
    																																javax.swing.GroupLayout.Alignment.BASELINE)
    																														.addComponent(
    																																jrb_1)
    																														.addComponent(
    																																jrb_2))
    																										.addPreferredGap(
    																												javax.swing.LayoutStyle.ComponentPlacement.RELATED)
    																										.addGroup(
    																												layout
    																														.createParallelGroup(
    																																javax.swing.GroupLayout.Alignment.BASELINE)
    																														.addComponent(
    																																jrb_4)
    																														.addComponent(
    																																jrb_3)))
    																						.addComponent(
    																								jButton1)))
    														.addComponent(
    																jScrollPane1,
    																javax.swing.GroupLayout.PREFERRED_SIZE,
    																199,
    																javax.swing.GroupLayout.PREFERRED_SIZE))
    										.addContainerGap(58, Short.MAX_VALUE)));
    
    		pack();
    	}// </editor-fold>
    	//GEN-END:initComponents
    	//填充ordertable
    	@SuppressWarnings("unchecked")
    	private void fillOrderTable() {
    		//填充ordertable
    		String orderId = this.orderIdTxt.getText();
    		Order order = new Order();
    		order.setOrderId(orderId);
    		DefaultTableModel dtm = (DefaultTableModel) orderTable.getModel();
    		dtm.setRowCount(0);
    		Connection con = null;
    		try {
    			con = dbUtil.getCon();
    			ResultSet rs = orderDao.orderList(con, order);
    			while (rs.next()) {
    				Vector v = new Vector();
    				v.add(rs.getString("orderId"));
    				v.add(rs.getInt("orderNum"));
    				v.add(rs.getFloat("orderTotalMoney"));
    				v.add(rs.getString("userName"));
    				int status = rs.getInt("orderStatus");
    				switch (status) {
    				case 0:
    					v.add("未处理");
    					break;
    				case 1:
    					v.add("烹饪中");
    					break;
    				case 2:
    					v.add("已送达");
    					break;
    				case 3:
    					v.add("已付款");
    					break;
    				case 4:
    					v.add("已取消");
    				}
    				dtm.addRow(v);
    			}
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} finally {
    			try {
    				dbUtil.closeCon(con);
    			} catch (Exception e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();		}		}}
    	//重置carttable
    	private void resetCartTable() {
    		this.totalNumTxt.setText("");
    		this.totalMoneyTxt.setText("");
    		this.userNameTxt.setText("");
    		this.orderStatusTxt.setText("");
    		this.iamgeLb.setIcon(null);
    		DefaultTableModel dtm = (DefaultTableModel) cartTable.getModel();
    		dtm.setRowCount(0);}
    
    	//订单处理操作
    	private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
    		//获取选中的行
    		int row = orderTable.getSelectedRow();
    		if (row < 0) {
    			JOptionPane.showMessageDialog(null, "请选择一个订单");
    			return;
    		}
    		//获取订单编号
    		String orderId = (String) orderTable.getValueAt(row, 0);
    		Order order = new Order();
    		order.setOrderId(orderId);
    		//
    		String orderStatus = this.orderStatusTxt.getText();
    		int statusNum = 0;//是否为删除订单或者处理订单的标志位
    		if (this.jrb_1.isSelected()) {//确定订单
    			orderStatus = "烹饪中";
    			order.setOrderStatus(1);
    		} else if (this.jrb_2.isSelected()) {//去送餐
    			orderStatus = "已送达";
    			order.setOrderStatus(2);
    		} else if (this.jrb_3.isSelected()) {//已付款
    			orderStatus = "已付款";
    			order.setOrderStatus(3);
    		} else if (this.jrb_4.isSelected()) {//删除订单
    			orderStatus = "";
    			statusNum = 1;
    		} else {
    			return;}
    		if (statusNum != 1) {
    			try {
    				Connection con = dbUtil.getCon();
    				int modifyNum = orderDao.orderStatusModify(con, order);
    				if (modifyNum == 1) {
    					JOptionPane.showMessageDialog(null, "操作成功!");
    					fillOrderTable();
    					this.orderStatusTxt.setText(orderStatus);
    					this.jb_status.setEnabled(false);
    				} else {
    					JOptionPane.showMessageDialog(null, "订单操作失败!");
    				}
    			} catch (Exception e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		} else if (statusNum == 4) {
    			try {
    				Connection con = dbUtil.getCon();
    				int modifyNum = orderDao.deleteOrder(con, order);
    				if (modifyNum == 1) {
    					JOptionPane.showMessageDialog(null, "删除成功!");
    					fillOrderTable();
    					this.jb_status.setEnabled(false);
    					resetCartTable();
    				} else {
    					JOptionPane.showMessageDialog(null, "订单删除失败!");
    				}
    			} catch (Exception e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();		}	}}
    	//取消订单操作
    	private void jb_statusActionPerformed(java.awt.event.ActionEvent evt) {
    		//获取选中的行,如果为选中,row默认为-1
    		int row = orderTable.getSelectedRow();
    		if (row < 0) {
    			JOptionPane.showMessageDialog(null, "请选择一个订单");
    			return;
    		}
    		//获取订单编号
    		String orderId = (String) orderTable.getValueAt(row, 0);
    		Order order = new Order();
    		order.setOrderId(orderId);
    		order.setOrderStatus(4);//取消订单
    		try {
    			Connection con = dbUtil.getCon();
    			int modifyNum = orderDao.orderStatusModify(con, order);
    			if (modifyNum == 1) {
    				JOptionPane.showMessageDialog(null, "取消成功!");
    				this.orderStatusTxt.setText("已取消");
    				this.jb_status.setEnabled(false);
    				fillOrderTable();
    			} else {
    				JOptionPane.showMessageDialog(null, "取消订单失败!");
    			}
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();}}
    	//购物车点击显示商品图片
    	private void cartTableMousePressed(java.awt.event.MouseEvent evt) {
    		String picturePath = null;
    		//获取选中的行
    		int row = cartTable.getSelectedRow();
    		int goodsId = Integer.parseInt((String) cartTable.getValueAt(row, 0));
    		Goods goods = new Goods();
    		goods.setId(goodsId);
    		Connection con = null;
    		try {
    			con = dbUtil.getCon();
    			ResultSet rs = goodsDao.goodsList(con, goods);
    			while (rs.next()) {
    				picturePath = rs.getString("imageLink");
    			}
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} finally {
    			try {
    				dbUtil.closeCon(con);
    			} catch (Exception e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}
    		}
    		if (StringUtil.isNotEmpty(picturePath)) {
    			Icon icon = new ImageIcon(picturePath);
    			this.iamgeLb.setIcon(icon);
    		} else {
    			this.iamgeLb.setIcon(null);	}}
    	//点击订单表,显示购物车表内容
    	@SuppressWarnings("unchecked")
    	private void orderTableMousePressed(java.awt.event.MouseEvent evt) {
    		//获取选中的行
    		int row = orderTable.getSelectedRow();
    		String orderId = (String) orderTable.getValueAt(row, 0);
    		this.totalNumTxt.setText(orderTable.getValueAt(row, 1) + "");//把int,float型转化为string
    		this.totalMoneyTxt.setText(orderTable.getValueAt(row, 2) + "");
    		this.userNameTxt.setText((String) orderTable.getValueAt(row, 3));
    		String orderStatus = (String) orderTable.getValueAt(row, 4);
    		this.orderStatusTxt.setText(orderStatus);
    		this.iamgeLb.setIcon(null);
    		//修改取消订单按钮状态
    		if (!orderStatus.equals("未处理")) {
    			jb_status.setEnabled(false);
    		} else {
    			jb_status.setEnabled(true);
    		}
    		Order order = new Order();
    		order.setOrderId(orderId);
    		DefaultTableModel dtm = (DefaultTableModel) cartTable.getModel();
    		dtm.setRowCount(0);
    		Connection con = null;
    		try {
    			con = dbUtil.getCon();
    			ResultSet rs = orderDao.orderGoodsList(con, order);
    			while (rs.next()) {
    				Vector v = new Vector();
    				v.add(rs.getString("goodsId"));
    				v.add(rs.getString("goodsName"));
    				v.add(rs.getInt("goodsNum"));
    				v.add(rs.getFloat("goodsPrice"));
    				v.add(rs.getFloat("goodsTotalPrice"));
    				dtm.addRow(v);
    			}
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} finally {
    			try {
    				dbUtil.closeCon(con);
    			} catch (Exception e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();		}	}}
    
    	//查找显示订单列表
    	private void jb_searchActionPerformed(java.awt.event.ActionEvent evt) {
    		fillOrderTable();}}
    

    GoodsAddInterFrm

    package sut.rj.view;
    
    import java.io.File;
    import java.sql.Connection;
    
    import javax.swing.*;
    import javax.swing.filechooser.FileNameExtensionFilter;
    
    import sut.rj.dao.GoodsDao;
    import sut.rj.model.Goods;
    import sut.rj.dbconnection.DbUtil;
    import sut.rj.dbconnection.StringUtil;
    
    public class GoodsAddInterFrm extends javax.swing.JInternalFrame {
    	//GEN-BEGIN:variables
    	// Variables declaration - do not modify
    	private javax.swing.JTextArea goodsDescTxt;
    	private javax.swing.JTextField goodsNameTxt;
    	private javax.swing.JLabel iamgeLb;
    	private javax.swing.JTextField imageLinkTxt;
    	private javax.swing.JLabel jLabel2;
    	private javax.swing.JLabel jLabel3;
    	private javax.swing.JLabel jLabel4;
    	private javax.swing.JLabel jLabel5;
    	private javax.swing.JPanel jPanel1;
    	private javax.swing.JScrollPane jScrollPane1;
    	private javax.swing.JButton jb_add;
    	private javax.swing.JButton jb_chooser;
    	private javax.swing.JButton jb_reset;
    	private javax.swing.JTextField priceTxt;
    	// End of variables declaration//GEN-END:variables
    	private static final long serialVersionUID = 1L;
    	//实现序列化,serialVersionUID 用来表明实现序列化类的不同版本间的兼容性
    
    	DbUtil dbUtil = new DbUtil();
    	GoodsDao goodsDao = new GoodsDao();
    
    	/** Creates new form GoodsAddInterFrm */
    	public GoodsAddInterFrm() {
    		initComponents();
    		this.setLocation(200, 80);}
    
    	//GEN-BEGIN:initComponents
    	// <editor-fold defaultstate="collapsed" desc="Generated Code">
    	private void initComponents() {
    
    		jLabel2 = new javax.swing.JLabel();
    		jLabel3 = new javax.swing.JLabel();
    		jLabel4 = new javax.swing.JLabel();
    		jb_chooser = new javax.swing.JButton();
    		jPanel1 = new javax.swing.JPanel();
    		iamgeLb = new javax.swing.JLabel();
    		imageLinkTxt = new javax.swing.JTextField();
    		goodsNameTxt = new javax.swing.JTextField();
    		priceTxt = new javax.swing.JTextField();
    		jLabel5 = new javax.swing.JLabel();
    		jScrollPane1 = new javax.swing.JScrollPane();
    		goodsDescTxt = new javax.swing.JTextArea();
    		jb_add = new javax.swing.JButton();
    		jb_reset = new javax.swing.JButton();
    
    		setClosable(true);
    		setIconifiable(true);
    		setTitle("\u5957\u9910\u6dfb\u52a0");
    		jLabel2.setText("\u5957\u9910\u540d\u79f0\uff1a");
    		jLabel3.setText("\u5957\u9910\u4ef7\u683c\uff1a");
    		jLabel4.setText("\u5957\u9910\u63cf\u8ff0\uff1a");
    		jb_chooser.setIcon(new javax.swing.ImageIcon(getClass().getResource(
    				"/images/2.png"))); // NOI18N
    		jb_chooser.setText("\u8bf7\u9009\u62e9");
    		jb_chooser.addActionListener(new java.awt.event.ActionListener() {
    			public void actionPerformed(java.awt.event.ActionEvent evt) {
    				jb_chooserActionPerformed(evt);		}	});
    		jPanel1.setBorder(javax.swing.BorderFactory
    				.createTitledBorder("\u5957\u9910\u56fe\u7247"));
    		javax.swing.GroupLayout jPanel1Layout = new javax.swing.GroupLayout(
    				jPanel1);
    		jPanel1.setLayout(jPanel1Layout);
    		jPanel1Layout.setHorizontalGroup(jPanel1Layout.createParallelGroup(
    				javax.swing.GroupLayout.Alignment.LEADING).addGroup(
    				javax.swing.GroupLayout.Alignment.TRAILING,
    				jPanel1Layout.createSequentialGroup().addContainerGap(23,
    						Short.MAX_VALUE).addComponent(iamgeLb,
    						javax.swing.GroupLayout.PREFERRED_SIZE, 60,
    						javax.swing.GroupLayout.PREFERRED_SIZE).addGap(21, 21,
    						21)));
    		jPanel1Layout.setVerticalGroup(jPanel1Layout.createParallelGroup(
    				javax.swing.GroupLayout.Alignment.LEADING).addGroup(
    				jPanel1Layout.createSequentialGroup().addContainerGap()
    						.addComponent(iamgeLb,
    								javax.swing.GroupLayout.PREFERRED_SIZE, 60,
    								javax.swing.GroupLayout.PREFERRED_SIZE)
    						.addContainerGap(26, Short.MAX_VALUE)));
    		imageLinkTxt.setEditable(false);
    		jLabel5.setText("\u5957\u9910\u56fe\u7247\uff1a");
    		goodsDescTxt.setColumns(20);
    		goodsDescTxt.setRows(5);
    		jScrollPane1.setViewportView(goodsDescTxt);
    		jb_add.setIcon(new javax.swing.ImageIcon(getClass().getResource(
    				"/images/add.png"))); // NOI18N
    		jb_add.setText("\u6dfb\u52a0");
    		jb_add.addActionListener(new java.awt.event.ActionListener() {
    			public void actionPerformed(java.awt.event.ActionEvent evt) {
    				jb_addActionPerformed(evt);	}});
    		jb_reset.setIcon(new javax.swing.ImageIcon(getClass().getResource(
    				"/images/reset.png"))); // NOI18N
    		jb_reset.setText("\u91cd\u7f6e");
    		jb_reset.addActionListener(new java.awt.event.ActionListener() {
    			public void actionPerformed(java.awt.event.ActionEvent evt) {
    				jb_resetActionPerformed(evt);	}});
    		javax.swing.GroupLayout layout = new javax.swing.GroupLayout(
    				getContentPane());
    		getContentPane().setLayout(layout);
    		layout
    				.setHorizontalGroup(layout
    						.createParallelGroup(
    								javax.swing.GroupLayout.Alignment.LEADING)
    						.addGroup(
    								layout
    										.createSequentialGroup()
    										.addGroup(
    												layout
    														.createParallelGroup(
    																javax.swing.GroupLayout.Alignment.LEADING)
    														.addGroup(
    																layout
    																		.createSequentialGroup()
    																		.addContainerGap()
    																		.addGroup(
    																				layout
    																						.createParallelGroup(
    																								javax.swing.GroupLayout.Alignment.LEADING)
    																						.addComponent(
    																								jLabel2)
    																						.addGroup(
    																								layout
    																										.createSequentialGroup()
    																										.addComponent(
    																												jLabel3)
    																										.addGap(
    																												30,
    																												30,
    																												30)
    																										.addGroup(
    																												layout
    																														.createParallelGroup(
    																																javax.swing.GroupLayout.Alignment.LEADING)
    																														.addComponent(
    																																priceTxt,
    																																javax.swing.GroupLayout.PREFERRED_SIZE,
    																																103,
    																																javax.swing.GroupLayout.PREFERRED_SIZE)
    																														.addGroup(
    																																layout
    																																		.createSequentialGroup()
    																																		.addComponent(
    																																				goodsNameTxt,
    																																				javax.swing.GroupLayout.PREFERRED_SIZE,
    																																				135,
    																																				javax.swing.GroupLayout.PREFERRED_SIZE)
    																																		.addGap(
    																																				49,
    																																				49,
    																																				49)
    																																		.addComponent(
    																																				jLabel5))
    																														.addComponent(
    																																jScrollPane1,
    																																javax.swing.GroupLayout.PREFERRED_SIZE,
    																																230,
    																																javax.swing.GroupLayout.PREFERRED_SIZE)))
    																						.addComponent(
    																								jLabel4))
    																		.addGap(
    																				4,
    																				4,
    																				4)
    																		.addGroup(
    																				layout
    																						.createParallelGroup(
    																								javax.swing.GroupLayout.Alignment.LEADING)
    																						.addGroup(
    																								layout
    																										.createSequentialGroup()
    																										.addGap(
    																												47,
    																												47,
    																												47)
    																										.addComponent(
    																												jb_reset))
    																						.addGroup(
    																								layout
    																										.createParallelGroup(
    																												javax.swing.GroupLayout.Alignment.TRAILING)
    																										.addComponent(
    																												jPanel1,
    																												javax.swing.GroupLayout.PREFERRED_SIZE,
    																												javax.swing.GroupLayout.DEFAULT_SIZE,
    																												javax.swing.GroupLayout.PREFERRED_SIZE)
    																										.addComponent(
    																												jb_chooser)
    																										.addComponent(
    																												imageLinkTxt,
    																												javax.swing.GroupLayout.PREFERRED_SIZE,
    																												161,
    																												javax.swing.GroupLayout.PREFERRED_SIZE))))
    														.addGroup(
    																layout
    																		.createSequentialGroup()
    																		.addGap(
    																				56,
    																				56,
    																				56)
    																		.addComponent(
    																				jb_add)))
    										.addContainerGap(32, Short.MAX_VALUE)));
    		layout
    				.setVerticalGroup(layout
    						.createParallelGroup(
    								javax.swing.GroupLayout.Alignment.LEADING)
    						.addGroup(
    								layout
    										.createSequentialGroup()
    										.addContainerGap()
    										.addGroup(
    												layout
    														.createParallelGroup(
    																javax.swing.GroupLayout.Alignment.BASELINE)
    														.addComponent(jLabel2)
    														.addComponent(
    																goodsNameTxt,
    																javax.swing.GroupLayout.PREFERRED_SIZE,
    																javax.swing.GroupLayout.DEFAULT_SIZE,
    																javax.swing.GroupLayout.PREFERRED_SIZE)
    														.addComponent(jLabel5)
    														.addComponent(
    																imageLinkTxt,
    																javax.swing.GroupLayout.PREFERRED_SIZE,
    																javax.swing.GroupLayout.DEFAULT_SIZE,
    																javax.swing.GroupLayout.PREFERRED_SIZE))
    										.addPreferredGap(
    												javax.swing.LayoutStyle.ComponentPlacement.RELATED)
    										.addGroup(
    												layout
    														.createParallelGroup(
    																javax.swing.GroupLayout.Alignment.BASELINE)
    														.addComponent(jLabel3)
    														.addComponent(
    																priceTxt,
    																javax.swing.GroupLayout.PREFERRED_SIZE,
    																javax.swing.GroupLayout.DEFAULT_SIZE,
    																javax.swing.GroupLayout.PREFERRED_SIZE)
    														.addComponent(
    																jb_chooser))
    										.addPreferredGap(
    												javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
    										.addGroup(
    												layout
    														.createParallelGroup(
    																javax.swing.GroupLayout.Alignment.LEADING)
    														.addComponent(
    																jPanel1,
    																javax.swing.GroupLayout.DEFAULT_SIZE,
    																javax.swing.GroupLayout.DEFAULT_SIZE,
    																Short.MAX_VALUE)
    														.addComponent(
    																jScrollPane1,
    																javax.swing.GroupLayout.DEFAULT_SIZE,
    																125,
    																Short.MAX_VALUE)
    														.addComponent(jLabel4))
    										.addGap(16, 16, 16)
    										.addGroup(
    												layout
    														.createParallelGroup(
    																javax.swing.GroupLayout.Alignment.BASELINE)
    														.addComponent(jb_add)
    														.addComponent(jb_reset))
    										.addContainerGap()));
    
    		pack();
    	}// </editor-fold>
    	//GEN-END:initComponents
    	//	套餐添加操作
    	private void jb_addActionPerformed(java.awt.event.ActionEvent evt) {
    		String goodsName = this.goodsNameTxt.getText();
    		String goodsDesc = this.goodsDescTxt.getText();
    		String price = this.priceTxt.getText();
    		String imageLink = this.imageLinkTxt.getText();
    		if (StringUtil.isEmpty(goodsName)) {
    			JOptionPane.showMessageDialog(null, "套餐名称不能为空!");
    			return;
    		}
    		if (StringUtil.isEmpty(price)) {
    			JOptionPane.showMessageDialog(null, "套餐价格不能为空!");
    			return;
    		}
    		if (!StringUtil.isNum(price)) {
    			JOptionPane.showMessageDialog(null, "请重新输入套餐价格!");
    			return;
    		}
    		Goods goods = new Goods(goodsName, goodsDesc, Float.parseFloat(price),
    				imageLink);
    		Connection con = null;
    		try {
    			con = dbUtil.getCon();
    			int n = goodsDao.GoodsAdd(con, goods);
    			if (n == 1) {
    				JOptionPane.showMessageDialog(null, "套餐添加成功");
    				this.resetValues();
    			} else {
    				JOptionPane.showMessageDialog(null, "套餐添加失败");
    			}
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    			JOptionPane.showMessageDialog(null, "套餐添加失败2");
    		}}
    	//重置函数
    	private void resetValues() {
    		this.goodsNameTxt.setText("");
    		this.goodsDescTxt.setText("");
    		this.priceTxt.setText("");
    		this.imageLinkTxt.setText("");
    		this.iamgeLb.setIcon(null);
    	}
    	//重置表单操作
    	private void jb_resetActionPerformed(java.awt.event.ActionEvent evt) {
    		resetValues();
    	}
    	//点击选择图片操作
    	private void jb_chooserActionPerformed(java.awt.event.ActionEvent evt) {
    		JFileChooser chooser = new JFileChooser();//创建文件对话框
    		FileNameExtensionFilter filter = new FileNameExtensionFilter(
    				"JPG & GIF Images", "jpg", "gif");//创建文件过滤器
    		chooser.setFileFilter(filter);//为文件对话框设置文件过滤器
    		int returnValue = chooser.showOpenDialog(getParent());//打开文件选择对话框
    		if (returnValue == JFileChooser.APPROVE_OPTION) { // 判断是否选择了文件
    			File file = chooser.getSelectedFile(); // 获得文件对象
    			if (file.length() / 1024.0 > 50.0) {
    				JOptionPane.showMessageDialog(null, "请选择小于等于50KB的图片文件。");
    				return;
    			}
    			String picturePath = file.getAbsolutePath();//获取路径
    			//System.out.println(picturePath);
    			Icon icon = new ImageIcon(picturePath);//新建图标
    			this.iamgeLb.setIcon(icon);//设置图片并显示
    			this.imageLinkTxt.setText(picturePath);//文本框显示路径}}}
    

    GoodsManageInterFrm

    package sut.rj.view;
    
    import java.io.File;
    import java.sql.Connection;
    import java.sql.ResultSet;
    import java.util.Vector;
    
    import javax.swing.*;
    import javax.swing.filechooser.FileNameExtensionFilter;
    import javax.swing.table.DefaultTableModel;
    
    import sut.rj.dao.GoodsDao;
    import sut.rj.model.Goods;
    import sut.rj.dbconnection.DbUtil;
    import sut.rj.dbconnection.StringUtil;
    
    public class GoodsManageInterFrm extends javax.swing.JInternalFrame {
    	//GEN-BEGIN:variables
    	// Variables declaration - do not modify
    	private javax.swing.JTextArea goodsDescTxt;
    	private javax.swing.JTextField goodsIdTxt;
    	private javax.swing.JTextField goodsNameTxt;
    	private javax.swing.JTable goodsTable;
    	private javax.swing.JLabel iamgeLb;
    	private javax.swing.JTextField imageLinkTxt;
    	private javax.swing.JButton jButton1;
    	private javax.swing.JLabel jLabel1;
    	private javax.swing.JLabel jLabel2;
    	private javax.swing.JLabel jLabel3;
    	private javax.swing.JLabel jLabel4;
    	private javax.swing.JLabel jLabel5;
    	private javax.swing.JLabel jLabel6;
    	private javax.swing.JLabel jLabel7;
    	private javax.swing.JLabel jLabel8;
    	private javax.swing.JPanel jPanel1;
    	private javax.swing.JPanel jPanel2;
    	private javax.swing.JScrollPane jScrollPane1;
    	private javax.swing.JScrollPane jScrollPane2;
    	private javax.swing.JButton jb_chooser;
    	private javax.swing.JButton jb_delete;
    	private javax.swing.JButton jb_modify;
    	private javax.swing.JButton jb_search;
    	private javax.swing.JTextField priceTxt;
    	private javax.swing.JTextField s_goodsName;
    	private javax.swing.JTextField s_price_1;
    	private javax.swing.JTextField s_price_2;
    	// End of variables declaration//GEN-END:variables
    	private static final long serialVersionUID = 1L;
    	//实现序列化,serialVersionUID 用来表明实现序列化类的不同版本间的兼容性
    	DbUtil dbUtil = new DbUtil();
    	GoodsDao goodsDao = new GoodsDao();
    
    	/** Creates new form GoodsManageInterFrm */
    	public GoodsManageInterFrm() {
    		initComponents();
    		this.setLocation(320, 100);
    		this.filltable(new Goods());
    	}
    
    	//填充table操作,刷新内容
    	@SuppressWarnings("unchecked")
    	private void filltable(Goods goods) {
    		DefaultTableModel dtm = (DefaultTableModel) goodsTable.getModel();
    		//清空之前显示
    		dtm.setRowCount(0);
    		Connection con = null;
    		try {
    			con = dbUtil.getCon();
    			ResultSet rs = goodsDao.goodsList(con, goods);
    			while (rs.next()) {
    				Vector v = new Vector();
    				v.add(rs.getString("id"));
    				v.add(rs.getString("goodsName"));
    				v.add(rs.getString("goodsDesc"));
    				v.add(rs.getString("price"));
    				v.add(rs.getString("imageLink"));
    				dtm.addRow(v);
    			}
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} finally {
    			try {
    				dbUtil.closeCon(con);
    			} catch (Exception e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();	}}}
    
    	//GEN-BEGIN:initComponents
    	// <editor-fold defaultstate="collapsed" desc="Generated Code">
    	private void initComponents() {
    
    		jButton1 = new javax.swing.JButton();
    		jLabel1 = new javax.swing.JLabel();
    		jb_search = new javax.swing.JButton();
    		s_goodsName = new javax.swing.JTextField();
    		s_price_1 = new javax.swing.JTextField();
    		jLabel2 = new javax.swing.JLabel();
    		jScrollPane1 = new javax.swing.JScrollPane();
    		goodsTable = new javax.swing.JTable();
    		jPanel1 = new javax.swing.JPanel();
    		jLabel3 = new javax.swing.JLabel();
    		jLabel4 = new javax.swing.JLabel();
    		jLabel5 = new javax.swing.JLabel();
    		goodsNameTxt = new javax.swing.JTextField();
    		priceTxt = new javax.swing.JTextField();
    		jScrollPane2 = new javax.swing.JScrollPane();
    		goodsDescTxt = new javax.swing.JTextArea();
    		jLabel6 = new javax.swing.JLabel();
    		imageLinkTxt = new javax.swing.JTextField();
    		jPanel2 = new javax.swing.JPanel();
    		iamgeLb = new javax.swing.JLabel();
    		jb_modify = new javax.swing.JButton();
    		jb_delete = new javax.swing.JButton();
    		jb_chooser = new javax.swing.JButton();
    		jLabel7 = new javax.swing.JLabel();
    		goodsIdTxt = new javax.swing.JTextField();
    		s_price_2 = new javax.swing.JTextField();
    		jLabel8 = new javax.swing.JLabel();
    
    		jButton1.setText("jButton1");
    		setClosable(true);
    		setIconifiable(true);
    		setTitle("\u5957\u9910\u4fe1\u606f\u7ef4\u62a4");
    
    		jLabel1.setText("\u5957\u9910\u540d\u79f0\uff1a");
    
    		jb_search.setIcon(new javax.swing.ImageIcon(getClass().getResource(
    				"/images/search.png"))); // NOI18N
    		jb_search.setText("\u67e5\u8be2");
    		jb_search.addActionListener(new java.awt.event.ActionListener() {
    			public void actionPerformed(java.awt.event.ActionEvent evt) {
    				jb_searchActionPerformed(evt);	}});
    		jLabel2.setText("\u5957\u9910\u4ef7\u683c\u533a\u95f4\uff1a");
    		goodsTable.setModel(new javax.swing.table.DefaultTableModel(
    				new Object[][] {
    
    				}, new String[] { "序号", "套餐名称", "套餐描述", "套餐价格", "图片地址" }) {
    					private static final long serialVersionUID = 1L;
    			boolean[] canEdit = new boolean[] { false, false, false, false,
    					false };
    			public boolean isCellEditable(int rowIndex, int columnIndex) {
    				return canEdit[columnIndex];}});
    		goodsTable.addMouseListener(new java.awt.event.MouseAdapter() {
    			public void mousePressed(java.awt.event.MouseEvent evt) {
    				goodsTableMousePressed(evt);}});
    		jScrollPane1.setViewportView(goodsTable);
    		jPanel1.setBorder(javax.swing.BorderFactory
    				.createTitledBorder("\u8868\u5355\u64cd\u4f5c"));
    		jLabel3.setText("\u5957\u9910\u540d\u79f0\uff1a");
    		jLabel4.setText("\u5957\u9910\u4ef7\u683c\uff1a");
    		jLabel5.setText("\u5957\u9910\u63cf\u8ff0\uff1a");
    		goodsDescTxt.setColumns(20);
    		goodsDescTxt.setRows(5);
    		jScrollPane2.setViewportView(goodsDescTxt);
    		jLabel6.setText("\u5957\u9910\u56fe\u7247\uff1a");
    		imageLinkTxt.setEnabled(false);
    		jPanel2.setBorder(javax.swing.BorderFactory
    				.createTitledBorder("\u5957\u9910\u56fe\u7247"));
    
    		javax.swing.GroupLayout jPanel2Layout = new javax.swing.GroupLayout(
    				jPanel2);
    		jPanel2.setLayout(jPanel2Layout);
    		jPanel2Layout.setHorizontalGroup(jPanel2Layout.createParallelGroup(
    				javax.swing.GroupLayout.Alignment.LEADING).addGroup(
    				jPanel2Layout.createSequentialGroup().addContainerGap()
    						.addComponent(iamgeLb,
    								javax.swing.GroupLayout.PREFERRED_SIZE, 60,
    								javax.swing.GroupLayout.PREFERRED_SIZE)
    						.addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE,
    								Short.MAX_VALUE)));
    		jPanel2Layout.setVerticalGroup(jPanel2Layout.createParallelGroup(
    				javax.swing.GroupLayout.Alignment.LEADING).addGroup(
    				jPanel2Layout.createSequentialGroup().addComponent(iamgeLb,
    						javax.swing.GroupLayout.PREFERRED_SIZE, 60,
    						javax.swing.GroupLayout.PREFERRED_SIZE)
    						.addContainerGap(javax.swing.GroupLayout.DEFAULT_SIZE,
    								Short.MAX_VALUE)));
    		jb_modify.setIcon(new javax.swing.ImageIcon(getClass().getResource(
    				"/images/modify.png"))); // NOI18N
    		jb_modify.setText("\u4fee\u6539");
    		jb_modify.addActionListener(new java.awt.event.ActionListener() {
    			public void actionPerformed(java.awt.event.ActionEvent evt) {
    				jb_modifyActionPerformed(evt);}});
    		jb_delete.setIcon(new javax.swing.ImageIcon(getClass().getResource(
    				"/images/delete.png"))); // NOI18N
    		jb_delete.setText("\u5220\u9664");
    		jb_delete.addActionListener(new java.awt.event.ActionListener() {
    			public void actionPerformed(java.awt.event.ActionEvent evt) {
    				jb_deleteActionPerformed(evt);}});
    		jb_chooser.setIcon(new javax.swing.ImageIcon(getClass().getResource(
    				"/images/2.png"))); // NOI18N
    		jb_chooser.setText("\u8bf7\u9009\u62e9");
    		jb_chooser.addActionListener(new java.awt.event.ActionListener() {
    			public void actionPerformed(java.awt.event.ActionEvent evt) {
    				jb_chooserActionPerformed(evt);}});
    		jLabel7.setText("\u7f16\u53f7\uff1a");
    		goodsIdTxt.setEditable(false);
    		javax.swing.GroupLayout jPanel1Layout = new javax.swing.GroupLayout(
    				jPanel1);
    		jPanel1.setLayout(jPanel1Layout);
    		jPanel1Layout
    				.setHorizontalGroup(jPanel1Layout
    						.createParallelGroup(
    								javax.swing.GroupLayout.Alignment.LEADING)
    						.addGroup(
    								jPanel1Layout
    										.createSequentialGroup()
    										.addContainerGap()
    										.addGroup(
    												jPanel1Layout
    														.createParallelGroup(
    																javax.swing.GroupLayout.Alignment.LEADING)
    														.addGroup(
    																jPanel1Layout
    																		.createSequentialGroup()
    																		.addComponent(
    																				jLabel3)
    																		.addPreferredGap(
    																				javax.swing.LayoutStyle.ComponentPlacement.RELATED)
    																		.addComponent(
    																				goodsNameTxt,
    																				javax.swing.GroupLayout.PREFERRED_SIZE,
    																				76,
    																				javax.swing.GroupLayout.PREFERRED_SIZE)
    																		.addGap(
    																				18,
    																				18,
    																				18)
    																		.addComponent(
    																				jLabel4)
    																		.addPreferredGap(
    																				javax.swing.LayoutStyle.ComponentPlacement.RELATED)
    																		.addComponent(
    																				priceTxt,
    																				javax.swing.GroupLayout.PREFERRED_SIZE,
    																				59,
    																				javax.swing.GroupLayout.PREFERRED_SIZE)
    																		.addPreferredGap(
    																				javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
    																		.addComponent(
    																				jLabel7)
    																		.addPreferredGap(
    																				javax.swing.LayoutStyle.ComponentPlacement.RELATED)
    																		.addComponent(
    																				goodsIdTxt,
    																				javax.swing.GroupLayout.PREFERRED_SIZE,
    																				46,
    																				javax.swing.GroupLayout.PREFERRED_SIZE)
    																		.addGap(
    																				37,
    																				37,
    																				37)
    																		.addComponent(
    																				jLabel6))
    														.addGroup(
    																jPanel1Layout
    																		.createSequentialGroup()
    																		.addComponent(
    																				jLabel5)
    																		.addPreferredGap(
    																				javax.swing.LayoutStyle.ComponentPlacement.UNRELATED)
    																		.addComponent(
    																				jScrollPane2,
    																				javax.swing.GroupLayout.PREFERRED_SIZE,
    																				373,
    																				javax.swing.GroupLayout.PREFERRED_SIZE)))
    										.addPreferredGap(
    												javax.swing.LayoutStyle.ComponentPlacement.RELATED)
    										.addGroup(
    												jPanel1Layout
    														.createParallelGroup(
    																javax.swing.GroupLayout.Alignment.LEADING,
    																false)
    														.addGroup(
    																javax.swing.GroupLayout.Alignment.TRAILING,
    																jPanel1Layout
    																		.createSequentialGroup()
    																		.addGroup(
    																				jPanel1Layout
    																						.createParallelGroup(
    																								javax.swing.GroupLayout.Alignment.TRAILING)
    																						.addComponent(
    																								jPanel2,
    																								javax.swing.GroupLayout.PREFERRED_SIZE,
    																								85,
    																								javax.swing.GroupLayout.PREFERRED_SIZE)
    																						.addComponent(
    																								jb_modify))
    																		.addGroup(
    																				jPanel1Layout
    																						.createParallelGroup(
    																								javax.swing.GroupLayout.Alignment.LEADING)
    																						.addComponent(
    																								jb_delete,
    																								javax.swing.GroupLayout.Alignment.TRAILING)
    																						.addGroup(
    																								jPanel1Layout
    																										.createSequentialGroup()
    																										.addGap(
    																												30,
    																												30,
    																												30)
    																										.addComponent(
    																												jb_chooser))))
    														.addComponent(
    																imageLinkTxt,
    																javax.swing.GroupLayout.PREFERRED_SIZE,
    																214,
    																javax.swing.GroupLayout.PREFERRED_SIZE))
    										.addContainerGap()));
    		jPanel1Layout
    				.setVerticalGroup(jPanel1Layout
    						.createParallelGroup(
    								javax.swing.GroupLayout.Alignment.LEADING)
    						.addGroup(
    								jPanel1Layout
    										.createSequentialGroup()
    										.addGap(20, 20, 20)
    										.addGroup(
    												jPanel1Layout
    														.createParallelGroup(
    																javax.swing.GroupLayout.Alignment.LEADING)
    														.addComponent(jLabel3)
    														.addGroup(
    																jPanel1Layout
    																		.createParallelGroup(
    																				javax.swing.GroupLayout.Alignment.BASELINE)
    																		.addComponent(
    																				goodsNameTxt,
    																				javax.swing.GroupLayout.PREFERRED_SIZE,
    																				javax.swing.GroupLayout.DEFAULT_SIZE,
    																				javax.swing.GroupLayout.PREFERRED_SIZE)
    																		.addComponent(
    																				jLabel4)
    																		.addComponent(
    																				priceTxt,
    																				javax.swing.GroupLayout.PREFERRED_SIZE,
    																				javax.swing.GroupLayout.DEFAULT_SIZE,
    																				javax.swing.GroupLayout.PREFERRED_SIZE)
    																		.addComponent(
    																				jLabel7)
    																		.addComponent(
    																				jLabel6)
    																		.addComponent(
    																				imageLinkTxt,
    																				javax.swing.GroupLayout.PREFERRED_SIZE,
    																				javax.swing.GroupLayout.DEFAULT_SIZE,
    																				javax.swing.GroupLayout.PREFERRED_SIZE)
    																		.addComponent(
    																				goodsIdTxt,
    																				javax.swing.GroupLayout.PREFERRED_SIZE,
    																				javax.swing.GroupLayout.DEFAULT_SIZE,
    																				javax.swing.GroupLayout.PREFERRED_SIZE)))
    										.addGap(33, 33, 33)
    										.addGroup(
    												jPanel1Layout
    														.createParallelGroup(
    																javax.swing.GroupLayout.Alignment.LEADING)
    														.addGroup(
    																jPanel1Layout
    																		.createSequentialGroup()
    																		.addGroup(
    																				jPanel1Layout
    																						.createParallelGroup(
    																								javax.swing.GroupLayout.Alignment.LEADING)
    																						.addComponent(
    																								jLabel5)
    																						.addComponent(
    																								jb_chooser))
    																		.addPreferredGap(
    																				javax.swing.LayoutStyle.ComponentPlacement.RELATED,
    																				96,
    																				Short.MAX_VALUE)
    																		.addGroup(
    																				jPanel1Layout
    																						.createParallelGroup(
    																								javax.swing.GroupLayout.Alignment.BASELINE)
    																						.addComponent(
    																								jb_delete)
    																						.addComponent(
    																								jb_modify)))
    														.addComponent(
    																jScrollPane2,
    																javax.swing.GroupLayout.PREFERRED_SIZE,
    																javax.swing.GroupLayout.DEFAULT_SIZE,
    																javax.swing.GroupLayout.PREFERRED_SIZE)
    														.addComponent(
    																jPanel2,
    																javax.swing.GroupLayout.PREFERRED_SIZE,
    																87,
    																javax.swing.GroupLayout.PREFERRED_SIZE))
    										.addContainerGap()));
    
    		jLabel8.setText("\u2014\u2014");
    
    		javax.swing.GroupLayout layout = new javax.swing.GroupLayout(
    				getContentPane());
    		getContentPane().setLayout(layout);
    		layout
    				.setHorizontalGroup(layout
    						.createParallelGroup(
    								javax.swing.GroupLayout.Alignment.LEADING)
    						.addGroup(
    								layout
    										.createSequentialGroup()
    										.addGroup(
    												layout
    														.createParallelGroup(
    																javax.swing.GroupLayout.Alignment.LEADING)
    														.addGroup(
    																layout
    																		.createSequentialGroup()
    																		.addGap(
    																				51,
    																				51,
    																				51)
    																		.addComponent(
    																				jLabel1)
    																		.addPreferredGap(
    																				javax.swing.LayoutStyle.ComponentPlacement.RELATED)
    																		.addComponent(
    																				s_goodsName,
    																				javax.swing.GroupLayout.PREFERRED_SIZE,
    																				137,
    																				javax.swing.GroupLayout.PREFERRED_SIZE)
    																		.addGap(
    																				18,
    																				18,
    																				18)
    																		.addComponent(
    																				jLabel2)
    																		.addPreferredGap(
    																				javax.swing.LayoutStyle.ComponentPlacement.RELATED)
    																		.addComponent(
    																				s_price_1,
    																				javax.swing.GroupLayout.PREFERRED_SIZE,
    																				68,
    																				javax.swing.GroupLayout.PREFERRED_SIZE)
    																		.addGap(
    																				2,
    																				2,
    																				2)
    																		.addComponent(
    																				jLabel8)
    																		.addPreferredGap(
    																				javax.swing.LayoutStyle.ComponentPlacement.RELATED)
    																		.addComponent(
    																				s_price_2,
    																				javax.swing.GroupLayout.PREFERRED_SIZE,
    																				66,
    																				javax.swing.GroupLayout.PREFERRED_SIZE)
    																		.addGap(
    																				33,
    																				33,
    																				33)
    																		.addComponent(
    																				jb_search))
    														.addGroup(
    																layout
    																		.createSequentialGroup()
    																		.addContainerGap()
    																		.addGroup(
    																				layout
    																						.createParallelGroup(
    																								javax.swing.GroupLayout.Alignment.TRAILING)
    																						.addComponent(
    																								jPanel1,
    																								javax.swing.GroupLayout.PREFERRED_SIZE,
    																								javax.swing.GroupLayout.DEFAULT_SIZE,
    																								javax.swing.GroupLayout.PREFERRED_SIZE)
    																						.addComponent(
    																								jScrollPane1,
    																								javax.swing.GroupLayout.PREFERRED_SIZE,
    																								737,
    																								javax.swing.GroupLayout.PREFERRED_SIZE))))
    										.addContainerGap(128, Short.MAX_VALUE)));
    		layout
    				.setVerticalGroup(layout
    						.createParallelGroup(
    								javax.swing.GroupLayout.Alignment.LEADING)
    						.addGroup(
    								javax.swing.GroupLayout.Alignment.TRAILING,
    								layout
    										.createSequentialGroup()
    										.addContainerGap(44, Short.MAX_VALUE)
    										.addGroup(
    												layout
    														.createParallelGroup(
    																javax.swing.GroupLayout.Alignment.BASELINE)
    														.addComponent(jLabel1)
    														.addComponent(
    																s_goodsName,
    																javax.swing.GroupLayout.PREFERRED_SIZE,
    																javax.swing.GroupLayout.DEFAULT_SIZE,
    																javax.swing.GroupLayout.PREFERRED_SIZE)
    														.addComponent(jLabel2)
    														.addComponent(
    																s_price_2,
    																javax.swing.GroupLayout.PREFERRED_SIZE,
    																javax.swing.GroupLayout.DEFAULT_SIZE,
    																javax.swing.GroupLayout.PREFERRED_SIZE)
    														.addComponent(
    																s_price_1,
    																javax.swing.GroupLayout.PREFERRED_SIZE,
    																javax.swing.GroupLayout.DEFAULT_SIZE,
    																javax.swing.GroupLayout.PREFERRED_SIZE)
    														.addComponent(jLabel8)
    														.addComponent(jb_search))
    										.addGap(27, 27, 27)
    										.addComponent(
    												jScrollPane1,
    												javax.swing.GroupLayout.PREFERRED_SIZE,
    												122,
    												javax.swing.GroupLayout.PREFERRED_SIZE)
    										.addPreferredGap(
    												javax.swing.LayoutStyle.ComponentPlacement.RELATED)
    										.addComponent(
    												jPanel1,
    												javax.swing.GroupLayout.PREFERRED_SIZE,
    												javax.swing.GroupLayout.DEFAULT_SIZE,
    												javax.swing.GroupLayout.PREFERRED_SIZE)
    										.addContainerGap()));
    
    		pack();
    	}// </editor-fold>
    	//GEN-END:initComponents
    
    	/**
    	 * @param evt
    	 */
    	//修改操作
    	private void jb_modifyActionPerformed(java.awt.event.ActionEvent evt) {
    		String id = this.goodsIdTxt.getText();
    		if (StringUtil.isEmpty(id)) {
    			JOptionPane.showMessageDialog(null, "请选择要修改的记录");
    			return;
    		}
    		String goodsName = this.goodsNameTxt.getText();
    		String goodsDesc = this.goodsDescTxt.getText();
    		String imageLink = this.imageLinkTxt.getText();
    		String price = this.priceTxt.getText();
    		if (StringUtil.isEmpty(goodsName)) {
    			JOptionPane.showMessageDialog(null, "套餐名称不能为空");
    			return;
    		}
    		if (StringUtil.isEmpty(price)) {
    			JOptionPane.showMessageDialog(null, "套餐价格不能为空");
    			return;
    		}
    		if (!StringUtil.isNum(price)) {
    			JOptionPane.showMessageDialog(null, "请重新输入套餐价格");
    			return;
    		}
    		Goods goods = new Goods(Integer.parseInt(id), goodsName, goodsDesc,
    				Float.parseFloat(price), imageLink);
    		Connection con = null;
    		try {
    			con = dbUtil.getCon();
    			int modifyNum = goodsDao.goodsModify(con, goods);
    			if (modifyNum == 1) {
    				JOptionPane.showMessageDialog(null, "修改成功");
    				this.filltable(new Goods());//
    				resetValues();
    			} else
    				JOptionPane.showMessageDialog(null, "修改失败");
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    			JOptionPane.showMessageDialog(null, "修改失败");
    		} finally {
    			try {
    				dbUtil.closeCon(con);
    			} catch (Exception e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();}}}
    
    	//删除操作
    	private void jb_deleteActionPerformed(java.awt.event.ActionEvent evt) {
    		String id = this.goodsIdTxt.getText();
    		if (StringUtil.isEmpty(id)) {
    			JOptionPane.showMessageDialog(null, "请选择要删除的记录");
    			return;
    		}
    		int n = JOptionPane.showConfirmDialog(null, "确定要删除这条记录吗?");
    		if (n == 0) {
    			Connection con = null;
    			try {
    				con = dbUtil.getCon();
    				int deleteNum = goodsDao.goodsDelete(con, id);
    				if (deleteNum == 1) {
    					JOptionPane.showMessageDialog(null, "删除成功");
    					this.filltable(new Goods());
    					resetValues();
    				} else
    					JOptionPane.showMessageDialog(null, "删除失败");
    			} catch (Exception e) {
    				e.printStackTrace();
    				JOptionPane.showMessageDialog(null, "删除失败");
    			} finally {
    				try {
    					dbUtil.closeCon(con);
    				} catch (Exception e) {
    					// TODO Auto-generated catch block
    					e.printStackTrace();}}}}
    
    	//选择图片
    	private void jb_chooserActionPerformed(java.awt.event.ActionEvent evt) {
    		JFileChooser chooser = new JFileChooser();//创建文件对话框
    		FileNameExtensionFilter filter = new FileNameExtensionFilter(
    				"JPG & GIF Images", "jpg", "gif");//创建文件过滤器
    		chooser.setFileFilter(filter);//为文件对话框设置文件过滤器
    		int returnValue = chooser.showOpenDialog(getParent());//打开文件选择对话框
    		if (returnValue == JFileChooser.APPROVE_OPTION) { // 判断是否选择了文件
    			File file = chooser.getSelectedFile(); // 获得文件对象
    			if (file.length() / 1024.0 > 50.0) {
    				JOptionPane.showMessageDialog(null, "请选择小于等于50KB的图片文件。");
    				return;}
    			String picturePath = file.getAbsolutePath();
    			//System.out.println(picturePath);
    			Icon icon = new ImageIcon(picturePath);
    			this.iamgeLb.setIcon(icon);
    			this.imageLinkTxt.setText(picturePath);}}
    
    	//点击table中某一种套餐
    	private void goodsTableMousePressed(java.awt.event.MouseEvent evt) {
    		//获取选中的行
    		int row = goodsTable.getSelectedRow();
    		//在表单中写入选中的数据
    		this.goodsIdTxt.setText((String) goodsTable.getValueAt(row, 0));
    		this.goodsNameTxt.setText((String) goodsTable.getValueAt(row, 1));
    		this.goodsDescTxt.setText((String) goodsTable.getValueAt(row, 2));
    		this.priceTxt.setText((String) goodsTable.getValueAt(row, 3));
    		this.imageLinkTxt.setText((String) goodsTable.getValueAt(row, 4));
    		String picturePath = (String) goodsTable.getValueAt(row, 4);
    		if (StringUtil.isNotEmpty(picturePath)) {
    			Icon icon = new ImageIcon(picturePath);
    			this.iamgeLb.setIcon(icon);
    		} else {
    			this.iamgeLb.setIcon(null);}}
    
    	//搜索操作
    	private void jb_searchActionPerformed(java.awt.event.ActionEvent evt) {
    		Goods goods = new Goods();
    		String s_goodsName = this.s_goodsName.getText();
    		String s_price1 = this.s_price_1.getText();
    		String s_price2 = this.s_price_2.getText();
    		if (StringUtil.isNotEmpty(s_price1)) {//price_1低价格非空
    			if(!StringUtil.isNum(s_price1)){
    				JOptionPane.showMessageDialog(null, "请重新输入套餐价格范围");
    				return;
    			}else{
    				goods.setPrice1(Float.parseFloat(s_price1));
    			}}
    		if (StringUtil.isNotEmpty(s_price2)) {//price_2高价格非空
    			if(!StringUtil.isNum(s_price2)){
    				JOptionPane.showMessageDialog(null, "请重新输入套餐价格范围");
    				return;
    			}else{
    				goods.setPrice(Float.parseFloat(s_price2));
    			}}	 
    		 if (StringUtil.isNotEmpty(s_price1) && StringUtil.isNotEmpty(s_price2)) {//若都为非空
    			if(goods.getPrice()<goods.getPrice1()){
    				JOptionPane.showMessageDialog(null, "请重新输入套餐价格范围");
    				return;
    			}else if(goods.getPrice()==goods.getPrice1()){
    				goods.setPrice(Float.parseFloat(s_price2));
    			}
    			else{
    				goods.setPrice1(Float.parseFloat(s_price1));
    				goods.setPrice(Float.parseFloat(s_price2));}} 
    		 //若都为空则不作为查询条件
    		goods.setGoodsName(s_goodsName);
    		this.filltable(goods);
    		System.out.println(goods.getPrice1());
    		System.out.println(goods.getPrice());}
    
    	private void resetValues() {
    		this.goodsNameTxt.setText("");
    		this.goodsDescTxt.setText("");
    		this.priceTxt.setText("");
    		this.imageLinkTxt.setText("");
    		this.iamgeLb.setIcon(null);}}
    

    LogOnFrm

    package sut.rj.view;
    
    import java.awt.*;
    import javax.swing.*;
    import java.sql.Connection;
    
    import sut.rj.dao.UserDao;
    import sut.rj.model.User;
    import sut.rj.dbconnection.DbUtil;
    import sut.rj.dbconnection.StringUtil;
    
    public class LogOnFrm extends javax.swing.JFrame {
    	//GEN-BEGIN:variables
    	// Variables declaration - do not modify
    	private javax.swing.JLabel jLabel1;
    	private javax.swing.JLabel jLabel2;
    	private javax.swing.JLabel jLabel3;
    	private javax.swing.JButton jb_logon;
    	private javax.swing.JButton jb_register;
    	private javax.swing.JButton jb_reset;
    	private javax.swing.JPasswordField passwordTxt;
    	private javax.swing.JTextField userNameTxt;
    	// End of variables declaration//GEN-END:variables
    	private static final long serialVersionUID = 1L;
    	//实现序列化,serialVersionUID 用来表明实现序列化类的不同版本间的兼容性
    
    	DbUtil dbUtil = new DbUtil();
    	UserDao userDao = new UserDao();
    	public static User s_currentUser = null;//保存登陆用户的参数
    
    	/** Creates new form LogOnFrm */
    	@SuppressWarnings("unchecked")
    	public LogOnFrm() {
    		//改变系统默认字体
    		Font font = new Font("Dialog", Font.PLAIN, 12);
    		java.util.Enumeration keys = UIManager.getDefaults().keys();
    		while (keys.hasMoreElements()) {
    			Object key = keys.nextElement();
    			Object value = UIManager.get(key);
    			if (value instanceof javax.swing.plaf.FontUIResource) {
    				UIManager.put(key, font);}}
    		initComponents();
    		//设置frame居中显示
    		this.setLocationRelativeTo(null);
    	}
    
    	//GEN-BEGIN:initComponents
    	// <editor-fold defaultstate="collapsed" desc="Generated Code">
    	private void initComponents() {
    
    		jLabel1 = new javax.swing.JLabel();
    		jLabel2 = new javax.swing.JLabel();
    		jLabel3 = new javax.swing.JLabel();
    		jb_logon = new javax.swing.JButton();
    		jb_register = new javax.swing.JButton();
    		userNameTxt = new javax.swing.JTextField();
    		passwordTxt = new javax.swing.JPasswordField();
    		jb_reset = new javax.swing.JButton();
    		setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
    		setTitle("\u9910\u5385\u70b9\u9910\u7cfb\u7edf");
    		setResizable(false);
    		jLabel1.setFont(new java.awt.Font("宋体", 1, 24));
    		jLabel1.setIcon(new javax.swing.ImageIcon(getClass().getResource(
    				"/images/OrderMeal.png"))); // NOI18N
    		jLabel1
    				.setText("\u9910\u5385\u70b9\u9910\u7cfb\u7edf\u6b22\u8fce\u60a8");
    		jLabel2.setIcon(new javax.swing.ImageIcon(getClass().getResource(
    				"/images/userName.png"))); // NOI18N
    		jLabel2.setText("\u7528\u6237\u540d\uff1a");
    		jLabel3.setIcon(new javax.swing.ImageIcon(getClass().getResource(
    				"/images/password.png"))); // NOI18N
    		jLabel3.setText("\u5bc6  \u7801\uff1a");
    		jb_logon.setIcon(new javax.swing.ImageIcon(getClass().getResource(
    				"/images/login.png"))); // NOI18N
    		jb_logon.setText("\u767b\u9646");
    		jb_logon.addActionListener(new java.awt.event.ActionListener() {
    			public void actionPerformed(java.awt.event.ActionEvent evt) {
    				jb_logonActionPerformed(evt);}});
    		jb_register.setIcon(new javax.swing.ImageIcon(getClass().getResource(
    				"/images/register.png"))); // NOI18N
    		jb_register.setText("\u6ce8\u518c\u7528\u6237");
    		jb_register.addActionListener(new java.awt.event.ActionListener() {
    			public void actionPerformed(java.awt.event.ActionEvent evt) {
    				jb_registerActionPerformed(evt);}});
    		jb_reset.setIcon(new javax.swing.ImageIcon(getClass().getResource(
    				"/images/reset.png"))); // NOI18N
    		jb_reset.setText("\u91cd\u7f6e");
    		jb_reset.addActionListener(new java.awt.event.ActionListener() {
    			public void actionPerformed(java.awt.event.ActionEvent evt) {
    				jb_resetActionPerformed(evt);}});
    		javax.swing.GroupLayout layout = new javax.swing.GroupLayout(
    				getContentPane());
    		getContentPane().setLayout(layout);
    		layout
    				.setHorizontalGroup(layout
    						.createParallelGroup(
    								javax.swing.GroupLayout.Alignment.LEADING)
    						.addGroup(
    								javax.swing.GroupLayout.Alignment.TRAILING,
    								layout
    										.createSequentialGroup()
    										.addGap(52, 52, 52)
    										.addGroup(
    												layout
    														.createParallelGroup(
    																javax.swing.GroupLayout.Alignment.LEADING)
    														.addGroup(
    																layout
    																		.createSequentialGroup()
    																		.addGroup(
    																				layout
    																						.createParallelGroup(
    																								javax.swing.GroupLayout.Alignment.LEADING)
    																						.addComponent(
    																								jLabel2)
    																						.addComponent(
    																								jLabel3))
    																		.addGap(
    																				33,
    																				33,
    																				33)
    																		.addGroup(
    																				layout
    																						.createParallelGroup(
    																								javax.swing.GroupLayout.Alignment.LEADING,
    																								false)
    																						.addComponent(
    																								passwordTxt)
    																						.addComponent(
    																								userNameTxt,
    																								javax.swing.GroupLayout.DEFAULT_SIZE,
    																								193,
    																								Short.MAX_VALUE)))
    														.addGroup(
    																layout
    																		.createParallelGroup(
    																				javax.swing.GroupLayout.Alignment.TRAILING)
    																		.addGroup(
    																				javax.swing.GroupLayout.Alignment.LEADING,
    																				layout
    																						.createSequentialGroup()
    																						.addGap(
    																								8,
    																								8,
    																								8)
    																						.addComponent(
    																								jb_logon)
    																						.addGap(
    																								18,
    																								18,
    																								18)
    																						.addComponent(
    																								jb_reset)
    																						.addGap(
    																								18,
    																								18,
    																								18)
    																						.addComponent(
    																								jb_register))
    																		.addComponent(
    																				jLabel1,
    																				javax.swing.GroupLayout.PREFERRED_SIZE,
    																				304,
    																				javax.swing.GroupLayout.PREFERRED_SIZE)))
    										.addContainerGap(54, Short.MAX_VALUE)));
    		layout
    				.setVerticalGroup(layout
    						.createParallelGroup(
    								javax.swing.GroupLayout.Alignment.LEADING)
    						.addGroup(
    								layout
    										.createSequentialGroup()
    										.addGap(18, 18, 18)
    										.addComponent(
    												jLabel1,
    												javax.swing.GroupLayout.PREFERRED_SIZE,
    												58,
    												javax.swing.GroupLayout.PREFERRED_SIZE)
    										.addGap(27, 27, 27)
    										.addGroup(
    												layout
    														.createParallelGroup(
    																javax.swing.GroupLayout.Alignment.BASELINE)
    														.addComponent(jLabel2)
    														.addComponent(
    																userNameTxt,
    																javax.swing.GroupLayout.PREFERRED_SIZE,
    																javax.swing.GroupLayout.DEFAULT_SIZE,
    																javax.swing.GroupLayout.PREFERRED_SIZE))
    										.addGap(38, 38, 38)
    										.addGroup(
    												layout
    														.createParallelGroup(
    																javax.swing.GroupLayout.Alignment.BASELINE)
    														.addComponent(jLabel3)
    														.addComponent(
    																passwordTxt,
    																javax.swing.GroupLayout.PREFERRED_SIZE,
    																javax.swing.GroupLayout.DEFAULT_SIZE,
    																javax.swing.GroupLayout.PREFERRED_SIZE))
    										.addGap(37, 37, 37)
    										.addGroup(
    												layout
    														.createParallelGroup(
    																javax.swing.GroupLayout.Alignment.BASELINE)
    														.addComponent(jb_logon)
    														.addComponent(jb_reset)
    														.addComponent(
    																jb_register))
    										.addContainerGap(55, Short.MAX_VALUE)));
    
    		pack();
    	}// </editor-fold>
    	//GEN-END:initComponents
        
    	//显示注册页面
    	private void jb_registerActionPerformed(java.awt.event.ActionEvent evt) {
    		this.dispose();
    		new RegisterFrm().setVisible(true);
    	}
    	//登陆验证显示登陆以后界面
    	private void jb_logonActionPerformed(java.awt.event.ActionEvent evt) {
    		String userName = this.userNameTxt.getText();
    		String password = new String(this.passwordTxt.getPassword());
    		if (StringUtil.isEmpty(userName)) {
    			JOptionPane.showMessageDialog(null, "用户名不能为空");
    			return;
    		}
    		if (StringUtil.isEmpty(password)) {
    			JOptionPane.showMessageDialog(null, "密码不能为空");
    			return;
    		}
    		User user = new User(userName, password);
    		Connection con = null;
    		try {
    			con = dbUtil.getCon();
    			User currentUser = userDao.login(con, user);
    			if (currentUser != null) {
    				s_currentUser = currentUser;//保存登陆的用户
    				int role = currentUser.getRank();
    				if (role == 1) {
    					this.dispose();
    					new AdminFrm().setVisible(true);//进入管理员页面
    				} else if (role == 0) {
    					this.dispose();
    					new UserOrderFrm().setVisible(true);//进入用户点餐界面
    				}
    			} else {
    				JOptionPane.showMessageDialog(null, "用户名或密码错误");
    			}
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    			JOptionPane.showMessageDialog(null, "用户名或密码错误");
    		} finally {
    			try {
    				dbUtil.closeCon(con);
    			} catch (Exception e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();		}	}}
    	//重置文本框内容
    	private void jb_resetActionPerformed(java.awt.event.ActionEvent evt) {
    		this.passwordTxt.setText("");
    		this.userNameTxt.setText("");}
    	public static void main(String args[]) {
    		java.awt.EventQueue.invokeLater(new Runnable() {
    			public void run() {
    				new LogOnFrm().setVisible(true);
    			}});}}
    

    OrderGoodsInterFrm

    package sut.rj.view;
    
    import java.sql.Connection;
    import java.sql.ResultSet;
    import java.util.Vector;
    
    import javax.swing.*;
    import javax.swing.table.DefaultTableModel;
    
    import sut.rj.dao.GoodsDao;
    import sut.rj.dao.OrderDao;
    import sut.rj.model.Goods;
    import sut.rj.model.Order;
    import sut.rj.dbconnection.DbUtil;
    import sut.rj.dbconnection.StringUtil;
    
    public class OrderGoodsInterFrm extends javax.swing.JInternalFrame {
    	//GEN-BEGIN:variables
    	// Variables declaration - do not modify
    	private javax.swing.JTable cartTable;
    	private javax.swing.JTable goodsTable;
    	private javax.swing.JLabel iamgeLb;
    	private javax.swing.JLabel jLabel1;
    	private javax.swing.JLabel jLabel2;
    	private javax.swing.JPanel jPanel2;
    	private javax.swing.JScrollPane jScrollPane1;
    	private javax.swing.JScrollPane jScrollPane2;
    	private javax.swing.JButton jb_add;
    	private javax.swing.JButton jb_delete;
    	private javax.swing.JButton jb_ok;
    	private javax.swing.JTextField totalMoneyTxt;
    	private javax.swing.JTextField totalNumTxt;
    	// End of variables declaration//GEN-END:variables
    	private static final long serialVersionUID = 1L;
    	//实现序列化,serialVersionUID 用来表明实现序列化类的不同版本间的兼容性
    
    	DbUtil dbUtil = new DbUtil();
    	GoodsDao goodsDao = new GoodsDao();
    	OrderDao orderDao = new OrderDao();
    
    	/** Creates new form OrderGoodsFrm */
    	public OrderGoodsInterFrm() {
    		initComponents();
    		this.setLocation(220, 100);
    		this.fillGoodsTable(new Goods());}
    	@SuppressWarnings("unchecked")
    	private void fillGoodsTable(Goods goods) {
    		DefaultTableModel dtm = (DefaultTableModel) goodsTable.getModel();
    		//清空之前显示
    		dtm.setRowCount(0);
    		Connection con = null;
    		try {
    			con = dbUtil.getCon();
    			ResultSet rs = goodsDao.goodsList(con, goods);
    			while (rs.next()) {
    				Vector v = new Vector();
    				v.add(rs.getString("id"));
    				v.add(rs.getString("goodsName"));
    				v.add(rs.getString("goodsDesc"));
    				v.add(rs.getString("price"));
    				v.add(rs.getString("imageLink"));
    				dtm.addRow(v);
    			}
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    		} finally {
    			try {
    				dbUtil.closeCon(con);
    			} catch (Exception e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();	}}}
    	//GEN-BEGIN:initComponents
    	// <editor-fold defaultstate="collapsed" desc="Generated Code">
    	private void initComponents() {
    
    		jScrollPane2 = new javax.swing.JScrollPane();
    		cartTable = new javax.swing.JTable();
    		jPanel2 = new javax.swing.JPanel();
    		iamgeLb = new javax.swing.JLabel();
    		jb_add = new javax.swing.JButton();
    		jb_ok = new javax.swing.JButton();
    		jb_delete = new javax.swing.JButton();
    		totalMoneyTxt = new javax.swing.JTextField();
    		jLabel1 = new javax.swing.JLabel();
    		jLabel2 = new javax.swing.JLabel();
    		totalNumTxt = new javax.swing.JTextField();
    		jScrollPane1 = new javax.swing.JScrollPane();
    		goodsTable = new javax.swing.JTable();
    		setClosable(true);
    		setIconifiable(true);
    		setTitle("\u7528\u6237\u70b9\u9910\u4e3b\u754c\u9762");
    		cartTable.setModel(new javax.swing.table.DefaultTableModel(
    				new Object[][] {
    				}, new String[] { "套餐编号", "套餐名称", "套餐数量", "套餐单价", "套餐金额" }) {
    					private static final long serialVersionUID = 1L;
    			boolean[] canEdit = new boolean[] { false, false, false, false,
    					false };
    			public boolean isCellEditable(int rowIndex, int columnIndex) {
    				return canEdit[columnIndex];}});
    		jScrollPane2.setViewportView(cartTable);
    		jPanel2.setBorder(javax.swing.BorderFactory
    				.createTitledBorder("\u5957\u9910\u56fe\u7247"));
    		javax.swing.GroupLayout jPanel2Layout = new javax.swing.GroupLayout(
    				jPanel2);
    		jPanel2.setLayout(jPanel2Layout);
    		jPanel2Layout.setHorizontalGroup(jPanel2Layout.createParallelGroup(
    				javax.swing.GroupLayout.Alignment.LEADING).addComponent(
    				iamgeLb, javax.swing.GroupLayout.DEFAULT_SIZE, 72,
    				Short.MAX_VALUE));
    		jPanel2Layout.setVerticalGroup(jPanel2Layout.createParallelGroup(
    				javax.swing.GroupLayout.Alignment.LEADING).addComponent(
    				iamgeLb, javax.swing.GroupLayout.DEFAULT_SIZE, 65,
    				Short.MAX_VALUE));
    		jb_add.setIcon(new javax.swing.ImageIcon(getClass().getResource(
    				"/images/cart.png"))); // NOI18N
    		jb_add.setText("\u52a0\u5165\u8d2d\u7269\u8f66");
    		jb_add.addActionListener(new java.awt.event.ActionListener() {
    			public void actionPerformed(java.awt.event.ActionEvent evt) {
    				jb_addActionPerformed(evt);}});
    		jb_ok.setIcon(new javax.swing.ImageIcon(getClass().getResource(
    				"/images/ok.png"))); // NOI18N
    		jb_ok.setText("\u7ed3\u7b97");
    		jb_ok.addActionListener(new java.awt.event.ActionListener() {
    			public void actionPerformed(java.awt.event.ActionEvent evt) {
    				jb_okActionPerformed(evt);}});
    		jb_delete.setIcon(new javax.swing.ImageIcon(getClass().getResource(
    				"/images/delete.png"))); // NOI18N
    		jb_delete.setText("\u5220\u9664");
    		jb_delete.addActionListener(new java.awt.event.ActionListener() {
    			public void actionPerformed(java.awt.event.ActionEvent evt) {
    				jb_deleteActionPerformed(evt);}});
    
    		totalMoneyTxt.setEditable(false);
    		jLabel1.setText("\u603b\u91d1\u989d\uff1a");
    		jLabel2.setText("\u603b\u6570\u91cf\uff1a");
    		totalNumTxt.setEditable(false);
    		goodsTable.setModel(new javax.swing.table.DefaultTableModel(
    				new Object[][] {
    				}, new String[] { "序号", "套餐名称", "套餐描述", "套餐价格", "图片地址" }) {
    					private static final long serialVersionUID = 1L;
    			boolean[] canEdit = new boolean[] { false, false, false, false,
    					false };
    			public boolean isCellEditable(int rowIndex, int columnIndex) {
    				return canEdit[columnIndex];}});
    		goodsTable.addMouseListener(new java.awt.event.MouseAdapter() {
    			public void mousePressed(java.awt.event.MouseEvent evt) {
    				goodsTableMousePressed(evt);}});
    		jScrollPane1.setViewportView(goodsTable);
    		javax.swing.GroupLayout layout = new javax.swing.GroupLayout(
    				getContentPane());
    		getContentPane().setLayout(layout);
    		layout
    				.setHorizontalGroup(layout
    						.createParallelGroup(
    								javax.swing.GroupLayout.Alignment.LEADING)
    						.addGroup(
    								layout
    										.createSequentialGroup()
    										.addContainerGap()
    										.addGroup(
    												layout
    														.createParallelGroup(
    																javax.swing.GroupLayout.Alignment.TRAILING)
    														.addGroup(
    																layout
    																		.createSequentialGroup()
    																		.addGroup(
    																				layout
    																						.createParallelGroup(
    																								javax.swing.GroupLayout.Alignment.TRAILING)
    																						.addComponent(
    																								jb_add)
    																						.addGroup(
    																								layout
    																										.createSequentialGroup()
    																										.addComponent(
    																												jScrollPane1,
    																												javax.swing.GroupLayout.DEFAULT_SIZE,
    																												449,
    																												Short.MAX_VALUE)
    																										.addGap(
    																												6,
    																												6,
    																												6)
    																										.addComponent(
    																												jPanel2,
    																												javax.swing.GroupLayout.PREFERRED_SIZE,
    																												javax.swing.GroupLayout.DEFAULT_SIZE,
    																												javax.swing.GroupLayout.PREFERRED_SIZE)))
    																		.addPreferredGap(
    																				javax.swing.LayoutStyle.ComponentPlacement.RELATED)
    																		.addGroup(
    																				layout
    																						.createParallelGroup(
    																								javax.swing.GroupLayout.Alignment.LEADING,
    																								false)
    																						.addGroup(
    																								javax.swing.GroupLayout.Alignment.TRAILING,
    																								layout
    																										.createSequentialGroup()
    																										.addComponent(
    																												jb_delete)
    																										.addPreferredGap(
    																												javax.swing.LayoutStyle.ComponentPlacement.RELATED,
    																												javax.swing.GroupLayout.DEFAULT_SIZE,
    																												Short.MAX_VALUE)
    																										.addComponent(
    																												jb_ok))
    																						.addComponent(
    																								jScrollPane2,
    																								javax.swing.GroupLayout.PREFERRED_SIZE,
    																								510,
    																								javax.swing.GroupLayout.PREFERRED_SIZE)))
    														.addGroup(
    																layout
    																		.createSequentialGroup()
    																		.addComponent(
    																				jLabel2)
    																		.addPreferredGap(
    																				javax.swing.LayoutStyle.ComponentPlacement.RELATED)
    																		.addComponent(
    																				totalNumTxt,
    																				javax.swing.GroupLayout.PREFERRED_SIZE,
    																				76,
    																				javax.swing.GroupLayout.PREFERRED_SIZE)
    																		.addPreferredGap(
    																				javax.swing.LayoutStyle.ComponentPlacement.RELATED)
    																		.addComponent(
    																				jLabel1)
    																		.addPreferredGap(
    																				javax.swing.LayoutStyle.ComponentPlacement.RELATED)
    																		.addComponent(
    																				totalMoneyTxt,
    																				javax.swing.GroupLayout.PREFERRED_SIZE,
    																				81,
    																				javax.swing.GroupLayout.PREFERRED_SIZE)))
    										.addContainerGap()));
    		layout
    				.setVerticalGroup(layout
    						.createParallelGroup(
    								javax.swing.GroupLayout.Alignment.LEADING)
    						.addGroup(
    								layout
    										.createSequentialGroup()
    										.addGap(32, 32, 32)
    										.addGroup(
    												layout
    														.createParallelGroup(
    																javax.swing.GroupLayout.Alignment.LEADING)
    														.addGroup(
    																layout
    																		.createSequentialGroup()
    																		.addGroup(
    																				layout
    																						.createParallelGroup(
    																								javax.swing.GroupLayout.Alignment.TRAILING)
    																						.addGroup(
    																								layout
    																										.createSequentialGroup()
    																										.addComponent(
    																												jPanel2,
    																												javax.swing.GroupLayout.PREFERRED_SIZE,
    																												javax.swing.GroupLayout.DEFAULT_SIZE,
    																												javax.swing.GroupLayout.PREFERRED_SIZE)
    																										.addPreferredGap(
    																												javax.swing.LayoutStyle.ComponentPlacement.RELATED,
    																												60,
    																												Short.MAX_VALUE))
    																						.addGroup(
    																								layout
    																										.createSequentialGroup()
    																										.addComponent(
    																												jScrollPane1,
    																												javax.swing.GroupLayout.PREFERRED_SIZE,
    																												122,
    																												javax.swing.GroupLayout.PREFERRED_SIZE)
    																										.addGap(
    																												18,
    																												18,
    																												18)))
    																		.addComponent(
    																				jb_add))
    														.addComponent(
    																jScrollPane2,
    																javax.swing.GroupLayout.PREFERRED_SIZE,
    																169,
    																javax.swing.GroupLayout.PREFERRED_SIZE))
    										.addPreferredGap(
    												javax.swing.LayoutStyle.ComponentPlacement.RELATED)
    										.addGroup(
    												layout
    														.createParallelGroup(
    																javax.swing.GroupLayout.Alignment.BASELINE)
    														.addComponent(jLabel1)
    														.addComponent(jLabel2)
    														.addComponent(
    																totalNumTxt,
    																javax.swing.GroupLayout.PREFERRED_SIZE,
    																javax.swing.GroupLayout.DEFAULT_SIZE,
    																javax.swing.GroupLayout.PREFERRED_SIZE)
    														.addComponent(
    																totalMoneyTxt,
    																javax.swing.GroupLayout.PREFERRED_SIZE,
    																javax.swing.GroupLayout.DEFAULT_SIZE,
    																javax.swing.GroupLayout.PREFERRED_SIZE))
    										.addPreferredGap(
    												javax.swing.LayoutStyle.ComponentPlacement.RELATED)
    										.addGroup(
    												layout
    														.createParallelGroup(
    																javax.swing.GroupLayout.Alignment.BASELINE)
    														.addComponent(jb_ok)
    														.addComponent(jb_delete))
    										.addContainerGap(43, Short.MAX_VALUE)));
    
    		pack();
    	}// </editor-fold>
    	//GEN-END:initComponents
    
    	private void jb_okActionPerformed(java.awt.event.ActionEvent evt) {
    		String userName = LogOnFrm.s_currentUser.getUserName();//
    		//生成订单号
    		String orderId = new java.text.SimpleDateFormat("yyyyMMddHHmmss")
    				.format(new java.util.Date());//将当前时间作为订单号码
    		float orderTotalMoney = Float.parseFloat(this.totalMoneyTxt.getText());//
    		int orderNum = Integer.parseInt(this.totalNumTxt.getText());//
    
    		int rowNum = cartTable.getRowCount();//计算行数
    		if (rowNum == 0) {
    			JOptionPane.showMessageDialog(null, "请添加上商品后再结算!");
    			return;
    		}
    		Connection con = null;
    		try {
    			con = dbUtil.getCon();
    			Order order = new Order(orderId, 0, orderNum, orderTotalMoney,
    					userName);
    			int addNum = orderDao.order_infoAdd(con, order);//插入数据到order_info表
    			if (addNum == 1) {
    				for (int i = 0; i < rowNum; i++) {
    
    					int goodsId = Integer.parseInt((String) cartTable
    							.getValueAt(i, 0));
    					String goodsName = (String) cartTable.getValueAt(i, 1);
    					int goodsNum = Integer.parseInt((String) cartTable
    							.getValueAt(i, 2));
    					float goodsPrice = Float.parseFloat((String) cartTable
    							.getValueAt(i, 3));
    					float goodsTotalPrice = Float.parseFloat((String) cartTable
    							.getValueAt(i, 4));
    					order = new Order(orderId, goodsTotalPrice, goodsId,
    							goodsPrice, goodsNum, goodsName);
    					//循环插入数据到order_goods表
    					addNum += orderDao.order_goodsAdd(con, order);
    				}
    			} else {
    				JOptionPane.showMessageDialog(null, "订单提交失败");
    			}
    			if (addNum == (1 + rowNum)) {
    				JOptionPane.showMessageDialog(null, "订单提交成功,请记住您的定单号:"
    						+ orderId);
    			} else {
    				JOptionPane.showMessageDialog(null, "订单提交失败");
    			}
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    			JOptionPane.showMessageDialog(null, "订单提交失败");
    		} finally {
    			try {
    				dbUtil.closeCon(con);
    			} catch (Exception e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}}
    		DefaultTableModel dtm = (DefaultTableModel) cartTable.getModel();
    		//删除选择的行
    		dtm.setRowCount(0);
    		fillCartTable();
    	}
    
    	private void fillCartTable() {
    		//修改商品总数和总金额
    		int rowNum = cartTable.getRowCount();//计算行数
    		int totalNum = 0;//总数量
    		float totalMoney = 0;//总金额
    		//累加总数量和总金额
    		for (int i = 0; i < rowNum; i++) {
    			totalNum += Integer.parseInt((String) cartTable.getValueAt(i, 2));
    			totalMoney += Float.parseFloat((String) cartTable.getValueAt(i, 4));
    		}
    		//文本框赋值
    		this.totalNumTxt.setText(Integer.toString(totalNum));
    		this.totalMoneyTxt.setText(Float.toString(totalMoney));
    	}
    	private void jb_deleteActionPerformed(java.awt.event.ActionEvent evt) {
    		int row = cartTable.getSelectedRow();
    		if (row == -1) {
    			JOptionPane.showMessageDialog(null, "请选择要删除的行!");
    		} else {
    			DefaultTableModel dtm = (DefaultTableModel) cartTable.getModel();
    			//删除选择的行
    			dtm.removeRow(row);
    		}
    		fillCartTable();
    	}
    
    	@SuppressWarnings("unchecked")
    	private void jb_addActionPerformed(java.awt.event.ActionEvent evt) {
    		DefaultTableModel dtm = (DefaultTableModel) cartTable.getModel();
    		//获取选中的行
    		int row = goodsTable.getSelectedRow();
    		if (row < 0) {
    			JOptionPane.showMessageDialog(null, "请选择一种套餐");
    			return;
    		}
    		//在表单中购物车table中显示加入的数据
    		int i = 0, flag = 0;//标记是否已经存在
    		int rowNum = cartTable.getRowCount();
    		for (i = 0; i < rowNum; i++) {
    			if (goodsTable.getValueAt(row, 0)
    					.equals(cartTable.getValueAt(i, 0))) {
    				flag = 1;
    				break;}}
    		if (flag == 0) {
    			Vector v = new Vector();
    			v.add((String) goodsTable.getValueAt(row, 0));
    			v.add((String) goodsTable.getValueAt(row, 1));
    			v.add("1");
    			v.add((String) goodsTable.getValueAt(row, 3));
    			v.add((String) goodsTable.getValueAt(row, 3));
    			dtm.addRow(v);
    		} else {
    			int goodsNum = Integer
    					.parseInt((String) cartTable.getValueAt(i, 2)) + 1;//获取当前数量
    			float goodsPrice = Float.parseFloat((String) cartTable.getValueAt(
    					i, 3));//获取当前单价
    			goodsPrice = goodsPrice
    					+ Float.parseFloat((String) cartTable.getValueAt(i, 4));//获取数量修改以后的总价
    			this.cartTable.setValueAt(Integer.toString(goodsNum), i, 2);
    			this.cartTable.setValueAt(Float.toString(goodsPrice), i, 4);
    		}
    		fillCartTable();}
    	private void goodsTableMousePressed(java.awt.event.MouseEvent evt) {
    		//获取选中的行
    		int row = goodsTable.getSelectedRow();
    		String picturePath = (String) goodsTable.getValueAt(row, 4);
    		if (StringUtil.isNotEmpty(picturePath)) {
    			Icon icon = new ImageIcon(picturePath);
    			this.iamgeLb.setIcon(icon);
    		} else {
    			this.iamgeLb.setIcon(null);	}}}
    

    RegisterFrm

    package sut.rj.view;
    
    import java.sql.Connection;
    
    import javax.swing.*;
    
    import sut.rj.dao.UserDao;
    import sut.rj.model.User;
    import sut.rj.dbconnection.DbUtil;
    import sut.rj.dbconnection.StringUtil;
    
    
    public class RegisterFrm extends javax.swing.JFrame {
    
    	//GEN-BEGIN:variables
    	// Variables declaration - do not modify
    	private javax.swing.JTextField emailTxt;
    	private javax.swing.JLabel jLabel1;
    	private javax.swing.JLabel jLabel2;
    	private javax.swing.JLabel jLabel3;
    	private javax.swing.JLabel jLabel4;
    	private javax.swing.JLabel jLabel5;
    	private javax.swing.JButton jb_register;
    	private javax.swing.JButton jb_reset;
    	private javax.swing.JPasswordField passwordConfirmTxt;
    	private javax.swing.JPasswordField passwordTxt;
    	private javax.swing.JTextField userNameTxt;
    	// End of variables declaration//GEN-END:variables
    	private static final long serialVersionUID = 1L;
    	//实现序列化,serialVersionUID 用来表明实现序列化类的不同版本间的兼容性
    	DbUtil dbUtil = new DbUtil();
    	UserDao userDao = new UserDao();
    
    	/** Creates new form RegisterFrm */
    	public RegisterFrm() {
    		initComponents();
    		//设置frame居中显示
    		this.setLocationRelativeTo(null);
    	}
    
    	/** This method is called from within the constructor to
    	 * initialize the form.
    	 * WARNING: Do NOT modify this code. The content of this method is
    	 * always regenerated by the Form Editor.
    	 */
    	//GEN-BEGIN:initComponents
    	// <editor-fold defaultstate="collapsed" desc="Generated Code">
    	private void initComponents() {
    		jLabel1 = new javax.swing.JLabel();
    		jLabel2 = new javax.swing.JLabel();
    		jLabel3 = new javax.swing.JLabel();
    		jLabel4 = new javax.swing.JLabel();
    		jLabel5 = new javax.swing.JLabel();
    		jb_register = new javax.swing.JButton();
    		jb_reset = new javax.swing.JButton();
    		userNameTxt = new javax.swing.JTextField();
    		emailTxt = new javax.swing.JTextField();
    		passwordTxt = new javax.swing.JPasswordField();
    		passwordConfirmTxt = new javax.swing.JPasswordField();
    		setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
    		setTitle("\u65b0\u7528\u6237\u6ce8\u518c");
    		setResizable(false);
    		jLabel1.setFont(new java.awt.Font("宋体", 1, 18));
    		jLabel1.setIcon(new javax.swing.ImageIcon(getClass().getResource(
    				"/images/new_register.png"))); // NOI18N
    		jLabel1.setText("\u65b0\u7528\u6237\u6ce8\u518c");
    
    		jLabel2.setIcon(new javax.swing.ImageIcon(getClass().getResource(
    				"/images/new_user.png"))); // NOI18N
    		jLabel2.setText("\u7528\u6237\u540d\uff1a");
    
    		jLabel3.setIcon(new javax.swing.ImageIcon(getClass().getResource(
    				"/images/new_password.png"))); // NOI18N
    		jLabel3.setText("\u5bc6\u7801\uff1a");
    
    		jLabel4.setIcon(new javax.swing.ImageIcon(getClass().getResource(
    				"/images/password_config.png"))); // NOI18N
    		jLabel4.setText("\u786e\u8ba4\u5bc6\u7801\uff1a");
    
    		jLabel5.setIcon(new javax.swing.ImageIcon(getClass().getResource(
    				"/images/email.png"))); // NOI18N
    		jLabel5.setText("\u90ae\u7bb1\uff1a");
    
    		jb_register.setIcon(new javax.swing.ImageIcon(getClass().getResource(
    				"/images/register.png"))); // NOI18N
    		jb_register.setText("\u6ce8\u518c");
    		jb_register.addActionListener(new java.awt.event.ActionListener() {
    			public void actionPerformed(java.awt.event.ActionEvent evt) {
    				jb_registerActionPerformed(evt);}});
    		jb_reset.setIcon(new javax.swing.ImageIcon(getClass().getResource(
    				"/images/reset.png"))); // NOI18N
    		jb_reset.setText("\u91cd\u7f6e");
    		jb_reset.addActionListener(new java.awt.event.ActionListener() {
    			public void actionPerformed(java.awt.event.ActionEvent evt) {
    				jb_resetActionPerformed(evt);}});
    		javax.swing.GroupLayout layout = new javax.swing.GroupLayout(
    				getContentPane());
    		getContentPane().setLayout(layout);
    		layout
    				.setHorizontalGroup(layout
    						.createParallelGroup(
    								javax.swing.GroupLayout.Alignment.LEADING)
    						.addGroup(
    								layout
    										.createSequentialGroup()
    										.addGroup(
    												layout
    														.createParallelGroup(
    																javax.swing.GroupLayout.Alignment.LEADING)
    														.addGroup(
    																layout
    																		.createSequentialGroup()
    																		.addGap(
    																				95,
    																				95,
    																				95)
    																		.addComponent(
    																				jLabel1))
    														.addGroup(
    																layout
    																		.createSequentialGroup()
    																		.addGap(
    																				57,
    																				57,
    																				57)
    																		.addComponent(
    																				jb_register)
    																		.addGap(
    																				63,
    																				63,
    																				63)
    																		.addComponent(
    																				jb_reset)))
    										.addContainerGap())
    						.addGroup(
    								layout
    										.createSequentialGroup()
    										.addGap(40, 40, 40)
    										.addGroup(
    												layout
    														.createParallelGroup(
    																javax.swing.GroupLayout.Alignment.LEADING)
    														.addComponent(jLabel2)
    														.addComponent(jLabel5)
    														.addComponent(jLabel3)
    														.addComponent(jLabel4))
    										.addGap(28, 28, 28)
    										.addGroup(
    												layout
    														.createParallelGroup(
    																javax.swing.GroupLayout.Alignment.TRAILING)
    														.addComponent(
    																passwordConfirmTxt,
    																javax.swing.GroupLayout.DEFAULT_SIZE,
    																146,
    																Short.MAX_VALUE)
    														.addComponent(
    																emailTxt,
    																javax.swing.GroupLayout.Alignment.LEADING,
    																javax.swing.GroupLayout.DEFAULT_SIZE,
    																146,
    																Short.MAX_VALUE)
    														.addComponent(
    																userNameTxt,
    																javax.swing.GroupLayout.DEFAULT_SIZE,
    																146,
    																Short.MAX_VALUE)
    														.addComponent(
    																passwordTxt,
    																javax.swing.GroupLayout.DEFAULT_SIZE,
    																146,
    																Short.MAX_VALUE))
    										.addGap(40, 40, 40)));
    		layout
    				.setVerticalGroup(layout
    						.createParallelGroup(
    								javax.swing.GroupLayout.Alignment.LEADING)
    						.addGroup(
    								layout
    										.createSequentialGroup()
    										.addGap(19, 19, 19)
    										.addComponent(jLabel1)
    										.addGap(18, 18, 18)
    										.addGroup(
    												layout
    														.createParallelGroup(
    																javax.swing.GroupLayout.Alignment.BASELINE)
    														.addComponent(jLabel2)
    														.addComponent(
    																userNameTxt,
    																javax.swing.GroupLayout.PREFERRED_SIZE,
    																javax.swing.GroupLayout.DEFAULT_SIZE,
    																javax.swing.GroupLayout.PREFERRED_SIZE))
    										.addPreferredGap(
    												javax.swing.LayoutStyle.ComponentPlacement.RELATED)
    										.addGroup(
    												layout
    														.createParallelGroup(
    																javax.swing.GroupLayout.Alignment.BASELINE)
    														.addComponent(jLabel3)
    														.addComponent(
    																passwordTxt,
    																javax.swing.GroupLayout.PREFERRED_SIZE,
    																javax.swing.GroupLayout.DEFAULT_SIZE,
    																javax.swing.GroupLayout.PREFERRED_SIZE))
    										.addPreferredGap(
    												javax.swing.LayoutStyle.ComponentPlacement.RELATED,
    												javax.swing.GroupLayout.DEFAULT_SIZE,
    												Short.MAX_VALUE)
    										.addGroup(
    												layout
    														.createParallelGroup(
    																javax.swing.GroupLayout.Alignment.BASELINE)
    														.addComponent(jLabel4)
    														.addComponent(
    																passwordConfirmTxt,
    																javax.swing.GroupLayout.PREFERRED_SIZE,
    																javax.swing.GroupLayout.DEFAULT_SIZE,
    																javax.swing.GroupLayout.PREFERRED_SIZE))
    										.addPreferredGap(
    												javax.swing.LayoutStyle.ComponentPlacement.RELATED)
    										.addGroup(
    												layout
    														.createParallelGroup(
    																javax.swing.GroupLayout.Alignment.BASELINE)
    														.addComponent(
    																emailTxt,
    																javax.swing.GroupLayout.PREFERRED_SIZE,
    																javax.swing.GroupLayout.DEFAULT_SIZE,
    																javax.swing.GroupLayout.PREFERRED_SIZE)
    														.addComponent(jLabel5))
    										.addGap(28, 28, 28)
    										.addGroup(
    												layout
    														.createParallelGroup(
    																javax.swing.GroupLayout.Alignment.BASELINE)
    														.addComponent(
    																jb_register)
    														.addComponent(jb_reset))
    										.addGap(55, 55, 55)));
    
    		pack();
    	}// </editor-fold>
    	//GEN-END:initComponents
    	//注册验证操作
    	private void jb_registerActionPerformed(java.awt.event.ActionEvent evt) {
    		String userName = this.userNameTxt.getText();
    		String password = new String(this.passwordTxt.getPassword());
    		String passwordConfirm = new String(this.passwordConfirmTxt
    				.getPassword());
    		String email = this.emailTxt.getText();
    		if (StringUtil.isEmpty(userName)) {
    			JOptionPane.showMessageDialog(null, "用户名不能为空");
    			return;
    		}
    		if (StringUtil.isEmpty(password)) {
    			JOptionPane.showMessageDialog(null, "密码不能为空");
    			return;
    		}
    		if (!password.equals(passwordConfirm)) {
    			JOptionPane.showMessageDialog(null, "两次输入的密码不一致!");
    			return;
    		}
    		if (!StringUtil.checkEmail(email)) {
    			JOptionPane.showMessageDialog(null, "邮箱格式错误!");
    			return;
    		}
    		User user = new User(userName, password, email);
    		Connection con = null;
    		try {
    			con = dbUtil.getCon();
    			if (!userDao.isUserExist(con, user)) {
    				int addNum = userDao.userAdd(con, user);
    				if (addNum == 1) {
    					JOptionPane.showMessageDialog(null, "注册成功!");
    					this.dispose();
    					new LogOnFrm().setVisible(true);
    				} else {
    					JOptionPane.showMessageDialog(null, "注册失败");
    				}
    			} else {
    				JOptionPane.showMessageDialog(null, "用户名存在,请重新输入!");
    			}
    		} catch (Exception e) {
    			// TODO Auto-generated catch block
    			e.printStackTrace();
    			JOptionPane.showMessageDialog(null, "注册失败,请重新注册!");
    		} finally {
    			try {
    				dbUtil.closeCon(con);
    			} catch (Exception e) {
    				// TODO Auto-generated catch block
    				e.printStackTrace();
    			}}}
    	//重置表单
    	private void jb_resetActionPerformed(java.awt.event.ActionEvent evt) {
    		this.userNameTxt.setText("");
    		this.passwordTxt.setText("");
    		this.passwordConfirmTxt.setText("");
    		this.emailTxt.setText("");}
    
    	/**
    	 * @param args the command line arguments
    	 */
    	public static void main(String args[]) {
    		java.awt.EventQueue.invokeLater(new Runnable() {
    			public void run() {
    				new RegisterFrm().setVisible(true);}});}}
    

    UserOrderFrm

    package sut.rj.view;
    
    import javax.swing.*;
    
    
    public class UserOrderFrm extends javax.swing.JFrame {
    	//GEN-BEGIN:variables
    	// Variables declaration - do not modify
    	private javax.swing.JMenu jMenu2;
    	private javax.swing.JMenu jMenu3;
    	private javax.swing.JMenuBar jMenuBar1;
    	private javax.swing.JMenu jm_order;
    	private javax.swing.JMenuItem jmiExit;
    	private javax.swing.JMenuItem jmi_checkOrder;
    	private javax.swing.JMenuItem jmi_modify;
    	private javax.swing.JMenuItem jmi_order;
    	private javax.swing.JDesktopPane table;
    	// End of variables declaration//GEN-END:variables
    	private static final long serialVersionUID = 1L;
    	//实现序列化,serialVersionUID 用来表明实现序列化类的不同版本间的兼容性
    
    	/** Creates new form UserFrm */
    	public UserOrderFrm() {
    		initComponents();
    		//设置最大化
    		this.setExtendedState(JFrame.MAXIMIZED_BOTH);
    	}
    
    	//GEN-BEGIN:initComponents
    	// <editor-fold defaultstate="collapsed" desc="Generated Code">
    	private void initComponents() {
    
    		table = new javax.swing.JDesktopPane();
    		jMenuBar1 = new javax.swing.JMenuBar();
    		jm_order = new javax.swing.JMenu();
    		jmi_order = new javax.swing.JMenuItem();
    		jMenu2 = new javax.swing.JMenu();
    		jmi_checkOrder = new javax.swing.JMenuItem();
    		jMenu3 = new javax.swing.JMenu();
    		jmi_modify = new javax.swing.JMenuItem();
    		jmiExit = new javax.swing.JMenuItem();
    
    		setDefaultCloseOperation(javax.swing.WindowConstants.EXIT_ON_CLOSE);
    		setTitle("\u7528\u6237\u70b9\u9910\u4e3b\u754c\u9762");
    
    		jm_order.setIcon(new javax.swing.ImageIcon(getClass().getResource(
    				"/images/order3.png"))); // NOI18N
    		jm_order.setText("\u7528\u6237\u70b9\u9910");
    
    		jmi_order.setIcon(new javax.swing.ImageIcon(getClass().getResource(
    				"/images/cart.png"))); // NOI18N
    		jmi_order.setText("\u5f00\u59cb\u70b9\u9910");
    		jmi_order.addActionListener(new java.awt.event.ActionListener() {
    			public void actionPerformed(java.awt.event.ActionEvent evt) {
    				jmi_orderActionPerformed(evt);
    			}
    		});
    		jm_order.add(jmi_order);
    
    		jMenuBar1.add(jm_order)