Compare commits

...

10 Commits
master ... ljc

Author SHA1 Message Date
pxake4hfp bfec87ad22 LJC
10 months ago
刘嘉成 230456050d Default Changelist
10 months ago
刘嘉成 7813bbbc1e Default Changelist
10 months ago
刘嘉成 d4098d3752 Default Changelist
10 months ago
刘嘉成 3f9ca4d387 Default Changelist
10 months ago
刘嘉成 bb0ad1f0ee Default Changelist
10 months ago
刘嘉成 60b677c77d Default Changelist
10 months ago
刘嘉成 ef069267d3 Default Changelist
10 months ago
刘嘉成 7db9097d2c Default Changelist
10 months ago
刘嘉成 e83197b6ab Default Changelist
10 months ago

@ -1,15 +1,26 @@
<component name="ArtifactManager">
<!-- 定义一个名为ArtifactManager的组件用于管理项目的工件artifact相关配置 -->
<artifact type="war" name="lingshiyqfkglsys">
<!-- 定义一个类型为war的工件名称为lingshiyqfkglsys -->
<output-path>$PROJECT_DIR$/out/artifacts/lingshiyqfkglsys</output-path>
<!-- 设置工件的输出路径,使用了变量$PROJECT_DIR$表示项目目录实际路径为项目目录下的out/artifacts/lingshiyqfkglsys -->
<root id="archive" name="lingshiyqfkglsys.war">
<!-- 定义工件的根结构id为archive名称为lingshiyqfkglsys.war -->
<element id="dir-copy" path="$PROJECT_DIR$/web" />
<!-- 定义一个元素类型为目录复制dir-copy复制的路径为项目目录下的web目录 -->
<element id="directory" name="WEB-INF">
<!-- 定义一个名为WEB-INF的目录元素 -->
<element id="directory" name="classes">
<!-- 在WEB-INF目录下定义一个名为classes的目录元素 -->
<element id="module-output" name="lsepidemicsituationsystem" />
<!-- 在classes目录下定义一个模块输出元素名称为lsepidemicsituationsystem -->
</element>
<element id="directory" name="lib">
<!-- 在WEB-INF目录下定义一个名为lib的目录元素 -->
<element id="library" level="project" name="jcommon-1.0.23" />
<!-- 在lib目录下定义一个项目级别的库元素名称为jcommon-1.0.23 -->
<element id="library" level="project" name="standard" />
<!-- 在lib目录下定义另一个项目级别的库元素名称为standard -->
</element>
</element>
</root>

@ -1,15 +1,39 @@
<component name="ArtifactManager">
<!-- 定义一个名为ArtifactManager的组件这个组件主要用于管理项目的工件artifact
比如定义如何打包、包含哪些文件等相关配置 -->
<artifact type="war" name="lingshiyqfkglsystem">
<!-- 定义一个类型为warWeb应用归档文件的工件名称为lingshiyqfkglsystem。
这意味着该工件会被打包成一个可部署的Web应用程序归档 -->
<output-path>$PROJECT_DIR$/out/artifacts/lingshiyqfkglsystem</output-path>
<!-- 设置工件的输出路径。这里使用了变量$PROJECT_DIR$,它通常表示项目的根目录。
实际的输出路径是项目目录下的out/artifacts/lingshiyqfkglsystem目录
最终生成的war文件会放在这个路径下 -->
<root id="archive" name="lingshiyqfkglsystem.war">
<!-- 定义工件的根结构。id为archive名称为lingshiyqfkglsystem.war
表示这个根结构对应的是最终生成的war文件 -->
<element id="dir-copy" path="$PROJECT_DIR$/web" />
<!-- 定义一个元素其id为dir-copy表示进行目录复制操作。
path属性指定了要复制的目录路径为项目目录下的web目录
这意味着web目录下的所有内容都会被复制到生成的war文件中 -->
<element id="directory" name="WEB-INF">
<!-- 定义一个元素类型为目录directory名称为WEB-INF。
在Web应用中WEB-INF目录是一个重要的目录用于存放配置文件、类文件、库文件等 -->
<element id="directory" name="classes">
<!-- 在WEB-INF目录下定义一个子目录元素名称为classes。
classes目录通常用于存放编译后的Java类文件 -->
<element id="module-output" name="lsepidemicsituationsystem" />
<!-- 在classes目录下定义一个模块输出元素名称为lsepidemicsituationsystem。
它可能表示将某个模块的输出内容放置到这个位置 -->
</element>
<element id="directory" name="lib">
<!-- 在WEB-INF目录下定义另一个子目录元素名称为lib。
lib目录通常用于存放项目依赖的库文件 -->
<element id="library" level="project" name="jcommon-1.0.23" />
<!-- 在lib目录下定义一个库元素id为library级别为project项目级别
名称为jcommon-1.0.23。这表示将名为jcommon-1.0.23的库文件包含到war文件的lib目录中 -->
<element id="library" level="project" name="standard" />
<!-- 在lib目录下定义另一个库元素id为library级别为project
名称为standard。这表示将名为standard的库文件包含到war文件的lib目录中 -->
</element>
</element>
</root>

@ -1,15 +1,39 @@
<component name="ArtifactManager">
<!-- 定义了一个名为 ArtifactManager 的组件主要用于管理项目中的工件artifact配置
例如指定工件的类型、名称、输出路径以及包含的内容等。 -->
<artifact type="exploded-war" name="lsepidemicsituationsystem:war exploded">
<!-- 定义了一个工件artifact其类型为 exploded-war展开的 WAR 包,
即未压缩成一个文件,而是以目录结构形式存在,方便开发调试),
名称为 "lsepidemicsituationsystem:war exploded"。 -->
<output-path>$PROJECT_DIR$/out/artifacts/lsepidemicsituationsystem_war_exploded</output-path>
<!-- 设置了该工件的输出路径,使用了变量 $PROJECT_DIR$ 表示项目目录,
实际路径是项目目录下的 out/artifacts/lsepidemicsituationsystem_war_exploded 目录,
生成的展开式 WAR 包内容将放置在此处。 -->
<root id="root">
<!-- 定义了工件的根结构id 为 "root",用于组织工件内的各个元素。 -->
<element id="javaee-facet-resources" facet="lsepidemicsituationsystem/web/Web" />
<!-- 定义了一个元素id 为 "javaee-facet-resources"
facet 属性指定了与该元素相关的方面facet为 "lsepidemicsituationsystem/web/Web"
这可能与 Java EE 相关的资源配置有关,用于指定该工件包含的特定 Web 相关资源。 -->
<element id="directory" name="WEB-INF">
<!-- 定义了一个名为 "WEB-INF" 的目录元素,在 Web 应用中,
WEB-INF 目录是一个重要的目录,用于存放配置文件、类文件、库文件等。 -->
<element id="directory" name="classes">
<!-- 在 WEB-INF 目录下定义了一个名为 "classes" 的子目录元素,
通常用于存放编译后的 Java 类文件。 -->
<element id="module-output" name="lsepidemicsituationsystem" />
<!-- 在 "classes" 目录下定义了一个模块输出元素id 为 "module-output"
名称为 "lsepidemicsituationsystem",可能表示将某个模块的输出内容放置在此处。 -->
</element>
<element id="directory" name="lib">
<!-- 在 WEB-INF 目录下定义了另一个名为 "lib" 的子目录元素,
通常用于存放项目依赖的库文件。 -->
<element id="library" level="project" name="jcommon-1.0.23" />
<!-- 在 "lib" 目录下定义了一个库元素id 为 "library",级别为 "project"(项目级别),
名称为 "jcommon-1.0.23",表示将名为 jcommon-1.0.23 的库文件包含到该工件的 lib 目录中。 -->
<element id="library" level="project" name="standard" />
<!-- 在 "lib" 目录下定义了另一个库元素id 为 "library",级别为 "project"
名称为 "standard",表示将名为 standard 的库文件包含到该工件的 lib 目录中。 -->
</element>
</element>
</root>

@ -1,36 +1,57 @@
<component name="InspectionProjectProfileManager">
<!-- 项目检查配置文件管理器组件,负责管理项目的代码检查规则 -->
<profile version="1.0">
<!-- 配置文件版本为1.0 -->
<option name="myName" value="Project Default" />
<!-- 设置此配置文件的名称为"Project Default",即项目默认配置 -->
<inspection_tool class="JavaDoc" enabled="true" level="WARNING" enabled_by_default="true">
<!-- 启用JavaDoc检查工具设置检查级别为警告默认启用 -->
<option name="TOP_LEVEL_CLASS_OPTIONS">
<!-- 顶级类的JavaDoc检查选项 -->
<value>
<option name="ACCESS_JAVADOC_REQUIRED_FOR" value="none" />
<!-- 不需要为任何访问修饰符的顶级类强制添加JavaDoc -->
<option name="REQUIRED_TAGS" value="" />
<!-- 顶级类的JavaDoc中不需要强制包含特定标签 -->
</value>
</option>
<option name="INNER_CLASS_OPTIONS">
<!-- 内部类的JavaDoc检查选项 -->
<value>
<option name="ACCESS_JAVADOC_REQUIRED_FOR" value="none" />
<!-- 不需要为任何访问修饰符的内部类强制添加JavaDoc -->
<option name="REQUIRED_TAGS" value="" />
<!-- 内部类的JavaDoc中不需要强制包含特定标签 -->
</value>
</option>
<option name="METHOD_OPTIONS">
<!-- 方法的JavaDoc检查选项 -->
<value>
<option name="ACCESS_JAVADOC_REQUIRED_FOR" value="none" />
<!-- 不需要为任何访问修饰符的方法强制添加JavaDoc -->
<option name="REQUIRED_TAGS" value="@return@param@throws or @exception" />
<!-- 方法的JavaDoc中必须包含@return、@param和@throws或@exception标签 -->
</value>
</option>
<option name="FIELD_OPTIONS">
<!-- 字段的JavaDoc检查选项 -->
<value>
<option name="ACCESS_JAVADOC_REQUIRED_FOR" value="none" />
<!-- 不需要为任何访问修饰符的字段强制添加JavaDoc -->
<option name="REQUIRED_TAGS" value="" />
<!-- 字段的JavaDoc中不需要强制包含特定标签 -->
</value>
</option>
<option name="IGNORE_DEPRECATED" value="false" />
<!-- 不忽略@Deprecated注解的元素的JavaDoc检查 -->
<option name="IGNORE_JAVADOC_PERIOD" value="true" />
<!-- 忽略JavaDoc中缺少句点的问题 -->
<option name="IGNORE_DUPLICATED_THROWS" value="false" />
<!-- 不忽略重复的@throws标签 -->
<option name="IGNORE_POINT_TO_ITSELF" value="false" />
<!-- 不忽略JavaDoc中指向自身的引用 -->
<option name="myAdditionalJavadocTags" value="date" />
<!-- 将"date"添加为额外的JavaDoc标签允许使用@date标签 -->
</inspection_tool>
</profile>
</component>

@ -1,12 +1,23 @@
<component name="libraryTable">
<!-- 定义了一个名为 "libraryTable" 的组件,这个组件可能用于管理项目中的库相关信息 -->
<library name="jcommon-1.0.23">
<!-- 定义了一个名为 "jcommon-1.0.23" 的库 -->
<CLASSES>
<!-- 表示该库包含的类的相关配置部分 -->
<root url="jar://$PROJECT_DIR$/web/WEB-INF/lib/jcommon-1.0.23.jar!/" />
<!-- 定义了一个类路径根,指定了库文件 "jcommon-1.0.23.jar" 的位置,
使用了变量 "$PROJECT_DIR$" 表示项目目录,意味着该文件位于项目目录下的 web/WEB-INF/lib 目录中。
"jar://" 表示这是一个 JAR 包的路径格式,"!/" 是这种路径格式的一部分 -->
<root url="jar://$PROJECT_DIR$/web/WEB-INF/lib/jfreechart-1.0.19.jar!/" />
<!-- 定义了另一个类路径根,指向 "jfreechart-1.0.19.jar" 库文件,位置同样在项目的 web/WEB-INF/lib 目录中 -->
<root url="jar://$PROJECT_DIR$/web/WEB-INF/lib/jfreechart-1.0.19-demo.jar!/" />
<!-- 定义了指向 "jfreechart-1.0.19-demo.jar" 库文件的类路径根,在项目的 web/WEB-INF/lib 目录中 -->
<root url="jar://$PROJECT_DIR$/web/WEB-INF/lib/jfreechart-1.0.19-experimental.jar!/" />
<!-- 定义了指向 "jfreechart-1.0.19-experimental.jar" 库文件的类路径根,在项目的 web/WEB-INF/lib 目录中 -->
</CLASSES>
<JAVADOC />
<!-- 表示该库没有相关的 Javadoc 配置(或者这里只是声明了 Javadoc 部分,但没有具体配置内容) -->
<SOURCES />
<!-- 表示该库没有相关的源代码配置(或者这里只是声明了源代码部分,但没有具体配置内容) -->
</library>
</component>

@ -1,20 +1,37 @@
<component name="libraryTable">
<!-- 定义一个名为libraryTable的组件用于管理项目依赖的库 -->
<library name="standard">
<!-- 定义一个名为standard的库包含多个项目依赖的JAR文件 -->
<CLASSES>
<!-- 定义该库的类路径条目 -->
<root url="jar://$PROJECT_DIR$/web/WEB-INF/lib/standard.jar!/" />
<!-- standard.jar可能包含项目自定义的标准工具类 -->
<root url="jar://$PROJECT_DIR$/web/WEB-INF/lib/spring-jdbc-5.1.10.RELEASE.jar!/" />
<!-- Spring JDBC模块提供数据库操作支持 -->
<root url="jar://$PROJECT_DIR$/web/WEB-INF/lib/spring-core-5.1.10.RELEASE.jar!/" />
<!-- Spring核心模块提供IoC和依赖注入功能 -->
<root url="jar://$PROJECT_DIR$/web/WEB-INF/lib/mysql-connector-java-5.1.48.jar!/" />
<!-- MySQL JDBC驱动用于连接MySQL数据库 -->
<root url="jar://$PROJECT_DIR$/web/WEB-INF/lib/druid-1.0.9.jar!/" />
<!-- Druid连接池阿里巴巴开源的高性能数据库连接池 -->
<root url="jar://$PROJECT_DIR$/web/WEB-INF/lib/commons-beanutils-1.8.3.jar!/" />
<!-- Apache BeanUtils用于JavaBean操作的工具库 -->
<root url="jar://$PROJECT_DIR$/web/WEB-INF/lib/c3p0-0.9.5.2.jar!/" />
<!-- C3P0连接池另一种常用的数据库连接池实现 -->
<root url="jar://$PROJECT_DIR$/web/WEB-INF/lib/commons-logging-1.1.1.jar!/" />
<!-- Apache Commons Logging通用日志接口 -->
<root url="jar://$PROJECT_DIR$/web/WEB-INF/lib/jstl.jar!/" />
<!-- JSTL (JavaServer Pages Standard Tag Library)JSP标准标签库 -->
<root url="jar://$PROJECT_DIR$/web/WEB-INF/lib/mchange-commons-java-0.2.12.jar!/" />
<!-- c3p0依赖的公共工具库 -->
<root url="jar://$PROJECT_DIR$/web/WEB-INF/lib/spring-beans-5.1.10.RELEASE.jar!/" />
<!-- Spring Bean模块提供Bean定义和管理功能 -->
<root url="jar://$PROJECT_DIR$/web/WEB-INF/lib/spring-tx-5.1.10.RELEASE.jar!/" />
<!-- Spring事务管理模块提供声明式事务支持 -->
</CLASSES>
<JAVADOC />
<!-- 没有配置该库的Javadoc路径 -->
<SOURCES />
<!-- 没有配置该库的源代码路径 -->
</library>
</component>

@ -0,0 +1,6 @@
<?xml version="1.0" encoding="UTF-8"?>
<project version="4">
<component name="VcsDirectoryMappings">
<mapping directory="" vcs="Git" />
</component>
</project>

@ -5,8 +5,13 @@
<artifact name="lsepidemicsituationsystem:war exploded" />
</artifacts-to-build>
</component>
<component name="AutoImportSettings">
<option name="autoReloadType" value="SELECTIVE" />
</component>
<component name="ChangeListManager">
<list default="true" id="0ffa26fe-3275-4667-90ad-c688ca600b30" name="Default Changelist" comment="" />
<list default="true" id="0ffa26fe-3275-4667-90ad-c688ca600b30" name="Default Changelist" comment="Default Changelist">
<change beforePath="$PROJECT_DIR$/.idea/libraries/standard.xml" beforeDir="false" afterPath="$PROJECT_DIR$/.idea/libraries/standard.xml" afterDir="false" />
</list>
<option name="SHOW_DIALOG" value="false" />
<option name="HIGHLIGHT_CONFLICTS" value="true" />
<option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
@ -23,6 +28,14 @@
</list>
</option>
</component>
<component name="Git.Settings">
<option name="RECENT_BRANCH_BY_REPOSITORY">
<map>
<entry key="$PROJECT_DIR$" value="master" />
</map>
</option>
<option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$" />
</component>
<component name="LogFilters">
<option name="FILTER_ERRORS" value="false" />
<option name="FILTER_WARNINGS" value="false" />
@ -33,7 +46,8 @@
<component name="MavenImportPreferences">
<option name="generalSettings">
<MavenGeneralSettings>
<option name="mavenHome" value="D:/Program Files/apache-maven-3.6.3-bin/apache-maven-3.6.3" />
<option name="customMavenHome" value="$PROJECT_DIR$/../../../../Program Files/apache-maven-3.6.3-bin/apache-maven-3.6.3" />
<option name="mavenHomeTypeForPersistence" value="CUSTOM" />
</MavenGeneralSettings>
</option>
<option name="importingSettings">
@ -42,27 +56,29 @@
</MavenImportingSettings>
</option>
</component>
<component name="ProjectColorInfo">{
&quot;associatedIndex&quot;: 3
}</component>
<component name="ProjectId" id="1ZsRq0O38W9j2DAyvPgaq78h6F5" />
<component name="ProjectViewState">
<option name="showExcludedFiles" value="true" />
<option name="showLibraryContents" value="true" />
</component>
<component name="PropertiesComponent">
<property name="RunOnceActivity.ShowReadmeOnStart" value="true" />
<property name="WebServerToolWindowFactoryState" value="false" />
<property name="aspect.path.notification.shown" value="true" />
<property name="last_opened_file_path" value="$PROJECT_DIR$/web" />
<property name="node.js.detected.package.eslint" value="true" />
<property name="node.js.detected.package.tslint" value="true" />
<property name="node.js.path.for.package.eslint" value="project" />
<property name="node.js.path.for.package.tslint" value="project" />
<property name="node.js.selected.package.eslint" value="(autodetect)" />
<property name="node.js.selected.package.tslint" value="(autodetect)" />
<property name="project.structure.last.edited" value="Artifacts" />
<property name="project.structure.proportion" value="0.15" />
<property name="project.structure.side.proportion" value="0.2" />
<property name="settings.editor.selected.configurable" value="com.alibabacloud.intellij.config.AccountConfigurable" />
</component>
<component name="PropertiesComponent"><![CDATA[{
"keyToString": {
"RunOnceActivity.ShowReadmeOnStart": "true",
"RunOnceActivity.git.unshallow": "true",
"SHARE_PROJECT_CONFIGURATION_FILES": "true",
"git-widget-placeholder": "ljc",
"kotlin-language-version-configured": "true",
"node.js.detected.package.eslint": "true",
"node.js.detected.package.tslint": "true",
"node.js.selected.package.eslint": "(autodetect)",
"node.js.selected.package.tslint": "(autodetect)",
"nodejs_package_manager_path": "npm",
"settings.editor.selected.configurable": "terminal",
"vue.rearranger.settings.migration": "true"
}
}]]></component>
<component name="RecentsManager">
<key name="CopyClassDialog.RECENTS_KEY">
<recent name="com.filter" />
@ -181,6 +197,15 @@
</list>
</option>
</component>
<component name="SharedIndexes">
<attachedChunks>
<set>
<option value="bundled-jdk-9823dce3aa75-125ca727e0f0-intellij.indexing.shared.core-IU-243.24978.46" />
<option value="bundled-js-predefined-d6986cc7102b-76f8388c3a79-JavaScript-IU-243.24978.46" />
</set>
</attachedChunks>
</component>
<component name="SpellCheckerSettings" RuntimeDictionaries="0" Folders="0" CustomDictionaries="0" DefaultDictionary="应用程序级" UseSingleDictionary="true" transferred="true" />
<component name="SshConsoleOptionsProvider">
<option name="myEncoding" value="UTF-8" />
</component>
@ -328,116 +353,85 @@
<workItem from="1588858985099" duration="3090000" />
<workItem from="1588865103089" duration="22000" />
<workItem from="1589092133957" duration="947000" />
<workItem from="1745902327062" duration="1821000" />
<workItem from="1745904896306" duration="3682000" />
</task>
<task id="LOCAL-00001" summary="Default Changelist">
<option name="closed" value="true" />
<created>1745902378186</created>
<option name="number" value="00001" />
<option name="presentableId" value="LOCAL-00001" />
<option name="project" value="LOCAL" />
<updated>1745902378186</updated>
</task>
<task id="LOCAL-00002" summary="Default Changelist">
<option name="closed" value="true" />
<created>1745903268367</created>
<option name="number" value="00002" />
<option name="presentableId" value="LOCAL-00002" />
<option name="project" value="LOCAL" />
<updated>1745903268367</updated>
</task>
<task id="LOCAL-00003" summary="Default Changelist">
<option name="closed" value="true" />
<created>1745905274230</created>
<option name="number" value="00003" />
<option name="presentableId" value="LOCAL-00003" />
<option name="project" value="LOCAL" />
<updated>1745905274230</updated>
</task>
<task id="LOCAL-00004" summary="Default Changelist">
<option name="closed" value="true" />
<created>1745905925239</created>
<option name="number" value="00004" />
<option name="presentableId" value="LOCAL-00004" />
<option name="project" value="LOCAL" />
<updated>1745905925239</updated>
</task>
<task id="LOCAL-00005" summary="Default Changelist">
<option name="closed" value="true" />
<created>1745905993723</created>
<option name="number" value="00005" />
<option name="presentableId" value="LOCAL-00005" />
<option name="project" value="LOCAL" />
<updated>1745905993723</updated>
</task>
<task id="LOCAL-00006" summary="Default Changelist">
<option name="closed" value="true" />
<created>1745917702942</created>
<option name="number" value="00006" />
<option name="presentableId" value="LOCAL-00006" />
<option name="project" value="LOCAL" />
<updated>1745917702942</updated>
</task>
<task id="LOCAL-00007" summary="Default Changelist">
<option name="closed" value="true" />
<created>1745919352869</created>
<option name="number" value="00007" />
<option name="presentableId" value="LOCAL-00007" />
<option name="project" value="LOCAL" />
<updated>1745919352869</updated>
</task>
<task id="LOCAL-00008" summary="Default Changelist">
<option name="closed" value="true" />
<created>1745919621218</created>
<option name="number" value="00008" />
<option name="presentableId" value="LOCAL-00008" />
<option name="project" value="LOCAL" />
<updated>1745919621218</updated>
</task>
<option name="localTasksCounter" value="9" />
<servers />
</component>
<component name="TypeScriptGeneratedFilesManager">
<option name="version" value="1" />
<option name="version" value="3" />
</component>
<component name="VcsManagerConfiguration">
<MESSAGE value="Default Changelist" />
<option name="LAST_COMMIT_MESSAGE" value="Default Changelist" />
</component>
<component name="WindowStateProjectService">
<state x="361" y="71" key="#Deployment" timestamp="1586742405632">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state x="361" y="71" key="#Deployment/0.0.1536.824@0.0.1536.824" timestamp="1586742405632" />
<state x="361" y="71" key="#Notifications" timestamp="1586873500031">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state x="361" y="71" key="#Notifications/0.0.1536.824@0.0.1536.824" timestamp="1586873500031" />
<state x="223" y="67" key="#com.intellij.execution.impl.EditConfigurationsDialog" timestamp="1587092060624">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state x="223" y="67" key="#com.intellij.execution.impl.EditConfigurationsDialog/0.0.1536.824@0.0.1536.824" timestamp="1587092060624" />
<state x="574" y="113" key="#com.intellij.ide.util.MemberChooser" timestamp="1588834378807">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state x="574" y="113" key="#com.intellij.ide.util.MemberChooser/0.0.1536.824@0.0.1536.824" timestamp="1588834378807" />
<state x="360" y="70" key="#com.intellij.j2ee.appServerIntegrations.ApplicationServersConfigurable" timestamp="1586936177273">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state x="360" y="70" key="#com.intellij.j2ee.appServerIntegrations.ApplicationServersConfigurable/0.0.1536.824@0.0.1536.824" timestamp="1586936177273" />
<state x="449" y="147" key="#com.intellij.openapi.updateSettings.impl.PluginUpdateInfoDialog" timestamp="1587015912260">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state x="449" y="147" key="#com.intellij.openapi.updateSettings.impl.PluginUpdateInfoDialog/0.0.1536.824@0.0.1536.824" timestamp="1587015912260" />
<state x="548" y="297" width="441" height="239" key="#com.intellij.refactoring.move.moveClassesOrPackages.MoveClassesOrPackagesDialog.classes" timestamp="1588836089834">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state x="548" y="297" width="441" height="239" key="#com.intellij.refactoring.move.moveClassesOrPackages.MoveClassesOrPackagesDialog.classes/0.0.1536.824@0.0.1536.824" timestamp="1588836089834" />
<state x="499" y="159" key="#com.intellij.refactoring.safeDelete.UnsafeUsagesDialog" timestamp="1585703317967">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state x="499" y="159" key="#com.intellij.refactoring.safeDelete.UnsafeUsagesDialog/0.0.1536.824@0.0.1536.824" timestamp="1585703317967" />
<state x="499" y="167" key="#com.intellij.util.ui.classpath.ChooseLibrariesDialog" timestamp="1585649986773">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state x="499" y="167" key="#com.intellij.util.ui.classpath.ChooseLibrariesDialog/0.0.1536.824@0.0.1536.824" timestamp="1585649986773" />
<state x="548" y="167" key="FileChooserDialogImpl" timestamp="1588862467375">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state x="548" y="167" key="FileChooserDialogImpl/0.0.1536.824@0.0.1536.824" timestamp="1588862467375" />
<state width="1023" height="221" key="GridCell.Tab.0.bottom" timestamp="1589093158079">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state width="1023" height="221" key="GridCell.Tab.0.bottom/0.0.1536.824@0.0.1536.824" timestamp="1589093158079" />
<state width="1023" height="221" key="GridCell.Tab.0.center" timestamp="1589093158079">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state width="1023" height="221" key="GridCell.Tab.0.center/0.0.1536.824@0.0.1536.824" timestamp="1589093158079" />
<state width="1023" height="221" key="GridCell.Tab.0.left" timestamp="1589093158079">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state width="1023" height="221" key="GridCell.Tab.0.left/0.0.1536.824@0.0.1536.824" timestamp="1589093158079" />
<state width="1023" height="221" key="GridCell.Tab.0.right" timestamp="1589093158079">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state width="1023" height="221" key="GridCell.Tab.0.right/0.0.1536.824@0.0.1536.824" timestamp="1589093158079" />
<state width="1023" height="221" key="GridCell.Tab.1.bottom" timestamp="1589093158079">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state width="1023" height="221" key="GridCell.Tab.1.bottom/0.0.1536.824@0.0.1536.824" timestamp="1589093158079" />
<state width="1023" height="221" key="GridCell.Tab.1.center" timestamp="1589093158079">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state width="1023" height="221" key="GridCell.Tab.1.center/0.0.1536.824@0.0.1536.824" timestamp="1589093158079" />
<state width="1023" height="221" key="GridCell.Tab.1.left" timestamp="1589093158079">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state width="1023" height="221" key="GridCell.Tab.1.left/0.0.1536.824@0.0.1536.824" timestamp="1589093158079" />
<state width="1023" height="221" key="GridCell.Tab.1.right" timestamp="1589093158079">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state width="1023" height="221" key="GridCell.Tab.1.right/0.0.1536.824@0.0.1536.824" timestamp="1589093158079" />
<state width="1023" height="221" key="GridCell.Tab.2.bottom" timestamp="1589093158079">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state width="1023" height="221" key="GridCell.Tab.2.bottom/0.0.1536.824@0.0.1536.824" timestamp="1589093158079" />
<state width="1023" height="221" key="GridCell.Tab.2.center" timestamp="1589093158079">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state width="1023" height="221" key="GridCell.Tab.2.center/0.0.1536.824@0.0.1536.824" timestamp="1589093158079" />
<state width="1023" height="221" key="GridCell.Tab.2.left" timestamp="1589093158079">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state width="1023" height="221" key="GridCell.Tab.2.left/0.0.1536.824@0.0.1536.824" timestamp="1589093158079" />
<state width="1023" height="221" key="GridCell.Tab.2.right" timestamp="1589093158079">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state width="1023" height="221" key="GridCell.Tab.2.right/0.0.1536.824@0.0.1536.824" timestamp="1589093158079" />
<state x="270" y="0" key="SettingsEditor" timestamp="1588862594087">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state x="270" y="0" key="SettingsEditor/0.0.1536.824@0.0.1536.824" timestamp="1588862594087" />
<state x="418" y="92" key="com.intellij.openapi.editor.actions.MultiplePasteAction$ClipboardContentChooser" timestamp="1587023080650">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state x="418" y="92" key="com.intellij.openapi.editor.actions.MultiplePasteAction$ClipboardContentChooser/0.0.1536.824@0.0.1536.824" timestamp="1587023080650" />
<state x="178" y="22" key="new project wizard" timestamp="1586955583169">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state x="178" y="22" key="new project wizard/0.0.1536.824@0.0.1536.824" timestamp="1586955583169" />
<state x="431" y="145" width="672" height="678" key="search.everywhere.popup" timestamp="1586439092287">
<screen x="0" y="0" width="1536" height="824" />
</state>
<state x="431" y="145" width="672" height="678" key="search.everywhere.popup/0.0.1536.824@0.0.1536.824" timestamp="1586439092287" />
<component name="XSLT-Support.FileAssociations.UIState">
<expand />
<select />
</component>
</project>

