华强北商城二手手机管理系统

shangyizaoxing

已于 2024-08-14 10:31:51 修改

阅读量517

点赞数 11

分类专栏： springboot 管理系统计算机毕设文章标签： springboot 后端 java

于 2024-08-14 09:37:39 首次发布

本文链接：https://blog.csdn.net/shangyizaoxing/article/details/141181956

版权

管理系统同时被 3 个专栏收录

250 篇文章 0 订阅

订阅专栏

计算机毕设

250 篇文章 0 订阅

订阅专栏

springboot

101 篇文章 1 订阅

订阅专栏

文章目录

- springboot139华强北商城二手手机管理系统
研究背景**
系统测试的方

springboot139华强北商城二手手机管理系统

研究背景**

自计算机发展以来给人们的生活带来了改变。第一代计算机为1946年美国设计，最开始用于复杂的科学计算，占地面积、开机时间要求都非常高，经过数十几的改变计算机技术才发展到今天。现如今已是电子时代、数据时代，所有的生活都离不开计算机和网络。工作中有各类办公软件、APP，娱乐中有各类游戏软件、视频软件等都为生活带来了便捷，特别是我国的手机支付功能更是领先世界。科技推动了时代的发展。现在人们购物大多数已从传统的实体购物转换到线上购物。线上购物拥有更大的优点，商品种类全、价格优惠、售后有保障。由于传统实体购物需要亲力亲为，商品单一，价格不透明已渐渐在线上购物的打压下难以发展。

现在，网络覆盖范围扩大，价格便宜，各大商户都开放的有无线网络。手机也得到了普及，计算机技术也深入到手机中。普通生活、娱乐等都可以在线上解决。线上已成为趋势，大部分的行业都可以在线上开通业务，通过线上为人们解决问题，改变面对面方式，提高工作效率以及减少时间浪费。

1.2课题现状与实现意义

现在二手交易使用率高的有淘宝、58、贴吧以及刚时兴出来的直播等。对于卖家来言，想要快速销售出二手商品就需要采用多种方式，但现在二手平台不集中，人流量分散，效果并不理想。淘宝、58、贴吧这类平台都属于通用平台，对于里用户来说太过于广泛，消费群体不够精准，还没有专业针对手机的二手交易平台。

本系统采用商家对用户的模式，用户利用本平台可以购买商品、管理订单等。本系统可以帮助商家工作管理，实现商品的无地域、无时间销售。购买用户可以随时浏览、查询商品，可以了解商品的详情以及商品的其它用户的评价内容。本系统可以帮助用户更快的选择商品和跟踪订单，帮助商家增加销售途径，减少时间成本。本基于Springboot的华强北商城二手手机管理系统实现数据的自动化，减少管理员的工作内容并实现数据的清晰化。

1.3课题内容

本基于Springboot的华强北商城二手手机管理系统使用角色可以分为游客、注册用户、管理员、商家。游客可以浏览商品信息、新闻、商品评价信息等，游客通过注册成为注册用户后可以购买、收藏商品和管理购物车、订单、个人信息、在线评价商品等，商家可以销售商品管理销售订单，管理员负责本系统的管理，可以发布商品、管理商品、审核注册用户信息以及查看商品的评价、用户的订单，发布新闻等。

1.4论文结构安排

本论文的结构安排为三部分，分别为：

（1）第一部分，

摘要，本部分为简单的阐述，使读者可以对本论文有大致的了解；

外文翻译，采用英语对摘要进行翻译；

目录，本部分可以使读者对本论文有详细的了解。

（2）第二部分为正文部分，

绪论，本章从课题开发的来源、现状来进行介绍，总结出本系统开发的意义以及内容等；

系统分析，本章包括语言、技术等的介绍以及系统的需求分析、可行性分析、流程分析等；

系统设计，本章包括系统的功能结构图、数据库设计等；

系统实现，本章采用系统运行截图加文字进行本系统的详细介绍；

系统测试，本章采用测试的方法进行主要核心功能的测试介绍；

（3）第三部分为总结、致谢、参考文献。

第2章　系统分析

2.1系统使用相关技术分析

2.1.1Java语言介绍

Java语言是一种分布式的简单的开发语言，有很好的特征，在安全方面、性能方面等。非常适合在Internet环境中使用，也是目前企业级运用中最常用的一个编程语言，具有很大的影响力。主要是通过面向对象的形式进行开发，这样的话，就更能满足人们的需求。在编程开发使用中，主要通过封装的方式，通过类来实现，具有很好的可编辑行和操作性，这就是面向对象语言的最大特性，还可以在同一个类中把共同特性的类封装起来，形成一个抽象类，抽象类形容的不是一个对象，而是一个实体，这样就使用过程中就可以进行实例化，达到更好的效果。类之间还可以进行继承，比如一个类可以把另个类的特征进行继承，这样就可以重复使用，所以说这种继承性的类实际上还是同一个类体，这样就可以达到最大的效果。通过Java开发的代码还有很好的扩展性，可以通过不同的类达到的不同的效果，更好的提高使用效率，而且在后期维护方面非常的方便，开发的代码更加实用，更加简洁。

2.1.2Mysql数据库介绍

Mysql数据库是Oracle公司推出的一个数据库管理软件，有很好的性能设计，可以充分发挥和利用互联网的优势，而且在数据库管理方面非常的方便，支持图形化管理，非常适合新手的使用，可以直接在本地进行数据管理和配置，而且有很强大的数据处理能力，还有很好的安全性。在数据存储的过程中可以支持多处理器的存储结构，可以自动生产和处理Sql语句，有很强大的数据读取和复制存储功能，最最重要的是一个开放式的数据软件，可以为开放人员提供一个很好的数据库管理平台。Mysql是一个开源软件，是面向用户免费的，适合小型项目的开发和使用，而且存储的数据非常的多，存储方式是标准的Sql语句形式。支持多种不同的语言开发，比如Java ，PHP，C++等都能很好的兼容，非常适合Web语言的开发。而且对于有个性化要求的开发者来说，还支持定制，因为采用的开源的GPL协议，所以开发者可以直接通过修改代码的方式来达到自己的需求。Mysql是一个C/S架构的数据库管理软件，可以直接通过数据库客户端来进行管理操作，主要分为服务端和一个客户端，服务端是安装的时候自动跟谁系统启动的，一般不需要额外操作，使用的时候直接打开客户端就可以，然后输入端口和安装时候设置的密码就可以登录，不用的时候可以断开数据库链接，从而保证数据安全。

2.1.3Tomcat服务器介绍

