基于java线上历史馆藏系统pf

最新推荐文章于 2024-08-20 16:05:08 发布
最新推荐文章于 2024-08-20 16:05:08 发布
阅读量280 收藏 3
点赞数 3
分类专栏： springboot 管理系统 计算机毕设 文章标签： springboot 后端 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a253399414/article/details/141351239
版权

@TOC

springboot492基于java线上历史馆藏系统pf

绪论

1.1 选题背景

当人们发现随着生产规模的不断扩大，人为计算方面才是一个巨大的短板，所以发明了各种计算设备，从结绳记事，到算筹，以及算盘，到如今的计算机，都是在无法满足生产的前提下出现的。随着计算机的发展，又出现了互联网技术。到现在为止，互联网已经发展了几十年了，在几十年的时间里就已经风靡世界。各行各业都发现了计算机的好处，计算机刚开始是军用的，后来在民用行业开始使用，到互联网时代，各种行业信息如井喷一般充斥着互联网，信息产生和传播的速度不断的提高。针对互联网的优点，结合互联网，对传统行业信息处理技术进行升级是非常有必要的。本课题对于历史馆藏系统方面，开发一个历史馆藏系统，在信息管理方面不至于混乱，也能降低数据的出错率，数据安全方面也有了保证，该系统还有其他的优点，比如优化信息处理流程，降低信息泄露风险，让管理人员的工作更有效率等。所以说，历史馆藏系统是目前不可缺的，对使用者相当的重要。

1.2 选题意义

如今的年代，已经是步入信息社会了，不仅信息更新速度频繁，信息量也大，在信息时代必须有相应的处理信息的方法，如果还采用以前的结绳记事或者笔写纸记，不仅是信息录入效率上赶不上节奏，在信息检索的速度上更是让人无法承受。幸而当今社会上计算机技术发展的相当不错，可以通过计算机在信息处理上面实现自动化或者半自动化的作业，采用计算机技术，能有效的提高信息录入以及信息检索的效率，社会上相同行业之间本身就是效率高的淘汰效率低的，既然采用计算机来替代手工记录，必然是效率更高，稳定性更强，成本更低等诸多优点。针对于母婴用品销售信息管理，开发一个历史馆藏系统不仅可以实现现代化的信息管理，也更符合现代化信息管理规范。

在实际的使用效果中，历史馆藏系统的意义如下：

第一点：历史馆藏系统的出现，就是为了提高工作人员的效率，能够在规定时间完成工作任务。

第二点：操作页面符合人体工程美学，符合日常人为操作习惯，使用友好。

第三点：区别于传统用纸张记录，提高了信息化水平。

第四点：在信息处理方面，极大的降低了人工处理成本。

1.3 研究内容

本文对系统的描述过程将按照绪论，系统开发技术，分析，设计，实现，测试等环节进行展开介绍。

绪论：本节内容主要展示研究该系统的背景和意义。

系统开发技术：本节内容主要展示该系统开发中需要使用的技术和搭建的开发环境。

系统分析：本节内容主要就是分析系统，包括性能，功能上的数据分析，也包括可行性分析等内容。

系统设计：本节内容主要就是根据系统分析的结果进行设计，主要包括功能和数据库的设计。

系统实现：本节内容主要就是通过程序编码对系统的功能进行实现，同时也对需要介绍的功能进行界面运行效果的展示。

系统测试：本节内容主要就是对系统的功能实现部分进行检测，发现系统的错误并及时纠正，让系统能够保证运行无误。

2 系统开发技术

对系统的开发需要做好准备工作，其中安装开发的工具以及学习开发中需要运用的技术都是需要提前进行的，本节内容就对开发中运用的工具还有技术进行阐述。

2.1 MySQL数据库

本设计用到的数据库就是MySQL数据库，之所以用到这个数据库的原因很多。首先，从满足功能需求上面来讲，MySQL是符合的；其次，从学习程度来讲，MySQL相比其他数据库不管是从安装还是使用上面来讲，都比较简单，最重要的是学习起来相当便捷，比较容易入手；再次，MySQL数据库对电脑要求不高，不管是什么样的电脑都可以安装MySQL数据库，并且并不会对电脑性能造成过多的影响。所以，就平常普普通通的电脑就可以作为开发用的电脑，不需要进行额外的电脑升级。虽然自从MySQL数据库被Oracle数据库收购后，有了一些闭源的风险，但是使用者还是很多，MySQL数据库目前的开发人员已经超过五百人了，对数据库开发者来讲已经是一个很大的开发团队了。MySQL在使用上面来讲，普通的增删改查操作已经可以满足大部分业务需求，像一些数据导出导入，以及一些函数，都可以满足一些不同的需求，最重要的是MySQL数据库可以创建索引，可以大大的提高数据的查询效率，当然，物极必反，如果因为索引好用而滥用，索引弄得比数据库表还要多，这样会造成MySQL数据库更新表数据时候的运行效率。总而言之，MySQL数据库在本次设计的使用上，是完全符合使用要求的。

2.2 IDEA简介

IDEA的诞生在Java集成开发工具行业正所谓平地起雷，瞬间震动了整个Java开发行业。真的是每个人用过的都说好。IDEA之所以相比于其他比如MyEclipse或者Eclipse之类的Java开发工具来讲比较好，原因首先在于设计方面。IDEA采用了所谓的人体工程学设计原理，让使用IDEA的人员用了就忘记不了。软件打开首先要设置主题，可以选择常规的白色或者暗色系列，长时间的白色或者长时间的暗色会让开发人员的眼睛疲劳加重，首先从这个细节就让程序开发人员备受青睐，让程序员看着舒服；然后再对一些常用性插件进行归类，让程序的开发注重于提升生产效率，而不是一味的让开发者找各种插件，有时候插件之间的版本还会存在不兼容，IDEA就把兼容的插件双手呈现，如此贴心的IDEA怎么能让人不喜爱。所以选择IDEA用来开发本项目就理所当然的了。

2.3 Ssm框架

Spring是一个很好的框架，但是发展到现在，在使用上面已经诟病不断，需要配置的越来越多，配置大于开发，让程序员用更多的精力去配置Spring，有点本末倒置了。Ssm框架是为了解决Spring框架的缺点而生，Spring框架好用是好用，但是配置起来相当的繁琐，Ssm则让简化了很多配置过程，让开发变得更有趣也更有效率，并且学过Spring框架的开发人员很容易理解Ssm框架，没有用过框架的人员学习Ssm框架的速度也很快的，Ssm得到了Java开发者的一致好评。

2.4 Vue框架

Vue框架的开发者是一个中国人，区别于其他框架的最核心的概念就是渐进式框架，Vue的出现，让网页前端的开发变成了一种纯前端职业，不需要在考虑后台数据类型以及业务逻辑，只需要进行数据绑定即可，大大的减少了前端开发工程师的学习难度。Vue是当前世界上最火的一种前段框架，学习成本比较低，只需要熟悉最基本的网页知识就可以理解相关知识，并且有很好的免费教程进行学习，有各个国家语言的教程，尤其是因为是中国人开发的框架，让中国的高级程序开发人员做了汉语教程。Vue框架发展之初就是高于IE8版本的，所以说只要是当前的主流浏览器都支持Vue框架，如果是很旧的那种电脑是不支持的，必须安装支持HTML5的浏览器才可以访问用Vue发布的站点。

3 系统分析

对于历史馆藏系统开发设计到的流程有，分析系统的功能，设计系统的结构，设计数据库，编码以及测试，其中，在系统分析中，所做的工作包括功能的确定，性能的分析等。

3.1 可行性研究

历史馆藏系统开发实现分析需要从不同的角度来进行分析可行性，比如从时间角度，经济角度，甚至操作角度。从不同的角度分析可行性会让历史馆藏系统开发具体化，进而达到辩证开发的正确性。