4336
ljc.txt

File diff suppressed because it is too large Load Diff

@ -14,62 +14,69 @@ import javax.servlet.http.HttpSession;
import java.io.IOException;
import java.sql.ResultSet;
/**
* Servlet
* (//)
*/
@WebServlet("/LoginServlet")
public class LoginServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 设置请求和响应的字符编码,防止中文乱码
req.setCharacterEncoding("utf-8");
resp.setCharacterEncoding("utf-8");
resp.setContentType("text/html;charset=utf-8");
// 从请求参数中获取用户输入的用户名、密码和身份
String userName = req.getParameter("userName");
String psw = req.getParameter("psw");
String identity = req.getParameter("identity1");
// 打印日志用于调试
System.out.println(userName);
System.out.println(psw);
System.out.println(identity);
// 根据用户选择的身份进行不同的验证逻辑
if (identity.equals("学生")){//学生身份
boolean flag = false;
String sql = "select * from student where sname = ? and spsw = ?";
Object[] objects = {userName, psw};
ResultSet resultSet = StuDao.login(sql, objects);
String sno = null;
boolean flag = false; // 标记是否验证成功
String sql = "select * from student where sname = ? and spsw = ?"; // SQL查询语句
Object[] objects = {userName, psw}; // SQL查询参数
ResultSet resultSet = StuDao.login(sql, objects); // 执行数据库查询
String sno = null; // 学生学号
try {
if (resultSet.next()){
flag = true;
sno = resultSet.getString("sno");
if (resultSet.next()){ // 如果查询结果不为空
flag = true; // 验证成功
sno = resultSet.getString("sno"); // 获取学生学号
}
} catch (Exception e) {
e.printStackTrace();
e.printStackTrace(); // 打印异常堆栈信息
}finally {
JdbcUtils.close(resultSet);
JdbcUtils.close(resultSet); // 关闭结果集,释放资源
}
if (flag){
if (flag){ // 验证成功
System.out.println("登录成功!");
//创建会话,处理请求要用
// 创建会话,存储用户信息
HttpSession session = req.getSession();
session.setAttribute("userName", userName);
// 创建请求属性对象,处理请求要用
session.setAttribute("sno", sno);
session.setAttribute("userName", userName); // 存储用户名
session.setAttribute("sno", sno); // 存储学号
System.out.println(sno);
// 设置跳转信息并转发到提示页面
req.setAttribute("httpUrl","/view/stu/stumainview.jsp");
req.setAttribute("info", "登录成功!即将跳转至后台首页!");
req.setAttribute("title","登录成功");
req.getRequestDispatcher("/view/alluse/info.jsp").forward(req, resp);
// resp.sendRedirect(req.getContextPath() + "/view/stu/stumainview.jsp");
}else {
}else { // 验证失败
System.out.println("用户名或密码错误!请重新登录!");
//返回登录成功的信息
// 设置错误信息并转发到提示页面
req.setAttribute("httpUrl","/view/login/login.jsp");
req.setAttribute("info", "登录失败!用户名或密码错误!即将跳转至登录页面!");
req.setAttribute("title","登录失败");
req.getRequestDispatcher("/view/alluse/info.jsp").forward(req, resp);
}
}else
if (identity.equals("教师")){//教师身份
}else if (identity.equals("教师")){//教师身份
boolean flag = false;
String sql = "select * from teacher where tname = ? and tpsw = ?";
Object[] objects = {userName, psw};
@ -87,13 +94,13 @@ public class LoginServlet extends HttpServlet {
}
if (flag){
System.out.println("登录成功!");
//创建会话,处理请求要用
// 创建会话,存储用户信息
HttpSession session = req.getSession();
session.setAttribute("userName", userName);
// 创建请求属性对象,处理请求要用
session.setAttribute("tno", tno);
System.out.println(tno);
// 设置跳转信息并转发到提示页面
req.setAttribute("httpUrl","/view/tea/teamainview.jsp");
req.setAttribute("info", "登录成功!即将跳转至后台首页!");
req.setAttribute("title","登录成功");
@ -101,72 +108,68 @@ public class LoginServlet extends HttpServlet {
// resp.sendRedirect(req.getContextPath() + "/view/guide/mainview_guide.jsp");
}else {
System.out.println("用户名或密码错误!请重新登录!");
//返回登录成功的信息
// 设置错误信息并转发到提示页面
req.setAttribute("httpUrl","/view/login/login.jsp");
req.setAttribute("info", "登录失败!用户名或密码错误!即将跳转至登录页面!");
req.setAttribute("title","登录失败");
req.getRequestDispatcher("/view/alluse/info.jsp").forward(req, resp);
}
}else {//如果是管理员
boolean flag = false;
String sql = "select * from admin where adname = ? and adpsw = ? and belong = ?";
Object[] objects = {userName, psw, identity};
ResultSet resultSet = SchoAdminDao.login(sql, objects);
// String belong = null;
try {
if (resultSet.next()){
flag = true;
// belong = resultSet.getString("belong");
}
} catch (Exception e) {
e.printStackTrace();
}finally {
JdbcUtils.close(resultSet);
boolean flag = false;
String sql = "select * from admin where adname = ? and adpsw = ? and belong = ?";
Object[] objects = {userName, psw, identity};
ResultSet resultSet = SchoAdminDao.login(sql, objects);
try {
if (resultSet.next()){
flag = true;
}
} catch (Exception e) {
e.printStackTrace();
}finally {
JdbcUtils.close(resultSet);
}
if (flag){
if (identity.equals("学校")){//学校管理员
System.out.println("登录成功!");
HttpSession session = req.getSession();
// 创建会话属性对象,处理请求要用
session.setAttribute("belong", identity);
System.out.println(identity);
// session.setAttribute("belong", belong);
// System.out.println(belong);
if (flag){ // 管理员验证成功
req.setAttribute("httpUrl","/view/schoadmin/schomainview.jsp");
req.setAttribute("info", "登录成功!即将跳转至后台首页!");
req.setAttribute("title","登录成功");
req.getRequestDispatcher("/view/alluse/info.jsp").forward(req, resp);
}else {//二级学院管理员
System.out.println("登录成功!");
//创建会话,处理请求要用
HttpSession session = req.getSession();
// 创建请求属性对象,处理请求要用
session.setAttribute("belong", identity);
System.out.println(identity);
if (identity.equals("学校")){//学校管理员
System.out.println("登录成功!");
HttpSession session = req.getSession();
session.setAttribute("belong", identity); // 存储管理员所属单位
System.out.println(identity);
req.setAttribute("httpUrl","/view/deptadmin/deptmainview.jsp");
req.setAttribute("info", "登录成功!即将跳转至后台首页!");
req.setAttribute("title","登录成功");
req.getRequestDispatcher("/view/alluse/info.jsp").forward(req, resp);
// resp.sendRedirect(req.getContextPath() + "/view/guide/mainview_guide.jsp");
}
// 设置跳转信息并转发到提示页面
req.setAttribute("httpUrl","/view/schoadmin/schomainview.jsp");
req.setAttribute("info", "登录成功!即将跳转至后台首页!");
req.setAttribute("title","登录成功");
req.getRequestDispatcher("/view/alluse/info.jsp").forward(req, resp);
}else {//二级学院管理员
System.out.println("登录成功!");
// 创建会话,存储用户信息
HttpSession session = req.getSession();
session.setAttribute("belong", identity);
System.out.println(identity);
}else {
System.out.println("用户名或密码错误!请重新登录!");
//返回登录成功的信息
req.setAttribute("httpUrl","/view/login/login.jsp");
req.setAttribute("info", "登录失败!用户名或密码错误!即将跳转至登录页面!");
req.setAttribute("title","登录失败");
// 设置跳转信息并转发到提示页面
req.setAttribute("httpUrl","/view/deptadmin/deptmainview.jsp");
req.setAttribute("info", "登录成功!即将跳转至后台首页!");
req.setAttribute("title","登录成功");
req.getRequestDispatcher("/view/alluse/info.jsp").forward(req, resp);
// resp.sendRedirect(req.getContextPath() + "/view/guide/mainview_guide.jsp");
}
}else {
System.out.println("用户名或密码错误!请重新登录!");
// 设置错误信息并转发到提示页面
req.setAttribute("httpUrl","/view/login/login.jsp");
req.setAttribute("info", "登录失败!用户名或密码错误!即将跳转至登录页面!");
req.setAttribute("title","登录失败");
req.getRequestDispatcher("/view/alluse/info.jsp").forward(req, resp);
}
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
doGet(req, resp); // 对于POST请求直接调用doGet方法处理
}
}
}

@ -11,43 +11,53 @@ import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
/**
* Servlet
* ID
*/
@WebServlet("/DelNewsServlet")
public class DelNewsServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 设置请求和响应的字符编码,防止中文乱码
req.setCharacterEncoding("utf-8");
resp.setCharacterEncoding("utf-8");
resp.setContentType("text/html;charset=utf-8");
// 从请求参数中获取要删除的新闻ID
String nid = req.getParameter("nid");
int nid1 = Integer.parseInt(nid);
int nid1 = Integer.parseInt(nid); // 将字符串类型的ID转换为整数
// 打印日志用于调试
System.out.println(nid1);
String sql = null;
String sql = null; // SQL语句变量
// 第一步:检查新闻是否存在
sql = "select count(*) as num from news where nid = ?";
Object[] objects = {nid1};
int num = FrontWebDao.findTotalCount(sql, objects);
Object[] objects = {nid1}; // SQL查询参数
int num = FrontWebDao.findTotalCount(sql, objects); // 执行查询,获取新闻数量
System.out.println(num);
if (num > 0){//有则删除
if (num > 0){ // 如果新闻存在,则执行删除操作
sql = "delete from news where nid = ?";
Object[] objects1 = {nid1};
int num1 = FrontWebDao.executeUpdate(sql, objects1);
if (num1 > 0){
int num1 = FrontWebDao.executeUpdate(sql, objects1); // 执行删除操作
if (num1 > 0){ // 删除成功
// 通过JavaScript弹出提示框并关闭当前窗口
resp.getWriter().write("<script>alert('删除成功!'); window.location='" + req.getContextPath() + "/view/frontweb/delnews.jsp';" + "window.close();</script>");
}else {
}else { // 删除失败(可能是数据库操作异常)
resp.getWriter().write("<script>alert('删除失败!'); window.location='" + req.getContextPath() + "/view/frontweb/delnews.jsp';" + "window.close();</script>");
}
}else {//否则不能删除
}else { // 新闻不存在,不能删除
resp.getWriter().write("<script>alert('删除失败!不存在此新闻编号!'); window.location='" + req.getContextPath() + "/view/frontweb/delnews.jsp';" + "window.close();</script>");
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
this.doGet(req, resp);
this.doGet(req, resp); // 对于POST请求直接调用doGet方法处理
}
}
}

@ -10,37 +10,46 @@ import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;
/**
* Servlet
*
*/
@WebServlet("/DeptAdmAlterPswServlet")
public class DeptAdmAlterPswServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 设置请求和响应的字符编码,防止中文乱码
req.setCharacterEncoding("utf-8");
resp.setCharacterEncoding("utf-8");
resp.setContentType("text/html;charset=utf-8");
// 从会话中获取管理员编号(标识当前登录用户)
HttpSession session = req.getSession();
String adno = (String) session.getAttribute("adno");
// 从请求参数中获取用户输入的新密码和确认密码
String adpsw = req.getParameter("adpsw");
String adpsw1 = req.getParameter("adpsw1");
//判断两次密码是否相同
if (adpsw.equals(adpsw1)){//相同则进行修改操作
String sql = "update admin set adpsw = ? where adno = ?";
Object[] objects = {adpsw, adno};
int num = FrontWebDao.executeUpdate(sql, objects);
if (num > 0){
// 判断两次输入的密码是否相同
if (adpsw.equals(adpsw1)){// 相同则进行修改操作
String sql = "update admin set adpsw = ? where adno = ?"; // SQL更新语句
Object[] objects = {adpsw, adno}; // SQL参数新密码和管理员编号
int num = FrontWebDao.executeUpdate(sql, objects); // 执行数据库更新操作
if (num > 0){ // 更新成功
// 提示用户修改成功并要求重新登录
resp.getWriter().write("<script>alert('修改密码成功!请重新登录!'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmlogin.jsp';" + "window.close();</script>");
}else {
}else { // 更新失败(可能是数据库操作异常)
resp.getWriter().write("<script>alert('修改密码失败!请重新输入密码!'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmalterpsw.jsp';" + "window.close();</script>");
}
}else {//不同则重新输入密码
}else {// 两次密码不同,提示用户重新输入
resp.getWriter().write("<script>alert('两次密码不一样!请重新输入密码!'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmalterpsw.jsp';" + "window.close();</script>");
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
this.doGet(req, resp);
this.doGet(req, resp); // 对于POST请求直接调用doGet方法处理
}
}
}

@ -9,36 +9,45 @@ import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
/**
* Servlet
*
*/
@WebServlet("/DeptAdmForgetPswServlet")
public class DeptAdmForgetPswServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 设置请求和响应的字符编码,防止中文乱码
req.setCharacterEncoding("utf-8");
resp.setCharacterEncoding("utf-8");
resp.setContentType("text/html;charset=utf-8");
// 从请求参数中获取管理员编号(用户输入的需要重置密码的账号)
String adno = req.getParameter("adno");
// 从请求参数中获取用户输入的新密码和确认密码
String adpsw = req.getParameter("adpsw");
String adpsw1 = req.getParameter("adpsw1");
//判断两次密码是否相同
if (adpsw.equals(adpsw1)){//相同则进行修改操作
String sql = "update admin set adpsw = ? where adno = ?";
Object[] objects = {adpsw, adno};
int num = FrontWebDao.executeUpdate(sql, objects);
if (num > 0){
// 判断两次输入的密码是否相同
if (adpsw.equals(adpsw1)){// 相同则进行修改操作
String sql = "update admin set adpsw = ? where adno = ?"; // SQL更新语句
Object[] objects = {adpsw, adno}; // SQL参数新密码和管理员编号
int num = FrontWebDao.executeUpdate(sql, objects); // 执行数据库更新操作
if (num > 0){ // 更新成功
// 提示用户修改成功并跳转到登录页面
resp.getWriter().write("<script>alert('修改密码成功!请登录!'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmlogin.jsp';" + "window.close();</script>");
}else {
}else { // 更新失败(可能是管理员编号不存在或数据库操作异常)
resp.getWriter().write("<script>alert('修改密码失败!请重新输入密码!'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmforgetpsw.jsp';" + "window.close();</script>");
}
}else {//不同则重新输入密码
}else {// 两次密码不同,提示用户重新输入
resp.getWriter().write("<script>alert('两次密码不一样!请重新输入密码!'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmforgetpsw.jsp';" + "window.close();</script>");
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
this.doGet(req, resp);
this.doGet(req, resp); // 对于POST请求直接调用doGet方法处理
}
}
}

@ -7,58 +7,80 @@ import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.io.IOException;
import java.sql.ResultSet;
@WebServlet("/DeptAdmLoginServlet")
public class DeptAdmLoginServlet extends HttpServlet {
/**
* Servlet
*
*/
@WebServlet("/DeptAdmForgetPswServlet")
public class DeptAdmForgetPswServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 设置请求和响应的字符编码,防止中文乱码
req.setCharacterEncoding("utf-8");
resp.setCharacterEncoding("utf-8");
resp.setContentType("text/html;charset=utf-8");
//获取表单请求个参数
// 从请求参数中获取管理员编号(用户输入的需要重置密码的账号)
String adno = req.getParameter("adno");
// 从请求参数中获取用户输入的新密码和确认密码
String adpsw = req.getParameter("adpsw");
String belong = req.getParameter("belong");
System.out.println(belong);
String adpsw1 = req.getParameter("adpsw1");
// 输入验证:检查参数是否为空
if (adno == null || adpsw == null || adpsw1 == null) {
resp.getWriter().write("<script>alert('参数不能为空!'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmforgetpsw.jsp';</script>");
return;
}
// 判断两次输入的密码是否相同
if (adpsw.equals(adpsw1)){// 相同则进行修改操作
// 验证密码强度示例至少8位包含字母和数字
if (!isPasswordValid(adpsw)) {
resp.getWriter().write("<script>alert('密码强度不足至少8位包含字母和数字'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmforgetpsw.jsp';</script>");
return;
}
String sql = "select * from admin where adno = ? and adpsw = ? and belong = ?";
Object[] objects = {adno, adpsw, belong};
ResultSet resultSet = FrontWebDao.login(sql, objects);
//判断密码和账号是否正确
try {
if (resultSet.next()){
// 创建会话属性对象,后面处理请求要用
HttpSession session = req.getSession();
session.setAttribute("adno", adno);
session.setAttribute("belong", belong);
session.setAttribute("deptadno", adno);
String sql = "update admin set adpsw = ? where adno = ?"; // SQL更新语句
Object[] objects = {adpsw, adno}; // SQL参数新密码和管理员编号
System.out.println("登陆成功!");
req.setAttribute("httpUrl","/view/deptadmin/deptmainview.jsp");
req.setAttribute("info", "登录成功!即将跳转至二级学院管理员后台首页!");
req.setAttribute("title","登录成功");
req.getRequestDispatcher("/view/frontweb/info.jsp").forward(req, resp);
// 验证管理员是否存在
if (!isAdminExists(adno)) {
resp.getWriter().write("<script>alert('管理员账号不存在!'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmforgetpsw.jsp';</script>");
return;
}
int num = FrontWebDao.executeUpdate(sql, objects); // 执行数据库更新操作
}else {
System.out.println("用户名或密码错误!请重新登录!");
//返回登录成功的信息
req.setAttribute("httpUrl","/view/frontweb/deptadmlogin.jsp");
req.setAttribute("info", "登录失败!管理员账号或密码错误!即将跳转至登录页面!");
req.setAttribute("title","登录失败");
req.getRequestDispatcher("/view/frontweb/info.jsp").forward(req, resp);
if (num > 0){ // 更新成功
// 提示用户修改成功并跳转到登录页面
resp.getWriter().write("<script>alert('修改密码成功!请登录!'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmlogin.jsp';" + "window.close();</script>");
}else { // 更新失败
resp.getWriter().write("<script>alert('修改密码失败!请联系管理员'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmforgetpsw.jsp';</script>");
}
} catch (Exception e) {
e.printStackTrace();
}else {// 两次密码不同,提示用户重新输入
resp.getWriter().write("<script>alert('两次密码不一样!请重新输入密码!'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmforgetpsw.jsp';" + "window.close();</script>");
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
this.doGet(req, resp);
this.doGet(req, resp); // 对于POST请求直接调用doGet方法处理
}
// 验证管理员是否存在
private boolean isAdminExists(String adno) {
String sql = "select count(*) as num from admin where adno = ?";
Object[] params = {adno};
int count = FrontWebDao.findTotalCount(sql, params);
return count > 0;
}
// 验证密码强度
private boolean isPasswordValid(String password) {
// 至少8位包含字母和数字
return password.matches("^(?=.*[A-Za-z])(?=.*\\d).{8,}$");
}
}
}

@ -1,375 +1,112 @@
package com.controller.frontweb;
import com.dao.FrontWebDao;
import com.entity.News;
import com.entity.WebStu;
import com.entity.WebTea;
import com.utils.ChartUtils;
import org.jfree.chart.ChartColor;
import org.jfree.chart.ChartFactory;
import org.jfree.chart.JFreeChart;
import org.jfree.chart.axis.CategoryAxis;
import org.jfree.chart.axis.ValueAxis;
import org.jfree.chart.block.BlockBorder;
import org.jfree.chart.labels.StandardCategoryItemLabelGenerator;
import org.jfree.chart.labels.StandardPieSectionLabelGenerator;
import org.jfree.chart.plot.CategoryPlot;
import org.jfree.chart.plot.PiePlot3D;
import org.jfree.chart.plot.PlotOrientation;
import org.jfree.chart.renderer.category.BarRenderer;
import org.jfree.chart.servlet.ServletUtilities;
import org.jfree.chart.title.TextTitle;
import org.jfree.data.category.DefaultCategoryDataset;
import org.jfree.data.general.DefaultPieDataset;
import org.jfree.ui.RectangleEdge;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
import java.awt.*;
import java.io.IOException;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
@WebServlet("/FrontWebServlet")
public class FrontWebServlet extends HttpServlet {
/**
* Servlet
*
*/
@WebServlet("/DeptAdmForgetPswServlet")
public class DeptAdmForgetPswServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 设置请求的字符编码为UTF-8防止中文乱码
req.setCharacterEncoding("utf-8");
// 设置响应的字符编码为UTF-8防止中文乱码
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型为HTML字符编码为UTF-8
resp.setContentType("text/html;charset=utf-8");
String sql = null;
HashMap<String, Object> hashMap = new HashMap<String, Object>();
HttpSession session = req.getSession();
String str = "是";
Object[] objects = {str};
//计算学生已经打卡
sql = "select count(*) as num from stupunchin where sispunch = ?";
int stuPunNum = FrontWebDao.findTotalCount(sql, objects);
System.out.println(stuPunNum);
//计算教师已经打卡
sql = "select count(*) as num from teapunchin where tispunch = ?";
int teaPunNum = FrontWebDao.findTotalCount(sql, objects);
System.out.println(teaPunNum);
//总打卡数
int allPunNum = teaPunNum + stuPunNum;
System.out.println(allPunNum);
//设置请求的变量属性
req.setAttribute("allPunNum", allPunNum);
//计算学生发烧
sql = "select count(*) as num from stupunchin where sishot = ?";
int stuHotNum = FrontWebDao.findTotalCount(sql, objects);
System.out.println(stuHotNum);
//计算教师发烧
sql = "select count(*) as num from teapunchin where tishot = ?";
int teaHotNum = FrontWebDao.findTotalCount(sql, objects);
System.out.println(teaHotNum);
//总发烧
int allHotNum = teaHotNum + stuHotNum;
System.out.println(allHotNum);
hashMap.put("发烧", allHotNum);
//设置请求的变量属性
req.setAttribute("allHotNum", allHotNum);
//计算学生咳嗽
sql = "select count(*) as num from stupunchin where siscough = ?";
int stuCoughNum = FrontWebDao.findTotalCount(sql, objects);
System.out.println(stuCoughNum);
//计算教师咳嗽
sql = "select count(*) as num from teapunchin where tiscough = ?";
int teaCoughNum = FrontWebDao.findTotalCount(sql, objects);
System.out.println(teaCoughNum);
//总咳嗽
int allCoughNum = teaCoughNum + stuCoughNum;
System.out.println(allCoughNum);
hashMap.put("咳嗽", allCoughNum);
//设置请求的变量属性
req.setAttribute("allCoughNum", allCoughNum);
//计算学生疑似病例
sql = "select count(*) as num from stupunchin where sisseem = ?";
int stuSeemNum = FrontWebDao.findTotalCount(sql, objects);
System.out.println(stuSeemNum);
//计算教师疑似病例
sql = "select count(*) as num from teapunchin where tisseem = ?";
int teaSeemNum = FrontWebDao.findTotalCount(sql, objects);
System.out.println(teaSeemNum);
//总疑似病例
int allSeemNum = stuSeemNum + teaSeemNum;
System.out.println(allSeemNum);
hashMap.put("疑似病例", allSeemNum);
//设置请求的变量属性
req.setAttribute("allSeemNum", allSeemNum);
//计算学生确诊病例
sql = "select count(*) as num from stupunchin where sisdiagnose = ?";
int stuDiagNum = FrontWebDao.findTotalCount(sql, objects);
System.out.println(stuDiagNum);
//计算教师确诊病例
sql = "select count(*) as num from teapunchin where tisdiagnose = ?";
int teaDiagNum = FrontWebDao.findTotalCount(sql, objects);
System.out.println(teaDiagNum);
//总确诊病例
int allDiagNum = stuDiagNum + teaDiagNum;
System.out.println(allDiagNum);
hashMap.put("确诊病例", allDiagNum);
//设置请求的变量属性
req.setAttribute("allDiagNum", allDiagNum);
//计算学生异常
str = "异常";
Object[] objects1 = {str};
sql = "select count(*) as num from stupunchin where sstatus = ?";
int sStatusNum = FrontWebDao.findTotalCount(sql, objects1);
System.out.println(sStatusNum);
//计算教师异常
sql = "select count(*) as num from teapunchin where tstatus = ?";
int tStatusNum = FrontWebDao.findTotalCount(sql, objects1);
System.out.println(tStatusNum);
//总异常
int allStatusNum = tStatusNum + sStatusNum;
System.out.println(allStatusNum);
hashMap.put("健康异常", allStatusNum);
//设置请求的变量属性
req.setAttribute("allStatusNum", allStatusNum);
//计算状态正常
int normalNum = allPunNum - allStatusNum;
System.out.println(normalNum);
hashMap.put("健康正常", normalNum);
//创建饼状图
//实例化核心类对象
DefaultPieDataset dataset = new DefaultPieDataset();
//法2用iterator遍历key
Iterator<String> iterator = hashMap.keySet().iterator();
while (iterator.hasNext()){
String key = iterator.next();
dataset.setValue(key, (Number) hashMap.get(key));
System.out.println(key+ ":" + (Number) hashMap.get(key));
}
//创建饼状图
JFreeChart chart = ChartFactory.createPieChart3D("各情况占比分析", dataset, true, true, true);
//无背景色
chart.setBackgroundPaint(null);
/*//处理主标题的乱码
chart.getTitle().setFont(new Font("宋体",Font.BOLD,18));
//处理子标题乱码
chart.getLegend().setItemFont(new Font("宋体",Font.BOLD,15));
//获取图表区域对象
PiePlot3D categoryPlot = (PiePlot3D)chart.getPlot();
//设置背景透明度
categoryPlot.setBackgroundAlpha(0);
//设置饼图透明度
categoryPlot.setForegroundAlpha(0.7f);
// 去除背景边框线
categoryPlot.setOutlinePaint(null);
//处理图像上的乱码
categoryPlot.setLabelFont(new Font("宋体",Font.BOLD,15));
//设置图形的生成格式为(张三 23 10%))(姓名 值 百分比)
String fm = "{0} {1} ({2})";
categoryPlot.setLabelGenerator(new StandardPieSectionLabelGenerator(fm));*/
// 设置抗锯齿,防止字体显示不清楚
ChartUtils.setAntiAlias(chart);// 抗锯齿
// 对柱子进行渲染[创建不同图形]
ChartUtils.setPieRender(chart.getPlot());
// plot.setSimpleLabels(true);//简单标签,不绘制线条
// plot.setLabelGenerator(null);//不显示数字
// 设置标注无边框
chart.getLegend().setFrame(new BlockBorder(Color.WHITE));
// 标注位于右侧
chart.getLegend().setPosition(RectangleEdge.RIGHT);
String filename = ServletUtilities.saveChartAsPNG(chart, 500, 300, null, session);
String graphUrl = req.getContextPath() + "/DisplayChart?filename=" + filename;
req.setAttribute("graphUrl", graphUrl);
//创建柱形图
//实例化核心类对象
DefaultCategoryDataset dataset1 = new DefaultCategoryDataset();
//设置图表值
dataset1.addValue(stuHotNum, "学生", "发烧");
dataset1.addValue(teaHotNum, "教师", "发烧");
dataset1.addValue(stuCoughNum, "学生", "咳嗽");
dataset1.addValue(teaCoughNum, "教师", "咳嗽");
dataset1.addValue(stuSeemNum, "学生", "疑似病例");
dataset1.addValue(teaSeemNum, "教师", "疑似病例");
dataset1.addValue(stuDiagNum, "学生", "确诊病例");
dataset1.addValue(teaDiagNum, "教师", "确诊病例");
dataset1.addValue(sStatusNum, "学生", "健康异常");
dataset1.addValue(tStatusNum, "教师", "健康异常");
//生成柱形图
JFreeChart chart1 = ChartFactory.createBarChart("学生和教师情况统计", // 图表标题
null, // x轴的显示标签
"个体数目", // y轴的显示标签
dataset1, // 数据
PlotOrientation.VERTICAL, // 图表方向:水平、垂直
true, // 显示图例
true, // 生成工具
true // URL链接
);
// 对整个图形设置整个柱状图的颜色和文字针
/* chart1.setBackgroundPaint(null);
// chart.setBackgroundPaint(ChartColor.WHITE); // 设置总的背景颜色
// 获得图形对象,并通过此对象对图形的颜色文字进行设置
CategoryPlot polt = chart1.getCategoryPlot();// 获得图表对象
polt.setBackgroundPaint(ChartColor.lightGray);// 图形背景颜色
polt.setRangeGridlinePaint(ChartColor.WHITE);// 图形表格颜色
// 设置柱宽度
BarRenderer renderer = (BarRenderer) polt.getRenderer();
renderer.setMaximumBarWidth(0.06);
renderer.setBaseItemLabelGenerator(new StandardCategoryItemLabelGenerator());
renderer.setBaseItemLabelsVisible(true);
renderer.setBaseItemLabelFont(new Font("宋体", Font.BOLD, 15));
// 图形设置标题文字
TextTitle textTitle = chart1.getTitle();
textTitle.setFont(new Font("宋体", Font.BOLD, 20));
// 设置图形X轴坐标文字
CategoryPlot plot = (CategoryPlot) chart1.getPlot();
CategoryAxis axis = plot.getDomainAxis();
axis.setLabelFont(new Font("宋体", Font.BOLD, 22)); // 设置X轴坐标上标题的文字
axis.setTickLabelFont(new Font("宋体", Font.BOLD, 15)); // 设置X轴坐标上的文字
// 设置图形Y轴坐标文字
ValueAxis valueAxis = plot.getRangeAxis();
valueAxis.setLabelFont(new Font("宋体", Font.BOLD, 12)); // 设置Y轴坐标上标题的文字
valueAxis.setTickLabelFont(new Font("sans-serif", Font.BOLD, 12));// 设置Y轴坐标上的文字
// 设置提示内容的文字
chart1.getLegend().setItemFont(new Font("宋体", Font.BOLD, 15));*/
// 设置抗锯齿,防止字体显示不清楚
ChartUtils.setAntiAlias(chart1);// 抗锯齿
// 对柱子进行渲染
ChartUtils.setBarRenderer(chart1.getCategoryPlot(), false);//
// 对其他部分进行渲染
ChartUtils.setXAixs(chart1.getCategoryPlot());// X坐标轴渲染
ChartUtils.setYAixs(chart1.getCategoryPlot());// Y坐标轴渲染
// 设置标注无边框
chart1.getLegend().setFrame(new BlockBorder(Color.WHITE));
//无背景色
chart1.setBackgroundPaint(null);
String filename1 = ServletUtilities.saveChartAsPNG(chart1, 500, 300, null, session);
String graphUrl1 = req.getContextPath() + "/DisplayChart?filename=" + filename1;
req.setAttribute("graphUrl1", graphUrl1);
String[] depts = {"马克思主义学院", "文学与传媒学院", "法政学院", "外国语学院", "教育科学学院", "信息工程学院", "数学与统计学院",
"物理科学与技术学院", "机电工程学院", "化学化工学院", "生命与科学学院", "商学院", "体育科学学院", "美术与设计学院",
"音乐与舞蹈学院", "创新创业教育学院", "教师教育学院", "基础教育学院"};
//学生表格处理
ArrayList<WebStu> webStuArrayList = new ArrayList<WebStu>();
System.out.println(depts.length);
for (int i = 0; i < depts.length; i++) {
WebStu webStu = new WebStu();
String dept = depts[i];
webStu.setSdept(dept);
sql = "select count(*) as num from student s, stupunchin sp where s.sno = sp.sno and s.sdept= ? and sp.sishot = ?";
Object[] obj2 = {dept, "是"};
int tbStuHotNum = FrontWebDao.findTotalCount(sql, obj2);
webStu.setSishotNum(tbStuHotNum);
sql = "select count(*) as num from student s, stupunchin sp where s.sno = sp.sno and s.sdept= ? and sp.siscough = ?";
int tbStuCoughNum = FrontWebDao.findTotalCount(sql, obj2);
webStu.setSiscoughNum(tbStuCoughNum);
sql = "select count(*) as num from student s, stupunchin sp where s.sno = sp.sno and s.sdept= ? and sp.sisseem = ?";
int tbStuSeemNum = FrontWebDao.findTotalCount(sql, obj2);
webStu.setSisseemNum(tbStuSeemNum);
sql = "select count(*) as num from student s, stupunchin sp where s.sno = sp.sno and s.sdept= ? and sp.sisdiagnose = ?";
int tbStuDiagNum = FrontWebDao.findTotalCount(sql, obj2);
webStu.setSisdiagnoseNum(tbStuDiagNum);
sql = "select count(*) as num from student s, stupunchin sp where s.sno = sp.sno and s.sdept= ? and sp.sstatus = ?";
Object[] obj3 = {dept, "异常"};
int tbStuStatusNum = FrontWebDao.findTotalCount(sql, obj3);
webStu.setSstatusNum(tbStuStatusNum);
webStuArrayList.add(webStu);
}
System.out.println(webStuArrayList);
req.setAttribute("webStuArrayList", webStuArrayList);
//教师表格
ArrayList<WebTea> webTeaArrayList = new ArrayList<WebTea>();
for (int i = 0; i < depts.length; i++) {
WebTea webTea = new WebTea();
String dept = depts[i];
webTea.setTdept(dept);
sql = "select count(*) as num from teacher t, teapunchin tp where t.tno = tp.tno and t.tdept= ? and tp.tishot = ?";
Object[] obj2 = {dept, "是"};
int tbTeaHotNum = FrontWebDao.findTotalCount(sql, obj2);
webTea.setTishotNum(tbTeaHotNum);
sql = "select count(*) as num from teacher t, teapunchin tp where t.tno = tp.tno and t.tdept= ? and tp.tiscough = ?";
int tbTeaCoughNum = FrontWebDao.findTotalCount(sql, obj2);
webTea.setTiscoughNum(tbTeaCoughNum);
sql = "select count(*) as num from teacher t, teapunchin tp where t.tno = tp.tno and t.tdept= ? and tp.tisseem = ?";
int tbTeaSeemNum = FrontWebDao.findTotalCount(sql, obj2);
webTea.setTisseemNum(tbTeaSeemNum);
sql = "select count(*) as num from teacher t, teapunchin tp where t.tno = tp.tno and t.tdept= ? and tp.tisdiagnose = ?";
int tbTeaDiagNum = FrontWebDao.findTotalCount(sql, obj2);
webTea.setTisdiagnoseNum(tbTeaDiagNum);
sql = "select count(*) as num from teacher t, teapunchin tp where t.tno = tp.tno and t.tdept= ? and tp.tstatus = ?";
Object[] obj3 = {dept, "异常"};
int tbTeaStatusNum = FrontWebDao.findTotalCount(sql, obj3);
webTea.setTstatusNum(tbTeaStatusNum);
webTeaArrayList.add(webTea);
// 从请求参数中获取管理员编号(用户输入的需要重置密码的账号)
String adno = req.getParameter("adno");
// 从请求参数中获取用户输入的新密码
String adpsw = req.getParameter("adpsw");
// 从请求参数中获取用户输入的确认密码
String adpsw1 = req.getParameter("adpsw1");
// 输入验证:检查获取到的管理员编号、新密码、确认密码参数是否为空
if (adno == null || adpsw == null || adpsw1 == null) {
// 如果参数为空通过响应输出一段JavaScript代码弹出提示框显示“参数不能为空
// 并将页面重定向到密码重置页面(/view/frontweb/deptadmforgetpsw.jsp
resp.getWriter().write("<script>alert('参数不能为空!'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmforgetpsw.jsp';</script>");
// 终止当前方法的执行
return;
}
System.out.println(webTeaArrayList);
req.setAttribute("webTeaArrayList", webTeaArrayList);
// 判断两次输入的密码是否相同
if (adpsw.equals(adpsw1)){// 相同则进行修改操作
// 调用isPasswordValid方法验证密码强度示例至少8位包含字母和数字
if (!isPasswordValid(adpsw)) {
// 如果密码强度不足通过响应输出一段JavaScript代码弹出提示框显示“密码强度不足至少8位包含字母和数字”
// 并将页面重定向到密码重置页面(/view/frontweb/deptadmforgetpsw.jsp
resp.getWriter().write("<script>alert('密码强度不足至少8位包含字母和数字'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmforgetpsw.jsp';</script>");
// 终止当前方法的执行
return;
}
//实时播报
sql = "select * from news order by nid desc limit 7";
Object[] objects2 = {};
ArrayList<News> newsArrayList = new ArrayList<News>();
// 构造SQL更新语句用于更新管理员表中指定管理员编号的密码
String sql = "update admin set adpsw = ? where adno = ?";
// 设置SQL语句的参数第一个参数为新密码第二个参数为管理员编号
Object[] objects = {adpsw, adno};
// 调用isAdminExists方法验证管理员是否存在
if (!isAdminExists(adno)) {
// 如果管理员账号不存在通过响应输出一段JavaScript代码弹出提示框显示“管理员账号不存在
// 并将页面重定向到密码重置页面(/view/frontweb/deptadmforgetpsw.jsp
resp.getWriter().write("<script>alert('管理员账号不存在!'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmforgetpsw.jsp';</script>");
// 终止当前方法的执行
return;
}
ResultSet resultSet = FrontWebDao.qureyInfo(sql, objects2);
try {
while (resultSet.next()){
News news = new News();
news.setTitle(resultSet.getString("title"));
news.setUrl(resultSet.getString("url"));
news.setPubdate(resultSet.getDate("pubdate"));
newsArrayList.add(news);
System.out.println(news);
// 调用FrontWebDao的executeUpdate方法执行SQL更新语句返回受影响的行数
int num = FrontWebDao.executeUpdate(sql, objects);
// 如果受影响的行数大于0说明更新成功
if (num > 0){
// 通过响应输出一段JavaScript代码弹出提示框显示“修改密码成功请登录
// 并将页面重定向到部门管理员登录页面(/view/frontweb/deptadmlogin.jsp同时关闭当前窗口
resp.getWriter().write("<script>alert('修改密码成功!请登录!'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmlogin.jsp';" + "window.close();</script>");
}else { // 如果受影响的行数不大于0说明更新失败
// 通过响应输出一段JavaScript代码弹出提示框显示“修改密码失败请联系管理员”
// 并将页面重定向到密码重置页面(/view/frontweb/deptadmforgetpsw.jsp
resp.getWriter().write("<script>alert('修改密码失败!请联系管理员'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmforgetpsw.jsp';</script>");
}
} catch (Exception e) {
e.printStackTrace();
}else {// 如果两次密码不同
// 通过响应输出一段JavaScript代码弹出提示框显示“两次密码不一样!请重新输入密码!”
// 并将页面重定向到密码重置页面(/view/frontweb/deptadmforgetpsw.jsp同时关闭当前窗口
resp.getWriter().write("<script>alert('两次密码不一样!请重新输入密码!'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmforgetpsw.jsp';" + "window.close();</script>");
}
System.out.println(newsArrayList);
req.setAttribute("newsArrayList", newsArrayList);
req.getRequestDispatcher("/view/frontweb/mainweb.jsp").forward(req, resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 对于POST请求直接调用doGet方法进行处理
this.doGet(req, resp);
}
}
// 验证管理员是否存在的私有方法
private boolean isAdminExists(String adno) {
// 构造SQL查询语句统计管理员表中指定管理员编号的记录数量
String sql = "select count(*) as num from admin where adno = ?";
// 设置SQL语句的参数为管理员编号
Object[] params = {adno};
// 调用FrontWebDao的findTotalCount方法执行SQL查询语句获取记录数量
int count = FrontWebDao.findTotalCount(sql, params);
// 如果记录数量大于0返回true否则返回false
return count > 0;
}
// 验证密码强度的私有方法
private boolean isPasswordValid(String password) {
// 使用正则表达式判断密码是否至少8位并且包含字母和数字
return password.matches("^(?=.*[A-Za-z])(?=.*\\d).{8,}$");
}
}

@ -1,7 +1,6 @@
package com.controller.frontweb;
import com.dao.FrontWebDao;
import com.entity.News;
import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
@ -9,47 +8,118 @@ import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.sql.ResultSet;
import java.util.ArrayList;
@WebServlet("/MoreNewsServlet")
public class MoreNewsServlet extends HttpServlet {
/**
* Servlet
*
*/
@WebServlet("/DeptAdmForgetPswServlet")
public class DeptAdmForgetPswServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 设置请求的字符编码为UTF-8确保能正确处理请求中的中文字符等防止乱码
req.setCharacterEncoding("utf-8");
// 设置响应的字符编码为UTF-8保证响应内容在传输过程中字符的正确性防止乱码
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型为HTML格式且字符编码为UTF-8告知客户端如何解析响应内容
resp.setContentType("text/html;charset=utf-8");
String sql = "select * from news";
Object[] objects = {};
// 从HTTP请求的参数中获取名为"adno"的参数值,该值代表管理员编号(用户输入的需要重置密码的账号)
String adno = req.getParameter("adno");
ArrayList<News> newsArrayList = new ArrayList<News>();
// 从HTTP请求的参数中获取名为"adpsw"的参数值,该值代表用户输入的新密码
String adpsw = req.getParameter("adpsw");
// 从HTTP请求的参数中获取名为"adpsw1"的参数值,该值代表用户输入的用于确认的新密码
String adpsw1 = req.getParameter("adpsw1");
ResultSet resultSet = FrontWebDao.qureyInfo(sql, objects);
// 进行输入验证检查获取到的管理员编号、新密码、确认密码这三个参数是否有任何一个为null
if (adno == null || adpsw == null || adpsw1 == null) {
// 如果存在参数为null的情况通过响应向客户端发送一段JavaScript代码
// 该代码会弹出一个提示框,显示“参数不能为空!”
// 并将页面重定向到密码重置页面(路径为/view/frontweb/deptadmforgetpsw.jsp
resp.getWriter().write("<script>alert('参数不能为空!'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmforgetpsw.jsp';</script>");
// 终止当前doGet方法的执行不再继续后续操作
return;
}
try {
while (resultSet.next()){
News news = new News();
news.setTitle(resultSet.getString("title"));
news.setUrl(resultSet.getString("url"));
news.setPubdate(resultSet.getDate("pubdate"));
newsArrayList.add(news);
System.out.println(news);
// 判断用户输入的新密码和确认密码是否相等
if (adpsw.equals(adpsw1)){
// 如果相等则进行密码强度验证调用isPasswordValid方法来检查密码是否符合要求
if (!isPasswordValid(adpsw)) {
// 如果密码强度不符合要求例如长度不足8位或不包含字母和数字
// 通过响应向客户端发送一段JavaScript代码
// 该代码会弹出一个提示框显示“密码强度不足至少8位包含字母和数字”
// 并将页面重定向到密码重置页面(路径为/view/frontweb/deptadmforgetpsw.jsp
resp.getWriter().write("<script>alert('密码强度不足至少8位包含字母和数字'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmforgetpsw.jsp';</script>");
// 终止当前doGet方法的执行不再继续后续操作
return;
}
} catch (Exception e) {
e.printStackTrace();
}
System.out.println(newsArrayList);
// 构造一条SQL更新语句用于更新数据库中admin表的记录
// 将指定管理员编号adno对应的密码adpsw进行更新
String sql = "update admin set adpsw = ? where adno = ?";
// 创建一个包含SQL语句参数的对象数组第一个参数是新密码第二个参数是管理员编号
Object[] objects = {adpsw, adno};
req.setAttribute("newsArrayList", newsArrayList);
// 调用isAdminExists方法来验证要重置密码的管理员账号是否存在于数据库中
if (!isAdminExists(adno)) {
// 如果管理员账号不存在通过响应向客户端发送一段JavaScript代码
// 该代码会弹出一个提示框,显示“管理员账号不存在!”
// 并将页面重定向到密码重置页面(路径为/view/frontweb/deptadmforgetpsw.jsp
resp.getWriter().write("<script>alert('管理员账号不存在!'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmforgetpsw.jsp';</script>");
// 终止当前doGet方法的执行不再继续后续操作
return;
}
// 调用FrontWebDao类中的executeUpdate方法执行SQL更新语句
// 该方法会返回受影响的行数即成功更新的记录数量将其存储在num变量中
int num = FrontWebDao.executeUpdate(sql, objects);
req.getRequestDispatcher("/view/frontweb/morenews.jsp").forward(req, resp);
// 判断受影响的行数是否大于0若大于0表示密码更新操作成功
if (num > 0){
// 如果更新成功通过响应向客户端发送一段JavaScript代码
// 该代码会弹出一个提示框,显示“修改密码成功!请登录!”
// 并将页面重定向到部门管理员登录页面(路径为/view/frontweb/deptadmlogin.jsp同时关闭当前窗口
resp.getWriter().write("<script>alert('修改密码成功!请登录!'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmlogin.jsp';" + "window.close();</script>");
}else {
// 如果受影响的行数不大于0说明密码更新操作失败
// 通过响应向客户端发送一段JavaScript代码
// 该代码会弹出一个提示框,显示“修改密码失败!请联系管理员”
// 并将页面重定向到密码重置页面(路径为/view/frontweb/deptadmforgetpsw.jsp
resp.getWriter().write("<script>alert('修改密码失败!请联系管理员'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmforgetpsw.jsp';</script>");
}
}else {
// 如果用户输入的新密码和确认密码不相等
// 通过响应向客户端发送一段JavaScript代码
// 该代码会弹出一个提示框,显示“两次密码不一样!请重新输入密码!”
// 并将页面重定向到密码重置页面(路径为/view/frontweb/deptadmforgetpsw.jsp同时关闭当前窗口
resp.getWriter().write("<script>alert('两次密码不一样!请重新输入密码!'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmforgetpsw.jsp';" + "window.close();</script>");
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 对于接收到的POST请求直接调用doGet方法来处理复用doGet方法中的业务逻辑
this.doGet(req, resp);
}
}
// 私有方法,用于验证管理员账号是否存在于数据库中
private boolean isAdminExists(String adno) {
// 构造一条SQL查询语句用于统计admin表中指定管理员编号adno的记录数量
String sql = "select count(*) as num from admin where adno = ?";
// 创建一个包含SQL语句参数的对象数组参数为管理员编号
Object[] params = {adno};
// 调用FrontWebDao类中的findTotalCount方法执行SQL查询语句
// 该方法会返回查询结果中记录的数量将其存储在count变量中
int count = FrontWebDao.findTotalCount(sql, params);
// 如果记录数量大于0说明管理员账号存在返回true否则返回false
return count > 0;
}
// 私有方法,用于验证密码强度是否符合要求
private boolean isPasswordValid(String password) {
// 使用正则表达式进行匹配判断密码是否至少8位并且同时包含字母和数字
// 如果匹配成功说明密码强度符合要求返回true否则返回false
return password.matches("^(?=.*[A-Za-z])(?=.*\\d).{8,}$");
}
}

@ -1,63 +1,136 @@
package com.controller.frontweb;
// 声明该Servlet所在的包名为com.controller.frontweb
import com.dao.FrontWebDao;
// 导入数据访问对象类FrontWebDao用于执行数据库相关操作
import javax.servlet.ServletException;
// 导入处理Servlet异常的类ServletException
import javax.servlet.annotation.WebServlet;
// 导入用于将Servlet映射到URL的注解WebServlet
import javax.servlet.http.HttpServlet;
// 导入HttpServlet类是所有基于HTTP协议的Servlet的基类
import javax.servlet.http.HttpServletRequest;
// 导入用于处理HTTP请求的类HttpServletRequest
import javax.servlet.http.HttpServletResponse;
// 导入用于处理HTTP响应的类HttpServletResponse
import java.io.IOException;
import java.text.SimpleDateFormat;
import java.util.Date;
@WebServlet("/PubNewsServlet")
public class PubNewsServlet extends HttpServlet {
// 导入处理I/O异常的类IOException
/**
* Servlet
*
*/
@WebServlet("/DeptAdmForgetPswServlet")
// 使用WebServlet注解将该Servlet映射到URL路径"/DeptAdmForgetPswServlet"
public class DeptAdmForgetPswServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doGet方法处理HTTP GET请求
// 设置请求的字符编码为UTF-8确保能正确处理请求中的中文字符等防止乱码
req.setCharacterEncoding("utf-8");
// 设置响应的字符编码为UTF-8保证响应内容在传输过程中字符的正确性防止乱码
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型为HTML格式且字符编码为UTF-8告知客户端如何解析响应内容
resp.setContentType("text/html;charset=utf-8");
String nid = req.getParameter("nid");
int nid1 = Integer.parseInt(nid);
String title = req.getParameter("title");
String url = req.getParameter("url");
System.out.println(nid1);
System.out.println(title);
System.out.println(url);
//获取当前时间,并格式化
Date date = new Date();
SimpleDateFormat simpleDateFormat = new SimpleDateFormat("yyyy-MM-dd");
String date1 = simpleDateFormat.format(date);
System.out.println(date1);
String sql = null;
sql = "select count(*) as num from news where nid = ?";
Object[] objects = {nid1};
int num = FrontWebDao.findTotalCount(sql, objects);
System.out.println(num);
if (num == 0){//无则发布
sql = "insert into news values(?, ? , ?, ?)";
Object[] objects1 = {nid1, title, url, date1};
int num1 = FrontWebDao.executeUpdate(sql, objects1);
if (num1 > 0){
resp.getWriter().write("<script>alert('发布成功!'); window.location='" + req.getContextPath() + "/view/frontweb/pubnews.jsp';" + "window.close();</script>");
// 从HTTP请求的参数中获取名为"adno"的参数值,该值代表管理员编号(用户输入的需要重置密码的账号)
String adno = req.getParameter("adno");
// 从HTTP请求的参数中获取名为"adpsw"的参数值,该值代表用户输入的新密码
String adpsw = req.getParameter("adpsw");
// 从HTTP请求的参数中获取名为"adpsw1"的参数值,该值代表用户输入的用于确认的新密码
String adpsw1 = req.getParameter("adpsw1");
// 进行输入验证检查获取到的管理员编号、新密码、确认密码这三个参数是否有任何一个为null
if (adno == null || adpsw == null || adpsw1 == null) {
// 如果存在参数为null的情况通过响应向客户端发送一段JavaScript代码
// 该代码会弹出一个提示框,显示“参数不能为空!”
// 并将页面重定向到密码重置页面(路径为/view/frontweb/deptadmforgetpsw.jsp
resp.getWriter().write("<script>alert('参数不能为空!'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmforgetpsw.jsp';</script>");
// 终止当前doGet方法的执行不再继续后续操作
return;
}
// 判断用户输入的新密码和确认密码是否相等
if (adpsw.equals(adpsw1)){
// 如果相等则进行密码强度验证调用isPasswordValid方法来检查密码是否符合要求
if (!isPasswordValid(adpsw)) {
// 如果密码强度不符合要求例如长度不足8位或不包含字母和数字
// 通过响应向客户端发送一段JavaScript代码
// 该代码会弹出一个提示框显示“密码强度不足至少8位包含字母和数字”
// 并将页面重定向到密码重置页面(路径为/view/frontweb/deptadmforgetpsw.jsp
resp.getWriter().write("<script>alert('密码强度不足至少8位包含字母和数字'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmforgetpsw.jsp';</script>");
// 终止当前doGet方法的执行不再继续后续操作
return;
}
// 构造一条SQL更新语句用于更新数据库中admin表的记录
// 将指定管理员编号adno对应的密码adpsw进行更新
String sql = "update admin set adpsw = ? where adno = ?";
// 创建一个包含SQL语句参数的对象数组第一个参数是新密码第二个参数是管理员编号
Object[] objects = {adpsw, adno};
// 调用isAdminExists方法来验证要重置密码的管理员账号是否存在于数据库中
if (!isAdminExists(adno)) {
// 如果管理员账号不存在通过响应向客户端发送一段JavaScript代码
// 该代码会弹出一个提示框,显示“管理员账号不存在!”
// 并将页面重定向到密码重置页面(路径为/view/frontweb/deptadmforgetpsw.jsp
resp.getWriter().write("<script>alert('管理员账号不存在!'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmforgetpsw.jsp';</script>");
// 终止当前doGet方法的执行不再继续后续操作
return;
}
// 调用FrontWebDao类中的executeUpdate方法执行SQL更新语句
// 该方法会返回受影响的行数即成功更新的记录数量将其存储在num变量中
int num = FrontWebDao.executeUpdate(sql, objects);
// 判断受影响的行数是否大于0若大于0表示密码更新操作成功
if (num > 0){
// 如果更新成功通过响应向客户端发送一段JavaScript代码
// 该代码会弹出一个提示框,显示“修改密码成功!请登录!”
// 并将页面重定向到部门管理员登录页面(路径为/view/frontweb/deptadmlogin.jsp同时关闭当前窗口
resp.getWriter().write("<script>alert('修改密码成功!请登录!'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmlogin.jsp';" + "window.close();</script>");
}else {
resp.getWriter().write("<script>alert('发布失败!'); window.location='" + req.getContextPath() + "/view/frontweb/pubnews.jsp';" + "window.close();</script>");
// 如果受影响的行数不大于0说明密码更新操作失败
// 通过响应向客户端发送一段JavaScript代码
// 该代码会弹出一个提示框,显示“修改密码失败!请联系管理员”
// 并将页面重定向到密码重置页面(路径为/view/frontweb/deptadmforgetpsw.jsp
resp.getWriter().write("<script>alert('修改密码失败!请联系管理员'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmforgetpsw.jsp';</script>");
}
}else {//否则不能发布
resp.getWriter().write("<script>alert('发布失败!此新闻编号已存在!'); window.location='" + req.getContextPath() + "/view/frontweb/pubnews.jsp';" + "window.close();</script>");
}else {
// 如果用户输入的新密码和确认密码不相等
// 通过响应向客户端发送一段JavaScript代码
// 该代码会弹出一个提示框,显示“两次密码不一样!请重新输入密码!”
// 并将页面重定向到密码重置页面(路径为/view/frontweb/deptadmforgetpsw.jsp同时关闭当前窗口
resp.getWriter().write("<script>alert('两次密码不一样!请重新输入密码!'); window.location='" + req.getContextPath() + "/view/frontweb/deptadmforgetpsw.jsp';" + "window.close();</script>");
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doPost方法处理HTTP POST请求
// 对于接收到的POST请求直接调用doGet方法来处理复用doGet方法中的业务逻辑
this.doGet(req, resp);
}
}
// 私有方法,用于验证管理员账号是否存在于数据库中
private boolean isAdminExists(String adno) {
// 构造一条SQL查询语句用于统计admin表中指定管理员编号adno的记录数量
String sql = "select count(*) as num from admin where adno = ?";
// 创建一个包含SQL语句参数的对象数组参数为管理员编号
Object[] params = {adno};
// 调用FrontWebDao类中的findTotalCount方法执行SQL查询语句
// 该方法会返回查询结果中记录的数量将其存储在count变量中
int count = FrontWebDao.findTotalCount(sql, params);
// 如果记录数量大于0说明管理员账号存在返回true否则返回false
return count > 0;
}
// 私有方法,用于验证密码强度是否符合要求
private boolean isPasswordValid(String password) {
// 使用正则表达式进行匹配判断密码是否至少8位并且同时包含字母和数字
// 如果匹配成功说明密码强度符合要求返回true否则返回false
return password.matches("^(?=.*[A-Za-z])(?=.*\\d).{8,}$");
}
}

@ -1,46 +1,86 @@
package com.controller.frontweb;
// 声明该Servlet所在的包为com.controller.frontweb
import com.dao.FrontWebDao;
// 导入数据访问对象类FrontWebDao用于执行数据库相关操作
import javax.servlet.ServletException;
// 导入Servlet异常类用于处理Servlet相关的异常情况
import javax.servlet.annotation.WebServlet;
// 导入用于将Servlet映射到URL的注解
import javax.servlet.http.HttpServlet;
// 导入HttpServlet类这是所有基于HTTP协议的Servlet的基类
import javax.servlet.http.HttpServletRequest;
// 导入用于处理HTTP请求的类
import javax.servlet.http.HttpServletResponse;
// 导入用于处理HTTP响应的类
import javax.servlet.http.HttpSession;
// 导入HttpSession类用于管理用户会话
import java.io.IOException;
// 导入用于处理I/O异常的类
@WebServlet("/SchoAdmAlterPswServlet")
// 使用@WebServlet注解将该Servlet映射到URL路径为"/SchoAdmAlterPswServlet"
public class SchoAdmAlterPswServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doGet方法用于处理HTTP GET请求
// 设置请求的字符编码为UTF-8防止请求参数中的中文乱码
req.setCharacterEncoding("utf-8");
// 设置响应的字符编码为UTF-8防止响应内容中的中文乱码
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型为HTML字符编码为UTF-8告知客户端如何解析响应内容
resp.setContentType("text/html;charset=utf-8");
// 获取当前请求的会话对象
HttpSession session = req.getSession();
// 从会话中获取名为"adno"的属性值并将其转换为String类型该值表示管理员编号
String adno = (String) session.getAttribute("adno");
// 从请求参数中获取名为"adpsw"的参数值,该值表示用户输入的新密码
String adpsw = req.getParameter("adpsw");
// 从请求参数中获取名为"adpsw1"的参数值,该值表示用户再次输入的新密码用于确认
String adpsw1 = req.getParameter("adpsw1");
//判断两次密码是否相同
if (adpsw.equals(adpsw1)){//相同则进行修改操作
// 判断两次输入的密码是否相同
if (adpsw.equals(adpsw1)){
// 如果相同,则进行密码修改操作
// 构造SQL更新语句用于更新admin表中指定adno的管理员的密码
String sql = "update admin set adpsw = ? where adno = ?";
// 创建包含SQL语句参数的对象数组第一个参数是新密码第二个参数是管理员编号
Object[] objects = {adpsw, adno};
// 调用FrontWebDao的executeUpdate方法执行SQL更新语句并获取受影响的行数
int num = FrontWebDao.executeUpdate(sql, objects);
if (num > 0){
// 如果受影响的行数大于0说明密码修改成功
// 通过响应输出一段JavaScript代码弹出提示框提示修改密码成功并要求用户重新登录
// 同时将页面重定向到学校管理员登录页面,并关闭当前窗口
resp.getWriter().write("<script>alert('修改密码成功!请重新登录!'); window.location='" + req.getContextPath() + "/view/frontweb/schoadmlogin.jsp';" + "window.close();</script>");
}else {
// 如果受影响的行数不大于0说明密码修改失败
// 通过响应输出一段JavaScript代码弹出提示框提示修改密码失败并让用户重新输入密码
// 同时将页面重定向到学校管理员修改密码页面,并关闭当前窗口
resp.getWriter().write("<script>alert('修改密码失败!请重新输入密码!'); window.location='" + req.getContextPath() + "/view/frontweb/schoadmalterpsw.jsp';" + "window.close();</script>");
}
}else {//不同则重新输入密码
}else {
// 如果两次输入的密码不同
// 通过响应输出一段JavaScript代码弹出提示框提示两次密码不一样并让用户重新输入密码
// 同时将页面重定向到学校管理员修改密码页面,并关闭当前窗口
resp.getWriter().write("<script>alert('两次密码不一样!请重新输入密码!'); window.location='" + req.getContextPath() + "/view/frontweb/schoadmalterpsw.jsp';" + "window.close();</script>");
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doPost方法用于处理HTTP POST请求
// 直接调用doGet方法来处理POST请求复用doGet方法中的逻辑
this.doGet(req, resp);
}
}
}

@ -1,44 +1,81 @@
package com.controller.frontweb;
// 声明该Servlet所属的包为com.controller.frontweb
import com.dao.FrontWebDao;
// 导入数据访问对象类FrontWebDao用于后续执行数据库操作
import javax.servlet.ServletException;
// 导入Servlet异常类用于处理Servlet运行时可能出现的异常
import javax.servlet.annotation.WebServlet;
// 导入注解用于将Servlet映射到特定的URL
import javax.servlet.http.HttpServlet;
// 导入HttpServlet类这是编写Servlet时的基础类用于处理HTTP请求和响应
import javax.servlet.http.HttpServletRequest;
// 导入用于处理HTTP请求的类通过它可以获取请求参数等信息
import javax.servlet.http.HttpServletResponse;
// 导入用于处理HTTP响应的类通过它可以设置响应内容、状态码等
import java.io.IOException;
// 导入用于处理I/O异常的类例如在读写数据时可能出现的异常
@WebServlet("/SchoAdmForgetPswServlet")
// 使用@WebServlet注解将当前Servlet映射到URL路径为"/SchoAdmForgetPswServlet"
public class SchoAdmForgetPswServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doGet方法用于处理HTTP GET请求
// 设置请求的字符编码为UTF-8防止请求参数中出现中文乱码问题
req.setCharacterEncoding("utf-8");
// 设置响应的字符编码为UTF-8防止响应内容中出现中文乱码问题
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型为HTML格式并且字符编码为UTF-8告知客户端如何解析响应内容
resp.setContentType("text/html;charset=utf-8");
// 从HTTP请求的参数中获取名为"adno"的参数值,该值代表管理员编号
String adno = req.getParameter("adno");
// 从HTTP请求的参数中获取名为"adpsw"的参数值,该值代表用户输入的新密码
String adpsw = req.getParameter("adpsw");
// 从HTTP请求的参数中获取名为"adpsw1"的参数值,该值代表用户再次输入的用于确认的新密码
String adpsw1 = req.getParameter("adpsw1");
//判断两次密码是否相同
if (adpsw.equals(adpsw1)){//相同则进行修改操作
// 判断用户输入的新密码和确认密码是否相等
if (adpsw.equals(adpsw1)){
// 如果相等,则进行密码修改操作
// 构造SQL更新语句用于更新数据库中admin表的记录将指定管理员编号adno对应的密码adpsw进行更新
String sql = "update admin set adpsw = ? where adno = ?";
// 创建一个包含SQL语句参数的对象数组第一个参数是新密码第二个参数是管理员编号
Object[] objects = {adpsw, adno};
// 调用FrontWebDao类中的executeUpdate方法执行SQL更新语句并获取受影响的行数
int num = FrontWebDao.executeUpdate(sql, objects);
if (num > 0){
// 如果受影响的行数大于0说明密码更新操作成功
// 通过响应输出一段JavaScript代码弹出提示框显示“修改密码成功请登录
// 并将页面重定向到学校管理员登录页面,同时关闭当前窗口
resp.getWriter().write("<script>alert('修改密码成功!请登录!'); window.location='" + req.getContextPath() + "/view/frontweb/schoadmlogin.jsp';" + "window.close();</script>");
}else {
// 如果受影响的行数不大于0说明密码更新操作失败
// 通过响应输出一段JavaScript代码弹出提示框显示“修改密码失败请重新输入密码
// 并将页面重定向到学校管理员忘记密码重置页面,同时关闭当前窗口
resp.getWriter().write("<script>alert('修改密码失败!请重新输入密码!'); window.location='" + req.getContextPath() + "/view/frontweb/schoadmforgetpsw.jsp';" + "window.close();</script>");
}
}else {//不同则重新输入密码
}else {
// 如果用户输入的新密码和确认密码不相等
// 通过响应输出一段JavaScript代码弹出提示框显示“两次密码不一样!请重新输入密码!”
// 并将页面重定向到学校管理员忘记密码重置页面,同时关闭当前窗口
resp.getWriter().write("<script>alert('两次密码不一样!请重新输入密码!'); window.location='" + req.getContextPath() + "/view/frontweb/schoadmforgetpsw.jsp';" + "window.close();</script>");
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doPost方法用于处理HTTP POST请求
// 直接调用doGet方法来处理POST请求复用doGet方法中的业务逻辑
this.doGet(req, resp);
}
}
}

@ -1,64 +1,111 @@
package com.controller.frontweb;
// 声明该Servlet所在的包名为com.controller.frontweb
import com.dao.FrontWebDao;
// 导入数据访问对象类FrontWebDao用于执行数据库相关操作如查询等
import javax.servlet.ServletException;
// 导入处理Servlet异常的类在Servlet处理请求过程中发生异常时使用
import javax.servlet.annotation.WebServlet;
// 导入用于将Servlet映射到URL的注解
import javax.servlet.http.HttpServlet;
// 导入HttpServlet类所有基于HTTP协议的Servlet都继承自该类
import javax.servlet.http.HttpServletRequest;
// 导入用于处理HTTP请求的类通过它可以获取请求参数、请求头信息等
import javax.servlet.http.HttpServletResponse;
// 导入用于处理HTTP响应的类通过它可以设置响应内容、响应头信息等
import javax.servlet.http.HttpSession;
// 导入HttpSession类用于管理用户会话存储用户相关信息
import javax.sql.rowset.serial.SerialStruct;
// 导入SerialStruct类这里未使用到属于无用导入可删除
import java.io.IOException;
// 导入处理I/O异常的类如在读取或写入数据时可能发生的异常
import java.sql.ResultSet;
// 导入用于处理数据库查询结果的类,用于获取查询到的数据
@WebServlet("/SchoAdmLoginServlet")
// 使用@WebServlet注解将该Servlet映射到URL路径为"/SchoAdmLoginServlet"
public class SchoAdmLoginServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doGet方法用于处理HTTP GET请求
// 设置请求的字符编码为UTF-8防止请求参数中的中文乱码
req.setCharacterEncoding("utf-8");
// 设置响应的字符编码为UTF-8防止响应内容中的中文乱码
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型为HTML字符编码为UTF-8告知客户端如何解析响应内容
resp.setContentType("text/html;charset=utf-8");
//获取表单请求个参数
// 获取表单请求中的参数,这里获取管理员编号
String adno = req.getParameter("adno");
// 获取表单请求中的参数,这里获取管理员密码
String adpsw = req.getParameter("adpsw");
// 固定设置所属单位为"学校",表示学校管理员
String belong = "学校";
// 构造SQL查询语句用于从admin表中查询匹配的管理员记录
String sql = "select * from admin where adno = ? and adpsw = ? and belong = ?";
// 创建包含SQL语句参数的对象数组依次为管理员编号、密码、所属单位
Object[] objects = {adno, adpsw, belong};
// 调用FrontWebDao的login方法执行SQL查询并获取结果集
ResultSet resultSet = FrontWebDao.login(sql, objects);
//判断密码和账号是否正确
// 判断密码和账号是否正确
try {
// 如果结果集有下一条记录,说明查询到了匹配的管理员记录
if (resultSet.next()){
// 创建会话属性对象,后面处理请求要
// 创建会话对象,用于存储用户会话信息
HttpSession session = req.getSession();
// 在会话中存储管理员编号
session.setAttribute("adno", adno);
// 在会话中存储所属单位(这里是"学校"
session.setAttribute("belong", belong);
// 在会话中存储学校管理员编号与adno相同这里可能存在命名重复问题
session.setAttribute("schoadno", adno);
// 打印登录成功信息到控制台,用于调试
System.out.println("登陆成功!");
// 设置请求属性指定跳转的URL路径
req.setAttribute("httpUrl","/view/schoadmin/schomainview.jsp");
// 设置请求属性,指定提示信息
req.setAttribute("info", "登录成功!即将跳转至学校管理员后台首页!");
// 设置请求属性,指定页面标题
req.setAttribute("title","登录成功");
// 转发请求到指定的页面(/view/frontweb/info.jsp并传递请求和响应对象
req.getRequestDispatcher("/view/frontweb/info.jsp").forward(req, resp);
}else {
// 如果结果集没有下一条记录,说明账号或密码错误
System.out.println("用户名或密码错误!请重新登录!");
//返回登录成功的信息
// 设置请求属性指定跳转回登录页面的URL路径
req.setAttribute("httpUrl","/view/frontweb/schoadmlogin.jsp");
// 设置请求属性,指定错误提示信息
req.setAttribute("info", "登录失败!管理员账号或密码错误!即将跳转至登录页面!");
// 设置请求属性,指定页面标题
req.setAttribute("title","登录失败");
// 转发请求到指定的页面(/view/frontweb/info.jsp并传递请求和响应对象
req.getRequestDispatcher("/view/frontweb/info.jsp").forward(req, resp);
}
} catch (Exception e) {
// 捕获异常并打印异常堆栈信息,用于调试和错误排查
e.printStackTrace();
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doPost方法用于处理HTTP POST请求
// 直接调用doGet方法来处理POST请求复用doGet方法中的业务逻辑
this.doGet(req, resp);
}
}
}

@ -1,46 +1,86 @@
package com.controller.frontweb;
// 声明该Servlet所在的包为com.controller.frontweb
import com.dao.FrontWebDao;
// 导入数据访问对象类FrontWebDao用于执行数据库相关操作如更新操作
import javax.servlet.ServletException;
// 导入Servlet异常类用于处理Servlet在运行过程中可能出现的异常情况
import javax.servlet.annotation.WebServlet;
// 导入注解用于将Servlet映射到特定的URL
import javax.servlet.http.HttpServlet;
// 导入HttpServlet类这是编写Servlet时继承的基础类用于处理HTTP请求和响应
import javax.servlet.http.HttpServletRequest;
// 导入用于处理HTTP请求的类通过它可以获取请求参数、请求头信息等
import javax.servlet.http.HttpServletResponse;
// 导入用于处理HTTP响应的类通过它可以设置响应内容、状态码等
import javax.servlet.http.HttpSession;
// 导入HttpSession类用于管理用户会话存储用户相关的信息
import java.io.IOException;
// 导入用于处理I/O异常的类例如在读写数据时可能出现的异常
@WebServlet("/StuAlterPswServlet")
// 使用@WebServlet注解将该Servlet映射到URL路径为"/StuAlterPswServlet"
public class StuAlterPswServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doGet方法用于处理HTTP GET请求
// 设置请求的字符编码为UTF-8防止请求参数中的中文乱码
req.setCharacterEncoding("utf-8");
// 设置响应的字符编码为UTF-8防止响应内容中的中文乱码
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型为HTML格式并且字符编码为UTF-8告知客户端如何解析响应内容
resp.setContentType("text/html;charset=utf-8");
// 获取当前请求的会话对象
HttpSession session = req.getSession();
// 从会话中获取名为"sno"的属性值并将其转换为String类型该值表示学生编号
String sno = (String) session.getAttribute("sno");
// 从请求参数中获取名为"spsw"的参数值,该值表示学生输入的新密码
String spsw = req.getParameter("spsw");
// 从请求参数中获取名为"spsw1"的参数值,该值表示学生再次输入的新密码用于确认
String spsw1 = req.getParameter("spsw1");
//判断两次密码是否相同
if (spsw.equals(spsw1)){//相同则进行修改操作
// 判断两次输入的密码是否相同
if (spsw.equals(spsw1)){
// 如果相同,则进行密码修改操作
// 构造SQL更新语句用于更新student表中指定sno的学生的密码
String sql = "update student set spsw = ? where sno = ?";
// 创建包含SQL语句参数的对象数组第一个参数是新密码第二个参数是学生编号
Object[] objects = {spsw, sno};
// 调用FrontWebDao的executeUpdate方法执行SQL更新语句并获取受影响的行数
int num = FrontWebDao.executeUpdate(sql, objects);
if (num > 0){
// 如果受影响的行数大于0说明密码修改成功
// 通过响应输出一段JavaScript代码弹出提示框提示修改密码成功并要求学生重新登录
// 同时将页面重定向到学生登录页面,并关闭当前窗口
resp.getWriter().write("<script>alert('修改密码成功!请重新登录!'); window.location='" + req.getContextPath() + "/view/frontweb/stulogin.jsp';" + "window.close();</script>");
}else {
// 如果受影响的行数不大于0说明密码修改失败
// 通过响应输出一段JavaScript代码弹出提示框提示修改密码失败并让学生重新输入密码
// 同时将页面重定向到学生修改密码页面,并关闭当前窗口
resp.getWriter().write("<script>alert('修改密码失败!请重新输入密码!'); window.location='" + req.getContextPath() + "/view/frontweb/stualterpsw.jsp';" + "window.close();</script>");
}
}else {//不同则重新输入密码
}else {
// 如果两次输入的密码不同
// 通过响应输出一段JavaScript代码弹出提示框提示两次密码不一样并让学生重新输入密码
// 同时将页面重定向到学生修改密码页面,并关闭当前窗口
resp.getWriter().write("<script>alert('两次密码不一样!请重新输入密码!'); window.location='" + req.getContextPath() + "/view/frontweb/stualterpsw.jsp';" + "window.close();</script>");
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doPost方法用于处理HTTP POST请求
// 直接调用doGet方法来处理POST请求复用doGet方法中的逻辑
this.doGet(req, resp);
}
}
}

@ -1,45 +1,84 @@
package com.controller.frontweb;
// 声明该Servlet所在的包名为com.controller.frontweb
import com.dao.FrontWebDao;
// 导入数据访问对象类FrontWebDao用于执行数据库操作如更新密码的SQL语句
import javax.servlet.ServletException;
// 导入Servlet异常类用于处理Servlet在运行过程中可能抛出的异常
import javax.servlet.annotation.WebServlet;
// 导入注解用于将Servlet映射到特定的URL
import javax.servlet.http.HttpServlet;
// 导入HttpServlet类这是编写Servlet时的基类用于处理HTTP请求和响应
import javax.servlet.http.HttpServletRequest;
// 导入用于处理HTTP请求的类可获取请求参数等信息
import javax.servlet.http.HttpServletResponse;
// 导入用于处理HTTP响应的类可设置响应内容、状态码等
import javax.servlet.http.HttpSession;
// 导入HttpSession类用于管理用户会话存储用户相关信息虽然此处未使用会话存储相关信息但导入了该类
import java.io.IOException;
// 导入用于处理I/O异常的类例如在读写数据时可能出现的异常
@WebServlet("/StuForgetPswServlet")
// 使用@WebServlet注解将该Servlet映射到URL路径为"/StuForgetPswServlet"
public class StuForgetPswServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doGet方法用于处理HTTP GET请求
// 设置请求的字符编码为UTF-8防止请求参数中的中文乱码
req.setCharacterEncoding("utf-8");
// 设置响应的字符编码为UTF-8防止响应内容中的中文乱码
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型为HTML格式且字符编码为UTF-8告知客户端如何解析响应内容
resp.setContentType("text/html;charset=utf-8");
// 从HTTP请求的参数中获取名为"sno"的参数值,该值代表学生编号
String sno = req.getParameter("sno");
// 从HTTP请求的参数中获取名为"spsw"的参数值,该值代表学生输入的新密码
String spsw = req.getParameter("spsw");
// 从HTTP请求的参数中获取名为"spsw1"的参数值,该值代表学生再次输入的用于确认的新密码
String spsw1 = req.getParameter("spsw1");
//判断两次密码是否相同
if (spsw.equals(spsw1)){//相同则进行修改操作
// 判断用户输入的新密码和确认密码是否相等
if (spsw.equals(spsw1)){
// 如果相等,则进行密码修改操作
// 构造SQL更新语句用于更新student表中指定学生编号sno对应的密码spsw
String sql = "update student set spsw = ? where sno = ?";
// 创建一个包含SQL语句参数的对象数组第一个参数是新密码第二个参数是学生编号
Object[] objects = {spsw, sno};
// 调用FrontWebDao类中的executeUpdate方法执行SQL更新语句并获取受影响的行数
int num = FrontWebDao.executeUpdate(sql, objects);
if (num > 0){
// 如果受影响的行数大于0说明密码更新操作成功
// 通过响应输出一段JavaScript代码弹出提示框显示“修改密码成功请登录
// 并将页面重定向到学生登录页面,同时关闭当前窗口
resp.getWriter().write("<script>alert('修改密码成功!请登录!'); window.location='" + req.getContextPath() + "/view/frontweb/stulogin.jsp';" + "window.close();</script>");
}else {
// 如果受影响的行数不大于0说明密码更新操作失败
// 通过响应输出一段JavaScript代码弹出提示框显示“修改密码失败请重新输入密码
// 并将页面重定向到学生忘记密码重置页面,同时关闭当前窗口
resp.getWriter().write("<script>alert('修改密码失败!请重新输入密码!'); window.location='" + req.getContextPath() + "/view/frontweb/stuforgetpsw.jsp';" + "window.close();</script>");
}
}else {//不同则重新输入密码
}else {
// 如果用户输入的新密码和确认密码不相等
// 通过响应输出一段JavaScript代码弹出提示框显示“两次密码不一样!请重新输入密码!”
// 并将页面重定向到学生忘记密码重置页面,同时关闭当前窗口
resp.getWriter().write("<script>alert('两次密码不一样!请重新输入密码!'); window.location='" + req.getContextPath() + "/view/frontweb/stuforgetpsw.jsp';" + "window.close();</script>");
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doPost方法用于处理HTTP POST请求
// 直接调用doGet方法来处理POST请求复用doGet方法中的业务逻辑
this.doGet(req, resp);
}
}
}

@ -1,61 +1,113 @@
package com.controller.frontweb;
// 声明该Servlet所在的包名为com.controller.frontweb
import com.dao.FrontWebDao;
// 导入数据访问对象类FrontWebDao用于执行数据库查询操作
import com.dao.StuDao;
// 导入StuDao类这里未使用到属于无用导入可删除
import com.entity.Student;
// 导入Student实体类用于封装学生相关信息
import com.utils.JDBCUtils;
// 导入JDBC工具类用于数据库连接的管理和资源关闭等操作
import javax.servlet.ServletException;
// 导入Servlet异常类用于处理Servlet运行时可能出现的异常
import javax.servlet.annotation.WebServlet;
// 导入注解用于将Servlet映射到特定的URL
import javax.servlet.http.HttpServlet;
// 导入HttpServlet类所有基于HTTP协议的Servlet都继承自该类
import javax.servlet.http.HttpServletRequest;
// 导入用于处理HTTP请求的类通过它可以获取请求参数、请求头信息等
import javax.servlet.http.HttpServletResponse;
// 导入用于处理HTTP响应的类通过它可以设置响应内容、响应头信息等
import javax.servlet.http.HttpSession;
// 导入HttpSession类用于管理用户会话存储用户相关信息
import java.io.IOException;
// 导入用于处理I/O异常的类如在读取或写入数据时可能发生的异常
import java.sql.ResultSet;
// 导入用于处理数据库查询结果的类,用于获取查询到的数据
import java.util.ArrayList;
// 导入ArrayList类这里未使用到属于无用导入可删除
@WebServlet("/StuInfoServlet")
// 使用@WebServlet注解将该Servlet映射到URL路径为"/StuInfoServlet"
public class StuInfoServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doGet方法用于处理HTTP GET请求
// 设置请求的字符编码为UTF-8防止请求参数中的中文乱码
req.setCharacterEncoding("utf-8");
// 设置响应的字符编码为UTF-8防止响应内容中的中文乱码
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型为HTML字符编码为UTF-8告知客户端如何解析响应内容
resp.setContentType("text/html;charset=utf-8");
// 获取当前请求的会话对象
HttpSession session = req.getSession();
// 从会话中获取名为"sno"的属性值并将其转换为String类型该值表示学生编号
String sno = (String) session.getAttribute("sno");
// 构造SQL查询语句用于从student表中查询指定学生编号sno的学生信息
String sql = "select * from student where sno = ?";
// 创建包含SQL语句参数的对象数组参数为学生编号
Object[] objects = {sno};
// 调用FrontWebDao的qureyInfo方法执行SQL查询并获取结果集
ResultSet resultSet = FrontWebDao.qureyInfo(sql, objects);
// 创建一个Student对象用于存储查询到的学生信息
Student student = new Student();
try {
// 遍历结果集将每一行数据封装到Student对象中
while (resultSet.next()){
// 设置学生编号
student.setSno(resultSet.getString("sno"));
// 设置学生姓名
student.setSname(resultSet.getString("sname"));
// 设置学生性别
student.setSsex(resultSet.getString("ssex"));
// 设置学生年龄将数据库中的整数类型值转换为int类型
student.setSage(resultSet.getInt("sage"));
// 设置学生班级
student.setSclass(resultSet.getString("sclass"));
// 设置学生专业
student.setSpecialty(resultSet.getString("specialty"));
// 设置学生所在系部
student.setSdept(resultSet.getString("sdept"));
// 设置学生电话号码
student.setSphone(resultSet.getString("sphone"));
}
} catch (Exception e) {
// 捕获异常并打印异常堆栈信息,用于调试和错误排查
e.printStackTrace();
}finally {
} finally {
// 无论是否发生异常都调用JDBCUtils的close方法关闭结果集释放资源
JDBCUtils.close(resultSet);
}
// 将封装好的学生信息对象student设置为请求属性以便在后续页面中使用
req.setAttribute("student", student);
// 转发请求到指定的页面(/view/frontweb/stuinfo.jsp并传递请求和响应对象
req.getRequestDispatcher("/view/frontweb/stuinfo.jsp").forward(req, resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doPost方法用于处理HTTP POST请求
// 直接调用doGet方法来处理POST请求复用doGet方法中的业务逻辑
this.doGet(req, resp);
}
}
}