Tomcat服务器是一个小型的轻量级服务器，非常适合一些小型的系统和本地的服务器使用，特别适合一些新手开发者使用。Tomcat服务器主要是当成JAVA程序的服务器使用，Tomcat服务器相当于就是Apache的一个扩展应用，区别就是他可以独立运行，当客户端上配置好Tomcat服务器以后，就可以直接通过服务器对HTML页面完成数据访问和响应。非常受程序员的喜欢，因为占用的运行空间非常的小时，不影响服务器性能，而且扩展性很好，支持很多开发过程中常用的功能，可以根据开发者的需求进行不断的改进和完善，所以说Tomcat服务器是目前使用非常广泛的一个服务器。

2.1.4 Springboot框架介绍

Springboot框架是一种SSM框架，属于一种简单的网页框架。在工作中通过页面向控制器发送请求，然后由控制器进行处理逻辑的调用，最后由逻辑层向持久层传送消息，最终由控制器调用视图进行数据的展示。SpringBoot可以理解为是一个简化版的Spring框架模型，可以直接独立运行于各种开发应用中，从而开发各种产品应用。SpringBoot结合了很多框架到一起的，建立好框架模型好，就可以直接自动生成所需要的所有Spring组件，非常的智能化，不需要自己在单独去写各种xml配置，可以自动配置各种所需要的文件包，使开发更加的简化，如果有自己额外需求，也可以手动进行修改默认值。SpringBoot还直接集成了嵌入式的Servlet容器，所以不需要在额外打包WAR包，可以直接进行自动配置和版本控制。不需要多余的代码生成，开箱即用，这样可以减少垃圾，提高系统的运行效率。而SpringBoot最核心的特色功能就是可以生成独立的微服务单元，就是把所有的代码模块都写在一个单独的应用里，这样功能代码直接的粘合度就非常的高，兼容性更好，而且还可以进行每个功能模块单独部署，不同的模块都能生成不同的小型服务，从而可以进行单独升级，然后实现应用之间的通信。用SpringBoot建立项目的首要步骤就是先配置SpringBoot依赖，建立的时候不需要单独设置版本，直接通过系统自带的场景启动器，就可以直接导入项目所需要的各种web模块，然后在把所需要的功能场景调取出来，生成一个启动器，直接在项目里引入各种依赖的组件就行，然后需要什么功能就导入什么场景就可以了。

2.1.5 VUE框架介绍

目前也有好多的前台框架都可以使用，为什么要选择Vue框架呢：因为随着目前科技的进步，前端也需要有很大的业务工作需要处理，网页功能也需要变的更加的强大，才能满足前端开发的需求，而这些都离不开JavaScript框架，现在开发的前台代码都是直接生成到浏览器里来执行，这就自动生成了很多JavaScript代码，然后这些代码是和各种页面布局和样式文件结合在一起的，通过vue可以进行各种融合；其次通过vue创建的代码维护性更好，还有很好的可测试性，比如你已经有了服务端的代码应用，可以直接嵌入到vue中进行使用，从而有更好的交互体验，更好的满足用户需求，也可以根据你的需求直接把业务代码逻辑放到前段代码里实现，满足用户的各种需求，可以进行各种定制化操作。Vue还可以把前台网页代码进行重复使用，直接使用到需要网页渲染的地方，通过vue进行执行命令，使开发更加的简单。

2.1.6 Idea运行软件介绍

一般运行Java语言开发的项目会采用Eclipse软件和Myeclipse软件以及Idea软件。Idea软件和Myeclipse软件相比，加入了智能助手，可以使系统的调试更快速，加快系统的运行。Idea软件和Eclipse软件相比，Idea软件拥有更多的插件，节省了下载更多插件的时间。Idea软件是后起之秀，现在SpringBoot框架开发的项目大多都采用Idea软件运行。Idea软件可通过网上搜索安装包进行安装，在安装时根据提示即可完成，并且可以免费注册，非常适合练习使用。Idea软件使用时也非常简单，导入项目后，只要通过简单的设置就可以运行项目，并且可以实现系统开发和系统调试为一体，最重要的是，使用Idea软件在开发系统项目时，Idea软件会自我改错和提示错误。它所拥有的智能助手可以智能的修改编程人员在编程中的初级错误，对于重大型的错误也可以智能提示，方便开发者在错误的源头修改，以便发生更严重不好修改的问题。

2.2系统可行性分析

系统是否可行决定了系统开发的成功性。想要系统的设计工作不会白费就需要经过详细的系统可行性分析。根据充分调查和参考相关论文发现，系统的可行性分析一般包括系统的技术可行性分析、系统的经济可行性分析、系统的操作可行性分析三种。

2.2.1系统经济可行性分析

本系统是Web型的网站，采用的Java语言开发的，开发周期比较短，而且技术成熟，所以在开发过程中没有过高的投入要求，有很好的经济可行性。

2.2.2系统技术可行性分析

本系统采用的技术有Vue网页技术、Mysql数据库、B/s模式、Java语言等。

（1）通过Vue进行前台的页面开发，具有很好的稳定性，而且可以直接在线升级维护，可以更方便的实现数据管理，通过Vue的最大特征就是系统提前已经自动完成了很大不重要的简单工作，可以自动生成很多常规代码，这样减少很大的工作量。而且Vue技术非常成熟，可以参考的案例也非常多。

（2）数据库采用Mysql数据库，也是非常适合学生用的一款小型数据库，使用起来非常的简单，而且数据处理效率高。

（3）采用B/s模式的网站已经是目前的开发主流，也是未来的发展方向。

（4）采用Java语言进行后台代码的开发，是面向对象的开发语言，可以直接查看和调用已用的案例，可以直接调用Xml服务，而且兼容性非常的强，不管是哪个平台，都可以直接调用，而且是通用的，可以提高开发者的工作效率，而且有很好的灵活性，使用起来非常的方便。

所以通过以上几点的分析，开发人员只要能熟练的操作以上的技术就行，具有开发技术可行性。

2.2.3系统操作可行性分析

　因为本系统是采用B/s的架构模式进行开发的，所以只有安装的有浏览器和数据库服务器就可以进行系统的访问的使用。而且非常的简单易操作，普通用户只需要有最简单的互联网操作经验就行。

2.3系统需求分析

需求分析指在系统开发前确定系统开发是要解决什么问题，以及在系统中如果输入了什么信息，想要得到什么结果，最后呈现了什么结果。简单来说，需求分析就是在问“想要干什么”然后通过“想要干什么”的问题找寻答案。需求分析是非常重要的过程，也是非常困难的过程。需求分析具有系统是否要开发的决定权，同时也为系统后期的开发提供基石。在需求分析阶段需要注意由于系统的使用者和开发者之间难以形成交流而且系统使用者的需求会一直变化，所以在需求分析时要采用动态发展的眼光看问题。