3.1.1 经济可行性

从经济方面分析是第一要素，没有经济的支持，任何项目都如水中捞月，无法实现。实现历史馆藏系统，开发过程不需要额外的经济条件，用本人现有的计算机就可以实现，这方面不需要额外的支出。

3.1.2 时间可行性

历史馆藏系统设计主要作为毕业设计，在题目确定之后，答辩之前使用的项目，对不同的开发进度上面都有时间的要求，总不至于答辩完成后才能实现功能，这个肯定不行，所以从时间上来分析项目的工作量，发现是可行的，符合正常开发时间。

3.1.3 操作可行性

操作必须符合正常人的思维模式，市面上有很多符合要求的程序正在使用中，可以借鉴其他程序的操作流程，变成符合本设计的操作流程，在操作上面进行无缝衔接，让使用者操作过程中不会感到迷茫。

从上面的角度来分析，后续工作可以继续进展。

3.2 系统性能分析

性能分析是软件开发过程中必不可少的一个环节，主要是为了降低软件在使用的过程中的容错率。通常来讲，分析软件系统的性能一般从以下几个方面进行分析。

3.2.1 系统的安全性

系统开发出来就是让正常使用的，那么在如今的互联网时代，首先考虑的就是安全性的问题。如果系统的安全性不够，那么使用价值就会降低。如果出现使用过程中丢失数据，那么用户就不再信赖，所以系统的安全性是第一要位，只有安全性存在了，才能考虑使用的问题，总不至于今天用户注册，明天用户账号泄露，这些都是不友好的。所以账号一般在数据库里存储会通过MD5进行加密，这样关键数据加密可以保证系统的安全性。

3.2.2 系统的易用性

安全性分析处理完毕，才考虑易用性。一个软件设计得符合操作规范，符合正常人类的理解逻辑，那么在使用上面就会很舒服，如果违背了这条原则，安全性再高的软件也是设计失败的，毕竟软件开发出来就是让人使用的，这一点尤为重要。

3.2.3 系统的健壮性

系统设计易用不代表没有规则，那么系统设计使用方面必须健壮，必须符合软件处理逻辑。比如设计一个价格类的输入框，用户需要输入价格，那么可以设定输入框最多两位小数的纯数字输入，如果用户不小心输入了其他字符，那么就会友好的提示让用户修改正确，只有输入符合规范的数据，才能进行提交，并且存储到数据库里。系统的健壮性就是这样，越是规范，越是健壮，有助于用户理解，还有助于程序使用。

3.3 系统流程分析

系统设计不是胡乱的设计，必须符合软件设计思想，具体的流程参考下图。系统设计的前期就是做各种分析，功能的设计，数据库的设计等，等一切都设计好了，逻辑上没有问题，符合设计流程和设计规范，才可以继续编码环节，编码只是实现设计的一个环节而已。

图3.1系统开发流程图

用户是一切应用的基础，只要牵扯到用户，那么肯定需要用户进行注册，只有这样才能让注册的用户进行使用。如果用户没有注册，只能算是游客，那么只能访问一些大众用户可以浏览的信息，如果需要用户操作的部分是不允许访问的，这样能极大的保证用户的权利。用户注册流程用下面的图来表示，主要是先判断用户名，只有用户名能用了才可以进行后面的信息注册。

图3.2 注册流程图

当需要用户登录的时候，肯定是要验证的，只有验证通过的用户才可以进行下一步操作，用户登录成功代表着用户模块的功能对登录用户进行了开放。流程就是如下面的图所示。

图3.3 登录流程图

3.4 系统功能分析

在对设计的总体要求理解了之后，就要把要求给具体化，也就是功能化，要尽量的把每个功能模块和模块之前的关系理清楚，必须符合正常人的行为逻辑才可以，并且尽量研究同类型的项目，这样能避免走弯路，最终才能得到设计的具体功能。

历史馆藏系统把操作该系统的用户群分为两类，即管理员，用户。

4 系统设计

系统在设计的过程中，必然要遵循一定的原则才可以，胡乱设计是不可取的。首先用户在使用过程中，能够直观感受到功能操作的便利性，符合正常思维逻辑的操作，这才是系统好用的一个开端，给使用者第一印象就是这个系统设计的相当不错。

4.1 系统设计原则

系统遵循设计原则进行开发，会有很多可以预料到的好处，只要遵循了设计原则，那么开发出来的系统必然是有质量保证的。

首先第一条原则就是安全性原则：程序必须设定角色管理，不同的角色有不同的功能模块，不同的角色登录都需要输入相对应的账号和密码，否则不允许进行操作相对应的权限。每个用户登录只能修改自己的密码，不需要对别的账号进行密码或者其他资料的修改，否则就违背了安全性原则的设定。

其次第二条原则就是易用性原则：符合安全性只是功能的符合，不代表操作就符合，所以要设定易用性原则。易用性原则就是规定程序符合操作流程，正常人的思维定向为基础，在不违背程序运行逻辑定义的情况下，必须使用简单，操作规范，让每个用户使用起来都能看到页面，就能感知功能模块的作用，短时间的就能使用程序，达到易用效果。

再次第三条原则就是实用性原则：实用性代表着花里胡哨的功能必须抛弃，尽量符合数据处理的简洁性，不仅需要这样进行设定，还需要有预知性，系统后期可能会出现的功能模块尽量要解耦，与程序设定要模块化体现，这样才能达到扩展性。

第四条原则就是准确性原则：准确性原则的唯一定义就是准确，包含数据输入格式的准确，数据处理的准确，以及数据存储的准确。程序里面关于数据准确才有存在的意义，如果一堆不相干的数据存在是没有任何用处的，甚至会产生各种问题，所以必须要保证数据的准确性。

第五条原则是易维护原则：易维护代表着程序运行必须是可控的状态，如果不可控出现各种问题，那么所有的工作都是空谈。程序开发中对于各种程序判定异常，必须有统一的处理模式，异常是程序开发中不可避免的，但是可以对出现的异常进行抛出，有助于程序异常处理的复盘，只要每个异常都能定位准确，那么代表程序设计是趋于完美的，维护起来会更加的方便，只要有助于程序维护的都必须给予支持。

4.2 功能模块设计

对管理员具体功能的设计结果将以图4.1所示的管理员功能结构图来进行体现。管理员对于历史馆藏系统操作的功能包括审核用户评价商品的信息，查看商品评价统计报表，对商品，商品分类，订单等信息进行管理。

结构设计图

图4.1 管理员功能结构图

对用户具体功能的设计结果将以图4.2所示的用户功能结构图来进行体现。用户对于历史馆藏系统操作的功能包括在前台购买商品，咨询留言，对个人收货地址以及订单，留言的博物馆进行管理。

4.3 数据库设计

用户通过系统的功能操作来进行数据交互，包括数据的添加，数据的更新，数据的删除，数据的查询等基本功能操作，表面上虽然是操作系统界面提供的功能，但是实际上系统的这些数据是在数据库当中进行访问与操作的。目前市场上可供选择的存储数据的数据库有很多，除了简单版的Access之外，还有SQL Server，DB2，Informix，MySQL等关系型数据库可供选择，由于关系型数据库具有固定的表结构，以及对数据一致性要求比较强，所以相比没有固定表结构以及具有灵活的数据格式的非关系型数据库而言，在程序配套数据库的选择中，关系型数据库的使用率更高。本系统选择MySQL来存放数据，其相关理论以及技术在经过了很长时间的发展之后，变得非常成熟，各大网络平台都公开分享其开发源码，而且其对计算机的配置要求很低，不需要过多内存进行安装，很符合本系统对于数据库的选择要求。

4.3.1 数据库E-R图