@ -1,56 +1,104 @@
package com.controller.frontweb;
// 声明该Servlet所在的包名为com.controller.frontweb
import com.dao.FrontWebDao;
// 导入数据访问对象类FrontWebDao用于执行数据库查询操作
import javax.servlet.ServletException;
// 导入Servlet异常类用于处理Servlet运行时可能出现的异常
import javax.servlet.annotation.WebServlet;
// 导入注解用于将Servlet映射到特定的URL
import javax.servlet.http.HttpServlet;
// 导入HttpServlet类所有基于HTTP协议的Servlet都继承自该类
import javax.servlet.http.HttpServletRequest;
// 导入用于处理HTTP请求的类通过它可以获取请求参数等信息
import javax.servlet.http.HttpServletResponse;
// 导入用于处理HTTP响应的类通过它可以设置响应内容、状态码等
import javax.servlet.http.HttpSession;
// 导入HttpSession类用于管理用户会话存储用户相关信息
import java.io.IOException;
// 导入用于处理I/O异常的类如在读写数据时可能发生的异常
import java.sql.ResultSet;
// 导入用于处理数据库查询结果的类
import java.sql.SQLException;
// 导入用于处理SQL异常的类
@WebServlet("/StuLoginServlet")
// 使用@WebServlet注解将该Servlet映射到URL路径为"/StuLoginServlet"
public class StuLoginServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doGet方法用于处理HTTP GET请求
// 设置请求的字符编码为UTF-8防止请求参数中的中文乱码
req.setCharacterEncoding("utf-8");
// 设置响应的字符编码为UTF-8防止响应内容中的中文乱码
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型为HTML格式并且字符编码为UTF-8告知客户端如何解析响应内容
resp.setContentType("text/html;charset=utf-8");
// 从HTTP请求的参数中获取名为"sno"的参数值,该值代表学生编号
String sno = req.getParameter("sno");
// 从HTTP请求的参数中获取名为"spsw"的参数值,该值代表学生密码
String spsw = req.getParameter("spsw");
// 将获取到的学生编号打印到控制台,用于调试
System.out.println(sno);
// 将获取到的学生密码打印到控制台,用于调试
System.out.println(spsw);
// 获取当前请求的会话对象,如果不存在则创建一个新的会话
HttpSession session = req.getSession();
// 将学生编号存储到会话中,以便在后续请求中可以获取该信息
session.setAttribute("sno", sno);
// 构造SQL查询语句用于从student表中查询匹配的学生记录
String sql = "select * from student where sno = ? and spsw = ?";
// 创建包含SQL语句参数的对象数组依次为学生编号、学生密码
Object[] objects = {sno, spsw};
// 调用FrontWebDao的login方法执行SQL查询并获取结果集
ResultSet resultSet = FrontWebDao.login(sql, objects);
try {
// 如果结果集有下一条记录,说明查询到了匹配的学生记录
if (resultSet.next()){
// 设置请求属性指定跳转的URL路径为"/StuInfoServlet"即学生信息Servlet
req.setAttribute("httpUrl","/StuInfoServlet");
// 设置请求属性,指定提示信息
req.setAttribute("info", "登录成功!即将跳转至学生信息页面!");
// 设置请求属性,指定页面标题
req.setAttribute("title","登录成功");
// 转发请求到指定的页面(/view/frontweb/info.jsp并传递请求和响应对象
req.getRequestDispatcher("/view/frontweb/info.jsp").forward(req, resp);
}else {
// 如果结果集没有下一条记录,说明学号或密码错误
// 设置请求属性指定跳转回登录页面的URL路径
req.setAttribute("httpUrl","/view/frontweb/stulogin.jsp");
// 设置请求属性,指定错误提示信息
req.setAttribute("info", "登录失败!学号或密码错误!即将跳转至登录页面!");
// 设置请求属性,指定页面标题
req.setAttribute("title","登录失败");
// 转发请求到指定的页面(/view/frontweb/info.jsp并传递请求和响应对象
req.getRequestDispatcher("/view/frontweb/info.jsp").forward(req, resp);
}
} catch (SQLException e) {
// 捕获SQL异常并打印异常堆栈信息用于调试和错误排查
e.printStackTrace();
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doPost方法用于处理HTTP POST请求
// 直接调用doGet方法来处理POST请求复用doGet方法中的业务逻辑
this.doGet(req, resp);
}
}
}