现在网上购物系统的技术发展已经非常成熟，各大电商平台的销售额也非常可观，特别是在一些重要的节日里一天的销售额都会达到几十亿。本基于Springboot的华强北商城二手手机管理系统可以方便用户选择到更适合自己的商品，并且售后服务非常完善。现在商家销售二手商品也会采用线上、线下相结合的方式进行商品的销售，由用户自主购物，商家在线发货、上新等，非常适合现代生活。二手交易网站是时代的趋势，其需求性不言而喻。

2.3.1传统销售系统优缺点分析

在最早出现的销售系统中主要使用人为工作人员，这类销售系统主要是采用C/s模式，这种模式可以保证数据的安全和存储性，数据库采用的也都是复杂、高性能的数据库，这类销售系统需要使用人员经过定期的培训才可以使用。随着网络的快速发展，这类销售系统的缺点也逐渐暴露出来，由于采用C/s模式就必须要求固定的客户端，这就需要足够严格的客户端条件，一旦客户端出现问题，系统里的数据都会出现问题，稳定性差，而且C/s模式的系统最大的问题是不能多次修改，如果系统经过了多次的补充、修改就会造成运行出错，为系统的使用造成不便。传统的销售系统通常采用的是脚本语言，脚本语言不够成熟，更容易出错，造成使用人员的损失。

2.3.2本基于Springboot的华强北商城二手手机管理系统分析

通过对传统销售系统的分析发现主要问题在于系统的模式架构上和数据库上。想要数据更为稳定就需要更稳定的数据库，好的数据库可以保证系统拥有更大的容错率和移植性，也可以在多种数据库中进行相互结合以此来保证系统里数据的安全。同时还需要注意系统的延续性，时代不断的发展，就会要求系统的服务更加的完善。想要使系统的生命周期更长就需要更为成熟的开发语言、技术、环境等。

本基于Springboot的华强北商城二手手机管理系统采用的模式架构为B/s，B/s框架可以脱离固定的客户端，把系统部署到浏览器上供用户使用，还可以把功能进行模块划分使数据库和操作界面分开，这样可以实现当任何一方出现问题时，另一方不受影响。数据库采用Mysql，Mysql数据库可以单独运行，当用户在进行操作后可自动保存操作后的数据，改变需要去数据库里修改数据的问题。开发语言采用Java，Java语言为动态语言，使用时间长久，已发展的非常成熟。本系统的其它技术包括Idea运行软件，Vue网页技术，Html技术等都是经过时间考验的。

2.4系统功能分析

本人参考大量的二手交易软件以及充分调查工作人员和商家、买家的需求，设计出的本基于Springboot的华强北商城二手手机管理系统使用角色为游客、注册用户、管理员、商家。框架界面分为前台、注册用户操作界面、管理员操作界面、商家操作界面。前台的功能设计为：

搜索功能，不管是游客和注册用户、管理员、商家都可以使用本功能进行特定商品的搜索；
新闻功能，本界面里展示了不同的新闻，游客和注册用户、商家只可以在前台进行信息的浏览；
商品展示功能，本界面里展示了所有的商品详情，游客可以详细了解，注册用户在登录后可以进行购买；
用户注册功能，实现注册目的。

　后台管理员的功能设计为：

商品信息管理功能，对商品进行上架、下架、编辑等，还可以查看商品的评价；
订单管理功能，此功能可以收到用户的订单，并对订单进行审核；
新闻管理功能，实现新闻的发布；
商品类别管理功能，本功能可以帮助用户实现商品的分类；
用户管理功能，实现注册用户的管理；
管理员管理功能，实现管理员资料和密码的修改管理；
轮播图信息功能，添加图片和设置轮播图。

注册用户的功能设计为：

个人资料管理功能，实现注册时资料的修改、维护；
我的收藏功能，管理自己收藏的信息；
购物车管理功能，对购物车里的商品进行管理；
订单管理功能，管理自己购买的订单。

商家功能设计为：

个人中心功能，实现商家资料的管理；
商品信息管理功能，发布商品和管理商品的销售订单。

2.5系统性能分析

在系统分析中还有重要的一点就是系统的性能分析，除却系统的功能分析其它问题都可以划分到系统的性能分析。主要包括系统数据问题、系统运行问题、系统安全问题。

系统数据问题表现在数据库的设计中，因为基于Springboot的华强北商城二手手机管理系统的核心在于商品的购买与销售，在购买、销售操作中会引起多种数据的变化。想要数据在变化时不会出错就需要在数据库设计时注意不同数据字段、类型等的主外键联系；
系统的运行问题表现在多平台、多人在运行系统时的稳定性。系统的运行速度也需要注意，运行的卡顿、读码速度等都需要经过多次测试；
系统的安全性问题表现在不同角色的使用权限，游客做为权限最少的角色不能越权，管理员做为权限最多的角色要可以管理其它几种角色。

2.6用例图

根据功能分析得出，本系统的主要使用角色为管理员和注册用户、商家。注册用户可以查看新闻、浏览商品、购买商品以及管理购物车、订单等。管理员可以管理系统信息、注册用户、商品信息以及新闻、订单信息、商品评价、分类信息等。商家可以管理商品信息和商品订单。系统用例图如下图2-1所示：

图2-1基于Springboot的华强北商城二手手机管理系统用例图

2.7系统业务流程

业务流程可以按照用户使用本系统的步骤进行设计。本系统中注册用户的流程为查看新闻、浏览商品、购买商品、加入购物车、管理订单、对商品评价等。管理员的流程为管理新闻、用户的订单、用户的注册资讯、管理商品等。商家可以管理商品和商品订单等。基于Springboot的华强北商城二手手机管理系统的业务流程如下图2-2所示：

图2-2基于Springboot的华强北商城二手手机管理系统业务流程图

（1）用户注册是游客成为注册用户的必经之路，在注册时需要输入信息、判断信息。用户注册的流程图如下图2-3所示：

图2-3用户注册的流程图

（2）用户评价时需要判断是否为登录状态，然后判断评价的内容是否合法，用户评价功能可以实现用户也商家之间的沟通。用户评价流程图如下图2-4所示：

图2-4用户评价流程图

（3）购买商品的过程需要多种数据的配合，购买商品的流程属于本系统的核心。首页确定登录，然后浏览商品，加购物车，购买，结算等。商品购买流程如下图2-5所示：

图2-5商品购买流程图

第3章　系统设计

3.1系统设计流程分析

一个好的系统在系统设计时需要采用一定的流程才可以顺利开发。首先需要调研使用用户的需求，这里的使用用户不单单普通用户还指系统的管理人员、工作人员，只有充分了解他们的需求才可以设计也符合要求的系统，其次，选择要使用的开发语言和技术、环境，开发语言和技术、环境的选择非常重要，开源的、生命周期长的、兼容性强的技术、环境、语言才可以保证系统的生命周期，接着是研究目前已有相关类似系统的问题和找出可行的解决方案，最后，也是最重要的，需要尽可能的保证系统的先进性，这样才不会过早的被淘汰。