本节需要对系统中存放在数据库中的数据进行充分分析，对数据的实体，实体特征，联系等进行确定，然后通过概念模型的表示方法即E-R图进行表达，在E-R图绘制工具中，选择椭圆，菱形框，矩形等形状表达实体属性，实体间联系，实体这些信息，使用实线段将这些形状进行连接即可。初步完成E-R图之后，需要进行检查，及时进行有误数据的更改，删除实体间存在的冗余联系，删除E-R图中冗余的数据，最终要展示一个内容准确的E-R图。

（1）下图是博物馆实体和其具备的属性。

C:/Users/Administrator/Desktop/temp111\1\img\博物馆.jpg 博物馆实体属性图

（2）下图是博物馆预约实体和其具备的属性。

C:/Users/Administrator/Desktop/temp111\1\img\博物馆预约.jpg 博物馆预约实体属性图

（3）下图是留言板实体和其具备的属性。

C:/Users/Administrator/Desktop/temp111\1\img\留言板.jpg 留言板实体属性图

（4）下图是用户实体和其具备的属性。

C:/Users/Administrator/Desktop/temp111\1\img\用户.jpg 用户实体属性图

（5）下图是公告实体和其具备的属性。

C:/Users/Administrator/Desktop/temp111\1\img\公告.jpg 公告实体属性图

（6）下图是展品实体和其具备的属性。

C:/Users/Administrator/Desktop/temp111\1\img\展品.jpg 展品实体属性图

4.3.2 数据库表结构

在指定的数据库里面对数据表进行创建命名，然后设计各个数据表的存储结构，需要对该数据库的操作非常熟悉，并且还需要学习并掌握一定的数据表设计方面的知识，比如数据命名，作为系统的开发人员，为了避免程序运行产生乱码现象以及为了确保系统的正常运行，在对数据表进行命名时，一般都是采用英文名称，同时在对数据表的字段进行编辑时，也是采用英文的方式进行，为了方便今后对数据表的设计内容进行更改或查看，对一些比较重要的字段都会进行中文备注，或者是使用中文进行字段描述。设计期间，也需要对各个字段选择合适的数据类型以及设置匹配的取值范围，当一张数据表设计完成之后，还要对该表的主键进行标注，就是为了确保该数据表的唯一性与独立性。

表4.1博物馆表

序号列名数据类型说明允许空
1IdIntid否
2bowuguan_nameString博物馆名称是
3bowuguan_uuid_numberString博物馆编号是
4bowuguan_photoString博物馆照片是
5bowuguan_addressString博物馆地点是
6bowuguan_typesInteger博物馆分类是
7bowuguan_contentString博物馆介绍是
8bowuguan_kucun_numberInteger每天最大人数上限是
9bowuguan_deleteInteger逻辑删除是
10insert_timeDate录入时间是
11create_timeDate创建时间是

表4.2博物馆预约表

序号列名数据类型说明允许空
1IdIntid否
2bowuguan_idInteger博物馆是
3yonghu_idInteger用户是
4bowuguan_order_timeDate预约时间是
5buy_numberInteger预约人数是
6bowuguan_order_typesInteger订单类型是
7insert_timeDate订单创建时间是
8create_timeDate创建时间是

表4.3字典表

序号列名数据类型说明允许空
1IdIntid否
2dic_codeString字段是
3dic_nameString字段名是
4code_indexInteger编码是
5index_nameString编码名字是
6super_idInteger父字段id是
7beizhuString备注是
8create_timeDate创建时间是

表4.4公告表

序号列名数据类型说明允许空
1IdIntid否
2gonggao_nameString公告名称是
3gonggao_photoString公告图片是
4gonggao_typesInteger公告类型是
5insert_timeDate公告发布时间是
6gonggao_contentString公告详情是
7create_timeDate创建时间是

表4.5留言板表

序号列名数据类型说明允许空
1IdIntid否
2yonghu_idInteger用户是
3liuyan_nameString留言标题是
4liuyan_textString留言内容是
5insert_timeDate留言时间是
6reply_textString回复内容是
7update_timeDate回复时间是
8create_timeDate创建时间是

表4.6用户表

序号列名数据类型说明允许空
1IdIntid否
2yonghu_nameString用户姓名是
3yonghu_phoneString用户手机号是
4yonghu_id_numberString用户身份证号是
5yonghu_photoString用户头像是
6yonghu_emailString电子邮箱是
7create_timeDate创建时间是

表4.7展品表

序号列名数据类型说明允许空
1IdIntid否
2bowuguan_idInteger博物馆是
3zhanpin_nameString展品名称是
4zhanpin_uuid_numberString展品编号是
5zhanpin_photoString展品照片是
6zhanpin_chuchuString展品出处是
7zhanpin_contentString展品介绍是
8jieru_timeDate展品借入时间是
9yanghu_timeDate展品养护时间是
10zhanpin_deleteInteger逻辑删除是
11insert_timeDate录入时间是
12create_timeDate创建时间是

表4.8管理员表

序号列名数据类型说明允许空
1IdIntid否
2usernameString用户名是
3passwordString密码是
4roleString角色是
5addtimeDate新增时间是

5 系统实现

下面主要是通过功能实现界面截图的形式，并且运用文字来描述功能实现界面的内容。

5.1 管理员功能实现

5.1.1 博物馆管理

博物馆可以是给大家带来趣味性运行效果见图5.1。；

图5.1 博物馆界面

5.1.2 展品管理

该功能主要用于相应的介绍运行效果见图5.2。

图5.2 展品管理界面

5.1.3 博物馆预约管理

该功能主要用于实现对博物馆预约管理，博物馆预约管理界面的运行效果见图5.3。

图5.3 博物馆预约管理面

5.1.4 公告管理

该功能主要用于实现对公告管理基本信息的管理，公告管理界面的运行效果见图5.4。在此界面，管理员需要及时查看，对无效的公告管理删除。

图5.4 公告管理界面

5.1.5 留言板管理

该功能主要用于实现对留言板管理基本信息的管理，留言板管理界面的运行效果见图5.5。在此界面，主要是展示所有的留言板管理，无效的留言板管理可以删除。

图5.5 留言板管理界面

5.2 用户功能实现

5.2.1 博物馆

博物馆界面的运行效果见图5.6。

图5.6 博物馆界面

5.2.2 展品

展品界面的运行效果见图5.7。展品进行相应的介绍。

图5.7 展品界面

5.2.3 博物馆预约

博物馆预约界面的运行效果见图5.8。等。

图5.8 博物馆预约界面

5.2.4 公告

公告界面的运行效果见图5.9。在此界面，；

图5.9 公告界面

5.2.5 留言

留言界面的运行效果见图5.10。在此界面，留言功能给用户提供了信息便利，若用户觉得此资讯非常有趣，或觉得此资讯对之后的日常生活有所需要，用户登录之后就可以进行留言，留言后可在个人中心中进行查看

图5.10 留言界面

系统

BowuguanController.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("/bowuguan")
public class BowuguanController {
    private static final Logger logger = LoggerFactory.getLogger(BowuguanController.class);

    private static final String TABLE_NAME = "bowuguan";

    @Autowired
    private BowuguanService bowuguanService;


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

    @Autowired
    private BowuguanOrderService bowuguanOrderService;
    //级联表非注册的service
    //注册表service
    @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(false)
            return R.error(511,"永不会进入");
        else if("用户".equals(role))
            params.put("yonghuId",request.getSession().getAttribute("userId"));
        params.put("bowuguanDeleteStart",1);params.put("bowuguanDeleteEnd",1);
        CommonUtil.checkMap(params);
        PageUtils page = bowuguanService.queryPage(params);