@ -1,80 +1,144 @@
package com.controller.frontweb;
// 声明该Servlet所在的包为com.controller.frontweb
import com.dao.DeptAdminDao;
// 导入部门管理员数据访问对象类但在本Servlet中未使用
import com.dao.FrontWebDao;
// 导入前端数据访问对象类,用于执行数据库操作
import com.mysql.fabric.Response;
// 导入MySQL Fabric响应类但在本Servlet中未使用
import javax.servlet.ServletException;
// 导入Servlet异常类用于处理Servlet运行时可能出现的异常
import javax.servlet.annotation.WebServlet;
// 导入注解用于将Servlet映射到特定的URL
import javax.servlet.http.HttpServlet;
// 导入HttpServlet类所有基于HTTP协议的Servlet都继承自该类
import javax.servlet.http.HttpServletRequest;
// 导入用于处理HTTP请求的类通过它可以获取请求参数等信息
import javax.servlet.http.HttpServletResponse;
// 导入用于处理HTTP响应的类通过它可以设置响应内容、状态码等
import javax.servlet.http.HttpSession;
// 导入HttpSession类用于管理用户会话存储用户相关信息
import javax.swing.*;
// 导入Swing组件类但在本Servlet中未使用
import java.io.IOException;
// 导入用于处理I/O异常的类如在读写数据时可能发生的异常
import java.io.PrintWriter;
// 导入用于输出响应内容的类但在本Servlet中未直接使用
import java.sql.ResultSet;
// 导入用于处理数据库查询结果的类
import java.sql.SQLException;
// 导入用于处理SQL异常的类
import java.text.SimpleDateFormat;
// 导入用于格式化日期的类
import java.util.Date;
// 导入日期类,用于获取当前日期和时间
@WebServlet("/StuPunchServlet")
// 使用@WebServlet注解将该Servlet映射到URL路径为"/StuPunchServlet"
public class StuPunchServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doGet方法用于处理HTTP GET请求
// 设置请求的字符编码为UTF-8防止请求参数中的中文乱码
req.setCharacterEncoding("utf-8");
// 设置响应的字符编码为UTF-8防止响应内容中的中文乱码
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型为HTML格式并且字符编码为UTF-8告知客户端如何解析响应内容
resp.setContentType("text/html;charset=utf-8");
//获取sno
// 获取当前请求的会话对象
HttpSession session = req.getSession();
// 从会话中获取名为"sno"的属性值并将其转换为String类型该值表示学生编号
String sno = (String) session.getAttribute("sno");
// 打印学生编号到控制台,用于调试
System.out.println(sno);
//获取表单请求的参数
/*String sno = req.getParameter("sno");*/
// 从HTTP请求的参数中获取名为"sishot"的参数值,该值表示学生是否发热
String sishot = req.getParameter("sishot");
// 从HTTP请求的参数中获取名为"siscough"的参数值,该值表示学生是否咳嗽
String siscough = req.getParameter("siscough");
// 从HTTP请求的参数中获取名为"sisseem"的参数值,该值表示学生是否有其他症状
String sisseem = req.getParameter("sisseem");
// 从HTTP请求的参数中获取名为"sisdiagnose"的参数值,该值表示学生是否被诊断
String sisdiagnose = req.getParameter("sisdiagnose");
// 从HTTP请求的参数中获取名为"sstatus"的参数值,该值表示学生当前状态
String sstatus = req.getParameter("sstatus");
// 设置学生打卡状态为"是",表示已打卡
String sispunch = "是";
// 创建Date对象获取当前时间
Date date = new Date();
//获取当前日期
// 创建SimpleDateFormat对象用于将日期格式化为"yyyy-MM-dd"的字符串
SimpleDateFormat sf1 = new SimpleDateFormat("yyyy-MM-dd");
// 格式化当前日期
String spunchdate = sf1.format(date);
// 打印当前日期到控制台,用于调试
System.out.println(spunchdate);
//获取当前时间
// 创建SimpleDateFormat对象用于将时间格式化为"HH:mm"的字符串
SimpleDateFormat sf2 = new SimpleDateFormat("HH:mm");
// 格式化当前时间
String spunchtime = sf2.format(date);
// 打印当前时间到控制台,用于调试
System.out.println(spunchtime);
// 声明SQL语句变量初始化为null
String sql = null;
//查询是否已经打卡
// 构造SQL查询语句,用于查询该学生今天是否已经打卡
sql = "select count(*) as num from stupunchin where sno = ? and spunchdate = ?";
// 创建包含SQL语句参数的对象数组依次为学生编号、打卡日期
Object[] objects1 = {sno, spunchdate};
// 调用FrontWebDao的findTotalCount方法执行SQL查询获取查询结果的数量
int count = FrontWebDao.findTotalCount(sql, objects1);
if (count == 0){//无则操作
if (count == 0){
// 如果查询结果数量为0表示该学生今天还未打卡则执行插入操作
sql = "insert into stupunchin values(?, ?, ?, ?, ?, ?, ?, ?, ?)";
// 创建包含SQL语句参数的对象数组依次为学生编号、是否打卡、打卡日期、打卡时间、是否发热、是否咳嗽、是否有其他症状、是否被诊断、当前状态
Object[] objects2 = {sno, sispunch, spunchdate, spunchtime, sishot, siscough, sisseem, sisdiagnose, sstatus};
// 调用FrontWebDao的executeUpdate方法执行SQL插入语句并获取受影响的行数
int num = FrontWebDao.executeUpdate(sql, objects2);
// 打印受影响的行数到控制台,用于调试
System.out.println(num);
// 通过响应输出一段JavaScript代码弹出提示框提示打卡成功
// 并将页面重定向到学生信息页面,同时关闭当前窗口
resp.getWriter().write("<script>alert('打卡成功!'); window.location='" + req.getContextPath() + "/StuInfoServlet';" + "window.close();</script>");
}else {//已打卡
}else {
// 如果查询结果数量不为0表示该学生今天已经打卡
// 通过响应输出一段JavaScript代码弹出提示框提示今天已打卡不能再次打卡
// 并将页面重定向到学生信息页面,同时关闭当前窗口
resp.getWriter().write("<script>alert('您今天已成功打卡!不能再次打卡!'); window.location='" + req.getContextPath() + "/StuInfoServlet';" + "window.close();</script>");
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doPost方法用于处理HTTP POST请求
// 直接调用doGet方法来处理POST请求复用doGet方法中的业务逻辑
doGet(req, resp);
}
}
}