3.2系统详细设计和设计原则

详细设计就是首先要确定好打算具体怎么实施这个系统，也就是说，通过这个过程，就要完成系统的具体功能的描述和规划，这样就可以在程序编码的时候直接根据自己规划好的功能模块进行开发。详细设计阶段还并不没有到程序开发阶段，而是要先把程序设计出来，相当于就是一个草稿，先规划好设计的每个步骤，然后代码实施的时候直接编码就行了，不需要在进行系统设计。所以说系统详细设计也是很重要的一步，设计的质量高低也决定了你程序最终的质量，所以首先要进行系统的合理化详细设计，然后还有读懂理解透彻这个程序的设计规划，这样编写代码的时候才不会出现错误，还要检验逻辑是否正确，性能是否满足用户需求，还要看是否容易理解，是否方便操作，要把所有需要考虑的问题都设计好。这样编写代码的时候才能更省事。

开发一个成功的系统首先要有一个明确的定位，就是开发这个系统的目的，然后确定系统的具体实施功能，具体需要投入的费用，然后进行市场可行性分析，最终确定系统是否可行，然后才能开展下一步的工作。只有经过了详细的前期调研，才能避免在系统开发中出现的很多其他问题，保障系统顺利开发进行。所以说一个成功的系统，首先必须方案思路正确，然后在根据需求设计对应的数据结构，开发环境，网络架构，然后构成一个完整的系统，只有这样才能使系统发挥更大的用处。所以通过本思路，开发本系统采用以下具体原则来进行：
（1）有效性：这里的有效性主要是通过两个层面，首先是有用性，其次还要有可用性。有用性主要是指开发的这个系统有市场需求，是站在用户角度就是实施的，，可用性主要是指用户使用后能满足用户的需求。所以说两个方面都要同时兼顾到，这样开发的系统才是一个好的系统，是一个成功的系统，才能让用户满意。
（2）兼容性：一个成功的系统必须是可以兼容不同的环境的，要充分考虑到用户不同的硬件下，可以达到一样的效果，必须保证非常好的兼容性。
（3）安全性：用户安全也是最重要的一个环节，因为目前随着网络信息的发展，用户的数据安全，信息安全，隐私安全都是非常重要。既然把硬件和软件进行合理的充分利用，保证用户资源共享的情况下，还要保证系统数据安全，还要有备份和恢复的功能。每个权限的用户，有自己不同的操作权限，从来保证数据信息安全。
（4）先进性：开发本系统采用目前比较流行的springboot框架，可以满足开发本系统的所有功能，数据库采用mysql，数据也有很好的安全存储，采用微软平台上进行开发，这样很好的保证了系统的兼容性和易维护性。
（5）采用标准技术：开发本系统所用到的各种技术标准均是目前国际现行标准，从而使系统有很好的开放性。

3.3系统体系结构

系统的体系结构非常重要，往往决定了系统的质量和生命周期。针对不同的系统可以采用不同的系统体系结构。本系统为基于Springboot的华强北商城二手手机管理系统系统，属于开放式的平台，所以在体系结构中采用B/s。B/s结构抛弃了固定客户端要求，采用服务器、客户端的模式。用户操作界面在前台展示，管理员操作界面在后台展示。B/s结构基于互联网，需要网络的支持，由用户在浏览器上发布命令，服务器负责向数据库传送命令，最后再由服务器把反馈的结果传回浏览器给用户进行呈现。

3.4系统功能结构

系统的功能结构是系统实现的框架，本系统的主要结构为管理员和用户、商家。管理员的功能为个人中心管理、新闻管理、商品管理、订单管理、轮播图管理等。用户的功能为在线注册与登录、新闻浏览、商品信息浏览、我的购物车管理、我的订单管理、收藏管理和商品评价等。商家可以管理商品信息和商品的订单以及个人资料。本基于Springboot的华强北商城二手手机管理系统功能结构图如下图3-1所示：

图3-1基于Springboot的华强北商城二手手机管理系统功能结构图

3.5系统的界面设计

3.5.1界面设计的原则

系统在界面设计时如果遵循一定的原则可以使设计更加顺利，可以减少错误的发生和减少修改错误的次数。系统的界面设计同样非常重要，只有一个好的界面才可以吸引用户使用，也才可以保证留住用户。界面设计的原则一般为：

对于相同功能，比如不同角色的修改个人资料管理采用相同风格进行设计，这样可以养成用户的操作习惯，一眼看过去就知道本功能的作用，不需要再仔细研究；
不同角色的操作界面可以分开设计，这样可以区别角色，在角色的操作界面也需要设置提醒信息，方便用户可以一眼看到当前所登录的角色；
在界面设计时尽量设计可以减少手动打字，手动打字需要时间和精力，并且错误率也会提高，如果改变方式，改成选择、自动这种方式就可以减少用户的打字压力。比如在用户注册时的性别输入上、信息输入的类别上等；
在操作时可以设置尽量多的提示词和提示框来防止用户错误操作和为用户的操作提示指导，比如用户登录不成功后可以提示为什么登录不成功是密码错误还是账号错误。

3.5.2信息输入功能的设计原则

为了提高信息输入的正确率，减轻用户的信息输入压力，可以在信息输入功能设计时采用尽可能减少手动输入的原则进行设计。信息输入功能的设计原则有：

可以多选用选择框、列表框等方式减少手动输入，在需要输入大量文字时可以设计可以复制、粘贴，也可以使用特定缩写来代替；
采用固定格式设计来减少用户的错误输入，比如在输入联系方式时，只可以输入数字，当输入其它信息时会提示“格式不正确”，在输入数量时，也可以规定好只可以输入数字。

3.6数据库设计

数据库主要作为数据库存储，也是系统重要的一步，数据库设计的过程也分为三个阶段来实施，首先是进行数据库需求分析，其次对数据库建立概念模型，最后就是数据库逻辑设计。数据库需求分析就是要弄清楚用户对开发这个系统的明确需求，就是从这个数据库需要实现什么信息，然后具体建立什么类型的表，每个表对应什么数据存储，以及每个字段的设计都要考虑到，为了数据库的安全可靠，所以设计的时候必须站在系统工程的角度进行思考。需求分析阶段，还要站在用户的立场进行考虑，进行数据安全分析，同时进行数据统计和分析用户的需求。数据库建立阶段首先要考虑各个数据字段，日常数据是否能满足基本需求，系统是否安全可靠，性能是否良好，操作是否方便，还有后期维护等。最后就是数据库功能实施阶段，主要就是数据的增删改查，是否能正确的进行操作，是否满足系统需求。

数据库设计分为两部分，数据库概念设计和数据库逻辑设计。数据库概念设计主要是设计数据的ER图，数据库逻辑设计主要是设计数据的数据库表。