        //字典表数据转换
        List<BowuguanView> list =(List<BowuguanView>)page.getList();
        for(BowuguanView 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);
        BowuguanEntity bowuguan = bowuguanService.selectById(id);
        if(bowuguan !=null){
            //entity转view
            BowuguanView view = new BowuguanView();
            BeanUtils.copyProperties( bowuguan , view );//把实体数据重构到view中
            //修改对应字典表字段
            dictionaryService.dictionaryConvert(view, request);
            return R.ok().put("data", view);
        }else {
            return R.error(511,"查不到数据");
        }

    }

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

        String role = String.valueOf(request.getSession().getAttribute("role"));
        if(false)
            return R.error(511,"永远不会进入");

        Wrapper<BowuguanEntity> queryWrapper = new EntityWrapper<BowuguanEntity>()
            .eq("bowuguan_name", bowuguan.getBowuguanName())
            .eq("bowuguan_address", bowuguan.getBowuguanAddress())
            .eq("bowuguan_types", bowuguan.getBowuguanTypes())
            .eq("bowuguan_kucun_number", bowuguan.getBowuguanKucunNumber())
            .eq("bowuguan_delete", bowuguan.getBowuguanDelete())
            ;

        logger.info("sql语句:"+queryWrapper.getSqlSegment());
        BowuguanEntity bowuguanEntity = bowuguanService.selectOne(queryWrapper);
        if(bowuguanEntity==null){
            bowuguan.setBowuguanDelete(1);
            bowuguan.setInsertTime(new Date());
            bowuguan.setCreateTime(new Date());
            bowuguanService.insert(bowuguan);
            return R.ok();
        }else {
            return R.error(511,"表中有相同数据");
        }
    }

    /**
    * 后端修改
    */
    @RequestMapping("/update")
    public R update(@RequestBody BowuguanEntity bowuguan, HttpServletRequest request) throws NoSuchFieldException, ClassNotFoundException, IllegalAccessException, InstantiationException {
        logger.debug("update方法:,,Controller:{},,bowuguan:{}",this.getClass().getName(),bowuguan.toString());
        BowuguanEntity oldBowuguanEntity = bowuguanService.selectById(bowuguan.getId());//查询原先数据

        String role = String.valueOf(request.getSession().getAttribute("role"));
//        if(false)
//            return R.error(511,"永远不会进入");
        //根据字段查询是否有相同数据
        Wrapper<BowuguanEntity> queryWrapper = new EntityWrapper<BowuguanEntity>()
            .notIn("id",bowuguan.getId())
            .andNew()
            .eq("bowuguan_name", bowuguan.getBowuguanName())
            .eq("bowuguan_address", bowuguan.getBowuguanAddress())
            .eq("bowuguan_types", bowuguan.getBowuguanTypes())
            .eq("bowuguan_kucun_number", bowuguan.getBowuguanKucunNumber())
            .eq("bowuguan_delete", bowuguan.getBowuguanDelete())
            ;

        logger.info("sql语句:"+queryWrapper.getSqlSegment());
        BowuguanEntity bowuguanEntity = bowuguanService.selectOne(queryWrapper);
        if("".equals(bowuguan.getBowuguanPhoto()) || "null".equals(bowuguan.getBowuguanPhoto())){
                bowuguan.setBowuguanPhoto(null);
        }
        if(bowuguanEntity==null){
            bowuguanService.updateById(bowuguan);//根据id更新
            return R.ok();
        }else {
            return R.error(511,"表中有相同数据");
        }
    }



    /**
    * 删除
    */
    @RequestMapping("/delete")
    public R delete(@RequestBody Integer[] ids, HttpServletRequest request){
        logger.debug("delete:,,Controller:{},,ids:{}",this.getClass().getName(),ids.toString());
        List<BowuguanEntity> oldBowuguanList =bowuguanService.selectBatchIds(Arrays.asList(ids));//要删除的数据
        ArrayList<BowuguanEntity> list = new ArrayList<>();
        for(Integer id:ids){
            BowuguanEntity bowuguanEntity = new BowuguanEntity();
            bowuguanEntity.setId(id);
            bowuguanEntity.setBowuguanDelete(2);
            list.add(bowuguanEntity);
        }
        if(list != null && list.size() >0){
            bowuguanService.updateBatchById(list);
        }

        return R.ok();
    }


    /**
     * 批量上传
     */
    @RequestMapping("/batchInsert")
    public R save( String fileName, HttpServletRequest request){
        logger.debug("batchInsert方法:,,Controller:{},,fileName:{}",this.getClass().getName(),fileName);
        Integer yonghuId = Integer.valueOf(String.valueOf(request.getSession().getAttribute("userId")));
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        try {
            List<BowuguanEntity> bowuguanList = 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){
                            //循环
                            BowuguanEntity bowuguanEntity = new BowuguanEntity();
//                            bowuguanEntity.setBowuguanName(data.get(0));                    //博物馆名称 要改的
//                            bowuguanEntity.setBowuguanUuidNumber(data.get(0));                    //博物馆编号 要改的
//                            bowuguanEntity.setBowuguanPhoto("");//详情和图片
//                            bowuguanEntity.setBowuguanAddress(data.get(0));                    //博物馆地点 要改的
//                            bowuguanEntity.setBowuguanTypes(Integer.valueOf(data.get(0)));   //博物馆分类 要改的
//                            bowuguanEntity.setBowuguanContent("");//详情和图片
//                            bowuguanEntity.setBowuguanKucunNumber(Integer.valueOf(data.get(0)));   //每天最大人数上限 要改的
//                            bowuguanEntity.setBowuguanDelete(1);//逻辑删除字段
//                            bowuguanEntity.setInsertTime(date);//时间
//                            bowuguanEntity.setCreateTime(date);//时间
                            bowuguanList.add(bowuguanEntity);


                            //把要查询是否重复的字段放入map中
                                //博物馆编号
                                if(seachFields.containsKey("bowuguanUuidNumber")){
                                    List<String> bowuguanUuidNumber = seachFields.get("bowuguanUuidNumber");
                                    bowuguanUuidNumber.add(data.get(0));//要改的
                                }else{
                                    List<String> bowuguanUuidNumber = new ArrayList<>();
                                    bowuguanUuidNumber.add(data.get(0));//要改的
                                    seachFields.put("bowuguanUuidNumber",bowuguanUuidNumber);
                                }
                        }

                        //查询是否重复
                         //博物馆编号
                        List<BowuguanEntity> bowuguanEntities_bowuguanUuidNumber = bowuguanService.selectList(new EntityWrapper<BowuguanEntity>().in("bowuguan_uuid_number", seachFields.get("bowuguanUuidNumber")).eq("bowuguan_delete", 1));
                        if(bowuguanEntities_bowuguanUuidNumber.size() >0 ){
                            ArrayList<String> repeatFields = new ArrayList<>();
                            for(BowuguanEntity s:bowuguanEntities_bowuguanUuidNumber){
                                repeatFields.add(s.getBowuguanUuidNumber());
                            }
                            return R.error(511,"数据库的该表中的 [博物馆编号] 字段已经存在 存在数据为:"+repeatFields.toString());
                        }
                        bowuguanService.insertBatch(bowuguanList);
                        return R.ok();
                    }
                }
            }
        }catch (Exception e){
            e.printStackTrace();
            return R.error(511,"批量插入数据异常，请联系管理员");
        }
    }




    /**
    * 个性推荐
    */
    @IgnoreAuth
    @RequestMapping("/gexingtuijian")
    public R gexingtuijian(@RequestParam Map<String, Object> params, HttpServletRequest request){
        logger.debug("gexingtuijian方法:,,Controller:{},,params:{}",this.getClass().getName(),JSONObject.toJSONString(params));
        CommonUtil.checkMap(params);
        List<BowuguanView> returnBowuguanViewList = new ArrayList<>();

        //查询订单
        Map<String, Object> params1 = new HashMap<>(params);params1.put("sort","id");params1.put("yonghuId",request.getSession().getAttribute("userId"));
        PageUtils pageUtils = bowuguanOrderService.queryPage(params1);
        List<BowuguanOrderView> orderViewsList =(List<BowuguanOrderView>)pageUtils.getList();
        Map<Integer,Integer> typeMap=new HashMap<>();//购买的类型list
        for(BowuguanOrderView orderView:orderViewsList){
            Integer bowuguanTypes = orderView.getBowuguanTypes();
            if(typeMap.containsKey(bowuguanTypes)){
                typeMap.put(bowuguanTypes,typeMap.get(bowuguanTypes)+1);
            }else{
                typeMap.put(bowuguanTypes,1);
            }
        }
        List<Integer> typeList = new ArrayList<>();//排序后的有序的类型 按最多到最少
        typeMap.entrySet().stream().sorted((o1, o2) -> o2.getValue() - o1.getValue()).forEach(e -> typeList.add(e.getKey()));//排序
        Integer limit = Integer.valueOf(String.valueOf(params.get("limit")));
        for(Integer type:typeList){
            Map<String, Object> params2 = new HashMap<>(params);params2.put("bowuguanTypes",type);
            PageUtils pageUtils1 = bowuguanService.queryPage(params2);
            List<BowuguanView> bowuguanViewList =(List<BowuguanView>)pageUtils1.getList();
            returnBowuguanViewList.addAll(bowuguanViewList);
            if(returnBowuguanViewList.size()>= limit) break;//返回的推荐数量大于要的数量 跳出循环
        }
        //正常查询出来商品,用于补全推荐缺少的数据
        PageUtils page = bowuguanService.queryPage(params);
        if(returnBowuguanViewList.size()<limit){//返回数量还是小于要求数量
            int toAddNum = limit - returnBowuguanViewList.size();//要添加的数量
            List<BowuguanView> bowuguanViewList =(List<BowuguanView>)page.getList();
            for(BowuguanView bowuguanView:bowuguanViewList){
                Boolean addFlag = true;
                for(BowuguanView returnBowuguanView:returnBowuguanViewList){
                    if(returnBowuguanView.getId().intValue() ==bowuguanView.getId().intValue()) addFlag=false;//返回的数据中已存在此商品
                }
                if(addFlag){
                    toAddNum=toAddNum-1;
                    returnBowuguanViewList.add(bowuguanView);
                    if(toAddNum==0) break;//够数量了
                }
            }
        }else {
            returnBowuguanViewList = returnBowuguanViewList.subList(0, limit);
        }

        for(BowuguanView c:returnBowuguanViewList)
            dictionaryService.dictionaryConvert(c, request);
        page.setList(returnBowuguanViewList);
        return R.ok().put("data", page);
    }

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

        CommonUtil.checkMap(params);
        PageUtils page = bowuguanService.queryPage(params);

        //字典表数据转换
        List<BowuguanView> list =(List<BowuguanView>)page.getList();
        for(BowuguanView 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);
        BowuguanEntity bowuguan = bowuguanService.selectById(id);
            if(bowuguan !=null){


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

                //修改对应字典表字段
                dictionaryService.dictionaryConvert(view, request);
                return R.ok().put("data", view);
            }else {
                return R.error(511,"查不到数据");
            }
    }


    /**
    * 前端保存
    */
    @RequestMapping("/add")
    public R add(@RequestBody BowuguanEntity bowuguan, HttpServletRequest request){
        logger.debug("add方法:,,Controller:{},,bowuguan:{}",this.getClass().getName(),bowuguan.toString());
        Wrapper<BowuguanEntity> queryWrapper = new EntityWrapper<BowuguanEntity>()
            .eq("bowuguan_name", bowuguan.getBowuguanName())
            .eq("bowuguan_uuid_number", bowuguan.getBowuguanUuidNumber())
            .eq("bowuguan_address", bowuguan.getBowuguanAddress())
            .eq("bowuguan_types", bowuguan.getBowuguanTypes())
            .eq("bowuguan_kucun_number", bowuguan.getBowuguanKucunNumber())
            .eq("bowuguan_delete", bowuguan.getBowuguanDelete())
            ;
        logger.info("sql语句:"+queryWrapper.getSqlSegment());
        BowuguanEntity bowuguanEntity = bowuguanService.selectOne(queryWrapper);
        if(bowuguanEntity==null){
            bowuguan.setBowuguanDelete(1);
            bowuguan.setInsertTime(new Date());
            bowuguan.setCreateTime(new Date());
        bowuguanService.insert(bowuguan);

            return R.ok();
        }else {
            return R.error(511,"表中有相同数据");
        }
    }

}
BaiduUtil.java
package com.utils;

