球助！真的球助！
问题：利用SSM框架做一个宿舍信息管理系统，实现基础的四个功能：增删改查
要求：使用SSM框架（Spring+SpringMVC+MyBatis）
使用MySQL数据库创建相应的表
使用IDEA
使用MySQL数据库创建相应的表
界面设计整洁
功能实现在网页中体现
这种还是比较简单的，好写，就是价格太低，会的不想做。
现在作业都不用自己做，花个15光明正大的来贴吧要答案了？
哈哈，你至少自己要先做一点工作呀。如果谁帮你把这个做了，那不是害了你吗？
直接查看详细步骤：IDEA中配置MySQL数据库的连接
由于这个问题需要涉及到SSM框架的使用，所以在回答之前，首先需要确保你已经掌握以下几个基础概念：Spring、SpringMVC、MyBatis。
首先，需要进行数据库表的设计，设计的思路应该是建立一个 Branches 和一个 Cityarea 表来管理宿舍信息。
创建 Branches 表格，需要按照 Branches.java 里面的字段进行创建，这里假设使用的是 MySQL 数据库：
CREATE TABLE Branches(
id INT AUTO_INCREMENT PRIMARY KEY,
name VARCHAR(255) NOT NULL,
city_area_id INT NOT NULL,
address VARCHAR(255) NOT NULL,
telephone VARCHAR(255) NOT NULL,
FOREIGN KEY (city_area_id) REFERENCES Cityarea(id)
);
同样，创建 Cityarea 表格，需要按照 Cityarea.java 里面的字段进行创建：
CREATE TABLE Cityarea(
id INT AUTO_INCREMENT PRIMARY KEY,
name VARCHAR(255) NOT NULL
);
在 SSM 框架中，一般使用 MyBatis 来操作数据库，所以需要编写实体类、Mapper、Service、Controller。
实体类 Branches 和 Cityarea 已经在参考资料中给出，这里需要对它们进行相关注解的配置。
Branches.java
@Data //注解来自于 lombok, @Data 包含了 @ToString、@EqualsAndHashCode、@Getter、@Setter 和 @RequiredArgsConstrucotor 注解
@AllArgsConstructor //注解来自于 lombok, 自动生成含有所有参数的构造函数
@NoArgsConstructor //注解来自于 lombok, 自动生成无参构造函数
public class Branches {
/**
* 网点ID
*/
private Integer id;
/**
* 网点名称
*/
private String name;
/**
*城区ID
*/
private Cityarea cityAreald;
/**
*地址
*/
private String address;
/**
*联系电话
*/
private String telephone;
}
Cityarea.java
@Data //注解来自于 lombok, @Data 包含了 @ToString、@EqualsAndHashCode、@Getter、@Setter 和 @RequiredArgsConstrucotor 注解
@AllArgsConstructor //注解来自于 lombok, 自动生成含有所有参数的构造函数
@NoArgsConstructor //注解来自于 lombok, 自动生成无参构造函数
public class Cityarea {
/**
* 城区ID
*/
private Integer id;
/**
* 城区名称
*/
private String name;
}
接下来是映射文件 Mapper，文件名为 BranchesMapper.xml：
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
"http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.xxx.xxx.mapper.BranchesMapper">
<!-- 查询 -->
<select id="findAllBranches" resultType="com.xxx.xxx.entity.Branches">
SELECT * FROM Branches
</select>
<!-- 增加 -->
<insert id="addBranches" parameterType="com.xxx.xxx.entity.Branches">
INSERT INTO Branches (name, city_area_id, address, telephone)
VALUES(#{name}, #{cityAreald.id}, #{address}, #{telephone})
</insert>
<!-- 删除 -->
<delete id="deleteBranches" parameterType="int">
DELETE FROM Branches WHERE id = #{id}
</delete>
<!-- 修改 -->
<update id="updateBranches" parameterType="com.xxx.xxx.entity.Branches">
UPDATE Branches SET name=#{name}, city_area_id=#{cityAreald.id}, address=#{address}, telephone=#{telephone}
WHERE id=#{id}
</update>
</mapper>
然后是 Service 层，BranchesService.java：
public interface BranchesService {
List<Branches> findAllBranches();
void addBranches(Branches branches);
void deleteBranches(int id);
void updateBranches(Branches branches);
Branches findById(int id);
}
ServiceImpl 的代码如下，BranchesServiceImpl.java：
@Service
@Transactional //可以开启事务
public class BranchesServiceImpl implements BranchesService {
@Autowired
private BranchesMapper branchesMapper;
@Override
public List<Branches> findAllBranches() {
return branchesMapper.findAllBranches();
}
@Override
public void addBranches(Branches branches) {
branchesMapper.addBranches(branches);
}
@Override
public void deleteBranches(int id) {
branchesMapper.deleteBranches(id);
}
@Override
public void updateBranches(Branches branches) {
branchesMapper.updateBranches(branches);
}
@Override
public Branches findById(int id) {
return branchesMapper.findById(id);
}
}
RestController 层代码如下，BranchesController.java：
@RestController
@RequestMapping("/branches")
public class BranchesController {
@Autowired
private BranchesService branchesService;
@GetMapping("/show")
public String show(Model model) {
List<Branches> branchesList = branchesService.findAllBranches();
model.addAttribute("ShowList", branchesList);
return "show.jsp";
}
@RequestMapping(value = "/add", method = RequestMethod.GET)
public String add(Model model) {
model.addAttribute("cityareaList", cityareaService.findAllCityarea());
return "add.jsp";
}
@PostMapping("/add")
public String add(@ModelAttribute Branches branches) {
branchesService.addBranches(branches);
return "redirect:/branches/show";
}
@RequestMapping(value = "/update/{id}", method = RequestMethod.GET)
public String update(@PathVariable("id") Integer id, Model model) {
Branches branches = branchesService.findById(id);
model.addAttribute("updateList", branches);
model.addAttribute("cityareaList", cityareaService.findAllCityarea());
return "update.jsp";
}
@PostMapping("/update")
public String update(@ModelAttribute Branches branches) {
branchesService.updateBranches(branches);
return "redirect:/branches/show";
}
@RequestMapping("/del/{id}")
public String del(@PathVariable("id") Integer id) {
branchesService.deleteBranches(id);
return "redirect:/branches/show";
}
}
最后是界面设计，在上面的 Controller 代码片段已经给出了show.jsp、add.jsp、update.jsp。
需要使用的工具和技术支持包括：Eclipse、Tomcat、MySQL、Spring、MyBatis、SpringMVC。
实现一个基础的宿舍信息管理系统，需要按照以下步骤进行：
创建MySQL数据库，并创建相应表格
可以使用MySQL Workbench等工具来创建数据库以及表格。为了创建一个宿舍信息管理系统，你需要创建一些表格，例如dorm表、student表等，以存储相关的信息。在这些表格中，你需要注意选择各种属性的数据类型和关系类型等。
下载并配置SSM框架
SSM框架是一组被广泛使用的Java技术，它提供了一个结构清晰的应用程序开发框架。你可以在此处 下载 SSM框架，然后在你的项目中引入相应的依赖项。在引入依赖项后，你需要在mybatis-config.xml和spring.xml文件中配置数据库连接，以便在应用程序中使用数据库。
创建Java Bean类和Mapper接口
使用MyBatis ORM框架，你可以将各种数据映射到Java Bean类中。你需要创建一些Java Bean类，例如Dorm和Student，然后为这些Bean类创建相应的Mapper接口。这些Mapper接口负责首次操作数据库查询、插入、更新和删除。
创建Service和Controller层
在你的应用程序中，Service和Controller是两个重要的层次。 Service层可以将你的数据库操作封装起来，而Controller层管理你视图和请求。你需要在你的应用程序中创建一些Service和Controller层的类，并使用@Service和@Controller注释标注。
创建JSP视图
你需要使用JSP视图来处理用户请求，并将这些请求转发到相应的控制器。可以从模板库中使用一些现有的JSP文件，或者自己创建设计良好的JSP文件。
使用上述步骤，你可以完整地构建一个基础的宿舍信息管理系统，实现增删改查等基础功能。
为了帮助您实现宿舍信息管理系统的增删改查功能，我将为您提供一个基本的SSM框架的示例代码和步骤。以下是一般的步骤和要求：
创建数据库表：首先，在MySQL数据库中创建适当的表，以存储宿舍信息。您可以根据您的需求和数据模型创建适当的表结构，例如dormitory表，包含id、name、capacity等字段。
配置Spring和SpringMVC：在项目中配置Spring和SpringMVC，确保您的项目正确加载这些框架，并能够处理请求和响应。
创建实体类：创建与数据库表对应的Java实体类，例如Dormitory类，包含与数据库表字段对应的属性。
创建数据访问层（DAO）：使用MyBatis框架创建数据访问层，编写数据库操作的接口和实现类。在这个例子中，您将需要创建一个DormitoryMapper接口，定义增删改查等数据库操作的方法。
创建业务逻辑层（Service）：创建业务逻辑层，编写对宿舍信息进行增删改查等操作的方法。在这个例子中，您可以创建一个DormitoryService类，调用数据访问层的方法来实现相应的功能。
创建控制器（Controller）：创建控制器类，处理前端请求并调用业务逻辑层的方法进行相应的处理。在这个例子中，您可以创建一个DormitoryController类，使用SpringMVC注解来处理请求，并调用DormitoryService中的方法来实现对宿舍信息的增删改查。
创建网页界面：根据您的需求和设计，创建相应的网页界面。使用HTML、CSS和JavaScript等前端技术来设计整洁和用户友好的界面。
请注意，这里只提供了一般的步骤和要求，具体的代码实现可能因您的需求和设计而有所不同。建议您参考相关的SSM框架教程和示例，以获取更具体和准确的代码和配置细节。
网上有若依单体，自己看看用户管理怎么写的，增删改查你就会了。程序员不能只想别人给你现成的东西。
可以为您提供一些关于使用SSM框架开发宿舍信息管理系统的基本步骤及相关技术要点。下面是一个简单的演示：
1.创建数据库
首先，您需要在MySQL数据库中创建相应的表以存储您的宿舍信息。您可以使用以下SQL语句创建一个名为“dormitory”的数据库，并在其中创建一个名为“dorm_info”的表：
CREATE DATABASE dormitory;
USE dormitory;
CREATE TABLE dorm_info (
id INT(11) NOT NULL AUTO_INCREMENT,
dorm_no VARCHAR(20) DEFAULT NULL COMMENT '宿舍号',
building_no INT(11) DEFAULT NULL COMMENT '楼号',
student_count INT(11) DEFAULT NULL COMMENT '入住人数',
PRIMARY KEY (id)
) ENGINE=INNODB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_general_ci;
2.配置SSM框架
接下来，您需要在IDEA中配置SSM框架，包括Spring、SpringMVC和MyBatis三个组件。具体步骤如下：
（1）添加Spring依赖
在您的项目中添加Spring依赖项，例如通过Maven添加以下依赖项：
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-core</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<version>${spring.version}</version>
</dependency>
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-jdbc</artifactId>
<version>${spring.version}</version>
</dependency>
（2）添加SpringMVC依赖
同样，在您的项目中添加SpringMVC依赖项，例如通过Maven添加以下依赖项：
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-webmvc</artifactId>
<version>${spring.version}</version>
</dependency>
（3）添加MyBatis依赖
在您的项目中添加MyBatis依赖项，例如通过Maven添加以下依赖项：
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis</artifactId>
<version>${mybatis.version}</version>
</dependency>
<dependency>
<groupId>org.mybatis</groupId>
<artifactId>mybatis-spring</artifactId>
<version>${mybatis-spring.version}</version>
</dependency>
（4）配置Spring和MyBatis
创建Spring配置文件，并在其中配置数据源和MyBatis的SqlSessionFactory等相关信息。例如，在applicationContext.xml文件中添加以下内容：
<!-- 数据源配置 -->
<bean id="dataSource" class="org.apache.commons.dbcp.BasicDataSource">
<property name="driverClassName" value="${jdbc.driverClassName}"/>
<property name="url" value="${jdbc.url}"/>
<property name="username" value="${jdbc.username}"/>
<property name="password" value="${jdbc.password}"/>
</bean>
<!-- SqlSessionFactory 配置 -->
<bean id="sqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">
<property name="dataSource" ref="dataSource"/>
<property name="configLocation" value="classpath:mybatis-config.xml"/>
</bean>
<!-- 扫描dao包，动态实现Dao接口，注入到spring容器中 -->
<bean class="org.mybatis.spring.mapper.MapperScannerConfigurer">
<property name="basePackage" value="com.example.dao"/>
</bean>
（5）配置SpringMVC
创建SpringMVC的配置文件，并在其中配置视图解析器和控制器等相关信息。例如，在springmvc-servlet.xml文件中添加以下内容：
<!-- 视图解析器 -->
<bean class="org.springframework.web.servlet.view.InternalResourceViewResolver">
<property name="prefix" value="/WEB-INF/views/"/>
<property name="suffix" value=".jsp"/>
</bean>
<!-- 静态资源处理 -->
<mvc:default-servlet-handler/>
<mvc:annotation-driven/>
<!-- 扫描controller包，注入到spring容器中 -->
<context:component-scan base-package="com.example.controller"/>
3.编写实体类、DAO接口及Mapper文件
在您的项目中创建相应的实体类和DAO接口，并使用MyBatis的注解或XML文件配置相关的SQL语句。例如，您可以创建一个名为DormInfo的实体类：
public class DormInfo {
private Integer id;
private String dormNo;
private Integer buildingNo;
private Integer studentCount;
// getter / setter
}
然后，在DAO接口中定义相关的增删改查方法：
public interface DormInfoDao {
void addDormInfo(DormInfo dormInfo);
void deleteDormInfo(Integer id);
void updateDormInfo(DormInfo dormInfo);
DormInfo getDormInfoById(Integer id);
List<DormInfo> getAllDormInfo();
}
最后，在Mapper文件中配置相应的SQL语句。例如，在DormInfoMapper.xml文件中添加以下内容：
<mapper namespace="com.example.dao.DormInfoDao">
<resultMap id="dormInfoResultMap" type="com.example.entity.DormInfo">
<id property="id" column="id"/>
<result property="dormNo" column="dorm_no"/>
<result property="buildingNo" column="building_no"/>
<result property="studentCount" column="student_count"/>
</resultMap>
<insert id="addDormInfo" parameterType="com.example.entity.DormInfo">
INSERT INTO dorm_info (dorm_no, building_no, student_count) VALUES (#{dormNo}, #{buildingNo}, #{studentCount})
</insert>
<delete id="deleteDormInfo" parameterType="int">
DELETE FROM dorm_info WHERE id = #{id}
</delete>
<update id="updateDormInfo" parameterType="com.example.entity.DormInfo">
UPDATE dorm_info SET dorm_no = #{dormNo}, building_no = #{buildingNo}, student_count = #{studentCount} WHERE id = #{id}
</update>
<select id="getDormInfoById" resultMap="dormInfoResultMap" parameterType="int">
SELECT * FROM dorm_info WHERE id = #{id}
</select>
<select id="getAllDormInfo" resultMap="dormInfoResultMap">
SELECT * FROM dorm_info
</select>
</mapper>
4.编写Controller和JSP页面
最后，您需要编写相关的Controller和JSP页面以实现宿舍信息管理系统的基础四个功能：增删改查。例如，在DormInfoController中添加以下方法：
@Controller
@RequestMapping("/dorm")
public class DormInfoController {
@Autowired
private DormInfoDao dormInfoDao;
@RequestMapping("/add")
public String add(DormInfo dormInfo) {
dormInfoDao.addDormInfo(dormInfo);
return "redirect:/dorm/list";
}
@RequestMapping("/delete/{id}")
public String delete(@PathVariable("id") Integer id) {
dormInfoDao.deleteDormInfo(id);
return "redirect:/dorm/list";
}
@RequestMapping("/update")
public String update(DormInfo dormInfo) {
dormInfoDao.updateDormInfo(dormInfo);
return "redirect:/dorm/list";
}
@RequestMapping("/list")
public String list(Model model) {
List<DormInfo> dormInfoList = dormInfoDao.getAllDormInfo();
model.addAttribute("dormInfoList", dormInfoList);
return "dorm_list";
}
@RequestMapping("/edit/{id}")
public String edit(@PathVariable("id") Integer id, Model model) {
DormInfo dormInfo = dormInfoDao.getDormInfoById(id);
model.addAttribute("dormInfo", dormInfo);
return "dorm_edit";
}
}
然后，您需要创建相关的JSP页面以展示宿舍信息和实现基本操作。例如，您可以创建一个名为dorm_list.jsp的页面用于展示所有宿舍信息，并添加以下内容：
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>宿舍信息管理系统</title>
</head>
<body>
<h2>宿舍列表</h2>
<table border="1">
<tr>
<th>ID</th>
<th>宿舍号</th>
<th>楼号</th>
<th>入住人数</th>
<th>操作</th>
</tr>
<c:forEach items="
�
�
�
�
�
�
�
�
�
�
�
�
"
�
�
�
=
"
�
�
�
�
�
�
�
�
"
>
<
�
�
>
<
�
�
>
dormInfoList"var="dormInfo"><tr><td>{dormInfo.id}</td>
<td>
�
�
�
�
�
�
�
�
.
�
�
�
�
�
�
<
/
�
�
>
<
�
�
>
dormInfo.dormNo</td><td>{dormInfo.buildingNo}</td>
<td>
�
�
�
�
�
�
�
�
.
�
�
�
�
�
�
�
�
�
�
�
�
<
/
�
�
>
<
�
�
>
<
�
ℎ
�
�
�
=
"
dormInfo.studentCount</td><td><ahref="{pageContext.request.contextPath}/dorm/edit/
�
�
�
�
�
�
�
�
.
�
�
"
>
编辑
<
/
�
>
<
�
ℎ
�
�
�
=
"
dormInfo.id">编辑</a><ahref="{pageContext.request.contextPath}/dorm/delete/${dormInfo.id}">删除</a>
</td>
</tr>
</c:forEach>
</table>
<br />
<a href="${pageContext.request.contextPath}/dorm/add.jsp">添加宿舍信息</a>
</body>
</html>
还可以创建一个名为dorm_edit.jsp的页面用于编辑宿舍信息，并添加以下内容：
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>编辑宿舍信息</title>
</head>
<body>
<h2>编辑宿舍信息</h2>
<form action="
�
�
�
�
�
�
�
�
�
�
�
.
�
�
�
�
�
�
�
.
�
�
�
�
�
�
�
�
�
�
ℎ
/
�
�
�
�
/
�
�
�
�
�
�
"
�
�
�
ℎ
�
�
=
"
�
�
�
�
"
>
<
�
�
�
�
�
�
�
�
�
=
"
ℎ
�
�
�
�
�
"
�
�
�
�
=
"
�
�
"
�
�
�
�
�
=
"
pageContext.request.contextPath/dorm/update"method="post"><inputtype="hidden"name="id"value="{dormInfo.id}" />
<p><label>宿舍号：</label><input type="text" name="dormNo" value="${dormInfo.dormNo}" /></p>
<p><label>楼号：</label><input type="text" name="buildingNo" value="${dormInfo.buildingNo}" /></p>
<p><label>入住人数：</label><input type="text" name="studentCount" value="${dormInfo.studentCount}" /></p>
<p><input type="submit" value="保存" /></p>
</form>
<br />
<a href="${pageContext.request.contextPath}/dorm/list">返回宿舍列表</a>
</body>
</html>
最后，您可以创建一个名为dorm_add.jsp的页面用于添加宿舍信息，并添加以下内容：
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>添加宿舍信息</title>
</head>
<body>
<h2>添加宿舍信息</h2>
<form action="${pageContext.request.contextPath}/dorm/add" method="post">
<p><label>宿舍号：</label><input type="text" name="dormNo" /></p>
<p><label>楼号：</label><input type="text" name="buildingNo" /></p>
<p><label>入住人数：</label><input type="text" name="studentCount" /></p>
<p><input type="submit" value="保存" /></p>
</form>
<br />
<a href="${pageContext.request.contextPath}/dorm/list">返回宿舍列表</a>
</body>
</html>
这些JSP页面将直接与Controller中的方法交互，实现基本的增删改查功能。
简单看下
package com.znz.controller;
import com.znz.po.Admin;
import com.znz.po.PageInfo;
import com.znz.service.AdminService;
import com.znz.util.MD5Util;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Controller;
import org.springframework.ui.Model;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestMethod;
import org.springframework.web.bind.annotation.ResponseBody;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import java.util.List;
/**
* 用户控制器类
*/
@Controller
public class AdminController {
// 依赖注入
@Autowired
private AdminService adminService;
/**
* 用户登录
*/
/**
* 将提交数据(username,password)写入Admin对象
*/
@RequestMapping(value = "/login")
public String login( Admin admin, Model model, HttpSession session, HttpServletRequest request) {
// 通过账号和密码查询用户
//将用户名使用 MD5进行加密
admin.setA_password(MD5Util.MD5EncodeUtf8(admin.getA_password()));
Admin ad = adminService.findAdmin(admin);
if(ad!=null){
session.setAttribute("ad", ad);
return "homepage";
}
model.addAttribute("msg", "用户名或密码错误，请重新登录！");
return "login";
}
/**
* 退出登录
*/
@RequestMapping(value = "/loginOut")
public String loginOut(Admin admin, Model model, HttpSession session) {
session.invalidate();
return "login";
}
/**
* 分页查询
*/
@RequestMapping(value = "/findAdmin")
public String findAdmin(String a_username, String a_describe,Integer pageIndex,
Integer a_id ,Integer pageSize, Model model) {
PageInfo<Admin> ai = adminService.findPageInfo(a_username,a_describe,
a_id,pageIndex,pageSize);
model.addAttribute("ai",ai);
return "admin_list";
}
/**
* 导出Excel
*/
@RequestMapping(value = "/exportadminlist" , method = RequestMethod.POST)
@ResponseBody
public List<Admin> exportAdmin(){
List<Admin> admin = adminService.getAll();
return admin;
}
/**
* 添加管理员信息
*/
@RequestMapping(value = "/addAdmin" ,method = RequestMethod.POST)
@ResponseBody
public String addAdmin( @RequestBody Admin admin) {
admin.setA_password(MD5Util.MD5EncodeUtf8(admin.getA_password()));
int a = adminService.addAdmin(admin);
return "admin_list";
}
/**
* 删除管理员信息；将请求体a_id写入参数a_id
*/
@RequestMapping( "/deleteAdmin")
@ResponseBody
public String deleteAdmin(Integer a_id) {
int a = adminService.deleteAdmin(a_id);
return "admin_list";
}
/**
* 修改管理员信息
*/
/**
* 将提交数据(a_id,a_username...)写入Admin对象
*/
@RequestMapping( value = "/updateAdmin", method = RequestMethod.POST)
public String updateAdmin(Admin admin) {
admin.setA_password(MD5Util.MD5EncodeUtf8(admin.getA_password()));
int a = adminService.updateAdmin(admin);
return "redirect:/findAdmin";
}
/**
* 根据管理员Id搜索;将请求数据a_id写入参数a_id
*/
@RequestMapping( "/findAdminById")
public String findAdminById( Integer a_id,HttpSession session) {
Admin a= adminService.findAdminById(a_id);
session.setAttribute("a",a);
return "admin_edit";
}
}
宿舍信息管理系统是一个常见的信息管理系统，可以利用SSM框架进行开发。下面是一个简单的实现宿舍信息管理系统的示例：
```java
public class Student {
private int id;
private String name;
private String gender;
private String dormitory;
// 省略getter和setter方法
}
public class Dormitory {
private int id;
private String number;
private int floor;
private int capacity;
// 省略getter和setter方法
}
public interface StudentMapper {
void addStudent(Student student);
void deleteStudent(int id);
void updateStudent(Student student);
List<Student> getAllStudents();
Student getStudentById(int id);
}
public interface DormitoryMapper {
void addDormitory(Dormitory dormitory);
void deleteDormitory(int id);
void updateDormitory(Dormitory dormitory);
List<Dormitory> getAllDormitories();
Dormitory getDormitoryById(int id);
}
@Service
public class StudentServiceImpl implements StudentService {
@Autowired
private StudentMapper studentMapper;
@Override
public void addStudent(Student student) {
studentMapper.addStudent(student);
}
@Override
public void deleteStudent(int id) {
studentMapper.deleteStudent(id);
}
@Override
public void updateStudent(Student student) {
studentMapper.updateStudent(student);
}
@Override
public List<Student> getAllStudents() {
return studentMapper.getAllStudents();
}
@Override
public Student getStudentById(int id) {
return studentMapper.getStudentById(id);
}
}
@Service
public class DormitoryServiceImpl implements DormitoryService {
@Autowired
private DormitoryMapper dormitoryMapper;
@Override
public void addDormitory(Dormitory dormitory) {
dormitoryMapper.addDormitory(dormitory);
}
@Override
public void deleteDormitory(int id) {
dormitoryMapper.deleteDormitory(id);
}
@Override
public void updateDormitory(Dormitory dormitory) {
dormitoryMapper.updateDormitory(dormitory);
}
@Override
public List<Dormitory> getAllDormitories() {
return dormitoryMapper.getAllDormitories();
}
@Override
public Dormitory getDormitoryById(int id) {
return dormitoryMapper.getDormitoryById(id);
}
}
@Controller
@RequestMapping("/student")
public class StudentController {
@Autowired
private StudentService studentService;
@GetMapping("/list")
public String list(Model model) {
List<Student> students = studentService.getAllStudents();
model.addAttribute("students", students);
return "student/list";
}
@GetMapping("/add")
public String add(Model model) {
model.addAttribute("student", new Student());
return "student/add";
}
@PostMapping("/add")
public String add(@ModelAttribute("student") Student student) {
studentService.addStudent(student);
return "redirect:/student/list";
}
@GetMapping("/edit/{id}")
public String edit(@PathVariable("id") int id, Model model) {
Student student = studentService.getStudentById(id);
model.addAttribute("student", student);
return "student/edit";
}
@PostMapping("/edit")
public String edit(@ModelAttribute("student") Student student) {
studentService.updateStudent(student);
return "redirect:/student/list";
}
@GetMapping("/delete/{id}")
public String delete(@PathVariable("id") int id) {
studentService.deleteStudent(id);
return "redirect:/student/list";
}
}
@Controller
@RequestMapping("/dormitory")
public class DormitoryController {
@Autowired
private DormitoryService dormitoryService;
@GetMapping("/list")
public String list(Model model) {
List<Dormitory> dormitories = dormitoryService.getAllDormitories();
model.addAttribute("dormitories", dormitories);
return "dormitory/list";
}
@GetMapping("/add")
public String add(Model model) {
model.addAttribute("dormitory", new Dormitory());
return "dormitory/add";
}
@PostMapping("/add")
public String add(@ModelAttribute("dormitory") Dormitory dormitory) {
dormitoryService.addDormitory(dormitory);
return "redirect:/dormitory/list";
}
@GetMapping("/edit/{id}")
public String edit(@PathVariable("id") int id, Model model) {
Dormitory dormitory = dormitoryService.getDormitoryById(id);
model.addAttribute("dormitory", dormitory);
return "dormitory/edit";
}
@PostMapping("/edit")
public String edit(@ModelAttribute("dormitory") Dormitory dormitory) {
dormitoryService.updateDormitory(dormitory);
return "redirect:/dormitory/list";
}
@GetMapping("/delete/{id}")
public String delete(@PathVariable("id") int id) {
dormitoryService.deleteDormitory(id);
return "redirect:/dormitory/list";
}
}
前端代码稍微修改
html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>增加宿舍信息</title>
</head>
<body>
<h1>增加宿舍信息</h1>
<form action="addDormitory" method="post">
<label for="dormitoryNumber">宿舍编号：</label>
<input type="text" id="dormitoryNumber" name="dormitoryNumber"><br><br>
<label for="dormitoryBuilding">宿舍楼号：</label>
<input type="text" id="dormitoryBuilding" name="dormitoryBuilding"><br><br>
<label for="dormitoryType">宿舍类型：</label>
<input type="text" id="dormitoryType" name="dormitoryType"><br><br>
<label for="bedNumber">床位数量：</label>
<input type="text" id="bedNumber" name="bedNumber"><br><br>
<input type="submit" value="提交">
</form>
</body>
</html>
删除
html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>删除宿舍信息</title>
</head>
<body>
<h1>删除宿舍信息</h1>
<form action="deleteDormitory" method="post">
<label for="dormitoryNumber">宿舍编号：</label>
<input type="text" id="dormitoryNumber" name="dormitoryNumber"><br><br>
<input type="submit" value="提交">
</form>
</body>
</html>
修改
html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>修改宿舍信息</title>
</head>
<body>
<h1>修改宿舍信息</h1>
<form action="updateDormitory" method="post">
<label for="dormitoryNumber">宿舍编号：</label>
<input type="text" id="dormitoryNumber" name="dormitoryNumber"><br><br>
<label for="dormitoryBuilding">宿舍楼号：</label>
<input type="text" id="dormitoryBuilding" name="dormitoryBuilding"><br><br>
<label for="dormitoryType">宿舍类型：</label>
<input type="text" id="dormitoryType" name="dormitoryType"><br><br>
<label for="bedNumber">床位数量：</label>
<input type="text" id="bedNumber" name="bedNumber"><br><br>
<input type="submit" value="提交">
</form>
</body>
</html>
查询
html
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>查询宿舍信息</title>
</head>
<body>
<h1>查询宿舍信息</h1>
<form action="getDormitory" method="post">
<label for="dormitoryNumber">宿舍编号：</label>
<input type="text" id="dormitoryNumber" name="dormitoryNumber"><br><br>
<input type="submit" value="查询">
</form>
</body>
</html>
```