3.6.1ER图设计

数据库ER图设计时采用的是自底向上的方式，首先从使用者的角色进行视图设计，然后把设计的这些视图进行整合，最后根据整合进行分析，得出结果。ER图是采用实体、联系的方式进行设计，ER图中的内容包括实体、属性、关系。实体是指系统中在工作时所使用的数据，属性是实体所包括的内容描述，关系是指实体与实体之间的联系。根据本系统的特点，本系统设计的主要实体包括管理员信息、用户信息、商品信息、订单信息、新闻和评价信息等。

管理员ER图包括的属性有管理员的编号、用户名和密码。管理员ER图如下图3-2所示：

图3-2管理员实体的ER图

商品信息包含的属性为商品的详细描述，有商品编号、商品名称等。商品信息ER图如下图3-3所示：

图3-3商品信息实体ER图

（3）注册用户信息的属性包括用户的个人资料，有姓名、性别、电话等。注册用户信息实体ER图如下图3-4所示：

图3-4注册用户实体ER图

（4）订单实体的属性有订单时间、订单编号、订单人等。订单实体ER图如下图3-5所示：

图3-5订单信息实体ER图

（5）评价信息实体的属性有评价人、评价内容、评价时间等。评价信息实体的ER图如下图3-6所示：

图3-6评价信息实体ER图

（6）新闻实体的属性有标题、内容、发布时间。新闻实体ER图如下图3-7所示：

图3-7新闻实体ER图

（7）本基于Springboot的华强北商城二手手机管理系统的整体实体关系图如下图3-8所示：

图3-8系统关系ER图

3.6.2数据库表设计

根据数据ER图的设计，本系统的数据库表有管理员信息表、用户信息表、商品信息表、评价信息表等。本系统的数据库表如下图3-1至3-12所示：

表3-1 address

表3-2 cart

表3-3 config


表3-4 dictionary

表3-5 news


表3-6 shangjia


表3-7 shangpin


表3-8 shangpin_collection

表3-9 shangpin_order


表3-10 token

表3-11 users

表3-12 yonghu

第4章系统实现

4.1用户注册功能的界面实现

用户注册功能设计的目的是实现用户的操作。系统中想要进行操作就需要先成为注册用户，游客只能浏览信息。用户注册功能界面中设置了用户的资料字段，本界面的数据和用户信息表相连，当游客在本界面里注册成功，所填写的资料会保存到用户信息表中。用户注册功能的运行界面如下图4-1所示：

图4-1用户注册功能的运行界面

4.2登录功能的界面实现

用户注册成功后，需要登录。登录界面设计的目的是保证当前的使用角色等级。管理员、商家同样需要登录后才可以进行操作。用户登录和管理员、商家登录的界面分为两个，在登录时只需要填写用户账号和密码就可以实现。用户登录的运行界面如下图4-2所示：

图4-2用户登录的运行界面

管理员、商家登录的界面中包含的元素有系统题目、输入框、登录按钮，同时设计了商家注册、用户注册功能。管理员登录的条件是需要账号、密码、身份。管理员、商家登录的运行界面如下图4-3所示：

图4-3管理员、商家登录运行界面

4.3管理员功能的设计实现

4.3.1用户管理功能的实现界面

用户注册后的资料管理员可以在注册用户管理功能里看到，本功能设计的目的是审核注册用户的资料，当发现不当的使用用户可以删除其账号。当删除注册用户信息后相对应的用户信息表里的信息也会随着删除掉。注册用户管理功能的运行界面如下图4-4所示：

图4-4用户管理功能的运行界面

4.3.2 用户中心管理功能的实现界面

用户中心管理的内容包括管理管理员账号和修改密码。本系统中可以拥有多个管理员。用户中心管理功能的运行界面如下图4-5所示：

图4-5用户中心管理功能的运行界面

4.3.3新闻信息管理功能的实现界面

用户浏览的新闻都是由管理员在此功能里进行维护添加的，同样当管理员添加、编辑新闻后，数据库表中的版块表也会发生改变。添加新闻信息功能的运行界面如下图4-6所示：

图4-6添加新闻信息功能的运行界面

新闻信息管理功能还查询新闻。查询新闻的运行界面如下图4-7所示：

图4-7查询新闻的运行界面

4.3.4 商品收藏管理功能的实现界面

管理员可以查询收藏信息和管理收藏信息。查询商品收藏功能的运行界面如下图4-8所示：

图4.8查询商品收藏运行界面

4.3.5 订单管理功能的实现界面

用户下订单后，管理员都可以在本功能里收到。当审核订单无误后可以进行下一步操作。订单管理功能的运行界面如下图4-9所示：

图4-9订单管理功能的运行界面

4.3.6 商品信息管理功能的界面实现

商品信息由管理员进行审核，可以查询商品的评价。查询商品信息的运行界面如下图4-10所示：

图4-10查询商品信息功能的运行界面

4.4用户角色功能的界面实现

4.4.1商品浏览功能的界面实现

在前台可以浏览所有分类的商品。商品详情中主要展示商品的图片、价格、标题。商品信息浏览功能的运行界面如下图4-11所示：

图4-11浏览商品运行界面

4.4.2提交订单功能的实现界面

选择商品点击购买可以跳转到提交订单界面，在本界面里需要填写购买数量和收货地址。提交订单功能的运行界面如下图4-12所示：

图4-12用户提交订单的运行界面

4.4.3购物车管理中心功能的实现界面

用户也可以把商品加入到购物车。购物车管理功能的运行界面如下图4-13所示：

图4-13购物车管理功能的运行界面

4.4.4订单管理中心功能的实现界面

用户在自己的个人中心里可以管理订单并进行退货操作。订单管理功能的实现界面如下图4-14所示：

图4-14订单管理功能运行效果

4.5商家角色功能的实现界面

商家的主要功能为发布商品和管理商品订单，商家角色功能的实现界面如下图4-15所示：

图4-15商家角色的功能实现界面

第5章系统测试

系统测试的方

ShangpinCollectionController.java












package com.controller;

import java.io.File;
import java.math.BigDecimal;
import java.net.URL;
import java.text.SimpleDateFormat;
import com.alibaba.fastjson.JSONObject;
import java.util.*;
import org.springframework.beans.BeanUtils;
import javax.servlet.http.HttpServletRequest;
import org.springframework.web.context.ContextLoader;
import javax.servlet.ServletContext;
import com.service.TokenService;
import com.utils.*;
import java.lang.reflect.InvocationTargetException;

import com.service.DictionaryService;
import org.apache.commons.lang3.StringUtils;
import com.annotation.IgnoreAuth;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.web.bind.annotation.*;
import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.entity.*;
import com.entity.view.*;
import com.service.*;
import com.utils.PageUtils;
import com.utils.R;
import com.alibaba.fastjson.*;