import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.URL;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.json.JSONObject;


/**
* @author yangliyuan
* @version 创建时间：2020年2月7日 下午9:37:05
* 类说明 : 
*/

public class BaiduUtil {
	
    /**
     * 根据经纬度获得省市区信息
     * @param lon 纬度
     * @param lat 经度
     * @param coordtype 经纬度坐标系
     * @return
     */
    public static Map<String, String> getCityByLonLat(String key, String lng, String lat) {
        String location = lat + "," + lng;
        try {
            //拼装url
            String url = "http://api.map.baidu.com/reverse_geocoding/v3/?ak="+key+"&output=json&coordtype=wgs84ll&location="+location;
            String result = HttpClientUtils.doGet(url);
            JSONObject o = new JSONObject(result);
            Map<String, String> area = new HashMap<>();
			area.put("province", o.getJSONObject("result").getJSONObject("addressComponent").getString("province"));
			area.put("city", o.getJSONObject("result").getJSONObject("addressComponent").getString("city"));
			area.put("district", o.getJSONObject("result").getJSONObject("addressComponent").getString("district"));
			area.put("street", o.getJSONObject("result").getJSONObject("addressComponent").getString("street"));
            return area;
        }catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
	     * 获取API访问token
	     * 该token有一定的有效期，需要自行管理，当失效时需重新获取.
	     * @param ak - 百度云官网获取的 API Key
	     * @param sk - 百度云官网获取的 Securet Key
	     * @return assess_token
	     */
    public static String getAuth(String ak, String sk) {
        // 获取token地址
        String authHost = "https://aip.baidubce.com/oauth/2.0/token?";
        String getAccessTokenUrl = authHost
                // 1. grant_type为固定参数
                + "grant_type=client_credentials"
                // 2. 官网获取的 API Key
                + "&client_id=" + ak
                // 3. 官网获取的 Secret Key
                + "&client_secret=" + sk;
        try {
            URL realUrl = new URL(getAccessTokenUrl);
            // 打开和URL之间的连接
            HttpURLConnection connection = (HttpURLConnection) realUrl.openConnection();
            connection.setRequestMethod("GET");
            connection.connect();
            // 获取所有响应头字段
            Map<String, List<String>> map = connection.getHeaderFields();
            // 遍历所有的响应头字段
            for (String key : map.keySet()) {
                System.err.println(key + "--->" + map.get(key));
            }
            // 定义 BufferedReader输入流来读取URL的响应
            BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
            String result = "";
            String line;
            while ((line = in.readLine()) != null) {
                result += line;
            }
            /**
             * 返回结果示例
             */
            System.err.println("result:" + result);
            org.json.JSONObject jsonObject = new org.json.JSONObject(result);
            String access_token = jsonObject.getString("access_token");
            return access_token;
        } catch (Exception e) {
            System.err.printf("获取token失败！");
            e.printStackTrace(System.err);
        }
        return null;
    }

}
ConfigServiceImpl.java

package com.service.impl;


import java.util.Map;

import org.springframework.stereotype.Service;

import com.baomidou.mybatisplus.mapper.EntityWrapper;
import com.baomidou.mybatisplus.plugins.Page;
import com.baomidou.mybatisplus.service.impl.ServiceImpl;
import com.dao.ConfigDao;
import com.entity.ConfigEntity;
import com.service.ConfigService;
import com.utils.PageUtils;
import com.utils.Query;


/**
 * 系统用户
 * @author yangliyuan
 * @date 2019年10月10日 上午9:17:59
 */
@Service("configService")
public class ConfigServiceImpl extends ServiceImpl<ConfigDao, ConfigEntity> implements ConfigService {
	@Override
	public PageUtils queryPage(Map<String, Object> params) {
		Page<ConfigEntity> page = this.selectPage(
                new Query<ConfigEntity>(params).getPage(),
                new EntityWrapper<ConfigEntity>()
        );
        return new PageUtils(page);
	}
}
add-or-update.vue
<template>
    <div class="addEdit-block">
        <el-form
                class="detail-form-content"
                ref="ruleForm"
                :model="ruleForm"
                :rules="rules"
                label-width="auto"
                :style="{backgroundColor:addEditForm.addEditBoxColor}"
        >
            <el-row>
                <el-col :span="12">
                    <el-form-item class="input" v-if="type!='info'"  label="性别类型编码" prop="codeIndex">
                        <el-input v-model="ruleForm.codeIndex"
                                  placeholder="性别类型编码" clearable  :readonly="ro.codeIndex"></el-input>
                    </el-form-item>
                    <div v-else>
                        <el-form-item class="input" label="性别类型编码" prop="codeIndex">
                            <el-input v-model="ruleForm.codeIndex"
                                      placeholder="性别类型编码" readonly></el-input>
                        </el-form-item>
                    </div>
                </el-col>
                <el-col :span="12">
                    <el-form-item class="input" v-if="type!='info'"  label="性别类型" prop="indexName">
                        <el-input v-model="ruleForm.indexName"
                                  placeholder="性别类型" clearable  :readonly="ro.indexName"></el-input>
                    </el-form-item>
                    <div v-else>
                        <el-form-item class="input" label="性别类型" prop="indexName">
                            <el-input v-model="ruleForm.indexName"
                                      placeholder="性别类型" readonly></el-input>
                        </el-form-item>
                    </div>
                </el-col>
                <!--<el-col :span="12">
                    <el-form-item class="input" v-if="type!='info'"  label="备注" prop="beizhu">
                        <el-input v-model="ruleForm.beizhu"
                                  placeholder="备注" clearable  :readonly="ro.beizhu"></el-input>
                    </el-form-item>
                    <div v-else>
                        <el-form-item class="input" label="备注" prop="beizhu">
                            <el-input v-model="ruleForm.beizhu"
                                      placeholder="备注" readonly></el-input>
                        </el-form-item>
                    </div>
                </el-col>-->
            </el-row>
            <el-form-item class="btn">
                <el-button v-if="type!='info'" type="primary" class="btn-success" @click="onSubmit">提交</el-button>
                <el-button v-if="type!='info'" class="btn-close" @click="back()">取消</el-button>
                <el-button v-if="type=='info'" class="btn-close" @click="back()">返回</el-button>
            </el-form-item>
        </el-form>