@ -1,46 +1,86 @@
package com.controller.frontweb;
// 声明该Servlet所在的包名为com.controller.frontweb
import com.dao.FrontWebDao;
// 导入数据访问对象类FrontWebDao用于执行数据库相关操作如更新操作
import javax.servlet.ServletException;
// 导入Servlet异常类用于处理Servlet运行时可能出现的异常
import javax.servlet.annotation.WebServlet;
// 导入注解用于将Servlet映射到特定的URL
import javax.servlet.http.HttpServlet;
// 导入HttpServlet类这是编写Servlet时继承的基础类用于处理HTTP请求和响应
import javax.servlet.http.HttpServletRequest;
// 导入用于处理HTTP请求的类通过它可以获取请求参数、请求头信息等
import javax.servlet.http.HttpServletResponse;
// 导入用于处理HTTP响应的类通过它可以设置响应内容、状态码等
import javax.servlet.http.HttpSession;
// 导入HttpSession类用于管理用户会话存储用户相关信息
import java.io.IOException;
// 导入用于处理I/O异常的类例如在读写数据时可能出现的异常
@WebServlet("/TeaAlterPswServlet")
// 使用@WebServlet注解将该Servlet映射到URL路径为"/TeaAlterPswServlet"
public class TeaAlterPswServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doGet方法用于处理HTTP GET请求
// 设置请求的字符编码为UTF-8防止请求参数中的中文乱码
req.setCharacterEncoding("utf-8");
// 设置响应的字符编码为UTF-8防止响应内容中的中文乱码
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型为HTML格式并且字符编码为UTF-8告知客户端如何解析响应内容
resp.setContentType("text/html;charset=utf-8");
// 获取当前请求的会话对象
HttpSession session = req.getSession();
// 从会话中获取名为"tno"的属性值并将其转换为String类型该值表示教师编号
String tno = (String) session.getAttribute("tno");
// 从请求参数中获取名为"tpsw"的参数值,该值表示教师输入的新密码
String tpsw = req.getParameter("tpsw");
// 从请求参数中获取名为"tpsw1"的参数值,该值表示教师再次输入的新密码用于确认
String tpsw1 = req.getParameter("tpsw1");
//判断两次密码是否相同
if (tpsw.equals(tpsw1)){//相同则进行修改操作
// 判断两次输入的密码是否相同
if (tpsw.equals(tpsw1)){
// 如果相同,则进行密码修改操作
// 构造SQL更新语句用于更新teacher表中指定tno的教师的密码
String sql = "update teacher set tpsw = ? where tno = ?";
// 创建包含SQL语句参数的对象数组第一个参数是新密码第二个参数是教师编号
Object[] objects = {tpsw, tno};
// 调用FrontWebDao的executeUpdate方法执行SQL更新语句并获取受影响的行数
int num = FrontWebDao.executeUpdate(sql, objects);
if (num > 0){
// 如果受影响的行数大于0说明密码修改成功
// 通过响应输出一段JavaScript代码弹出提示框提示修改密码成功并要求教师重新登录
// 同时将页面重定向到教师登录页面,并关闭当前窗口
resp.getWriter().write("<script>alert('修改密码成功!请重新登录!'); window.location='" + req.getContextPath() + "/view/frontweb/tealogin.jsp';" + "window.close();</script>");
}else {
// 如果受影响的行数不大于0说明密码修改失败
// 通过响应输出一段JavaScript代码弹出提示框提示修改密码失败并让教师重新输入密码
// 同时将页面重定向到教师修改密码页面,并关闭当前窗口
resp.getWriter().write("<script>alert('修改密码失败!请重新输入密码!'); window.location='" + req.getContextPath() + "/view/frontweb/teaalterpsw.jsp';" + "window.close();</script>");
}
}else {//不同则重新输入密码
}else {
// 如果两次输入的密码不同
// 通过响应输出一段JavaScript代码弹出提示框提示两次密码不一样并让教师重新输入密码
// 同时将页面重定向到教师修改密码页面,并关闭当前窗口
resp.getWriter().write("<script>alert('两次密码不一样!请重新输入密码!'); window.location='" + req.getContextPath() + "/view/frontweb/teaalterpsw.jsp';" + "window.close();</script>");
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doPost方法用于处理HTTP POST请求
// 直接调用doGet方法来处理POST请求复用doGet方法中的逻辑
this.doGet(req, resp);
}
}
}

@ -1,44 +1,81 @@
package com.controller.frontweb;
// 声明该Servlet所在的包名为com.controller.frontweb
import com.dao.FrontWebDao;
// 导入数据访问对象类FrontWebDao用于执行数据库操作如更新密码相关的SQL操作
import javax.servlet.ServletException;
// 导入Servlet异常类用于处理Servlet在运行过程中可能出现的异常情况
import javax.servlet.annotation.WebServlet;
// 导入注解用于将Servlet映射到特定的URL
import javax.servlet.http.HttpServlet;
// 导入HttpServlet类所有基于HTTP协议的Servlet都继承自该类用于处理HTTP请求和响应
import javax.servlet.http.HttpServletRequest;
// 导入用于处理HTTP请求的类通过它可以获取请求参数等信息
import javax.servlet.http.HttpServletResponse;
// 导入用于处理HTTP响应的类通过它可以设置响应内容、状态码等
import java.io.IOException;
// 导入用于处理I/O异常的类例如在读写数据时可能出现的异常
@WebServlet("/TeaForgetPswServlet")
// 使用@WebServlet注解将该Servlet映射到URL路径为"/TeaForgetPswServlet"
public class TeaForgetPswServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doGet方法用于处理HTTP GET请求
// 设置请求的字符编码为UTF-8防止请求参数中的中文乱码
req.setCharacterEncoding("utf-8");
// 设置响应的字符编码为UTF-8防止响应内容中的中文乱码
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型为HTML格式并且字符编码为UTF-8告知客户端如何解析响应内容
resp.setContentType("text/html;charset=utf-8");
// 从HTTP请求的参数中获取名为"tno"的参数值,该值代表教师编号
String tno = req.getParameter("tno");
// 从HTTP请求的参数中获取名为"tpsw"的参数值,该值代表教师输入的新密码
String tpsw = req.getParameter("tpsw");
// 从HTTP请求的参数中获取名为"tpsw1"的参数值,该值代表教师再次输入的用于确认的新密码
String tpsw1 = req.getParameter("tpsw1");
//判断两次密码是否相同
if (tpsw.equals(tpsw1)){//相同则进行修改操作
// 判断教师输入的新密码和确认密码是否相等
if (tpsw.equals(tpsw1)){
// 如果相等,则进行密码修改操作
// 构造SQL更新语句用于更新teacher表中指定教师编号tno对应的密码tpsw
String sql = "update teacher set tpsw = ? where tno = ?";
// 创建一个包含SQL语句参数的对象数组第一个参数是新密码第二个参数是教师编号
Object[] objects = {tpsw, tno};
// 调用FrontWebDao类中的executeUpdate方法执行SQL更新语句并获取受影响的行数
int num = FrontWebDao.executeUpdate(sql, objects);
if (num > 0){
// 如果受影响的行数大于0说明密码更新操作成功
// 通过响应输出一段JavaScript代码弹出提示框显示“修改密码成功请登录
// 并将页面重定向到教师登录页面,同时关闭当前窗口
resp.getWriter().write("<script>alert('修改密码成功!请登录!'); window.location='" + req.getContextPath() + "/view/frontweb/tealogin.jsp';" + "window.close();</script>");
}else {
// 如果受影响的行数不大于0说明密码更新操作失败
// 通过响应输出一段JavaScript代码弹出提示框显示“修改密码失败请重新输入密码
// 并将页面重定向到教师忘记密码重置页面,同时关闭当前窗口
resp.getWriter().write("<script>alert('修改密码失败!请重新输入密码!'); window.location='" + req.getContextPath() + "/view/frontweb/teaforgetpsw.jsp';" + "window.close();</script>");
}
}else {//不同则重新输入密码
}else {
// 如果教师输入的新密码和确认密码不相等
// 通过响应输出一段JavaScript代码弹出提示框显示“两次密码不一样!请重新输入密码!”
// 并将页面重定向到教师忘记密码重置页面,同时关闭当前窗口
resp.getWriter().write("<script>alert('两次密码不一样!请重新输入密码!'); window.location='" + req.getContextPath() + "/view/frontweb/teaforgetpsw.jsp';" + "window.close();</script>");
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doPost方法用于处理HTTP POST请求
// 直接调用doGet方法来处理POST请求复用doGet方法中的业务逻辑
this.doGet(req, resp);
}
}
}