/**
 * 商品收藏
 * 后端接口
 * @author
 * @email
*/
@RestController
@Controller
@RequestMapping("/shangpinCollection")
public class ShangpinCollectionController {
    private static final Logger logger = LoggerFactory.getLogger(ShangpinCollectionController.class);

    @Autowired
    private ShangpinCollectionService shangpinCollectionService;


    @Autowired
    private TokenService tokenService;
    @Autowired
    private DictionaryService dictionaryService;

    //级联表service
    @Autowired
    private ShangpinService shangpinService;
    @Autowired
    private YonghuService yonghuService;



    /**
    * 后端列表
    */
    @RequestMapping("/page")
    public R page(@RequestParam Map<String, Object> params, HttpServletRequest request){
        logger.debug("page方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
        String role = String.valueOf(request.getSession().getAttribute("role"));
        if(StringUtil.isEmpty(role))
            return R.error(511,"权限为空");
        else if("用户".equals(role))
            params.put("yonghuId",request.getSession().getAttribute("userId"));
        else if("商家".equals(role))
            params.put("shangjiaId",request.getSession().getAttribute("userId"));
        if(params.get("orderBy")==null || params.get("orderBy")==""){
            params.put("orderBy","id");
        }
        PageUtils page = shangpinCollectionService.queryPage(params);

        //字典表数据转换
        List<ShangpinCollectionView> list =(List<ShangpinCollectionView>)page.getList();
        for(ShangpinCollectionView c:list){
            //修改对应字典表字段
            dictionaryService.dictionaryConvert(c, request);
        }
        return R.ok().put("data", page);
    }

    /**
    * 后端详情
    */
    @RequestMapping("/info/{id}")
    public R info(@PathVariable("id") Long id, HttpServletRequest request){
        logger.debug("info方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
        ShangpinCollectionEntity shangpinCollection = shangpinCollectionService.selectById(id);
        if(shangpinCollection !=null){
            //entity转view
            ShangpinCollectionView view = new ShangpinCollectionView();
            BeanUtils.copyProperties( shangpinCollection , view );//把实体数据重构到view中

                //级联表
                ShangpinEntity shangpin = shangpinService.selectById(shangpinCollection.getShangpinId());
                if(shangpin != null){
                    BeanUtils.copyProperties( shangpin , view ,new String[]{ "id", "createDate"});//把级联的数据添加到view中,并排除id和创建时间字段
                    view.setShangpinId(shangpin.getId());
                }
                //级联表
                YonghuEntity yonghu = yonghuService.selectById(shangpinCollection.getYonghuId());
                if(yonghu != null){
                    BeanUtils.copyProperties( yonghu , view ,new String[]{ "id", "createDate"});//把级联的数据添加到view中,并排除id和创建时间字段
                    view.setYonghuId(yonghu.getId());
                }
            //修改对应字典表字段
            dictionaryService.dictionaryConvert(view, request);
            return R.ok().put("data", view);
        }else {
            return R.error(511,"查不到数据");
        }

    }

    /**
    * 后端保存
    */
    @RequestMapping("/save")
    public R save(@RequestBody ShangpinCollectionEntity shangpinCollection, HttpServletRequest request){
        logger.debug("save方法:,,Controller:{},,shangpinCollection:{}",this.getClass().getName(),shangpinCollection.toString());

        String role = String.valueOf(request.getSession().getAttribute("role"));
        if(StringUtil.isEmpty(role))
            return R.error(511,"权限为空");
        else if("用户".equals(role))
            shangpinCollection.setYonghuId(Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId"))));

        Wrapper<ShangpinCollectionEntity> queryWrapper = new EntityWrapper<ShangpinCollectionEntity>()
            .eq("shangpin_id", shangpinCollection.getShangpinId())
            .eq("yonghu_id", shangpinCollection.getYonghuId())
            .eq("shangpin_collection_types", shangpinCollection.getShangpinCollectionTypes())
            ;

        logger.info("sql语句:"+queryWrapper.getSqlSegment());
        ShangpinCollectionEntity shangpinCollectionEntity = shangpinCollectionService.selectOne(queryWrapper);
        if(shangpinCollectionEntity==null){
            shangpinCollection.setInsertTime(new Date());
            shangpinCollection.setCreateTime(new Date());
            shangpinCollectionService.insert(shangpinCollection);
            return R.ok();
        }else {
            return R.error(511,"表中有相同数据");
        }
    }

    /**
    * 后端修改
    */
    @RequestMapping("/update")
    public R update(@RequestBody ShangpinCollectionEntity shangpinCollection, HttpServletRequest request){
        logger.debug("update方法:,,Controller:{},,shangpinCollection:{}",this.getClass().getName(),shangpinCollection.toString());

        String role = String.valueOf(request.getSession().getAttribute("role"));
//        if(StringUtil.isEmpty(role))
//            return R.error(511,"权限为空");
//        else if("用户".equals(role))
//            shangpinCollection.setYonghuId(Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId"))));
        //根据字段查询是否有相同数据
        Wrapper<ShangpinCollectionEntity> queryWrapper = new EntityWrapper<ShangpinCollectionEntity>()
            .notIn("id",shangpinCollection.getId())
            .andNew()
            .eq("shangpin_id", shangpinCollection.getShangpinId())
            .eq("yonghu_id", shangpinCollection.getYonghuId())
            .eq("shangpin_collection_types", shangpinCollection.getShangpinCollectionTypes())
            ;

        logger.info("sql语句:"+queryWrapper.getSqlSegment());
        ShangpinCollectionEntity shangpinCollectionEntity = shangpinCollectionService.selectOne(queryWrapper);
        if(shangpinCollectionEntity==null){
            //  String role = String.valueOf(request.getSession().getAttribute("role"));
            //  if("".equals(role)){
            //      shangpinCollection.set
            //  }
            shangpinCollectionService.updateById(shangpinCollection);//根据id更新
            return R.ok();
        }else {
            return R.error(511,"表中有相同数据");
        }
    }

    /**
    * 删除
    */
    @RequestMapping("/delete")
    public R delete(@RequestBody Integer[] ids){
        logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString());
        shangpinCollectionService.deleteBatchIds(Arrays.asList(ids));
        return R.ok();
    }

    /**
     * 批量上传
     */
    @RequestMapping("/batchInsert")
    public R save( String fileName){
        logger.debug("batchInsert方法:,,Controller:{},,fileName:{}",this.getClass().getName(),fileName);
        try {
            List<ShangpinCollectionEntity> shangpinCollectionList = new ArrayList<>();//上传的东西
            Map<String, List<String>> seachFields= new HashMap<>();//要查询的字段
            Date date = new Date();
            int lastIndexOf = fileName.lastIndexOf(".");
            if(lastIndexOf == -1){
                return R.error(511,"该文件没有后缀");
            }else{
                String suffix = fileName.substring(lastIndexOf);
                if(!".xls".equals(suffix)){
                    return R.error(511,"只支持后缀为xls的excel文件");
                }else{
                    URL resource = this.getClass().getClassLoader().getResource("static/upload/" + fileName);//获取文件路径
                    File file = new File(resource.getFile());
                    if(!file.exists()){
                        return R.error(511,"找不到上传文件，请联系管理员");
                    }else{
                        List<List<String>> dataList = PoiUtil.poiImport(file.getPath());//读取xls文件
                        dataList.remove(0);//删除第一行，因为第一行是提示
                        for(List<String> data:dataList){
                            //循环
                            ShangpinCollectionEntity shangpinCollectionEntity = new ShangpinCollectionEntity();
//                            shangpinCollectionEntity.setShangpinId(Integer.valueOf(data.get(0)));   //商品 要改的
//                            shangpinCollectionEntity.setYonghuId(Integer.valueOf(data.get(0)));   //用户 要改的
//                            shangpinCollectionEntity.setShangpinCollectionTypes(Integer.valueOf(data.get(0)));   //类型 要改的
//                            shangpinCollectionEntity.setInsertTime(date);//时间
//                            shangpinCollectionEntity.setCreateTime(date);//时间
                            shangpinCollectionList.add(shangpinCollectionEntity);


                            //把要查询是否重复的字段放入map中
                        }

                        //查询是否重复
                        shangpinCollectionService.insertBatch(shangpinCollectionList);
                        return R.ok();
                    }
                }
            }
        }catch (Exception e){
            return R.error(511,"批量插入数据异常，请联系管理员");
        }
    }




    /**
    * 前端列表
    */
    @IgnoreAuth
    @RequestMapping("/list")
    public R list(@RequestParam Map<String, Object> params, HttpServletRequest request){
        logger.debug("list方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));

        // 没有指定排序字段就默认id倒序
        if(StringUtil.isEmpty(String.valueOf(params.get("orderBy")))){
            params.put("orderBy","id");
        }
        PageUtils page = shangpinCollectionService.queryPage(params);

        //字典表数据转换
        List<ShangpinCollectionView> list =(List<ShangpinCollectionView>)page.getList();
        for(ShangpinCollectionView c:list)
            dictionaryService.dictionaryConvert(c, request); //修改对应字典表字段
        return R.ok().put("data", page);
    }

    /**
    * 前端详情
    */
    @RequestMapping("/detail/{id}")
    public R detail(@PathVariable("id") Long id, HttpServletRequest request){
        logger.debug("detail方法:,,Controller:{},,id:{}",this.getClass().getName(),id);
        ShangpinCollectionEntity shangpinCollection = shangpinCollectionService.selectById(id);
            if(shangpinCollection !=null){


                //entity转view
                ShangpinCollectionView view = new ShangpinCollectionView();
                BeanUtils.copyProperties( shangpinCollection , view );//把实体数据重构到view中

                //级联表
                    ShangpinEntity shangpin = shangpinService.selectById(shangpinCollection.getShangpinId());
                if(shangpin != null){
                    BeanUtils.copyProperties( shangpin , view ,new String[]{ "id", "createDate"});//把级联的数据添加到view中,并排除id和创建时间字段
                    view.setShangpinId(shangpin.getId());
                }
                //级联表
                    YonghuEntity yonghu = yonghuService.selectById(shangpinCollection.getYonghuId());
                if(yonghu != null){
                    BeanUtils.copyProperties( yonghu , view ,new String[]{ "id", "createDate"});//把级联的数据添加到view中,并排除id和创建时间字段
                    view.setYonghuId(yonghu.getId());
                }
                //修改对应字典表字段
                dictionaryService.dictionaryConvert(view, request);
                return R.ok().put("data", view);
            }else {
                return R.error(511,"查不到数据");
            }
    }


    /**
    * 前端保存
    */
    @RequestMapping("/add")
    public R add(@RequestBody ShangpinCollectionEntity shangpinCollection, HttpServletRequest request){
        logger.debug("add方法:,,Controller:{},,shangpinCollection:{}",this.getClass().getName(),shangpinCollection.toString());
        Wrapper<ShangpinCollectionEntity> queryWrapper = new EntityWrapper<ShangpinCollectionEntity>()
            .eq("shangpin_id", shangpinCollection.getShangpinId())
            .eq("yonghu_id", shangpinCollection.getYonghuId())
            .eq("shangpin_collection_types", shangpinCollection.getShangpinCollectionTypes())
            ;
        logger.info("sql语句:"+queryWrapper.getSqlSegment());
        ShangpinCollectionEntity shangpinCollectionEntity = shangpinCollectionService.selectOne(queryWrapper);
        if(shangpinCollectionEntity==null){
            shangpinCollection.setInsertTime(new Date());
            shangpinCollection.setCreateTime(new Date());
        //  String role = String.valueOf(request.getSession().getAttribute("role"));
        //  if("".equals(role)){
        //      shangpinCollection.set
        //  }
        shangpinCollectionService.insert(shangpinCollection);
            return R.ok();
        }else {
            return R.error(511,"您已经收藏过了");
        }
    }


}

TokenServiceImpl.java


package com.service.impl;


import java.util.Calendar;
import java.util.Date;
import java.util.List;
import java.util.Map;

import org.springframework.stereotype.Service;

import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.mapper.Wrapper;
import com.baomidou.mybatisplus.plugins.Page;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import com.dao.TokenDao;
import com.entity.TokenEntity;
import com.entity.TokenEntity;
import com.service.TokenService;
import com.utils.CommonUtil;
import com.utils.PageUtils;
import com.utils.Query;


/**
 * token
 * @author
 */
@Service("tokenService")
public class TokenServiceImpl extends ServiceImpl<TokenDao, TokenEntity> implements TokenService {

	@Override
	public PageUtils queryPage(Map<String, Object> params) {
		Page<TokenEntity> page = this.selectPage(
                new Query<TokenEntity>(params).getPage(),
                new EntityWrapper<TokenEntity>()
        );
        return new PageUtils(page);
	}

	@Override
	public List<TokenEntity> selectListView(Wrapper<TokenEntity> wrapper) {
		return baseMapper.selectListView(wrapper);
	}

	@Override
	public PageUtils queryPage(Map<String, Object> params,
			Wrapper<TokenEntity> wrapper) {
		 Page<TokenEntity> page =new Query<TokenEntity>(params).getPage();
	        page.setRecords(baseMapper.selectListView(page,wrapper));
	    	PageUtils pageUtil = new PageUtils(page);
	    	return pageUtil;
	}

	@Override
	public String generateToken(Integer userid,String username, String tableName, String role) {
		TokenEntity tokenEntity = this.selectOne(new EntityWrapper<TokenEntity>().eq("userid", userid).eq("role", role));
		String token = CommonUtil.getRandomString(32);
		Calendar cal = Calendar.getInstance();   
    	cal.setTime(new Date());   
    	cal.add(Calendar.HOUR_OF_DAY, 1);
		if(tokenEntity!=null) {
			tokenEntity.setToken(token);
			tokenEntity.setExpiratedtime(cal.getTime());
			this.updateById(tokenEntity);
		} else {
			this.insert(new TokenEntity(userid,username, tableName, role, token, cal.getTime()));
		}
		return token;
	}

	@Override
	public TokenEntity getTokenEntity(String token) {
		TokenEntity tokenEntity = this.selectOne(new EntityWrapper<TokenEntity>().eq("token", token));
		if(tokenEntity == null || tokenEntity.getExpiratedtime().getTime()<new Date().getTime()) {
			return null;
		}
		return tokenEntity;
	}
}

MPUtil.java

package com.utils;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import org.apache.commons.lang3.StringUtils;

import cn.hutool.core.bean.BeanUtil;

import com.baomidou.mybatisplus.mapper.Wrapper;

/**
 * Mybatis-Plus工具类
 */
public class MPUtil {
	public static final char UNDERLINE = '_';

	
	//mybatis plus allEQ 表达式转换
		public static Map allEQMapPre(Object bean,String pre) {
		   Map<String, Object> map =BeanUtil.beanToMap(bean);
		  return camelToUnderlineMap(map,pre);
	   }

		//mybatis plus allEQ 表达式转换
		public static Map allEQMap(Object bean) {
		   Map<String, Object> map =BeanUtil.beanToMap(bean);
		   return camelToUnderlineMap(map,"");
	   }

		public static Wrapper allLikePre(Wrapper wrapper,Object bean,String pre) {
			   Map<String, Object> map =BeanUtil.beanToMap(bean);
			   Map result = camelToUnderlineMap(map,pre);
			 
			return genLike(wrapper,result);
		}
	
		public static Wrapper allLike(Wrapper wrapper,Object bean) {
			  Map result = BeanUtil.beanToMap(bean, true, true);			 
			return genLike(wrapper,result);
		}
	
	
		public static Wrapper genLike( Wrapper wrapper,Map param) {
			Iterator<Map.Entry<String, Object>> it = param.entrySet().iterator();
			int i=0;
			while (it.hasNext()) {
				if(i>0) wrapper.and();
				Map.Entry<String, Object> entry = it.next();
				String key = entry.getKey();
				String value = (String) entry.getValue();
				wrapper.like(key, value);
				i++;
			}
			return wrapper;
		}
		
		public static Wrapper likeOrEq(Wrapper wrapper,Object bean) {
			  Map result = BeanUtil.beanToMap(bean, true, true);			 
			return genLikeOrEq(wrapper,result);
		}
		
		public static Wrapper genLikeOrEq( Wrapper wrapper,Map param) {
			Iterator<Map.Entry<String, Object>> it = param.entrySet().iterator();
			int i=0;
			while (it.hasNext()) {
				if(i>0) wrapper.and();
				Map.Entry<String, Object> entry = it.next();
				String key = entry.getKey();
				if(entry.getValue().toString().contains("%")) {
					wrapper.like(key, entry.getValue().toString().replace("%", ""));
				} else {
					wrapper.eq(key, entry.getValue());
				}
				i++;
			}
			return wrapper;
		}
		
		public static Wrapper allEq(Wrapper wrapper,Object bean) {
			  Map result = BeanUtil.beanToMap(bean, true, true);			 
			return genEq(wrapper,result);
		}
	
	
		public static Wrapper genEq( Wrapper wrapper,Map param) {
			Iterator<Map.Entry<String, Object>> it = param.entrySet().iterator();
			int i=0;
			while (it.hasNext()) {
				if(i>0) wrapper.and();
				Map.Entry<String, Object> entry = it.next();
				String key = entry.getKey();
				wrapper.eq(key, entry.getValue());
				i++;
			}
			return wrapper;
		}
	
	
		public static Wrapper between(Wrapper wrapper,Map<String, Object> params) {
			for(String key : params.keySet()) {
				String columnName = "";
				if(key.endsWith("_start")) {
					columnName = key.substring(0, key.indexOf("_start"));
					if(StringUtils.isNotBlank(params.get(key).toString())) {
						wrapper.ge(columnName, params.get(key));
					}
				}
				if(key.endsWith("_end")) {
					columnName = key.substring(0, key.indexOf("_end"));
					if(StringUtils.isNotBlank(params.get(key).toString())) {
						wrapper.le(columnName, params.get(key));
					}
				}
			}
			return wrapper;
		}
	
		public static Wrapper sort(Wrapper wrapper,Map<String, Object> params) {
			String order = "";
			if(params.get("order") != null && StringUtils.isNotBlank(params.get("order").toString())) {
				order = params.get("order").toString();
			}
			if(params.get("sort") != null && StringUtils.isNotBlank(params.get("sort").toString())) {
				if(order.equalsIgnoreCase("desc")) {
					wrapper.orderDesc(Arrays.asList(params.get("sort")));
				} else {
					wrapper.orderAsc(Arrays.asList(params.get("sort")));
				}
			}
			return wrapper;
		}
	
	
	/**
	 * 驼峰格式字符串转换为下划线格式字符串
	 * 
	 * @param param
	 * @return
	 */
	public static String camelToUnderline(String param) {
		if (param == null || "".equals(param.trim())) {
			return "";
		}
		int len = param.length();
		StringBuilder sb = new StringBuilder(len);
		for (int i = 0; i < len; i++) {
			char c = param.charAt(i);
			if (Character.isUpperCase(c)) {
				sb.append(UNDERLINE);
				sb.append(Character.toLowerCase(c));
			} else {
				sb.append(c);
			}
		}
		return sb.toString();
	}

	public static void main(String[] ages) {
		System.out.println(camelToUnderline("ABCddfANM"));
	}
	
	public static Map camelToUnderlineMap(Map param, String pre) {

		Map<String, Object> newMap = new HashMap<String, Object>();
		Iterator<Map.Entry<String, Object>> it = param.entrySet().iterator();
		while (it.hasNext()) {
			Map.Entry<String, Object> entry = it.next();
			String key = entry.getKey();
			String newKey = camelToUnderline(key);
			if (pre.endsWith(".")) {
				newMap.put(pre + newKey, entry.getValue());
			} else if (StringUtils.isEmpty(pre)) {
				newMap.put(newKey, entry.getValue());
			} else {

				newMap.put(pre + "." + newKey, entry.getValue());
			}
		}
		return newMap;
	}
}