    </div>
</template>
<script>
    import styleJs from "../../../utils/style.js";
    // 数字，邮件，手机，url，身份证校验
    import { isNumber,isIntNumer,isEmail,isPhone, isMobile,isURL,checkIdCard } from "@/utils/validate";
    export default {
        data() {
            let self = this
            return {
                addEditForm:null,
                id: '',
                type: '',
                ro:{
                    codeIndex : true,
                    indexName : false,
                    superId : false,
                    beizhu : false,
                },
                ruleForm: {
                    codeIndex: '',
                    indexName: '',
                    superId : '',
                    beizhu : '',
                },
                rules: {
                    /*beizhu: [
                        { required: true, message: '备注不能为空', trigger: 'blur' },
                        {  pattern: /^[1-9]\d*$/,
                            message: '备注只能为正整数',
                            trigger: 'blur'
                        }
                    ],*/
                }
            };
        },
        props: ["parent"],
        computed: {
        },
        created() {
            this.addEditForm = styleJs.addStyle();
            this.addEditStyleChange()
            this.addEditUploadStyleChange()
        },
        methods: {
            // 初始化
            init(id,type) {
                if (id) {
                    this.id = id;
                    this.type = type;
                }
                if(this.type=='info'||this.type=='else'){
                    this.info(id);
                }else{
                    //查询最大值 start
                    this.$http({
                        url: `dictionary/maxCodeIndex`,
                        method: "post",
                        data: {"dicCode":"sex_types"}
                    }).then(({ data }) => {
                        if (data && data.code === 0) {
                            this.ruleForm.codeIndex = data.maxCodeIndex;
                        } else {
                            this.$message.error(data.msg);
                        }
                    });
                    //查询最大值 end
                }
            },
            // 多级联动参数
            info(id) {
                this.$http({
                    url: `dictionary/info/${id}`,
                    method: "get"
                }).then(({ data }) => {
                    if (data && data.code === 0) {
                    this.ruleForm = data.data;
                    //解决前台上传图片后台不显示的问题
                    let reg=new RegExp('../../../upload','g')//g代表全部
                } else {
                    this.$message.error(data.msg);
                }
            });
            },
            // 提交
            onSubmit() {
                if((!this.ruleForm.indexName)){
                    this.$message.error('性别类型不能为空');
                    return
                }
                this.$refs["ruleForm"].validate(valid => {
                    if (valid) {
                        let ruleForm = this.ruleForm;
                        ruleForm["dicCode"]="sex_types";
                        ruleForm["dicName"]="性别类型";
                        this.$http({
                            url: `dictionary/${!this.ruleForm.id ? "save" : "update"}`,
                            method: "post",
                            data: ruleForm
                        }).then(({ data }) => {
                            if (data && data.code === 0) {
                                this.$message({
                                    message: "操作成功",
                                    type: "success",
                                    duration: 1500,
                                    onClose: () => {
                                        this.parent.showFlag = true;
                                        this.parent.addOrUpdateFlag = false;
                                        this.parent.dictionaryCrossAddOrUpdateFlag = false;
                                        this.parent.search();
                                        this.parent.contentStyleChange();

                                    }
                                });
                            } else {
                                this.$message.error(data.msg);
                            }
                        });
                    }
                });
            },
            // 返回
            back() {
                this.parent.showFlag = true;
                this.parent.addOrUpdateFlag = false;
                this.parent.dictionaryCrossAddOrUpdateFlag = false;
                this.parent.contentStyleChange();
            },
            addEditStyleChange() {
                this.$nextTick(()=>{
                    // input
                    document.querySelectorAll('.addEdit-block .input .el-input__inner').forEach(el=>{
                    el.style.height = this.addEditForm.inputHeight
                el.style.color = this.addEditForm.inputFontColor
                el.style.fontSize = this.addEditForm.inputFontSize
                el.style.borderWidth = this.addEditForm.inputBorderWidth
                el.style.borderStyle = this.addEditForm.inputBorderStyle
                el.style.borderColor = this.addEditForm.inputBorderColor
                el.style.borderRadius = this.addEditForm.inputBorderRadius
                el.style.backgroundColor = this.addEditForm.inputBgColor
            })
                document.querySelectorAll('.addEdit-block .input .el-form-item__label').forEach(el=>{
                    el.style.lineHeight = this.addEditForm.inputHeight
                el.style.color = this.addEditForm.inputLableColor
                el.style.fontSize = this.addEditForm.inputLableFontSize
            })
                // select
                document.querySelectorAll('.addEdit-block .select .el-input__inner').forEach(el=>{
                    el.style.height = this.addEditForm.selectHeight
                el.style.color = this.addEditForm.selectFontColor
                el.style.fontSize = this.addEditForm.selectFontSize
                el.style.borderWidth = this.addEditForm.selectBorderWidth
                el.style.borderStyle = this.addEditForm.selectBorderStyle
                el.style.borderColor = this.addEditForm.selectBorderColor
                el.style.borderRadius = this.addEditForm.selectBorderRadius
                el.style.backgroundColor = this.addEditForm.selectBgColor
            })
                document.querySelectorAll('.addEdit-block .select .el-form-item__label').forEach(el=>{
                    el.style.lineHeight = this.addEditForm.selectHeight
                el.style.color = this.addEditForm.selectLableColor
                el.style.fontSize = this.addEditForm.selectLableFontSize
            })
                document.querySelectorAll('.addEdit-block .select .el-select__caret').forEach(el=>{
                    el.style.color = this.addEditForm.selectIconFontColor
                el.style.fontSize = this.addEditForm.selectIconFontSize
            })
                // date
                document.querySelectorAll('.addEdit-block .date .el-input__inner').forEach(el=>{
                    el.style.height = this.addEditForm.dateHeight
                el.style.color = this.addEditForm.dateFontColor
                el.style.fontSize = this.addEditForm.dateFontSize
                el.style.borderWidth = this.addEditForm.dateBorderWidth
                el.style.borderStyle = this.addEditForm.dateBorderStyle
                el.style.borderColor = this.addEditForm.dateBorderColor
                el.style.borderRadius = this.addEditForm.dateBorderRadius
                el.style.backgroundColor = this.addEditForm.dateBgColor
            })
                document.querySelectorAll('.addEdit-block .date .el-form-item__label').forEach(el=>{
                    el.style.lineHeight = this.addEditForm.dateHeight
                el.style.color = this.addEditForm.dateLableColor
                el.style.fontSize = this.addEditForm.dateLableFontSize
            })
                document.querySelectorAll('.addEdit-block .date .el-input__icon').forEach(el=>{
                    el.style.color = this.addEditForm.dateIconFontColor
                el.style.fontSize = this.addEditForm.dateIconFontSize
                el.style.lineHeight = this.addEditForm.dateHeight
            })
                // upload
                let iconLineHeight = parseInt(this.addEditForm.uploadHeight) - parseInt(this.addEditForm.uploadBorderWidth) * 2 + 'px'
                document.querySelectorAll('.addEdit-block .upload .el-upload--picture-card').forEach(el=>{
                    el.style.width = this.addEditForm.uploadHeight
                el.style.height = this.addEditForm.uploadHeight
                el.style.borderWidth = this.addEditForm.uploadBorderWidth
                el.style.borderStyle = this.addEditForm.uploadBorderStyle
                el.style.borderColor = this.addEditForm.uploadBorderColor
                el.style.borderRadius = this.addEditForm.uploadBorderRadius
                el.style.backgroundColor = this.addEditForm.uploadBgColor
            })
                document.querySelectorAll('.addEdit-block .upload .el-form-item__label').forEach(el=>{
                    el.style.lineHeight = this.addEditForm.uploadHeight
                el.style.color = this.addEditForm.uploadLableColor
                el.style.fontSize = this.addEditForm.uploadLableFontSize
            })
                document.querySelectorAll('.addEdit-block .upload .el-icon-plus').forEach(el=>{
                    el.style.color = this.addEditForm.uploadIconFontColor
                el.style.fontSize = this.addEditForm.uploadIconFontSize
                el.style.lineHeight = iconLineHeight
                el.style.display = 'block'
            })
                // 多文本输入框
                document.querySelectorAll('.addEdit-block .textarea .el-textarea__inner').forEach(el=>{
                    el.style.height = this.addEditForm.textareaHeight
                el.style.color = this.addEditForm.textareaFontColor
                el.style.fontSize = this.addEditForm.textareaFontSize
                el.style.borderWidth = this.addEditForm.textareaBorderWidth
                el.style.borderStyle = this.addEditForm.textareaBorderStyle
                el.style.borderColor = this.addEditForm.textareaBorderColor
                el.style.borderRadius = this.addEditForm.textareaBorderRadius
                el.style.backgroundColor = this.addEditForm.textareaBgColor
            })
                document.querySelectorAll('.addEdit-block .textarea .el-form-item__label').forEach(el=>{
                    // el.style.lineHeight = this.addEditForm.textareaHeight
                    el.style.color = this.addEditForm.textareaLableColor
                el.style.fontSize = this.addEditForm.textareaLableFontSize
            })
                // 保存
                document.querySelectorAll('.addEdit-block .btn .btn-success').forEach(el=>{
                    el.style.width = this.addEditForm.btnSaveWidth
                el.style.height = this.addEditForm.btnSaveHeight
                el.style.color = this.addEditForm.btnSaveFontColor
                el.style.fontSize = this.addEditForm.btnSaveFontSize
                el.style.borderWidth = this.addEditForm.btnSaveBorderWidth
                el.style.borderStyle = this.addEditForm.btnSaveBorderStyle
                el.style.borderColor = this.addEditForm.btnSaveBorderColor
                el.style.borderRadius = this.addEditForm.btnSaveBorderRadius
                el.style.backgroundColor = this.addEditForm.btnSaveBgColor
            })
                // 返回
                document.querySelectorAll('.addEdit-block .btn .btn-close').forEach(el=>{
                    el.style.width = this.addEditForm.btnCancelWidth
                el.style.height = this.addEditForm.btnCancelHeight
                el.style.color = this.addEditForm.btnCancelFontColor
                el.style.fontSize = this.addEditForm.btnCancelFontSize
                el.style.borderWidth = this.addEditForm.btnCancelBorderWidth
                el.style.borderStyle = this.addEditForm.btnCancelBorderStyle
                el.style.borderColor = this.addEditForm.btnCancelBorderColor
                el.style.borderRadius = this.addEditForm.btnCancelBorderRadius
                el.style.backgroundColor = this.addEditForm.btnCancelBgColor
            })
            })
            },
            addEditUploadStyleChange() {
                this.$nextTick(()=>{
                    document.querySelectorAll('.addEdit-block .upload .el-upload-list--picture-card .el-upload-list__item').forEach(el=>{
                    el.style.width = this.addEditForm.uploadHeight
                el.style.height = this.addEditForm.uploadHeight
                el.style.borderWidth = this.addEditForm.uploadBorderWidth
                el.style.borderStyle = this.addEditForm.uploadBorderStyle
                el.style.borderColor = this.addEditForm.uploadBorderColor
                el.style.borderRadius = this.addEditForm.uploadBorderRadius
                el.style.backgroundColor = this.addEditForm.uploadBgColor
            })
            })
            },
        }
    };
</script>
<style lang="scss">
.editor{
  height: 500px;

  & /deep/ .ql-container {
	  height: 310px;
  }
}
.amap-wrapper {
  width: 100%;
  height: 500px;
}
.search-box {
  position: absolute;
}
.addEdit-block {
	margin: -10px;
}
.detail-form-content {
	padding: 12px;
	background-color: transparent;
}
.btn .el-button {
  padding: 0;
}</style>

声明

本博客适用于广泛的学术和教育用途，包括但不限于个人学习、开发设计，产品设计。仅供学习参考，旨在为读者提供深入理解和学术研究的材料。

赐你岁月如歌
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot492基于java线上历史馆藏系统pf.zip
06-24
【标题】"springboot492基于java线上历史馆藏系统pf"是一个使用Spring Boot框架构建的线上历史馆藏管理系统的项目。这个系统可能旨在提供一个高效、安全且用户友好的平台，用于存储、管理和展示历史文物或文献的数字...
基于java线上历史馆藏系统论文-java-毕设-论文-基于java线上历史馆藏系统文档
02-22
综上所述，基于Java的线上历史馆藏系统采用了现代化的技术栈，不仅实现了对历史馆藏信息的有效管理，还提供了良好的用户体验。通过上述关键技术和设计策略的应用，该系统能够有效地服务于目标用户群体，满足其对历史...
Java毕业设计174例，包含部署视频
热门推荐
biyesheji1000的专栏
04-27 4万+
基于Java的毕业设计，包含部署视频，一步一步教你加载数据库，运行，功能演示
各类Springboot管理系统源码获取
qq_26185495的博客
03-30 1011
获取方式+vx: lwbabinabin springboot001基于SpringBoot的在线拍卖系统 springboot002基于springboot的医护人员排班系统springboot003图书个性化推荐系统的设计与实现springboot004网页时装购物系统springboot005学生心理咨询评估系统springboot006基于SpringBoot的网上订餐系统springboot007大学生租房平台的设计与实现springboot008房屋租赁系统springboot009月度员工绩
2024年最全的软件项目分享：2000+软件项目
m0_72438098的博客
12-23 4357
计算机软件毕业设计选题 选题方向 毕设题目 项目演示 电商后台管理系统 点击这里查看演示 下载资源 图书推荐系统 点击这里查看演示 下载资源 学生选课系统 点击这里查看演示 下载资源 宿舍管理系统 点击这里查看演示 下载资源 基于协同过滤算法的乐购商城 点击这里查看演示 下载资源 校医院管理系统 点击这里查看演示 下载资源
2024年1000个计算机毕业设计项目推荐（源码+论文【万字】）
计算机程序定制、毕业项目
03-19 2526
2024年最新1000个计算机毕业设计项目推荐（源码+论文【万字】）2024年最新计算机毕业设计题目推荐，项目汇总！本科、专科。项目设计、项目定制、辅导、万字文档 | 技术栈包括但不限于：Java、JavaWeb、SSM、SpringBoot、JS、CSS、vue、Python。小程序。 管理系统、在线商城、二手交易、个人博客、小程序系统等。
基于java线上历史馆藏系统.zip
04-07
1、技术栈：java,springboot,vue，ajax，maven，mysql，MyBatisPlus等 开发语言：Java 框架：SpringBoot JDK版本：JDK1.8 数据库：mysql 5.7 数据库工具：SQLyog/Navicat 开发软件：eclipse/myeclipse/idea Maven包...
接口测试及常用接口测试工具
2301_78276982的博客
08-15 1072
接口一般来说有两种，一种是程序内部的接口，一种是系统对外的接口。系统对外的接口：比如你要从别的网站或服务器上获取资源或信息，别人肯定不会把数据库共享给你，他只能给你提供一个他们写好的方法来获取数据，你引用他提供的接口就能使用他写好的方法，从而达到数据共享的目的，比如说咱们用的app、网址这些它在进行数据处理的时候都是通过接口来进行调用的。
队列(笔记)
m0_62024160的博客
08-18 889
① 操作系统中的进程管理：可以控制进程执行的优先级(例如(大概过程，实际情况比这个复杂)：后台同时挂着游戏和工作软件，现在想打游戏，就把游戏放在首位，CPU、显卡等硬件都先给它用；③ 使用链表实现队列的条件：只顾头尾，甚至只顾头(例如：银行办理业务时谁先来先办理谁的，不会说先挨个问一下每个人办理什么业务，突然让某个人插个队或者说因为队伍最后一个人前面的人太多，就先给最后那个人办理)① 优点：链表有头指针和尾指针，这正好满足了队列的条件(只需要处理头(前端)和尾(后端)，一个删除，一个插入)
SQL— DDL语句学习【后端 9】
delepaste的博客
08-15 1557
DDL是SQL中用于定义数据库结构的部分，它允许我们创建、修改或删除数据库对象。在数据库设计阶段，DDL语句是不可或缺的工具。
微信云开发云存储 下载全部文件
u014288878的博客
08-17 319
首先按照这个按照好依赖。
Django后端架构开发：视图与模板的正确使用
weixin_52392194的博客
08-17 1100
以上内容涵盖了Django视图与模板的各个方面，并提供了深入的代码示例与详细的解释。
vue项目开发记录1：为v-html内的img元素添加点击放大效果
qq_41057206的博客
08-20 174
内容
从0到1学会nginx分布式框架
最新发布
qq_34820371的博客
08-20 534
同源策略是一种约定，由 Netscape 公司 1995 年引入浏览器，它是浏览器最核心也最基本的安全功能，如果缺少了同源策略，浏览器很容易受到 XSS、CSFR 等攻击。所谓同源是指"协议+域名+端口"三者相同， 即便两个不同的域名指向同一个 ip 地址，也非同源。Referer 是 Header 的一部分，当浏览器向 Web 服务器发送请求的时候，一般会带上 Referer，告诉服务器该请求是从哪个页面链接过来的，服务器就可以禁止或允许某些来源的网站访问资源。
LVS原理简介
2301_76842366的博客
08-16 871
可伸缩网络服务有很多结构，但都有一个共同点：它们都需要一个前端的负载调度器。而实现虚拟网络服务的主要技术指出IP负载均衡技术是在负载调度器的实现技术里面效率最高的一个。在已有的IP负载均衡技术中，主要有通过网络地址转换将一组服务器构成一个高性能的、高可用的虚拟服务器，通常称为VS/NAT技术。在分析VS/NAT的缺点和网络服务的非对称的基础上，可以通过IP隧道实现虚拟服务器的方法VS/TUN和通过直接路由实现虚拟服务器的方法VS/DR，它们可以极大地提高系统的伸缩性。
使用WebStorm进行高效的全栈JavaScript开发
vvvae1234的博客
08-17 883
WebStorm是由JetBrains出品的一款强大的JavaScript IDE，适用于开发现代的Web应用程序。它提供了一系列特性，包括智能代码补全、实时错误检查、调试工具、版本控制集成以及支持多种前端和后端框架（如React、Angular、Node.js等）。这些强大的功能使得WebStorm成为全栈JavaScript开发的理想选择。
nginx代理转发如何配置
weixin_42795092的博客
08-16 339
访问时根据server端配制得域名去访问如:http://localhost/path1/或http://localhost/path2去访问对应的界面。指令用于设置转发给后端服务器时的请求头，以确保后端服务器能获取到正确的原始请求信息。指令指定了转发请求到的后端服务器地址和端口。块定义了所有的入站请求将匹配这个位置。为你的后端服务器的实际IP地址和端口。表示Nginx监听80端口。
haproxy实验
2302_77150007的博客
08-17 642
haproxy实验
基于java的图书管理系统的需求分析
06-01
一、引言 随着信息技术的飞速发展，计算机在管理领域的应用越来越广泛，图书管理系统是其中一个重要的应用领域。本文将对基于Java的图书管理系统进行需求分析，旨在明确系统的功能、性能、安全等需求，以便于后续的设计和开发。 二、功能需求 1. 图书信息管理：对图书的基本信息包括书名、作者、出版社、价格、馆藏数量等进行录入、修改、查询和删除等操作。 2. 借阅管理：借书、还书、续借和预约等功能。 3. 读者管理：读者信息的录入、修改、查询和删除等操作。 4. 系统管理：包括系统用户管理、权限管理、日志管理等。 5. 统计报表：生成图书借阅、还书、预约等统计报表，方便管理员进行数据分析和管理决策。 三、性能需求 1. 系统响应时间：系统应具备良好的响应速度，用户在进行操作时不会出现明显的等待时间。 2. 并发处理能力：系统应支持多用户同时进行操作，不会出现数据冲突等问题。 3. 数据存储和处理能力：系统应具有高效的数据存储和处理能力，保证数据的完整性和安全性。 四、安全需求 1. 用户身份验证：系统应具备用户身份验证功能，保证系统只能被授权用户操作。 2. 数据备份和恢复：系统应具有数据备份和恢复功能，保证数据在系统故障或人为损坏时能够及时恢复。 3. 数据加密：系统应对重要的数据进行加密，保证数据的机密性和安全性。 五、总结 本文对基于Java的图书管理系统进行了需求分析，明确了系统的功能、性能和安全等需求。在后续的设计和开发过程中，应根据这些需求进行详细设计和开发，以保证系统的高效性和安全性。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值