@ -1,58 +1,107 @@
package com.controller.frontweb;
// 声明该Servlet所在的包名为com.controller.frontweb
import com.dao.FrontWebDao;
// 导入数据访问对象类FrontWebDao用于执行数据库查询操作
import com.entity.Student;
// 导入Student实体类这里未使用到属于无用导入可删除
import com.entity.Teacher;
// 导入Teacher实体类用于封装教师相关信息
import com.utils.JDBCUtils;
// 导入JDBC工具类用于数据库连接的管理和资源关闭等操作
import javax.servlet.ServletException;
// 导入Servlet异常类用于处理Servlet运行时可能出现的异常
import javax.servlet.annotation.WebServlet;
// 导入注解用于将Servlet映射到特定的URL
import javax.servlet.http.HttpServlet;
// 导入HttpServlet类所有基于HTTP协议的Servlet都继承自该类
import javax.servlet.http.HttpServletRequest;
// 导入用于处理HTTP请求的类通过它可以获取请求参数、请求头信息等
import javax.servlet.http.HttpServletResponse;
// 导入用于处理HTTP响应的类通过它可以设置响应内容、响应头信息等
import javax.servlet.http.HttpSession;
// 导入HttpSession类用于管理用户会话存储用户相关信息
import java.io.IOException;
// 导入用于处理I/O异常的类如在读取或写入数据时可能发生的异常
import java.sql.ResultSet;
// 导入用于处理数据库查询结果的类,用于获取查询到的数据
@WebServlet("/TeaInfoServlet")
// 使用@WebServlet注解将该Servlet映射到URL路径为"/TeaInfoServlet"
public class TeaInfoServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doGet方法用于处理HTTP GET请求
// 设置请求的字符编码为UTF-8防止请求参数中的中文乱码
req.setCharacterEncoding("utf-8");
// 设置响应的字符编码为UTF-8防止响应内容中的中文乱码
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型为HTML字符编码为UTF-8告知客户端如何解析响应内容
resp.setContentType("text/html;charset=utf-8");
// 获取当前请求的会话对象
HttpSession session = req.getSession();
// 从会话中获取名为"tno"的属性值并将其转换为String类型该值表示教师编号
String tno = (String) session.getAttribute("tno");
// 构造SQL查询语句用于从teacher表中查询指定教师编号tno的教师信息
String sql = "select * from teacher where tno = ?";
// 创建包含SQL语句参数的对象数组参数为教师编号
Object[] objects = {tno};
// 调用FrontWebDao的qureyInfo方法执行SQL查询并获取结果集
ResultSet resultSet = FrontWebDao.qureyInfo(sql, objects);
// 创建一个Teacher对象用于存储查询到的教师信息
Teacher teacher = new Teacher();
try {
// 遍历结果集将每一行数据封装到Teacher对象中
while (resultSet.next()){
// 设置教师编号
teacher.setTno(resultSet.getString("tno"));
// 设置教师姓名
teacher.setTname(resultSet.getString("tname"));
// 设置教师性别
teacher.setTsex(resultSet.getString("tsex"));
// 设置教师年龄将数据库中的整数类型值转换为int类型
teacher.setTage(resultSet.getInt("tage"));
// 设置教师所在系部
teacher.setTdept(resultSet.getString("tdept"));
// 设置教师电话号码
teacher.setTphone(resultSet.getString("tphone"));
}
} catch (Exception e) {
// 捕获异常并打印异常堆栈信息,用于调试和错误排查
e.printStackTrace();
}finally {
} finally {
// 无论是否发生异常都调用JDBCUtils的close方法关闭结果集释放资源
JDBCUtils.close(resultSet);
}
// 将封装好的教师信息对象teacher设置为请求属性以便在后续页面中使用
req.setAttribute("teacher", teacher);
// 转发请求到指定的页面(/view/frontweb/teainfo.jsp并传递请求和响应对象
req.getRequestDispatcher("/view/frontweb/teainfo.jsp").forward(req, resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doPost方法用于处理HTTP POST请求
// 直接调用doGet方法来处理POST请求复用doGet方法中的业务逻辑
this.doGet(req, resp);
}
}
```

@ -1,56 +1,104 @@
package com.controller.frontweb;
// 声明该Servlet所在的包名为com.controller.frontweb
import com.dao.FrontWebDao;
// 导入数据访问对象类FrontWebDao用于执行数据库查询操作
import javax.servlet.ServletException;
// 导入Servlet异常类用于处理Servlet运行时可能出现的异常
import javax.servlet.annotation.WebServlet;
// 导入注解用于将Servlet映射到特定的URL
import javax.servlet.http.HttpServlet;
// 导入HttpServlet类所有基于HTTP协议的Servlet都继承自该类
import javax.servlet.http.HttpServletRequest;
// 导入用于处理HTTP请求的类通过它可以获取请求参数等信息
import javax.servlet.http.HttpServletResponse;
// 导入用于处理HTTP响应的类通过它可以设置响应内容、状态码等
import javax.servlet.http.HttpSession;
// 导入HttpSession类用于管理用户会话存储用户相关信息
import java.io.IOException;
// 导入用于处理I/O异常的类如在读写数据时可能发生的异常
import java.sql.ResultSet;
// 导入用于处理数据库查询结果的类
import java.sql.SQLException;
// 导入用于处理SQL异常的类
@WebServlet("/TeaLoginServlet")
// 使用@WebServlet注解将该Servlet映射到URL路径为"/TeaLoginServlet"
public class TeaLoginServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doGet方法用于处理HTTP GET请求
// 设置请求的字符编码为UTF-8防止请求参数中的中文乱码
req.setCharacterEncoding("utf-8");
// 设置响应的字符编码为UTF-8防止响应内容中的中文乱码
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型为HTML格式并且字符编码为UTF-8告知客户端如何解析响应内容
resp.setContentType("text/html;charset=utf-8");
// 从HTTP请求的参数中获取名为"tno"的参数值,该值代表教师编号
String tno = req.getParameter("tno");
// 从HTTP请求的参数中获取名为"tpsw"的参数值,该值代表教师密码
String tpsw = req.getParameter("tpsw");
// 将获取到的教师编号打印到控制台,用于调试
System.out.println(tno);
// 将获取到的教师密码打印到控制台,用于调试
System.out.println(tpsw);
// 获取当前请求的会话对象,如果不存在则创建一个新的会话
HttpSession session = req.getSession();
// 将教师编号存储到会话中,以便在后续请求中可以获取该信息
session.setAttribute("tno", tno);
// 构造SQL查询语句用于从teacher表中查询匹配的教师记录
String sql = "select * from teacher where tno = ? and tpsw = ?";
// 创建包含SQL语句参数的对象数组依次为教师编号、教师密码
Object[] objects = {tno, tpsw};
// 调用FrontWebDao的login方法执行SQL查询并获取结果集
ResultSet resultSet = FrontWebDao.login(sql, objects);
try {
// 如果结果集有下一条记录,说明查询到了匹配的教师记录
if (resultSet.next()){
// 设置请求属性指定跳转的URL路径为"/TeaInfoServlet"即教师信息Servlet
req.setAttribute("httpUrl","/TeaInfoServlet");
// 设置请求属性,指定提示信息
req.setAttribute("info", "登录成功!即将跳转至教师信息页面!");
// 设置请求属性,指定页面标题
req.setAttribute("title","登录成功");
// 转发请求到指定的页面(/view/frontweb/info.jsp并传递请求和响应对象
req.getRequestDispatcher("/view/frontweb/info.jsp").forward(req, resp);
}else {
// 如果结果集没有下一条记录,说明教工号或密码错误
// 设置请求属性指定跳转回登录页面的URL路径
req.setAttribute("httpUrl","/view/frontweb/tealogin.jsp");
// 设置请求属性,指定错误提示信息
req.setAttribute("info", "登录失败!教工号或密码错误!即将跳转至登录页面!");
// 设置请求属性,指定页面标题
req.setAttribute("title","登录失败");
// 转发请求到指定的页面(/view/frontweb/info.jsp并传递请求和响应对象
req.getRequestDispatcher("/view/frontweb/info.jsp").forward(req, resp);
}
} catch (SQLException e) {
// 捕获SQL异常并打印异常堆栈信息用于调试和错误排查
e.printStackTrace();
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doPost方法用于处理HTTP POST请求
// 直接调用doGet方法来处理POST请求复用doGet方法中的业务逻辑
this.doGet(req, resp);
}
}
}

@ -1,76 +1,132 @@
package com.controller.frontweb;
// 声明该Servlet所在的包名为com.controller.frontweb
import com.dao.DeptAdminDao;
// 导入部门管理员数据访问对象类,在本类中未使用
import com.dao.FrontWebDao;
// 导入前端数据访问对象类,用于执行数据库操作,如查询、插入等
import javax.servlet.ServletException;
// 导入Servlet异常类用于处理Servlet运行时可能出现的异常
import javax.servlet.annotation.WebServlet;
// 导入注解用于将Servlet映射到特定的URL
import javax.servlet.http.HttpServlet;
// 导入HttpServlet类所有基于HTTP协议的Servlet都继承自该类
import javax.servlet.http.HttpServletRequest;
// 导入用于处理HTTP请求的类可获取请求参数等信息
import javax.servlet.http.HttpServletResponse;
// 导入用于处理HTTP响应的类可设置响应内容、状态码等
import javax.servlet.http.HttpSession;
// 导入HttpSession类用于管理用户会话存储用户相关信息
import java.io.IOException;
// 导入用于处理I/O异常的类如在读写数据时可能发生的异常
import java.sql.ResultSet;
// 导入用于处理数据库查询结果的类
import java.text.SimpleDateFormat;
// 导入用于格式化日期和时间的类
import java.util.Date;
// 导入日期类,用于获取当前日期和时间
@WebServlet("/TeaPunchServlet")
// 使用@WebServlet注解将该Servlet映射到URL路径为"/TeaPunchServlet"
public class TeaPunchServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doGet方法用于处理HTTP GET请求
// 设置请求的字符编码为UTF-8防止请求参数中的中文乱码
req.setCharacterEncoding("utf-8");
// 设置响应的字符编码为UTF-8防止响应内容中的中文乱码
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型为HTML格式并且字符编码为UTF-8告知客户端如何解析响应内容
resp.setContentType("text/html;charset=utf-8");
//获取sno
// 获取当前请求的会话对象
HttpSession session = req.getSession();
// 从会话中获取名为"tno"的属性值并将其转换为String类型该值表示教师编号
String tno = (String) session.getAttribute("tno");
// 将教师编号打印到控制台,用于调试
System.out.println(tno);
//获取表单请求的参数
/*String tno = req.getParameter("tno");*/
// 从HTTP请求的参数中获取名为"tishot"的参数值,该值表示教师是否发热
String tishot = req.getParameter("tishot");
// 从HTTP请求的参数中获取名为"tiscough"的参数值,该值表示教师是否咳嗽
String tiscough = req.getParameter("tiscough");
// 从HTTP请求的参数中获取名为"tisseem"的参数值,该值表示教师是否有其他症状
String tisseem = req.getParameter("tisseem");
// 从HTTP请求的参数中获取名为"tisdiagnose"的参数值,该值表示教师是否被诊断
String tisdiagnose = req.getParameter("tisdiagnose");
// 从HTTP请求的参数中获取名为"tstatus"的参数值,该值表示教师当前状态
String tstatus = req.getParameter("tstatus");
// 设置教师打卡状态为"是",表示已打卡
String tispunch = "是";
// 创建Date对象获取当前时间
Date date = new Date();
//获取当前日期
// 创建SimpleDateFormat对象用于将日期格式化为"yyyy-MM-dd"的字符串
SimpleDateFormat sf1 = new SimpleDateFormat("yyyy-MM-dd");
// 格式化当前日期
String tpunchdate = sf1.format(date);
// 将当前日期打印到控制台,用于调试
System.out.println(tpunchdate);
//获取当前时间
// 创建SimpleDateFormat对象用于将时间格式化为"HH:mm"的字符串
SimpleDateFormat sf2 = new SimpleDateFormat("HH:mm");
// 格式化当前时间
String tpunchtime = sf2.format(date);
// 将当前时间打印到控制台,用于调试
System.out.println(tpunchtime);
// 初始化SQL语句变量
String sql = null;
//查询是否已经打卡
// 构造SQL查询语句,用于查询该教师今天是否已经打卡
sql = "select count(*) as num from teapunchin where tno = ? and tpunchdate = ?";
// 创建包含SQL语句参数的对象数组依次为教师编号、打卡日期
Object[] objects1 = {tno, tpunchdate};
// 调用FrontWebDao的findTotalCount方法执行SQL查询获取查询结果的数量
int count = FrontWebDao.findTotalCount(sql, objects1);
if (count == 0){//无则操作
if (count == 0) {
// 如果查询结果数量为0表示该教师今天还未打卡则执行插入操作
sql = "insert into teapunchin values(?, ?, ?, ?, ?, ?, ?, ?, ?)";
// 创建包含SQL语句参数的对象数组依次为教师编号、是否打卡、打卡日期、打卡时间、是否发热、是否咳嗽、是否有其他症状、是否被诊断、当前状态
Object[] objects2 = {tno, tispunch, tpunchdate, tpunchtime, tishot, tiscough, tisseem, tisdiagnose, tstatus};
// 调用FrontWebDao的executeUpdate方法执行SQL插入语句并获取受影响的行数
int num = FrontWebDao.executeUpdate(sql, objects2);
// 将受影响的行数打印到控制台,用于调试
System.out.println(num);
// 通过响应输出一段JavaScript代码弹出提示框提示打卡成功
// 并将页面重定向到教师信息页面,同时关闭当前窗口
resp.getWriter().write("<script>alert('打卡成功!'); window.location='" + req.getContextPath() + "/TeaInfoServlet';" + "window.close();</script>");
}else {//已经打卡
} else {
// 如果查询结果数量不为0表示该教师今天已经打卡
// 通过响应输出一段JavaScript代码弹出提示框提示今天已打卡不能再次打卡
// 并将页面重定向到教师信息页面,同时关闭当前窗口
resp.getWriter().write("<script>alert('您今天已成功打卡!不能再次打卡!'); window.location='" + req.getContextPath() + "/TeaInfoServlet';" + "window.close();</script>");
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doPost方法用于处理HTTP POST请求
// 直接调用doGet方法来处理POST请求复用doGet方法中的业务逻辑
this.doGet(req, resp);
}
}
}

@ -1,59 +1,102 @@
package com.controller.schoadmin;
// 声明该类所在的包名为com.controller.schoadmin
import com.dao.DeptAdminDao;
// 导入自定义的DeptAdminDao类用于数据库操作
import javax.servlet.ServletException;
// 导入ServletException类用于处理Servlet异常
import javax.servlet.annotation.WebServlet;
// 导入WebServlet注解用于将Servlet映射到URL
import javax.servlet.http.HttpServlet;
// 导入HttpServlet类所有Servlet都继承自该类
import javax.servlet.http.HttpServletRequest;
// 导入HttpServletRequest类用于获取客户端请求信息
import javax.servlet.http.HttpServletResponse;
// 导入HttpServletResponse类用于向客户端发送响应信息
import java.io.IOException;
// 导入IOException类用于处理输入输出异常
/**
* Servlet
*
*/
@WebServlet("/SchoAddStuPunchServlet")
public class SchoAddStuPunchServlet extends HttpServlet {
/**
* GET
* @param req HttpServletRequest
* @param resp HttpServletResponse
* @throws ServletException Servlet
* @throws IOException
*/
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 设置请求编码为UTF-8确保能正确处理中文参数
req.setCharacterEncoding("utf-8");
// 设置响应编码为UTF-8
resp.setCharacterEncoding("utf-8");
// 设置响应内容类型为HTML编码为UTF-8
resp.setContentType("text/html;charset=utf-8");
//获取表单请求的参数
String sno = req.getParameter("sno");
String sispunch = req.getParameter("sispunch");
String spunchdate = req.getParameter("spunchdate");
String spunchtime = req.getParameter("spunchtime");
String sishot = req.getParameter("sishot");
String siscough = req.getParameter("siscough");
String sisseem = req.getParameter("sisseem");
String sisdiagnose = req.getParameter("sisdiagnose");
String sstatus = req.getParameter("sstatus");
// 获取表单请求的参数
String sno = req.getParameter("sno"); // 学生学号
String sispunch = req.getParameter("sispunch"); // 是否打卡
String spunchdate = req.getParameter("spunchdate"); // 打卡日期
String spunchtime = req.getParameter("spunchtime"); // 打卡时间
String sishot = req.getParameter("sishot"); // 是否发烧
String siscough = req.getParameter("siscough"); // 是否咳嗽
String sisseem = req.getParameter("sisseem"); // 是否有其他症状
String sisdiagnose = req.getParameter("sisdiagnose"); // 是否就医诊断
String sstatus = req.getParameter("sstatus"); // 健康状态
// 声明SQL语句变量
String sql = null;
// 打印调试信息
System.out.println("shgshgh");
//查询是否存在此人
// 查询是否存在该学生在指定日期的打卡记录
sql = "select count(*) as num from stupunchin where sno = ? and spunchdate = ?";
Object[] objects = {sno, spunchdate};
// 调用DeptAdminDao的方法查询记录数量
int count = DeptAdminDao.findTotalCount(sql, objects);
if (count == 0){//无则操作
// 如果记录不存在
if (count == 0) {
// 插入新的打卡记录
sql = "insert into stupunchin values(?, ?, ?, ?, ?, ?, ?, ?, ?)";
Object[] objects1 = {sno, sispunch, spunchdate, spunchtime, sishot, siscough, sisseem, sisdiagnose, sstatus};
// 执行插入操作并获取受影响的行数
int num = DeptAdminDao.executeUpdate(sql, objects1);
// 打印插入结果
System.out.println(num);
// 重定向到分页查询Servlet显示第一页数据
req.getRequestDispatcher("/SchoQueryStuPunchByPageServlet?currentPage=1&rows=7&sname=&sclass=&sdept=&spunchdate=").forward(req, resp);
}else {
} else {
// 如果记录已存在,转发到提示页面
req.getRequestDispatcher("/view/alluse/existdataofadd.jsp").forward(req, resp);
}
}
/**
* POSTdoGet
* @param req HttpServletRequest
* @param resp HttpServletResponse
* @throws ServletException Servlet
* @throws IOException
*/
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
}

@ -1,62 +1,105 @@
package com.controller.schoadmin;
// 声明该类所在的包名为com.controller.schoadmin
import com.dao.DeptAdminDao;
// 导入自定义的数据访问对象类,用于数据库操作
import javax.servlet.ServletException;
// 导入Servlet异常处理类
import javax.servlet.annotation.WebServlet;
// 导入Servlet注解用于映射Servlet到URL路径
import javax.servlet.http.HttpServlet;
// 导入HttpServlet基类所有Servlet都继承自此类
import javax.servlet.http.HttpServletRequest;
// 导入HTTP请求对象类用于获取客户端请求信息
import javax.servlet.http.HttpServletResponse;
// 导入HTTP响应对象类用于向客户端发送响应
import java.io.IOException;
// 导入输入输出异常类
/**
* Servlet
*
*/
@WebServlet("/SchoAddStuServlet")
public class SchoAddStuServlet extends HttpServlet {
/**
* GET
* @param req HTTP
* @param resp HTTP
* @throws ServletException Servlet
* @throws IOException
*/
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 设置请求编码为UTF-8确保中文参数能正确解析
req.setCharacterEncoding("utf-8");
// 设置响应编码为UTF-8
resp.setCharacterEncoding("utf-8");
// 设置响应内容类型为HTML编码为UTF-8
resp.setContentType("text/html;charset=utf-8");
//获取表单请求的参数
String sno = req.getParameter("sno");
String sname = req.getParameter("sname");
String ssex = req.getParameter("ssex");
String sage = req.getParameter("sage");
String specialty = req.getParameter("specialty");
String sclass = req.getParameter("sclass");
String sdept = req.getParameter("sdept");
String sphone = req.getParameter("sphone");
String spsw = req.getParameter("spsw");
//类型转换
// 获取表单请求的参数
String sno = req.getParameter("sno"); // 学生学号
String sname = req.getParameter("sname"); // 学生姓名
String ssex = req.getParameter("ssex"); // 学生性别
String sage = req.getParameter("sage"); // 学生年龄
String specialty = req.getParameter("specialty"); // 专业
String sclass = req.getParameter("sclass"); // 班级
String sdept = req.getParameter("sdept"); // 系部
String sphone = req.getParameter("sphone"); // 联系电话
String spsw = req.getParameter("spsw"); // 密码
// 将年龄字符串转换为整数类型
int sage1 = Integer.parseInt(sage);
// 声明SQL语句变量
String sql = null;
// 打印调试信息
System.out.println("shgshgh");
//查询是否存在此人
// 查询数据库中是否已存在该学号的学生
sql = "select count(*) as num from student where sno = ?";
Object[] objects = {sno};
// 调用DAO方法执行查询获取记录数量
int count = DeptAdminDao.findTotalCount(sql, objects);
if (count == 0){//无则操作
// 如果学生不存在
if (count == 0) {
// 构造插入学生信息的SQL语句
sql = "insert into student values(?, ?, ?, ?, ?, ?, ?, ?, ?)";
Object[] objects1 = {sno, sname, ssex, sage1, sclass, specialty, sdept, sphone, spsw};
// 调用DAO方法执行插入操作获取受影响的行数
int num = DeptAdminDao.executeUpdate(sql, objects1);
// 打印插入结果
System.out.println(num);
// 转发请求到分页查询Servlet显示第一页学生列表
req.getRequestDispatcher("/SchoQueryStuByPageServlet?currentPage=1&rows=7&sname=&sclass=&sdept=").forward(req, resp);
}else {
} else {
// 如果学生已存在,转发到提示页面
req.getRequestDispatcher("/view/alluse/existdataofadd.jsp").forward(req, resp);
}
}
/**
* POSTdoGet
* @param req HTTP
* @param resp HTTP
* @throws ServletException Servlet
* @throws IOException
*/
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
}

@ -1,59 +1,102 @@
package com.controller.schoadmin;
// 声明该类所在的包名为com.controller.schoadmin
import com.dao.DeptAdminDao;
// 导入自定义的数据访问对象类,用于数据库操作
import javax.servlet.ServletException;
// 导入Servlet异常处理类
import javax.servlet.annotation.WebServlet;
// 导入Servlet注解用于映射Servlet到URL路径
import javax.servlet.http.HttpServlet;
// 导入HttpServlet基类所有Servlet都继承自此类
import javax.servlet.http.HttpServletRequest;
// 导入HTTP请求对象类用于获取客户端请求信息
import javax.servlet.http.HttpServletResponse;
// 导入HTTP响应对象类用于向客户端发送响应
import java.io.IOException;
// 导入输入输出异常类
/**
* Servlet
*
*/
@WebServlet("/SchoAddTeaPunchServlet")
public class SchoAddTeaPunchServlet extends HttpServlet {
/**
* GET
* @param req HTTP
* @param resp HTTP
* @throws ServletException Servlet
* @throws IOException
*/
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 设置请求编码为UTF-8确保中文参数能正确解析
req.setCharacterEncoding("utf-8");
// 设置响应编码为UTF-8
resp.setCharacterEncoding("utf-8");
// 设置响应内容类型为HTML编码为UTF-8
resp.setContentType("text/html;charset=utf-8");
//获取表单请求的参数
String tno = req.getParameter("tno");
String tispunch = req.getParameter("tispunch");
String tpunchdate = req.getParameter("tpunchdate");
String tpunchtime = req.getParameter("tpunchtime");
String tishot = req.getParameter("tishot");
String tiscough = req.getParameter("tiscough");
String tisseem = req.getParameter("tisseem");
String tisdiagnose = req.getParameter("tisdiagnose");
String tstatus = req.getParameter("tstatus");
// 获取表单请求的参数
String tno = req.getParameter("tno"); // 教师工号
String tispunch = req.getParameter("tispunch"); // 是否打卡
String tpunchdate = req.getParameter("tpunchdate"); // 打卡日期
String tpunchtime = req.getParameter("tpunchtime"); // 打卡时间
String tishot = req.getParameter("tishot"); // 是否发烧
String tiscough = req.getParameter("tiscough"); // 是否咳嗽
String tisseem = req.getParameter("tisseem"); // 是否有其他症状
String tisdiagnose = req.getParameter("tisdiagnose"); // 是否就医诊断
String tstatus = req.getParameter("tstatus"); // 健康状态
// 声明SQL语句变量
String sql = null;
// 打印调试信息
System.out.println("shgshgh");
//查询是否存在此人
// 查询数据库中是否已存在该教师在指定日期的打卡记录
sql = "select count(*) as num from teapunchin where tno = ? and tpunchdate = ?";
Object[] objects = {tno, tpunchdate};
// 调用DAO方法执行查询获取记录数量
int count = DeptAdminDao.findTotalCount(sql, objects);
if (count == 0){//无则操作
// 如果记录不存在
if (count == 0) {
// 构造插入教师打卡记录的SQL语句
sql = "insert into teapunchin values(?, ?, ?, ?, ?, ?, ?, ?, ?)";
Object[] objects1 = {tno, tispunch, tpunchdate, tpunchtime, tishot, tiscough, tisseem, tisdiagnose, tstatus};
// 调用DAO方法执行插入操作获取受影响的行数
int num = DeptAdminDao.executeUpdate(sql, objects1);
// 打印插入结果
System.out.println(num);
// 转发请求到分页查询Servlet显示第一页教师打卡记录
req.getRequestDispatcher("/SchoQueryTeaPunchByPageServlet?currentPage=1&rows=7&tno=&tname=&tdept=&tpunchdate=").forward(req, resp);
}else {
} else {
// 如果记录已存在,转发到提示页面
req.getRequestDispatcher("/view/alluse/existdataofadd.jsp").forward(req, resp);
}
}
/**
* POSTdoGet
* @param req HTTP
* @param resp HTTP
* @throws ServletException Servlet
* @throws IOException
*/
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
}

@ -1,60 +1,89 @@
package com.controller.schoadmin;
// 声明该类所在的包名为com.controller.schoadmin
import com.dao.DeptAdminDao;
// 导入数据访问对象类,用于执行数据库的查询和更新操作
import javax.servlet.ServletException;
// 导入Servlet异常类用于处理Servlet运行时可能出现的异常
import javax.servlet.annotation.WebServlet;
// 导入注解用于将Servlet映射到特定的URL
import javax.servlet.http.HttpServlet;
// 导入HttpServlet类所有基于HTTP协议的Servlet都继承自该类
import javax.servlet.http.HttpServletRequest;
// 导入用于处理HTTP请求的类可获取请求参数等信息
import javax.servlet.http.HttpServletResponse;
// 导入用于处理HTTP响应的类可设置响应内容、状态码等
import java.io.IOException;
// 导入用于处理I/O异常的类如在读写数据时可能发生的异常
@WebServlet("/SchoAddTeaServlet")
// 使用@WebServlet注解将该Servlet映射到URL路径为"/SchoAddTeaServlet"
public class SchoAddTeaServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doGet方法用于处理HTTP GET请求
// 设置请求的字符编码为UTF-8防止请求参数中的中文乱码
req.setCharacterEncoding("utf-8");
// 设置响应的字符编码为UTF-8防止响应内容中的中文乱码
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型为HTML格式并且字符编码为UTF-8告知客户端如何解析响应内容
resp.setContentType("text/html;charset=utf-8");
//获取表单请求的参数
String tno = req.getParameter("tno");
String tname = req.getParameter("tname");
String tsex = req.getParameter("tsex");
String tage = req.getParameter("tage");
String tdept = req.getParameter("tdept");
String tphone = req.getParameter("tphone");
String tpsw = req.getParameter("tpsw");
// 获取表单请求的参数
String tno = req.getParameter("tno");// 教师编号
String tname = req.getParameter("tname");// 教师姓名
String tsex = req.getParameter("tsex");// 教师性别
String tage = req.getParameter("tage");// 教师年龄
String tdept = req.getParameter("tdept");// 教师所在系部
String tphone = req.getParameter("tphone");// 教师联系电话
String tpsw = req.getParameter("tpsw");// 教师密码
//数据类型转换
// 数据类型转换,将年龄从字符串转换为整数
int tage1 = Integer.parseInt(tage);
// 声明SQL语句变量
String sql = null;
// 打印调试信息
System.out.println("shgshgh");
//查询是否存在此人
// 查询是否存在该教师(根据教师编号查询)
sql = "select count(*) as num from teacher where tno = ?";
Object[] objects = {tno};
// 调用DeptAdminDao的方法执行SQL查询获取符合条件的记录数量
int count = DeptAdminDao.findTotalCount(sql, objects);
if (count == 0){//无则操作
if (count == 0) { // 如果不存在该教师记录
// 构造插入教师信息的SQL语句
sql = "insert into teacher values(?, ?, ?, ?, ?, ?, ?)";
Object[] objects1 = {tno, tname, tsex, tage1, tdept, tphone, tpsw};
// 调用DeptAdminDao的方法执行SQL插入操作获取受影响的行数
int num = DeptAdminDao.executeUpdate(sql, objects1);
// 打印插入操作影响的行数,用于调试
System.out.println(num);
// 转发请求到分页查询教师信息的Servlet传递参数设置当前页为1每页显示7条记录其他查询条件为空
req.getRequestDispatcher("/SchoQueryTeaByPageServlet?currentPage=1&rows=7&tno=&tname=&tdept=").forward(req, resp);
}else {
} else {
// 如果教师记录已存在,转发请求到提示已存在数据的页面
req.getRequestDispatcher("/view/alluse/existdataofadd.jsp").forward(req, resp);
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doPost方法用于处理HTTP POST请求
// 直接调用doGet方法来处理POST请求复用doGet方法中的业务逻辑
doGet(req, resp);
}
}
}

@ -1,47 +1,85 @@
package com.controller.schoadmin;
// 声明该类所在的包名为com.controller.schoadmin
import com.dao.DeptAdminDao;
// 导入数据访问对象类,用于执行数据库操作
import javax.servlet.ServletException;
// 导入Servlet异常处理类
import javax.servlet.annotation.WebServlet;
// 导入Servlet注解用于映射Servlet到URL路径
import javax.servlet.http.HttpServlet;
// 导入HttpServlet基类所有Servlet都继承自此类
import javax.servlet.http.HttpServletRequest;
// 导入HTTP请求对象类用于获取客户端请求信息
import javax.servlet.http.HttpServletResponse;
// 导入HTTP响应对象类用于向客户端发送响应
import java.io.IOException;
// 导入输入输出异常类
/**
* Servlet
*
*/
@WebServlet("/SchoAlterStuPunchServlet")
public class SchoAlterStuPunchServlet extends HttpServlet {
/**
* GET
* @param req HTTP
* @param resp HTTP
* @throws ServletException Servlet
* @throws IOException
*/
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 设置请求编码为UTF-8确保中文参数能正确解析
req.setCharacterEncoding("utf-8");
// 设置响应编码为UTF-8
resp.setCharacterEncoding("utf-8");
// 设置响应内容类型为HTML编码为UTF-8
resp.setContentType("text/html;charset=utf-8");
//获取表单请求的参数
String sno = req.getParameter("sno");
String sispunch = req.getParameter("sispunch");
String spunchdate = req.getParameter("spunchdate");
String spunchtime = req.getParameter("spunchtime");
String sishot = req.getParameter("sishot");
String siscough = req.getParameter("siscough");
String sisseem = req.getParameter("sisseem");
String sisdiagnose = req.getParameter("sisdiagnose");
String sstatus = req.getParameter("sstatus");
// 获取表单请求的参数
String sno = req.getParameter("sno"); // 学生学号
String sispunch = req.getParameter("sispunch"); // 是否打卡
String spunchdate = req.getParameter("spunchdate"); // 打卡日期
String spunchtime = req.getParameter("spunchtime"); // 打卡时间
String sishot = req.getParameter("sishot"); // 是否发烧
String siscough = req.getParameter("siscough"); // 是否咳嗽
String sisseem = req.getParameter("sisseem"); // 是否有其他症状
String sisdiagnose = req.getParameter("sisdiagnose"); // 是否就医诊断
String sstatus = req.getParameter("sstatus"); // 健康状态
// 构造更新学生打卡记录的SQL语句
String sql = "update stupunchin set sispunch = ?, spunchtime = ?, sishot = ?, siscough = ?, sisseem = ?, sisdiagnose = ?, sstatus = ? where sno = ? and spunchdate = ?";
// 准备SQL语句的参数
Object[] objects = {sispunch, spunchtime, sishot, siscough, sisseem, sisdiagnose, sstatus, sno, spunchdate};
// 调用DAO方法执行更新操作获取受影响的行数
int num = DeptAdminDao.executeUpdate(sql, objects);
// 打印更新结果
System.out.println(num);
// 转发请求到分页查询Servlet显示第一页学生打卡记录
req.getRequestDispatcher("/SchoQueryStuPunchByPageServlet?currentPage=1&rows=7&sname=&sclass=&sdept=&spunchdate=").forward(req, resp);
}
/**
* POSTdoGet
* @param req HTTP
* @param resp HTTP
* @throws ServletException Servlet
* @throws IOException
*/
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
}

@ -1,50 +1,75 @@
package com.controller.schoadmin;
// 声明该类所在的包名为com.controller.schoadmin
import com.dao.DeptAdminDao;
// 导入数据访问对象类,用于执行数据库的更新操作
import javax.servlet.ServletException;
// 导入Servlet异常类用于处理Servlet运行时可能出现的异常
import javax.servlet.annotation.WebServlet;
// 导入注解用于将Servlet映射到特定的URL
import javax.servlet.http.HttpServlet;
// 导入HttpServlet类所有基于HTTP协议的Servlet都继承自该类
import javax.servlet.http.HttpServletRequest;
// 导入用于处理HTTP请求的类可获取请求参数等信息
import javax.servlet.http.HttpServletResponse;
// 导入用于处理HTTP响应的类可设置响应内容、状态码等
import java.io.IOException;
// 导入用于处理I/O异常的类如在读写数据时可能发生的异常
@WebServlet("/SchoAlterStuServlet")
// 使用@WebServlet注解将该Servlet映射到URL路径为"/SchoAlterStuServlet"
public class SchoAlterStuServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doGet方法用于处理HTTP GET请求
// 设置请求的字符编码为UTF-8防止请求参数中的中文乱码
req.setCharacterEncoding("utf-8");
// 设置响应的字符编码为UTF-8防止响应内容中的中文乱码
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型为HTML格式并且字符编码为UTF-8告知客户端如何解析响应内容
resp.setContentType("text/html;charset=utf-8");
//获取表单请求的参数
String sno = req.getParameter("sno");
String sname = req.getParameter("sname");
String ssex = req.getParameter("ssex");
String sage = req.getParameter("sage");
String sclass = req.getParameter("sclass");
String specialty = req.getParameter("specialty");
String sdept = req.getParameter("sdept");
String sphone = req.getParameter("sphone");
String spsw = req.getParameter("spsw");
//数据类型转换
// 获取表单请求的参数
String sno = req.getParameter("sno");// 学生学号
String sname = req.getParameter("sname");// 学生姓名
String ssex = req.getParameter("ssex");// 学生性别
String sage = req.getParameter("sage");// 学生年龄
String sclass = req.getParameter("sclass");// 学生班级
String specialty = req.getParameter("specialty");// 学生专业
String sdept = req.getParameter("sdept");// 学生所在系部
String sphone = req.getParameter("sphone");// 学生联系电话
String spsw = req.getParameter("spsw");// 学生密码
// 数据类型转换,将年龄从字符串转换为整数
int sage1 = Integer.parseInt(sage);
// 构造更新学生信息的SQL语句
String sql = "update student set sname = ?, ssex = ?, sage = ?, sclass = ?, specialty = ?, sdept = ?, sphone = ?, spsw = ? where sno = ?";
// 创建包含SQL语句参数的对象数组
Object[] objects = {sname, ssex, sage1, sclass, specialty, sdept, sphone, spsw, sno};
// 调用DeptAdminDao的executeUpdate方法执行SQL更新操作获取受影响的行数
int num = DeptAdminDao.executeUpdate(sql, objects);
// 打印受影响的行数,用于调试
System.out.println(num);
// 转发请求到分页查询学生信息的Servlet传递参数设置当前页为1每页显示7条记录其他查询条件为空
req.getRequestDispatcher("/SchoQueryStuByPageServlet?currentPage=1&rows=7&sname=&sclass=&sdept=").forward(req, resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doPost方法用于处理HTTP POST请求
// 直接调用doGet方法来处理POST请求复用doGet方法中的业务逻辑
doGet(req, resp);
}
}
}

@ -1,47 +1,85 @@
package com.controller.schoadmin;
// 声明该类所在的包名为com.controller.schoadmin
import com.dao.DeptAdminDao;
// 导入自定义的数据访问对象类,用于数据库操作
import javax.servlet.ServletException;
// 导入Servlet异常处理类
import javax.servlet.annotation.WebServlet;
// 导入Servlet注解用于映射Servlet到URL路径
import javax.servlet.http.HttpServlet;
// 导入HttpServlet基类所有Servlet都继承自此类
import javax.servlet.http.HttpServletRequest;
// 导入HTTP请求对象类用于获取客户端请求信息
import javax.servlet.http.HttpServletResponse;
// 导入HTTP响应对象类用于向客户端发送响应
import java.io.IOException;
// 导入输入输出异常类
/**
* Servlet
*
*/
@WebServlet("/SchoAlterTeaPunchServlet")
public class SchoAlterTeaPunchServlet extends HttpServlet {
/**
* GET
* @param req HTTP
* @param resp HTTP
* @throws ServletException Servlet
* @throws IOException
*/
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 设置请求编码为UTF-8确保中文参数能正确解析
req.setCharacterEncoding("utf-8");
// 设置响应编码为UTF-8
resp.setCharacterEncoding("utf-8");
// 设置响应内容类型为HTML编码为UTF-8
resp.setContentType("text/html;charset=utf-8");
//获取表单请求的参数
String tno = req.getParameter("tno");
String tispunch = req.getParameter("tispunch");
String tpunchdate = req.getParameter("tpunchdate");
String tpunchtime = req.getParameter("tpunchtime");
String tishot = req.getParameter("tishot");
String tiscough = req.getParameter("tiscough");
String tisseem = req.getParameter("tisseem");
String tisdiagnose = req.getParameter("tisdiagnose");
String tstatus = req.getParameter("tstatus");
// 获取表单请求的参数
String tno = req.getParameter("tno"); // 教师工号
String tispunch = req.getParameter("tispunch"); // 是否打卡
String tpunchdate = req.getParameter("tpunchdate"); // 打卡日期
String tpunchtime = req.getParameter("tpunchtime"); // 打卡时间
String tishot = req.getParameter("tishot"); // 是否发烧
String tiscough = req.getParameter("tiscough"); // 是否咳嗽
String tisseem = req.getParameter("tisseem"); // 是否有其他症状
String tisdiagnose = req.getParameter("tisdiagnose"); // 是否就医诊断
String tstatus = req.getParameter("tstatus"); // 健康状态
// 构造用于更新教师打卡记录的SQL语句
String sql = "update teapunchin set tispunch = ?, tpunchtime = ?, tishot = ?, tiscough = ?, tisseem = ?, tisdiagnose = ?, tstatus = ? where tno = ? and tpunchdate = ?";
// 准备SQL语句的参数
Object[] objects = {tispunch, tpunchtime, tishot, tiscough, tisseem, tisdiagnose, tstatus, tno, tpunchdate};
// 调用DeptAdminDao的方法执行SQL更新操作获取受影响的行数
int num = DeptAdminDao.executeUpdate(sql, objects);
// 打印更新操作影响的行数,用于调试
System.out.println(num);
// 转发请求到分页查询教师打卡记录的Servlet设置当前页为1每页显示7条记录其他查询参数为空
req.getRequestDispatcher("/SchoQueryTeaPunchByPageServlet?currentPage=1&rows=7&tno=&tname=&tdept=&tpunchdate=").forward(req, resp);
}
/**
* POSTdoGet
* @param req HTTP
* @param resp HTTP
* @throws ServletException Servlet
* @throws IOException
*/
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
}

@ -1,48 +1,73 @@
package com.controller.schoadmin;
// 声明该类所属的包名为com.controller.schoadmin
import com.dao.DeptAdminDao;
// 导入数据访问对象类,用于执行数据库操作,如查询、更新等
import javax.servlet.ServletException;
// 导入Servlet异常类用于处理Servlet在运行过程中可能抛出的异常
import javax.servlet.annotation.WebServlet;
// 导入注解用于将Servlet映射到特定的URL
import javax.servlet.http.HttpServlet;
// 导入HttpServlet类这是所有基于HTTP协议的Servlet的基类
import javax.servlet.http.HttpServletRequest;
// 导入用于处理HTTP请求的类可获取请求参数、头信息等
import javax.servlet.http.HttpServletResponse;
// 导入用于处理HTTP响应的类可设置响应状态码、头信息和输出内容等
import java.io.IOException;
// 导入用于处理输入输出异常的类,如文件读写、网络传输等操作中可能出现的异常
@WebServlet("/SchoAlterTeaServlet")
// 使用@WebServlet注解将该Servlet映射到URL路径为"/SchoAlterTeaServlet"
public class SchoAlterTeaServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doGet方法用于处理HTTP GET请求
// 设置请求的字符编码为UTF-8以正确处理请求参数中的中文字符
req.setCharacterEncoding("utf-8");
// 设置响应的字符编码为UTF-8以正确处理响应内容中的中文字符
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型为HTML字符编码为UTF-8告知客户端如何解析响应内容
resp.setContentType("text/html;charset=utf-8");
//获取表单请求的参数
String tno = req.getParameter("tno");
String tname = req.getParameter("tname");
String tsex = req.getParameter("tsex");
String tage = req.getParameter("tage");
String tdept = req.getParameter("tdept");
String tphone = req.getParameter("tphone");
String tpsw = req.getParameter("tpsw");
// 获取表单请求的参数
String tno = req.getParameter("tno"); // 获取教师编号
String tname = req.getParameter("tname"); // 获取教师姓名
String tsex = req.getParameter("tsex"); // 获取教师性别
String tage = req.getParameter("tage"); // 获取教师年龄
String tdept = req.getParameter("tdept"); // 获取教师所在系部
String tphone = req.getParameter("tphone"); // 获取教师联系电话
String tpsw = req.getParameter("tpsw"); // 获取教师密码
//数据类型转换
// 数据类型转换,将年龄从字符串转换为整数
int tage1 = Integer.parseInt(tage);
// 构造SQL更新语句用于更新教师信息表中的记录
String sql = "update teacher set tname = ?, tsex = ?, tage = ?, tdept = ?, tphone = ?, tpsw = ? where tno = ?";
// 创建一个包含SQL语句参数的对象数组
Object[] objects = {tname, tsex, tage1, tdept, tphone, tpsw, tno};
// 调用DeptAdminDao的executeUpdate方法执行SQL更新操作并获取受影响的行数
int num = DeptAdminDao.executeUpdate(sql, objects);
// 打印受影响的行数,用于调试和查看更新操作是否成功
System.out.println(num);
// 转发请求到分页查询教师信息的Servlet设置当前页为1每页显示7条记录其他查询条件为空
req.getRequestDispatcher("/SchoQueryTeaByPageServlet?currentPage=1&rows=7&tno=&tname=&tdept=").forward(req, resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doPost方法用于处理HTTP POST请求
// 直接调用doGet方法来处理POST请求复用doGet方法中的业务逻辑
doGet(req, resp);
}
}
}

@ -1,64 +1,106 @@
package com.controller.schoadmin;
// 声明该类所在的包名为com.controller.schoadmin
import com.dao.DeptAdminDao;
// 导入数据访问对象类,用于执行数据库操作
import javax.servlet.ServletException;
// 导入Servlet异常处理类
import javax.servlet.annotation.WebServlet;
// 导入Servlet注解用于映射Servlet到URL路径
import javax.servlet.http.HttpServlet;
// 导入HttpServlet基类所有Servlet都继承自此类
import javax.servlet.http.HttpServletRequest;
// 导入HTTP请求对象类用于获取客户端请求信息
import javax.servlet.http.HttpServletResponse;
// 导入HTTP响应对象类用于向客户端发送响应
import java.io.IOException;
// 导入输入输出异常类
/**
* Servlet
*
*/
@WebServlet("/SchoDeleteStuPunchServlet")
public class SchoDeleteStuPunchServlet extends HttpServlet {
/**
* GET
* @param req HTTP
* @param resp HTTP
* @throws ServletException Servlet
* @throws IOException
*/
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 设置请求编码为UTF-8确保中文参数能正确解析
req.setCharacterEncoding("utf-8");
// 设置响应编码为UTF-8
resp.setCharacterEncoding("utf-8");
// 设置响应内容类型为HTML编码为UTF-8
resp.setContentType("text/html;charset=utf-8");
//获取请求参数
// 获取请求参数,参数格式为"学号,打卡日期"
String snodate = req.getParameter("snodate");
// 打印获取的参数,用于调试
System.out.println(snodate);
//分离两个参数,用日期和学号来删除
// 分离学号和打卡日期两个参数,使用逗号作为分隔符
String[] params = snodate.split(",");
String sno = params[0];
String spunchdate = params[1];
String sno = params[0]; // 学生学号
String spunchdate = params[1]; // 打卡日期
// 打印分离后的参数,用于调试
System.out.println(sno);
System.out.println(spunchdate);
//字符串转为日期类型
// 注释掉的代码,尝试将字符串转为日期类型(实际未使用)
// Date spunchdate1 = new Date(spunchdate);
//或
// SimpleDateFormat ft = new SimpleDateFormat("yyyy-MM-dd");
// Date spunchdate1 = ft.format(spunchdate);
// 声明SQL语句变量
String sql = null;
// 准备SQL语句的参数
Object[] objects = {sno, spunchdate};
//查询是否存在此人
// 查询是否存在该学生在指定日期的打卡记录
sql = "select count(*) as num from stupunchin where sno = ? and spunchdate = ?";
// 调用DAO方法执行查询获取记录数量
int count = DeptAdminDao.findTotalCount(sql, objects);
if (count > 0) { //有则继续操作
//删除stupunchin中的该信息
// 如果记录存在
if (count > 0) {
// 构造删除学生打卡记录的SQL语句
sql = "delete from stupunchin where sno = ? and spunchdate = ?";
// 调用DAO方法执行删除操作获取受影响的行数
int num1 = DeptAdminDao.executeUpdate(sql, objects);
// 打印删除结果
System.out.println(num1);
// 转发请求到分页查询Servlet显示第一页学生打卡记录
req.getRequestDispatcher("/SchoQueryStuPunchByPageServlet?currentPage=1&rows=7&sname=&sclass=&sdept=&spunchdate=").forward(req, resp);
}else {
} else {
// 如果记录不存在,转发到提示页面
req.getRequestDispatcher("/view/alluse/noexistdataofdelete.jsp").forward(req, resp);
}
}
/**
* POSTdoGet
* @param req HTTP
* @param resp HTTP
* @throws ServletException Servlet
* @throws IOException
*/
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
}

@ -1,66 +1,106 @@
package com.controller.schoadmin;
// 声明该类所在的包名为com.controller.schoadmin
import com.dao.DeptAdminDao;
// 导入自定义的数据访问对象类,用于数据库的查询和更新操作
import javax.servlet.ServletException;
// 导入Servlet异常处理类用于处理Servlet运行过程中可能出现的异常
import javax.servlet.annotation.WebServlet;
// 导入Servlet注解用于将Servlet映射到指定的URL路径
import javax.servlet.http.HttpServlet;
// 导入HttpServlet基类所有基于HTTP协议的Servlet都继承自该类
import javax.servlet.http.HttpServletRequest;
// 导入用于处理HTTP请求的类可获取请求参数、会话等信息
import javax.servlet.http.HttpServletResponse;
// 导入用于处理HTTP响应的类可设置响应内容、状态码等
import javax.servlet.http.HttpSession;
// 导入用于处理HTTP会话的类可获取和设置会话属性
import java.io.IOException;
// 导入用于处理I/O异常的类如文件读写、网络传输等操作中可能出现的异常
@WebServlet("/SchoDeleteStuPunchServlet1")
// 使用@WebServlet注解将该Servlet映射到URL路径为"/SchoDeleteStuPunchServlet1"
public class SchoDeleteStuPunchServlet1 extends HttpServlet {
/**
* GET
* @param req HTTP
* @param resp HTTP
* @throws ServletException Servlet
* @throws IOException
*/
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 设置请求的字符编码为UTF-8防止请求参数中的中文乱码
req.setCharacterEncoding("utf-8");
// 设置响应的字符编码为UTF-8防止响应内容中的中文乱码
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型为HTML格式并且字符编码为UTF-8告知客户端如何解析响应内容
resp.setContentType("text/html;charset=utf-8");
//获取请求参数
String sno = req.getParameter("sno");
String spunchdate = req.getParameter("spunchdate");
// 获取表单请求参数
String sno = req.getParameter("sno"); // 学生学号
String spunchdate = req.getParameter("spunchdate"); // 打卡日期
// 打印获取的学号参数,用于调试
System.out.println(sno);
// 打印获取的打卡日期参数,用于调试
System.out.println(spunchdate);
//获取登录时的session会话对象
// 获取登录时的session会话对象
HttpSession session = req.getSession();
// String userName = (String) session.getAttribute("userName");
// String sno = (String) session.getAttribute("sno");
String belong = (String) session.getAttribute("belong");
String belong = (String) session.getAttribute("belong"); // 获取会话中存储的"belong"属性值
//字符串转为日期类型
// 注释掉的代码,尝试将字符串转换为日期类型(实际未使用)
// Date spunchdate1 = new Date(spunchdate);
//或
// SimpleDateFormat ft = new SimpleDateFormat("yyyy-MM-dd");
// Date spunchdate1 = ft.format(spunchdate);
// 声明SQL语句变量
String sql = null;
// 创建包含SQL语句参数的对象数组
Object[] objects = {sno, spunchdate};
//查询是否存在此人
// 查询是否存在符合条件的学生打卡记录通过关联student和stupunchin表
sql = "select count(*) as num from student s,stupunchin sp where s.sno = sp.sno and s.sno = ? and sp.spunchdate = ?";
// 调用DeptAdminDao的方法执行SQL查询获取符合条件的记录数量
int count = DeptAdminDao.findTotalCount(sql, objects);
if (count > 0) { //有则继续操作
//删除stupunchin中的该信息
// 如果存在符合条件的记录
if (count > 0) {
// 构造删除学生打卡记录的SQL语句
sql = "delete from stupunchin where sno = ? and spunchdate = ?";
// 调用DeptAdminDao的方法执行SQL删除操作获取受影响的行数
int num1 = DeptAdminDao.executeUpdate(sql, objects);
// 打印受影响的行数,用于调试
System.out.println(num1);
// 转发请求到分页查询学生打卡记录的Servlet传递参数设置当前页为1每页显示7条记录其他查询条件为空
req.getRequestDispatcher("/SchoQueryStuPunchByPageServlet?currentPage=1&rows=7&sname=&sclass=&sdept=&spunchdate=").forward(req, resp);
}else {
} else {
// 如果不存在符合条件的记录,转发请求到提示已存在数据的页面
req.getRequestDispatcher("/view/alluse/noexistdataofdelete.jsp").forward(req, resp);
}
}
/**
* POSTdoGet
* @param req HTTP
* @param resp HTTP
* @throws ServletException Servlet
* @throws IOException
*/
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
doGet(req, resp);
}
}
}

@ -1,70 +1,129 @@
package com.controller.stu;
// 声明该Servlet所在的包名为com.controller.stu
import com.dao.StuDao;
// 导入学生数据访问对象类StuDao用于执行数据库查询操作
import com.entity.Student;
// 导入学生实体类,用于封装学生相关信息
import com.utils.JDBCUtils;
// 导入JDBC工具类用于数据库连接的管理和资源关闭等操作
import javax.servlet.ServletException;
// 导入Servlet异常类用于处理Servlet运行时可能出现的异常
import javax.servlet.annotation.WebServlet;
// 导入注解用于将Servlet映射到特定的URL
import javax.servlet.http.HttpServlet;
// 导入HttpServlet类所有基于HTTP协议的Servlet都继承自该类
import javax.servlet.http.HttpServletRequest;
// 导入用于处理HTTP请求的类通过它可以获取请求参数、请求头信息等
import javax.servlet.http.HttpServletResponse;
// 导入用于处理HTTP响应的类通过它可以设置响应内容、响应头信息等
import javax.servlet.http.HttpSession;
// 导入HttpSession类用于管理用户会话存储用户相关信息
import java.io.IOException;
// 导入用于处理I/O异常的类如在读取或写入数据时可能发生的异常
import java.sql.ResultSet;
// 导入用于处理数据库查询结果的类,用于获取查询到的数据
import java.util.ArrayList;
// 导入ArrayList类用于存储多个学生对象
@WebServlet("/StuQueryInfoServlet")
// 使用@WebServlet注解将该Servlet映射到URL路径为"/StuQueryInfoServlet"
public class StuQueryInfoServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doGet方法用于处理HTTP GET请求
// 设置请求的字符编码为UTF-8防止请求参数中的中文乱码
req.setCharacterEncoding("utf-8");
// 设置响应的字符编码为UTF-8防止响应内容中的中文乱码
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型为HTML格式并且字符编码为UTF-8告知客户端如何解析响应内容
resp.setContentType("text/html;charset=utf-8");
// 获取当前请求的会话对象
HttpSession session = req.getSession();
// 从会话中获取名为"userName"的属性值并将其转换为String类型
String userName = (String) session.getAttribute("userName");
// 从会话中获取名为"sno"的属性值并将其转换为String类型该值表示学生编号
String sno = (String) session.getAttribute("sno");
// 将userName打印到控制台用于调试
System.out.println(userName);
// 将sno打印到控制台用于调试
System.out.println(sno);
// 打印一个字符串到控制台,可能是用于调试的无意义字符串
System.out.println("hdghghjg");
// 构造SQL查询语句用于从student表中查询指定学生编号sno的学生信息
String sql = "select * from student where sno = ?";
// 创建包含SQL语句参数的对象数组参数为学生编号
Object[] objects = {sno};
// 调用StuDao的qureyInfo方法执行SQL查询并获取结果集
ResultSet resultSet = StuDao.qureyInfo(sql, objects);
// 创建一个ArrayList对象用于存储查询到的学生对象
ArrayList<Student> stuArrayList = new ArrayList<Student>();
try {
// 遍历结果集将每一行数据封装到Student对象中并添加到ArrayList中
while (resultSet.next()){
// 创建一个新的Student对象
Student student = new Student();
// 设置学生编号
student.setSno(resultSet.getString("sno"));
// 设置学生姓名
student.setSname(resultSet.getString("sname"));
// 设置学生性别
student.setSsex(resultSet.getString("ssex"));
// 设置学生年龄将数据库中的整数类型值转换为int类型
student.setSage(resultSet.getInt("sage"));
// 设置学生班级
student.setSclass(resultSet.getString("sclass"));
// 设置学生专业
student.setSpecialty(resultSet.getString("specialty"));
// 设置学生所在系部
student.setSdept(resultSet.getString("sdept"));
// 设置学生电话号码
student.setSphone(resultSet.getString("sphone"));
// 设置学生密码
student.setSpsw(resultSet.getString("spsw"));
// 将封装好的学生对象添加到ArrayList中
stuArrayList.add(student);
}
} catch (Exception e) {
// 捕获异常并打印异常堆栈信息,用于调试和错误排查
e.printStackTrace();
}finally {
} finally {
// 无论是否发生异常都调用JDBCUtils的close方法关闭结果集释放资源
JDBCUtils.close(resultSet);
}
// 将存储学生对象的ArrayList打印到控制台用于调试
System.out.println(stuArrayList);
// 将存储学生对象的ArrayList设置为请求属性以便在后续页面中使用
req.setAttribute("stuArrayList", stuArrayList);
// 转发请求到指定的页面(/view/stu/stuinfo.jsp并传递请求和响应对象
req.getRequestDispatcher("/view/stu/stuinfo.jsp").forward(req, resp);
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doPost方法用于处理HTTP POST请求
// 直接调用doGet方法来处理POST请求复用doGet方法中的业务逻辑
doGet(req, resp);
}
}
}

@ -1,112 +1,166 @@
package com.controller.stu;
// 声明该Servlet所在的包名为com.controller.stu
import com.dao.StuDao;
// 导入学生数据访问对象类,用于执行数据库的查询、统计等操作
import com.entity.PageBean;
// 导入分页数据封装的实体类,用于存储分页相关信息
import com.entity.StuPunch;
// 导入学生打卡信息的实体类,用于封装学生打卡的具体数据
import com.utils.JDBCUtils;
// 导入JDBC工具类用于数据库连接的获取、关闭以及结果集的处理等操作
import javax.servlet.ServletException;
// 导入Servlet异常类用于处理Servlet在运行过程中可能抛出的异常
import javax.servlet.annotation.WebServlet;
// 导入注解用于将Servlet映射到特定的URL
import javax.servlet.http.HttpServlet;
// 导入HttpServlet类所有基于HTTP协议的Servlet都继承自该类
import javax.servlet.http.HttpServletRequest;
// 导入用于处理HTTP请求的类可获取请求参数、会话等信息
import javax.servlet.http.HttpServletResponse;
// 导入用于处理HTTP响应的类可设置响应内容、状态码等
import javax.servlet.http.HttpSession;
// 导入HttpSession类用于管理用户会话存储用户相关信息
import java.io.IOException;
// 导入用于处理I/O异常的类如在读写数据时可能发生的异常
import java.sql.ResultSet;
// 导入用于处理数据库查询结果的类
import java.util.ArrayList;
// 导入ArrayList类用于存储多个对象这里用于存储学生打卡信息对象
@WebServlet("/StuQueryPunchByPageServlet")
// 使用@WebServlet注解将该Servlet映射到URL路径为"/StuQueryPunchByPageServlet"
public class StuQueryPunchByPageServlet extends HttpServlet {
@Override
protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doGet方法用于处理HTTP GET请求
// 设置请求的字符编码为UTF-8防止请求参数中的中文乱码
req.setCharacterEncoding("utf-8");
// 设置响应的字符编码为UTF-8防止响应内容中的中文乱码
resp.setCharacterEncoding("utf-8");
// 设置响应的内容类型为HTML格式并且字符编码为UTF-8告知客户端如何解析响应内容
resp.setContentType("text/html;charset=utf-8");
//获取查找的参数
// 获取查找的参数,这里是打卡日期
String spunchdate = req.getParameter("spunchdate");
// 如果获取的打卡日期为空,则设置为空字符串
if (spunchdate == null){
spunchdate = "";
}
// 对打卡日期进行模糊查询的格式处理,在前后添加通配符%
String spunchdate1 = "%" + spunchdate + "%";
// 打印处理后的打卡日期,用于调试
System.out.println(spunchdate1);
// 将原始的打卡日期设置为请求属性,以便在后续页面中使用
req.setAttribute("spunchdate", spunchdate);
//获取登录时的session会话对象
// 获取登录时的session会话对象
HttpSession session = req.getSession();
// 从会话中获取名为"userName"的属性值并将其转换为String类型
String userName = (String) session.getAttribute("userName");
// 从会话中获取名为"sno"的属性值并将其转换为String类型该值表示学生编号
String sno = (String) session.getAttribute("sno");
// 初始化SQL语句变量
String sql = null;
// 打印userName用于调试
System.out.println(userName);
// 打印sno用于调试
System.out.println(sno);
// 打印一个字符串,可能是用于调试的无意义字符串
System.out.println("hdghghjg");
String currentPage = req.getParameter("currentPage");//从请求对象中获取当前页码
String rows = req.getParameter("rows");//从请求获取对象中每页显示的行数
// 从请求对象中获取当前页码
String currentPage = req.getParameter("currentPage");
// 从请求对象中获取每页显示的行数
String rows = req.getParameter("rows");
//如果未设请求参数,此处自动设置参数为第一页
// 如果当前页码为空或为空字符串则设置当前页码为1
if (currentPage == null || "".equals(currentPage)){
currentPage = "1";
}
//如果没有设置rows的请求参数此处自动设置
// 如果每页显示的行数为空或为空字符串则设置每页显示的行数为7
if (rows == null || "".equals(rows)){
rows = "7";
}
//获取条件查询的参数
// 将当前页码转换为整数类型
int currentPage1 = Integer.parseInt(currentPage);
// 将每页显示的行数转换为整数类型
int rows1 = Integer.parseInt(rows);
//如果当前页数小于1则设置当前页数为1
// 如果当前页数小于1则设置当前页数为1
if (currentPage1 <= 0){
currentPage1 = 1;
}
//设置StuPunch类的对象类型
// 创建PageBean对象泛型为StuPunch用于存储分页信息和学生打卡信息列表
PageBean<StuPunch> pageBean = new PageBean<StuPunch>();
//设置当前页码
// 设置当前页码到PageBean对象中
pageBean.setCurrentPage(currentPage1);
//设置每页的记录数
// 设置每页的记录数到PageBean对象中
pageBean.setRows(rows1);
// 构造SQL语句用于统计符合条件打卡日期模糊匹配且学生编号匹配的记录总数
sql = " select count(*) as num from student s,stupunchin sp where s.sno = sp.sno and sp.spunchdate like ? and s.sno = ?";
// 创建包含SQL语句参数的对象数组参数为处理后的打卡日期和学生编号
Object[] objects = {spunchdate1, sno};
//计算总记录数,并设置
// 调用StuDao的findTotalCount方法执行SQL查询获取总记录数
int totalCount = StuDao.findTotalCount(sql, objects);
// 打印总记录数,用于调试
System.out.println(totalCount);
// 设置总记录数到PageBean对象中
pageBean.setTotalCount(totalCount);
if (totalCount > 0){
//计算总页码,并设置
// 计算总页码如果总记录数能被每页记录数整除则总页码为总记录数除以每页记录数否则为商加1
int totalPage = (totalCount % rows1) == 0 ? totalCount/rows1 : (totalCount/rows1 + 1);
// 设置总页码到PageBean对象中
pageBean.setTotalPage(totalPage);
//如果当前页数大于总页数
// 如果当前页数大于总页数,则将当前页数设置为总页数
if (currentPage1 > pageBean.getTotalPage()){
currentPage1 = pageBean.getTotalPage();
//重新设置当前页码
// 重新设置当前页码到PageBean对象中
pageBean.setCurrentPage(currentPage1);
}
//计算开始的记录和list对象集合并设置
// 计算开始的记录位置,为(当前页码 - 1乘以每页记录数
int start = (currentPage1 - 1) * rows1;
// 构造SQL语句用于查询符合条件的学生打卡信息进行分页查询
sql = "select s.sname,sp.* from student s,stupunchin sp where s.sno = sp.sno and sp.spunchdate like ? and sp.sno = ? limit ?, ?";
// 创建包含SQL语句参数的对象数组参数为处理后的打卡日期、学生编号、开始记录位置、每页记录数
Object[] objects1 = {spunchdate1, sno, start, rows1};
// 调用StuDao的QureyInfoByPage方法执行SQL查询获取查询结果集
ResultSet resultSet = StuDao.QureyInfoByPage(sql, objects1);
// 创建ArrayList对象用于存储查询到的学生打卡信息对象
ArrayList stuPunchArrayList = new ArrayList();
try {
// 遍历结果集将每一行数据封装到StuPunch对象中并添加到ArrayList中
while (resultSet.next()){
StuPunch stuPunch = new StuPunch();
stuPunch.setSname(resultSet.getString("sname"));
@ -121,25 +175,35 @@ public class StuQueryPunchByPageServlet extends HttpServlet {
stuPunchArrayList.add(stuPunch);
}
} catch (Exception e) {
// 捕获异常并打印异常堆栈信息,用于调试和错误排查
e.printStackTrace();
}finally {
} finally {
// 无论是否发生异常都调用JDBCUtils的close方法关闭结果集释放资源
JDBCUtils.close(resultSet);
}
// 将存储学生打卡信息对象的ArrayList设置到PageBean对象中
pageBean.setArrayList(stuPunchArrayList);
// 打印存储学生打卡信息对象的ArrayList用于调试
System.out.println(stuPunchArrayList);
// 打印PageBean对象用于调试
System.out.println(pageBean);
// 将PageBean对象设置为请求属性以便在后续页面中使用
req.setAttribute("pageBean", pageBean);
// 转发请求到指定的页面(/view/stu/stupunchinfo.jsp并传递请求和响应对象
req.getRequestDispatcher("/view/stu/stupunchinfo.jsp").forward(req, resp);
}else {
// 如果总记录数为0说明没有符合条件的数据转发请求到无数据提示页面/view/alluse/nodata.jsp
req.getRequestDispatcher("/view/alluse/nodata.jsp").forward(req, resp);
}
}
@Override
protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
// 重写父类HttpServlet的doPost方法用于处理HTTP POST请求
// 直接调用doGet方法来处理POST请求复用doGet方法中的业务逻辑
doGet(req, resp);
}
}
}

@ -1,25 +1,38 @@
package com.utils;
// 声明该类所在的包名为com.utils
import org.jfree.chart.JFreeChart;
// 导入JFreeChart类它是JFreeChart库中表示图表的核心类
import org.jfree.chart.block.BlockBorder;
// 导入BlockBorder类用于设置图表中块如图例的边框
import org.jfree.data.category.DefaultCategoryDataset;
// 导入DefaultCategoryDataset类用于处理柱状图、折线图等类别数据的数据集
import org.jfree.data.general.DefaultPieDataset;
// 导入DefaultPieDataset类用于处理饼图的数据集
import org.jfree.ui.RectangleEdge;
// 导入RectangleEdge类用于指定图表中元素如图例的位置如在矩形的哪条边上
import java.awt.*;
// 导入java.awt包包含用于处理图形和用户界面的类
import java.util.Vector;
// 导入Vector类它是一个动态数组用于存储数据系列等
/**
* JFreeChart<br/>
* MVC
*
*
* @author liuyimin
*
*/
public class ChartFactory {
/**
*
*
*
* @param title
*
* @param categoryAxisLabel
@ -33,28 +46,36 @@ public class ChartFactory {
* @return
*/
public static JFreeChart createBarChart(String title,
String categoryAxisLabel, String valueAxisLabel,
Vector<Serie> series, String[] categories) {
String categoryAxisLabel, String valueAxisLabel,
Vector<Serie> series, String[] categories) {
// 1创建数据集合
// 调用ChartUtils的createDefaultCategoryDataset方法根据传入的数据系列和类别创建一个默认的类别数据集
DefaultCategoryDataset dataset = ChartUtils
.createDefaultCategoryDataset(series, categories);
// 使用JFreeChart的工厂方法创建一个柱状图传入标题、x轴标题、y轴标题和数据集
JFreeChart chart = org.jfree.chart.ChartFactory.createBarChart(title,
categoryAxisLabel, valueAxisLabel, dataset);
// 3:设置抗锯齿,防止字体显示不清楚
// 调用ChartUtils的setAntiAlias方法为图表设置抗锯齿使字体等显示更清晰
ChartUtils.setAntiAlias(chart);// 抗锯齿
// 4:对柱子进行渲染
// 调用ChartUtils的setBarRenderer方法对柱状图的柱子进行渲染第二个参数false可能表示某种渲染相关的设置
ChartUtils.setBarRenderer(chart.getCategoryPlot(), false);//
// 5:对其他部分进行渲染
// 调用ChartUtils的setXAixs方法对图表的X坐标轴进行渲染
ChartUtils.setXAixs(chart.getCategoryPlot());// X坐标轴渲染
// 调用ChartUtils的setYAixs方法对图表的Y坐标轴进行渲染
ChartUtils.setYAixs(chart.getCategoryPlot());// Y坐标轴渲染
// 设置标注无边框
// 创建一个白色边框的BlockBorder对象并将其设置为图表图例的边框
chart.getLegend().setFrame(new BlockBorder(Color.WHITE));
// 返回创建并渲染好的柱状图
return chart;
}
/**
*
*
*
* @param title
*
* @param categories
@ -64,15 +85,19 @@ public class ChartFactory {
* @return
*/
public static JFreeChart createPieChart(String title, String[] categories,
Object[] datas) {
Object[] datas) {
// 1创建数据集合
// 调用ChartUtils的createDefaultPieDataset方法根据传入的类别和数据创建一个默认的饼图数据集
DefaultPieDataset dataset = ChartUtils.createDefaultPieDataset(
categories, datas);
// 使用JFreeChart的工厂方法创建一个饼图传入标题和数据集
JFreeChart chart = org.jfree.chart.ChartFactory.createPieChart(title,
dataset);
// 3:设置抗锯齿,防止字体显示不清楚
// 调用ChartUtils的setAntiAlias方法为图表设置抗锯齿使字体等显示更清晰
ChartUtils.setAntiAlias(chart);// 抗锯齿
// 4:对柱子进行渲染[创建不同图形]
// 调用ChartUtils的setPieRender方法对饼图的绘图区域进行渲染
ChartUtils.setPieRender(chart.getPlot());
/**
*
@ -80,15 +105,17 @@ public class ChartFactory {
// plot.setSimpleLabels(true);//简单标签,不绘制线条
// plot.setLabelGenerator(null);//不显示数字
// 设置标注无边框
// 创建一个白色边框的BlockBorder对象并将其设置为图表图例的边框
chart.getLegend().setFrame(new BlockBorder(Color.WHITE));
// 标注位于右侧
// 将图表的图例位置设置为右侧
chart.getLegend().setPosition(RectangleEdge.RIGHT);
// 返回创建并渲染好的饼图
return chart;
}
/**
* 线
*
*
* @param title
* 线
* @param categoryAxisLabel
@ -102,28 +129,36 @@ public class ChartFactory {
* @return
*/
public static JFreeChart createLineChart(String title,
String categoryAxisLabel, String valueAxisLabel,
Vector<Serie> series, String[] categories) {
String categoryAxisLabel, String valueAxisLabel,
Vector<Serie> series, String[] categories) {
// 1创建数据集合
// 调用ChartUtils的createDefaultCategoryDataset方法根据传入的数据系列和类别创建一个默认的类别数据集
DefaultCategoryDataset dataset = ChartUtils
.createDefaultCategoryDataset(series, categories);
// 使用JFreeChart的工厂方法创建一个折线图传入标题、x轴标题、y轴标题和数据集
JFreeChart chart = org.jfree.chart.ChartFactory.createLineChart(title,
categoryAxisLabel, valueAxisLabel, dataset);
// 3:设置抗锯齿,防止字体显示不清楚
// 调用ChartUtils的setAntiAlias方法为图表设置抗锯齿使字体等显示更清晰
ChartUtils.setAntiAlias(chart);// 抗锯齿
// 4:对柱子进行渲染[[采用不同渲染]]
// 调用ChartUtils的setLineRender方法对折线图的绘图区域进行渲染后面的参数false和true可能表示某种渲染相关的设置
ChartUtils.setLineRender(chart.getCategoryPlot(), false, true);//
// 5:对其他部分进行渲染
// 调用ChartUtils的setXAixs方法对图表的X坐标轴进行渲染
ChartUtils.setXAixs(chart.getCategoryPlot());// X坐标轴渲染
// 调用ChartUtils的setYAixs方法对图表的Y坐标轴进行渲染
ChartUtils.setYAixs(chart.getCategoryPlot());// Y坐标轴渲染
// 设置标注无边框
// 创建一个白色边框的BlockBorder对象并将其设置为图表图例的边框
chart.getLegend().setFrame(new BlockBorder(Color.WHITE));
// 返回创建并渲染好的折线图
return chart;
}
/**
* StackedBarChart
*
*
* @param title
* StackedBarChart
* @param domainAxisLabel
@ -135,22 +170,30 @@ public class ChartFactory {
* @return
*/
public static JFreeChart createStackedBarChart(String title,
String domainAxisLabel, String rangeAxisLabel,
Vector<Serie> series, String[] categories) {
String domainAxisLabel, String rangeAxisLabel,
Vector<Serie> series, String[] categories) {
// 1创建数据集合
// 调用ChartUtils的createDefaultCategoryDataset方法根据传入的数据系列和类别创建一个默认的类别数据集
DefaultCategoryDataset dataset = ChartUtils
.createDefaultCategoryDataset(series, categories);
// 使用JFreeChart的工厂方法创建一个堆积柱状图传入标题、x轴标题、y轴标题和数据集
JFreeChart chart = org.jfree.chart.ChartFactory.createStackedBarChart(
title, domainAxisLabel, rangeAxisLabel, dataset);
// 3:设置抗锯齿,防止字体显示不清楚
// 调用ChartUtils的setAntiAlias方法为图表设置抗锯齿使字体等显示更清晰
ChartUtils.setAntiAlias(chart);// 抗锯齿
// 4:对柱子进行渲染[创建不同图形]
// 调用ChartUtils的setStackBarRender方法对堆积柱状图的绘图区域进行渲染
ChartUtils.setStackBarRender(chart.getCategoryPlot());
// 5:对其他部分进行渲染
// 调用ChartUtils的setXAixs方法对图表的X坐标轴进行渲染
ChartUtils.setXAixs(chart.getCategoryPlot());// X坐标轴渲染
// 调用ChartUtils的setYAixs方法对图表的Y坐标轴进行渲染
ChartUtils.setYAixs(chart.getCategoryPlot());// Y坐标轴渲染
// 设置标注无边框
// 创建一个白色边框的BlockBorder对象并将其设置为图表图例的边框
chart.getLegend().setFrame(new BlockBorder(Color.WHITE));
// 返回创建并渲染好的堆积柱状图
return chart;
}
}
}

@ -1,36 +1,95 @@
package com.utils;
// 声明该类所在的包名为com.utils
import org.jfree.chart.ChartFactory;
// 导入JFreeChart库中的图表工厂类用于创建各种类型的图表
import org.jfree.chart.JFreeChart;
// 导入JFreeChart类它是JFreeChart库中表示图表的核心类
import org.jfree.chart.StandardChartTheme;
// 导入标准图表主题类,用于设置图表的外观主题
import org.jfree.chart.axis.DateAxis;
// 导入日期轴类,用于在图表中显示日期
import org.jfree.chart.axis.DateTickUnit;
// 导入日期刻度单位类,用于定义日期轴上的刻度间隔
import org.jfree.chart.axis.DateTickUnitType;
// 导入日期刻度单位类型枚举类,用于指定日期刻度的类型(如年、月、日等)
import org.jfree.chart.axis.ValueAxis;
// 导入值轴类,用于表示图表中的数值轴
import org.jfree.chart.block.BlockBorder;
// 导入块边框类,用于设置图表中块(如图例)的边框
import org.jfree.chart.labels.*;
// 导入JFreeChart中用于标签相关的类的包用于设置图表的标签显示等
import org.jfree.chart.plot.*;
// 导入JFreeChart中用于绘图区域相关的类的包用于处理图表的绘图区域设置
import org.jfree.chart.renderer.category.BarRenderer;
// 导入柱状图渲染器类,用于渲染柱状图
import org.jfree.chart.renderer.category.LineAndShapeRenderer;
// 导入折线图和形状渲染器类,用于渲染折线图和数据点的形状
import org.jfree.chart.renderer.category.StackedBarRenderer;
// 导入堆积柱状图渲染器类,用于渲染堆积柱状图
import org.jfree.chart.renderer.category.StandardBarPainter;
// 导入标准柱状图绘制器类,用于绘制柱状图的外观
import org.jfree.chart.renderer.xy.StandardXYBarPainter;
// 导入标准XY柱状图绘制器类用于绘制XY图表中的柱状图外观
import org.jfree.chart.renderer.xy.XYBarRenderer;
// 导入XY柱状图渲染器类用于渲染XY图表中的柱状图
import org.jfree.chart.renderer.xy.XYLineAndShapeRenderer;
// 导入XY折线图和形状渲染器类用于渲染XY图表中的折线图和数据点的形状
import org.jfree.data.category.DefaultCategoryDataset;
// 导入默认的类别数据集类,用于处理柱状图、折线图等类别数据的数据集
import org.jfree.data.general.DefaultPieDataset;
// 导入默认的饼图数据集类,用于处理饼图的数据集
import org.jfree.data.time.Day;
// 导入表示一天的时间类,用于时间序列数据
import org.jfree.data.time.TimeSeries;
// 导入时间序列类,用于处理时间序列数据
import org.jfree.ui.RectangleInsets;
// 导入矩形边距类,用于设置图表中元素的边距
import org.jfree.ui.TextAnchor;
// 导入文本锚点类,用于指定文本的位置
import java.awt.*;
// 导入java.awt包包含用于处理图形和用户界面的类
import java.text.DecimalFormat;
// 导入十进制格式化类,用于格式化数字
import java.text.NumberFormat;
// 导入数字格式化类,用于格式化数字
import java.text.ParseException;
// 导入解析异常类,用于处理日期等解析时可能抛出的异常
import java.text.SimpleDateFormat;
// 导入简单日期格式化类,用于格式化日期
import java.util.Date;
// 导入日期类,用于表示日期和时间
import java.util.Vector;
// 导入Vector类它是一个动态数组用于存储数据系列等
/**
* Jfreechart
@ -40,26 +99,31 @@ import java.util.Vector;
* 线<br>
* X-Y
* <p>
*
*
*
*
* @author chenchangwen
* @since:2014-2-18
*
*
*/
public class ChartUtils {
// 定义一个静态字符串,用于表示无数据时的提示信息
private static String NO_DATA_MSG = "暂无数据";
// 定义一个静态字体对象设置字体为宋体样式为普通大小为12
private static Font FONT = new Font("宋体", Font.PLAIN, 12);
// 定义一个静态颜色数组,包含多种颜色,用于图表的颜色设置
public static Color[] CHART_COLORS = { new Color(31, 129, 188),
new Color(92, 92, 97), new Color(144, 237, 125),
new Color(255, 188, 117), new Color(153, 158, 255),
new Color(255, 117, 153), new Color(253, 236, 109),
new Color(128, 133, 232), new Color(158, 90, 102),
new Color(255, 204, 102) };// 颜色
new Color(255, 204, 102) };
// 静态代码块,在类加载时执行,用于设置图表主题
static {
setChartTheme();
}
// 空的构造函数
public ChartUtils() {
}
@ -67,52 +131,75 @@ public class ChartUtils {
*
*/
public static void setChartTheme() {
// 设置中文主题样式 解决乱码
// 创建一个标准图表主题对象,命名为"CN"
StandardChartTheme chartTheme = new StandardChartTheme("CN");
// 设置标题字体
// 设置标题字体为之前定义的字体
chartTheme.setExtraLargeFont(FONT);
// 设置图例的字体
// 设置图例的字体为之前定义的字体
chartTheme.setRegularFont(FONT);
// 设置轴向的字体
// 设置轴向的字体为之前定义的字体
chartTheme.setLargeFont(FONT);
chartTheme.setSmallFont(FONT);
// 设置标题的颜色为灰色
chartTheme.setTitlePaint(new Color(51, 51, 51));
// 设置副标题的颜色为深灰色
chartTheme.setSubtitlePaint(new Color(85, 85, 85));
chartTheme.setLegendBackgroundPaint(Color.WHITE);// 设置标注
chartTheme.setLegendItemPaint(Color.BLACK);//
// 设置图例的背景颜色为白色
chartTheme.setLegendBackgroundPaint(Color.WHITE);
// 设置图例项的颜色为黑色
chartTheme.setLegendItemPaint(Color.BLACK);
// 设置图表的背景颜色为白色
chartTheme.setChartBackgroundPaint(Color.WHITE);
// 绘制颜色绘制颜色.轮廓供应商
// paintSequence,outlinePaintSequence,strokeSequence,outlineStrokeSequence,shapeSequence
// 定义轮廓颜色数组,这里只有白色
Paint[] OUTLINE_PAINT_SEQUENCE = new Paint[] { Color.WHITE };
// 绘制器颜色源
// 创建一个默认的绘图供应商,设置颜色、轮廓颜色等
DefaultDrawingSupplier drawingSupplier = new DefaultDrawingSupplier(
CHART_COLORS, CHART_COLORS, OUTLINE_PAINT_SEQUENCE,
DefaultDrawingSupplier.DEFAULT_STROKE_SEQUENCE,
DefaultDrawingSupplier.DEFAULT_OUTLINE_STROKE_SEQUENCE,
DefaultDrawingSupplier.DEFAULT_SHAPE_SEQUENCE);
// 设置图表主题的绘图供应商
chartTheme.setDrawingSupplier(drawingSupplier);
chartTheme.setPlotBackgroundPaint(Color.WHITE);// 绘制区域
chartTheme.setPlotOutlinePaint(Color.WHITE);// 绘制区域外边框
chartTheme.setLabelLinkPaint(new Color(8, 55, 114));// 链接标签颜色
// 设置绘图区域的背景颜色为白色
chartTheme.setPlotBackgroundPaint(Color.WHITE);
// 设置绘图区域外边框的颜色为白色
chartTheme.setPlotOutlinePaint(Color.WHITE);
// 设置链接标签的颜色
chartTheme.setLabelLinkPaint(new Color(8, 55, 114));
// 设置标签链接的样式为三次曲线
chartTheme.setLabelLinkStyle(PieLabelLinkStyle.CUBIC_CURVE);
// 设置图表的边距
chartTheme.setAxisOffset(new RectangleInsets(5, 12, 5, 12));
chartTheme.setDomainGridlinePaint(new Color(192, 208, 224));// X坐标轴垂直网格颜色
chartTheme.setRangeGridlinePaint(new Color(192, 192, 192));// Y坐标轴水平网格颜色
// 设置X坐标轴垂直网格的颜色
chartTheme.setDomainGridlinePaint(new Color(192, 208, 224));
// 设置Y坐标轴水平网格的颜色
chartTheme.setRangeGridlinePaint(new Color(192, 192, 192));
// 设置基线的颜色为白色
chartTheme.setBaselinePaint(Color.WHITE);
chartTheme.setCrosshairPaint(Color.BLUE);// 不确定含义
chartTheme.setAxisLabelPaint(new Color(51, 51, 51));// 坐标轴标题文字颜色
chartTheme.setTickLabelPaint(new Color(67, 67, 72));// 刻度数字
chartTheme.setBarPainter(new StandardBarPainter());// 设置柱状图渲染
chartTheme.setXYBarPainter(new StandardXYBarPainter());// XYBar 渲染
// 设置十字准线的颜色为蓝色
chartTheme.setCrosshairPaint(Color.BLUE);
// 设置坐标轴标题文字的颜色
chartTheme.setAxisLabelPaint(new Color(51, 51, 51));
// 设置刻度数字的颜色
chartTheme.setTickLabelPaint(new Color(67, 67, 72));
// 设置柱状图的渲染器为标准柱状图绘制器
chartTheme.setBarPainter(new StandardBarPainter());
// 设置XYBar的渲染器为标准XYBar绘制器
chartTheme.setXYBarPainter(new StandardXYBarPainter());
// 设置项目标签的颜色为黑色
chartTheme.setItemLabelPaint(Color.black);
chartTheme.setThermometerPaint(Color.white);// 温度计
// 设置温度计的颜色为白色
chartTheme.setThermometerPaint(Color.white);
// 设置JFreeChart的全局图表主题
ChartFactory.setChartTheme(chartTheme);
}
@ -120,16 +207,16 @@ public class ChartUtils {
* 齿
*/
public static void setAntiAlias(JFreeChart chart) {
// 设置图表的文本抗锯齿为关闭状态
chart.setTextAntiAlias(false);
}
/**
*
*/
public static void setLegendEmptyBorder(JFreeChart chart) {
// 创建一个白色边框的BlockBorder对象并将其设置为图表图例的边框
chart.getLegend().setFrame(new BlockBorder(Color.WHITE));
}
/**
@ -137,29 +224,39 @@ public class ChartUtils {
*/
public static DefaultCategoryDataset createDefaultCategoryDataset(
Vector<Serie> series, String[] categories) {
// 创建一个默认的类别数据集对象
DefaultCategoryDataset dataset = new DefaultCategoryDataset();
// 遍历数据系列
for (Serie serie : series) {
// 获取数据系列的名称
String name = serie.getName();
// 获取数据系列的数据
Vector<Object> data = serie.getData();
// 如果数据和类别都不为空,且数据数量和类别数量相等
if (data != null && categories != null
&& data.size() == categories.length) {
// 遍历数据
for (int index = 0; index < data.size(); index++) {
String value = data.get(index) == null ? "" : data.get(
// 获取数据值,并处理为字符串
String value = data.get(index) == null? "" : data.get(
index).toString();
// 如果数据是百分比形式
if (isPercent(value)) {
// 去掉百分比符号
value = value.substring(0, value.length() - 1);
}
// 如果数据是数字
if (isNumber(value)) {
// 将数据值添加到数据集中
dataset.setValue(Double.parseDouble(value), name,
categories[index]);
}
}
}
}
// 返回创建好的数据集
return dataset;
}
/**
@ -167,23 +264,30 @@ public class ChartUtils {
*/
public static DefaultPieDataset createDefaultPieDataset(
String[] categories, Object[] datas) {
// 创建一个默认的饼图数据集对象
DefaultPieDataset dataset = new DefaultPieDataset();
// 遍历类别
for (int i = 0; i < categories.length && categories != null; i++) {
// 获取数据值,并处理为字符串
String value = datas[i].toString();
// 如果数据是百分比形式
if (isPercent(value)) {
// 去掉百分比符号
value = value.substring(0, value.length() - 1);
}
// 如果数据是数字
if (isNumber(value)) {
// 将数据值添加到数据集中
dataset.setValue(categories[i], Double.valueOf(value));
}
}
// 返回创建好的数据集
return dataset;
}
/**
*
*
*
* @param category
*
* @param dateValues
@ -193,73 +297,96 @@ public class ChartUtils {
* @return
*/
public static TimeSeries createTimeseries(String category,
Vector<Object[]> dateValues) {
Vector<Object[]> dateValues) {
// 创建一个时间序列对象,传入类别名称
TimeSeries timeseries = new TimeSeries(category);
// 如果日期值数组不为空
if (dateValues != null) {
// 创建一个简单日期格式化对象,格式为"yyyy-MM-dd"
SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd");
// 遍历日期值数组
for (Object[] objects : dateValues) {
// 初始化日期对象
Date date = null;
try {
// 解析日期字符串为日期对象
date = dateFormat.parse(objects[0].toString());
} catch (ParseException e) {
}
// 获取数据值,并处理为字符串
String sValue = objects[1].toString();
// 初始化数据值为0
double dValue = 0;
// 如果日期不为空且数据是数字
if (date != null && isNumber(sValue)) {
// 将数据值转换为double类型
dValue = Double.parseDouble(sValue);
// 将数据添加到时间序列中
timeseries.add(new Day(date), dValue);
}
}
}
// 返回创建好的时间序列对象
return timeseries;
}
/**
* 线
*
*
* @param plot
* @param isShowDataLabels
*
*/
public static void setLineRender(CategoryPlot plot, boolean isShowDataLabels) {
// 调用另一个设置折线图样式的方法,不显示节点形状
setLineRender(plot, isShowDataLabels, false);
}
/**
* 线
*
*
* @param plot
* @param isShowDataLabels
*
*/
@SuppressWarnings("deprecation")
public static void setLineRender(CategoryPlot plot,
boolean isShowDataLabels, boolean isShapesVisible) {
boolean isShowDataLabels, boolean isShapesVisible) {
// 设置无数据时的提示信息
plot.setNoDataMessage(NO_DATA_MSG);
// 设置绘图区域的边距
plot.setInsets(new RectangleInsets(10, 10, 0, 10), false);
// 获取折线图的渲染器
LineAndShapeRenderer renderer = (LineAndShapeRenderer) plot
.getRenderer();
// 设置线条的粗细为1.5F
renderer.setStroke(new BasicStroke(1.5F));
// 如果要显示数据标签
if (isShowDataLabels) {
// 设置基本项目标签可见
renderer.setBaseItemLabelsVisible(true);
// 设置基本项目标签生成器
renderer.setBaseItemLabelGenerator(new StandardCategoryItemLabelGenerator(
StandardCategoryItemLabelGenerator.DEFAULT_LABEL_FORMAT_STRING,
NumberFormat.getInstance()));
// 设置基本正项目标签的位置
renderer.setBasePositiveItemLabelPosition(new ItemLabelPosition(
ItemLabelAnchor.OUTSIDE1, TextAnchor.BOTTOM_CENTER));// weizhi
ItemLabelAnchor.OUTSIDE1, TextAnchor.BOTTOM_CENTER));
}
renderer.setBaseShapesVisible(isShapesVisible);// 数据点绘制形状
// 设置数据点绘制形状的可见性
renderer.setBaseShapesVisible(isShapesVisible);
// 设置X坐标轴样式
setXAixs(plot);
// 设置Y坐标轴样式
setYAixs(plot);
}
/**
*
*
*
* @param plot
* @param isShowData
*
@ -267,249 +394,36 @@ public class ChartUtils {
*
*/
public static void setTimeSeriesRender(Plot plot, boolean isShowData,
boolean isShapesVisible) {
boolean isShapesVisible) {
// 将绘图区域转换为XYPlot类型
XYPlot xyplot = (XYPlot) plot;
// 设置无数据时的提示信息
xyplot.setNoDataMessage(NO_DATA_MSG);
// 设置绘图区域的边距
xyplot.setInsets(new RectangleInsets(10, 10, 5, 10));
// 获取XY折线图和形状渲染器
XYLineAndShapeRenderer xyRenderer = (XYLineAndShapeRenderer) xyplot
.getRenderer();
// 设置基本项目标签生成器
xyRenderer
.setBaseItemLabelGenerator(new StandardXYItemLabelGenerator());
// 设置基本数据点形状不可见
xyRenderer.setBaseShapesVisible(false);
// 如果要显示数据
if (isShowData) {
// 设置基本项目标签可见
xyRenderer.setBaseItemLabelsVisible(true);
// 设置基本项目标签生成器
xyRenderer
.setBaseItemLabelGenerator(new StandardXYItemLabelGenerator());
// 设置基本正项目标签的位置
xyRenderer.setBasePositiveItemLabelPosition(new ItemLabelPosition(
ItemLabelAnchor.OUTSIDE1, TextAnchor.BOTTOM_CENTER));// weizhi
}
xyRenderer.setBaseShapesVisible(isShapesVisible);// 数据点绘制形状
DateAxis domainAxis = (DateAxis) xyplot.getDomainAxis();
domainAxis.setAutoTickUnitSelection(false);
DateTickUnit dateTickUnit = new DateTickUnit(DateTickUnitType.YEAR, 1,
new SimpleDateFormat("yyyy-MM")); // 第二个参数是时间轴间距
domainAxis.setTickUnit(dateTickUnit);
StandardXYToolTipGenerator xyTooltipGenerator = new StandardXYToolTipGenerator(
"{1}:{2}", new SimpleDateFormat("yyyy-MM-dd"),
new DecimalFormat("0"));
xyRenderer.setBaseToolTipGenerator(xyTooltipGenerator);
setXY_XAixs(xyplot);
setXY_YAixs(xyplot);
}
/**
* -
*
* @param plot
* @param isShowData
*
*/
public static void setTimeSeriesRender(Plot plot, boolean isShowData) {
setTimeSeriesRender(plot, isShowData, false);
}
/**
* timeseries 线
*
* @param plot
* @param isShowDataLabels
*/
public static void setTimeSeriesBarRender(Plot plot,
boolean isShowDataLabels) {
XYPlot xyplot = (XYPlot) plot;
xyplot.setNoDataMessage(NO_DATA_MSG);
XYBarRenderer xyRenderer = new XYBarRenderer(0.1D);
xyRenderer
.setBaseItemLabelGenerator(new StandardXYItemLabelGenerator());
if (isShowDataLabels) {
xyRenderer.setBaseItemLabelsVisible(true);
xyRenderer
.setBaseItemLabelGenerator(new StandardXYItemLabelGenerator());
ItemLabelAnchor.OUTSIDE1, TextAnchor.BOTTOM_CENTER));
}
// 设置数据点绘制形状的可见性
xyRenderer.setBaseShapesVisible(isShapesVisible);
StandardXYToolTipGenerator xyTooltipGenerator = new StandardXYToolTipGenerator(
"{1}:{2}", new SimpleDateFormat("yyyy-MM-dd"),
new DecimalFormat("0"));
xyRenderer.setBaseToolTipGenerator(xyTooltipGenerator);
setXY_XAixs(xyplot);
setXY_YAixs(xyplot);
}
/**
*
*
* @param plot
* @param isShowDataLabels
*/
public static void setBarRenderer(CategoryPlot plot,
boolean isShowDataLabels) {
plot.setNoDataMessage(NO_DATA_MSG);
plot.setBackgroundAlpha(0);//设置背景透明度
plot.setInsets(new RectangleInsets(10, 10, 5, 10));
BarRenderer renderer = (BarRenderer) plot.getRenderer();
renderer.setBaseItemLabelGenerator(new StandardCategoryItemLabelGenerator());
renderer.setMaximumBarWidth(0.075);// 设置柱子最大宽度
if (isShowDataLabels) {
renderer.setBaseItemLabelsVisible(true);
}
setXAixs(plot);
setYAixs(plot);
}
/**
*
*
* @param plot
*/
public static void setStackBarRender(CategoryPlot plot) {
plot.setNoDataMessage(NO_DATA_MSG);
plot.setInsets(new RectangleInsets(10, 10, 5, 10));
StackedBarRenderer renderer = (StackedBarRenderer) plot.getRenderer();
renderer.setBaseItemLabelGenerator(new StandardCategoryItemLabelGenerator());
plot.setRenderer(renderer);
setXAixs(plot);
setYAixs(plot);
}
/**
* (CategoryPlot) X线
*
* @param axis
*/
public static void setXAixs(CategoryPlot plot) {
Color lineColor = new Color(31, 121, 170);
plot.getDomainAxis().setAxisLinePaint(lineColor);// X坐标轴颜色
plot.getDomainAxis().setTickMarkPaint(lineColor);// X坐标轴标记|竖线颜色
}
/**
* (CategoryPlot) Y线
*
* @param axis
*/
public static void setYAixs(CategoryPlot plot) {
Color lineColor = new Color(192, 208, 224);
ValueAxis axis = plot.getRangeAxis();
axis.setAxisLinePaint(lineColor);// Y坐标轴颜色
axis.setTickMarkPaint(lineColor);// Y坐标轴标记|竖线颜色
// 隐藏Y刻度
axis.setAxisLineVisible(false);
axis.setTickMarksVisible(false);
// Y轴网格线条
plot.setRangeGridlinePaint(new Color(192, 192, 192));
plot.setRangeGridlineStroke(new BasicStroke(1));
plot.getRangeAxis().setUpperMargin(0.1);// 设置顶部Y坐标轴间距,防止数据无法显示
plot.getRangeAxis().setLowerMargin(0.1);// 设置底部Y坐标轴间距
}
/**
* XY(XYPlot) X线
*
* @param axis
*/
public static void setXY_XAixs(XYPlot plot) {
Color lineColor = new Color(31, 121, 170);
plot.getDomainAxis().setAxisLinePaint(lineColor);// X坐标轴颜色
plot.getDomainAxis().setTickMarkPaint(lineColor);// X坐标轴标记|竖线颜色
}
/**
* XY(XYPlot) Y线
*
* @param axis
*/
public static void setXY_YAixs(XYPlot plot) {
Color lineColor = new Color(192, 208, 224);
ValueAxis axis = plot.getRangeAxis();
axis.setAxisLinePaint(lineColor);// X坐标轴颜色
axis.setTickMarkPaint(lineColor);// X坐标轴标记|竖线颜色
// 隐藏Y刻度
axis.setAxisLineVisible(false);
axis.setTickMarksVisible(false);
// Y轴网格线条
plot.setRangeGridlinePaint(new Color(192, 192, 192));
plot.setRangeGridlineStroke(new BasicStroke(1));
plot.setDomainGridlinesVisible(false);
plot.getRangeAxis().setUpperMargin(0.12);// 设置顶部Y坐标轴间距,防止数据无法显示
plot.getRangeAxis().setLowerMargin(0.12);// 设置底部Y坐标轴间距
}
/**
*
*/
public static void setPieRender(Plot plot) {
plot.setNoDataMessage(NO_DATA_MSG);
plot.setInsets(new RectangleInsets(10, 10, 5, 10));
PiePlot piePlot = (PiePlot) plot;
piePlot.setInsets(new RectangleInsets(0, 0, 0, 0));
piePlot.setCircular(true);// 圆形
// piePlot.setSimpleLabels(true);// 简单标签
piePlot.setLabelGap(0.01);
// piePlot.setForegroundAlpha(0.5f);// 饼图的透明度
piePlot.setBackgroundAlpha(0);//背景透明度
piePlot.setOutlinePaint(null);//去掉边框
piePlot.setInteriorGap(0.05D);
piePlot.setLegendItemShape(new Rectangle(10, 10));// 图例形状
piePlot.setIgnoreNullValues(true);
piePlot.setLabelBackgroundPaint(null);// 去掉背景色
piePlot.setLabelShadowPaint(null);// 去掉阴影
piePlot.setLabelOutlinePaint(null);// 去掉边框
piePlot.setShadowPaint(null);
// 0:category 1:value:2 :percentage(标签显示形式1)
/*piePlot.setLabelGenerator(new StandardPieSectionLabelGenerator(
"{0}:{2}"));// 显示标签数据*/
//设置图形的生成格式为(张三 23 10%))(姓名 值 百分比)(标签显示形式2)
piePlot.setLabelGenerator(new StandardPieSectionLabelGenerator(
"{0} {1} ({2})"));// 显示标签数据
}
/**
* %
*
* @param str
* @return
*/
public static boolean isPercent(String str) {
return str != null ? str.endsWith("%")
&& isNumber(str.substring(0, str.length() - 1)) : false;
}
/**
*
*
* @param str
* @return
*/
public static boolean isNumber(String str) {
return str != null ? str
.matches("^[-+]?(([0-9]+)((([.]{0})([0-9]*))|(([.]{1})([0-9]+))))$")
: false;
}
}
//

@ -1,35 +1,64 @@
package com.utils;
// 声明该类所在的包名为com.utils
import java.sql.Connection;
// 导入java.sql包中的Connection类用于表示与数据库的连接
import java.sql.DriverManager;
// 导入java.sql包中的DriverManager类用于管理数据库驱动程序
import java.sql.ResultSet;
import java.sql.Statement;
// 导入java.sql包中的ResultSet类用于处理数据库查询结果集
import java.sql.Statement;
// 导入java.sql包中的Statement类用于执行SQL语句
/**
* JDBC
*/
public class JDBCUtils {
// 数据库驱动类名这里使用的是MySQL的旧驱动
private static String driver = "com.mysql.jdbc.Driver";
// 数据库连接URL指定了连接的主机、端口和数据库名
private static String url = "jdbc:mysql://localhost:3306/lsyqfksys";
// 数据库用户名
private static String user = "root";
// 数据库密码
private static String psw = "105293";
/**
*
* @return null
*/
public static Connection getConnection(){
// 声明数据库连接对象
Connection connection = null;
try {
// 加载数据库驱动类
Class.forName(driver);
// 通过DriverManager获取数据库连接
connection = DriverManager.getConnection(url, user, psw);
// 打印连接成功信息
System.out.println("连接成功");
}
catch (Exception e){
// 打印异常堆栈信息
e.printStackTrace();
}
// 返回数据库连接对象
return connection;
}
//释放资源,对于查询
/**
* ResultSet, Statement, Connection
* @param resultSet
* @param statement SQL
* @param connection
*/
public static void close(ResultSet resultSet, Statement statement, Connection connection) {
// 关闭结果集
if (resultSet != null) {
try {
resultSet.close();
@ -38,6 +67,7 @@ public class JDBCUtils {
}
}
// 关闭Statement对象
if (statement != null) {
try {
statement.close();
@ -46,6 +76,7 @@ public class JDBCUtils {
}
}
// 关闭数据库连接
if (connection != null) {
try {
connection.close();
@ -55,8 +86,13 @@ public class JDBCUtils {
}
}
//释放资源,对于更新
/**
* Statement, Connection
* @param statement SQL
* @param connection
*/
public static void close(Statement statement, Connection connection) {
// 关闭Statement对象
if (statement != null) {
try {
statement.close();
@ -65,6 +101,7 @@ public class JDBCUtils {
}
}
// 关闭数据库连接
if (connection != null) {
try {
connection.close();
@ -74,8 +111,12 @@ public class JDBCUtils {
}
}
//关闭资源,用于查询
/**
*
* @param resultSet
*/
public static void close(ResultSet resultSet) {
// 关闭结果集
if (resultSet != null) {
try {
resultSet.close();
@ -84,7 +125,4 @@ public class JDBCUtils {
}
}
}
}
}

@ -1,73 +1,89 @@
package com.utils;
// 声明该类所在的包名为com.utils
import java.io.Serializable;
// 导入java.io包中的Serializable接口用于实现对象的序列化
import java.util.Vector;
// 导入java.util包中的Vector类用于存储数据集合
/**
* : 线</br> serie线
*
*
* <p>
* JS</br> series: [{ name: 'Tokyo', data: [7.0, 6.9, 9.5, 14.5]
* },</br> { name: 'New York', data: [-0.2, 0.8, 5.7, 11.3} ]</br>
* </p>
*
*
* @author ccw
* @date 2014-6-4
*/
public class Serie implements Serializable {
// 序列化版本号,用于确保序列化和反序列化的兼容性
private static final long serialVersionUID = 1L;
private String name;// 名字
private Vector<Object> data;// 数据值
// 系列的名称,例如在图表中表示一条线或一个柱子的名称
private String name;
// 系列的数据集合使用Vector存储各种类型的数据值
private Vector<Object> data;
// 无参构造函数
public Serie() {
}
/**
*
*
* @param name
* 线
* @param data
* 线
*/
public Serie(String name, Vector<Object> data) {
// 初始化系列名称
this.name = name;
// 初始化系列数据
this.data = data;
}
/**
*
*
* @param name
* 线
* @param array
* 线
*/
public Serie(String name, Object[] array) {
// 初始化系列名称
this.name = name;
// 如果传入的数据数组不为空
if (array != null) {
// 创建一个初始容量为数组长度的Vector
data = new Vector<Object>(array.length);
// 遍历数组将元素添加到Vector中
for (int i = 0; i < array.length; i++) {
data.add(array[i]);
}
}
}
// 获取系列名称的方法
public String getName() {
return name;
}
// 设置系列名称的方法
public void setName(String name) {
this.name = name;
}
// 获取系列数据集合的方法
public Vector<Object> getData() {
return data;
}
// 设置系列数据集合的方法
public void setData(Vector<Object> data) {
this.data = data;
}
}
}
Loading…
Cancel
Save