基于JSP和MYSQL实现的博客管理系统

Viewer

发布日期: 2019-02-26 13:36:01 浏览量: 2273
评分:
star star star star star star star star star star_border
*转载请注明来自write-bug.com

一、概述

1.1 开发背景

随着一个个开源社区的不断成长,越来越多的技术人员在各种论坛发表自己的技术博客(blog),本系统希望实现一个团队博客管理的目的,即将一个团队成员的所有博客进行统一管理,有利于团队内部人员的技术交流和共同成长。

1.2 开发目标

通过本系统,使用者可以看到团队中所有的成员,管理员登录后可以对团队的人员进行编辑和管理。同时,管理员可以对系统成员的博客进行查看和管理。

1.3 参考资料

二、需求分析

2.1 需求陈述

  • 管理员的注册以及登录

  • 用户的管理

  • 博客的管理

2.2 操作用例

2.2.1 管理员注册与登录

用户进入该模块之后只需输入nickname和密码然后点击登录即可进行登录,若需要注册只需点击对应的注册button进入注册页面,注册页面与登录页面想死,主要区别是后端的处理。

2.2.2 用户信息管理

这个模块首先使用表格的形式展示出当前系统所的用户信息,其次,对每一个用户都应该有详情、修改、删除三个按钮以管理用户。另外,在本页面还需有一个增加用户的button用于管理员增加用户。

2.2.3 博客信息管理

本页面以表格的形式列出当前系统的所有博客,博客信息包括博客的标题、作者、发布日期,对于每一篇博客应该留有详情、修改、删除三大按钮,另外在本页面还需设置一个添加博客的按钮以添加新博客。

2.3 功能分析划分

划分为登录注册、用户管理、博客管理三大功能模块

2.3.1 系统登录注册

实现管理员登录和注册,注册并登录成功后默认进入用户管理模块,可以看到当前系统的所有用户信息并对其进行管理。

2.3.2 用户管理

实现用户信息的显示、添加、删除、修改功能。

2.3.3 博客管理

实现博客的显示、添加、删除、修改功能。

2.4 运行环境

Ubuntu16.04+Intellij IDEA+tomcat8.5+MySQL

三、总体设计

3.1 UML类图

3.2 界面设计

3.2.1 登录界面设计

3.2.2 注册界面设计

3.2.3 用户管理界面设计

3.2.4 博客管理界面设计

3.3 数据库结构设计

3.3.1 user(用户)

Column Type Nullable Auto_increment
id int(11) NO YES
nickname varchar(45) NO NO
password varchar(45) NO NO
first_name varchar(45) YES NO
last_name varchar(45) YES NO

3.3.2 blog(博客)

Column Type Nullable Auto_increment
id int(11) NO YES
title varchar(100) NO NO
content varchar(255) YES NO
user_id int(11) NO NO
pub_date date NO NO

3.3.3 manager(管理员)

Column Type Nullable Auto_increment
id int(11) NO YES
nickname varchar(45) NO NO
password varchar(45) NO NO

3.3.4 数据库E-R图

四、详细设计

4.1 程序流程图

4.2 实现

4.2.1 controller

BlogController

  1. package com.dmrf.controller;
  2. import com.dmrf.model.BlogEntity;
  3. import com.dmrf.model.UserEntity;
  4. import com.dmrf.repository.BlogRepository;
  5. import com.dmrf.repository.UserRepository;
  6. import org.springframework.beans.factory.annotation.Autowired;
  7. import org.springframework.stereotype.Controller;
  8. import org.springframework.ui.ModelMap;
  9. import org.springframework.web.bind.annotation.ModelAttribute;
  10. import org.springframework.web.bind.annotation.PathVariable;
  11. import org.springframework.web.bind.annotation.RequestMapping;
  12. import org.springframework.web.bind.annotation.RequestMethod;
  13. import java.util.List;
  14. /**
  15. * Created by dmrf on 2018/5/10.
  16. */
  17. @Controller
  18. public class BlogController {
  19. @Autowired
  20. BlogRepository blogRepository;
  21. @Autowired
  22. UserRepository userRepository;
  23. // 查看所有博文
  24. @RequestMapping(value = "/admin/blogs", method = RequestMethod.GET)
  25. public String showBlogs(ModelMap modelMap) {
  26. List<BlogEntity> blogList = blogRepository.findAll();
  27. modelMap.addAttribute("blogList", blogList);
  28. return "admin/blogs";
  29. }
  30. // 添加博文
  31. @RequestMapping(value = "/admin/blogs/add", method = RequestMethod.GET)
  32. public String addBlog(ModelMap modelMap) {
  33. List<UserEntity> userList = userRepository.findAll();
  34. // 向jsp注入用户列表
  35. modelMap.addAttribute("userList", userList);
  36. return "admin/addBlog";
  37. }
  38. // 添加博文,POST请求,重定向为查看博客页面
  39. @RequestMapping(value = "/admin/blogs/addP", method = RequestMethod.POST)
  40. public String addBlogPost(@ModelAttribute("blog") BlogEntity blogEntity) {
  41. // 打印博客标题
  42. System.out.println(blogEntity.getTitle());
  43. // 打印博客作者
  44. System.out.println(blogEntity.getUserByUserId().getNickname());
  45. // 存库
  46. blogRepository.saveAndFlush(blogEntity);
  47. // 重定向地址
  48. return "redirect:/admin/blogs";
  49. }
  50. // 查看博文详情,默认使用GET方法时,method可以缺省
  51. @RequestMapping("/admin/blogs/show/{id}")
  52. public String showBlog(@PathVariable("id") int id, ModelMap modelMap) {
  53. BlogEntity blog = blogRepository.findOne(id);
  54. modelMap.addAttribute("blog", blog);
  55. return "admin/blogDetail";
  56. }
  57. // 修改博文内容,页面
  58. @RequestMapping("/admin/blogs/update/{id}")
  59. public String updateBlog(@PathVariable("id") int id, ModelMap modelMap) {
  60. // 是不是和上面那个方法很像
  61. BlogEntity blog = blogRepository.findOne(id);
  62. List<UserEntity> userList = userRepository.findAll();
  63. modelMap.addAttribute("blog", blog);
  64. modelMap.addAttribute("userList", userList);
  65. return "admin/updateBlog";
  66. }
  67. // 修改博客内容,POST请求
  68. @RequestMapping(value = "/admin/blogs/updateP", method = RequestMethod.POST)
  69. public String updateBlogP(@ModelAttribute("blogP") BlogEntity blogEntity) {
  70. // 更新博客信息
  71. System.out.println(blogEntity.getTitle());
  72. blogRepository.updateBlog(blogEntity.getTitle(), blogEntity.getUserByUserId().getId(),
  73. blogEntity.getContent(), blogEntity.getPubDate(), blogEntity.getId());
  74. blogRepository.flush();
  75. return "redirect:/admin/blogs";
  76. }
  77. // 删除博客文章
  78. @RequestMapping("/admin/blogs/delete/{id}")
  79. public String deleteBlog(@PathVariable("id") int id) {
  80. blogRepository.delete(id);
  81. blogRepository.flush();
  82. return "redirect:/admin/blogs";
  83. }
  84. }

UserController

  1. package com.dmrf.controller;
  2. import com.dmrf.model.UserEntity;
  3. import com.dmrf.repository.UserRepository;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.stereotype.Controller;
  6. import org.springframework.ui.ModelMap;
  7. import org.springframework.web.bind.annotation.ModelAttribute;
  8. import org.springframework.web.bind.annotation.PathVariable;
  9. import org.springframework.web.bind.annotation.RequestMapping;
  10. import org.springframework.web.bind.annotation.RequestMethod;
  11. import java.util.List;
  12. /**
  13. * Created by dmrf on 2018/5/10.
  14. */
  15. @Controller
  16. public class UserController {
  17. // 自动装配数据库接口,不需要再写原始的Connection来操作数据库
  18. @Autowired
  19. UserRepository userRepository;
  20. @RequestMapping(value = "/admin/users", method = {RequestMethod.GET,RequestMethod.POST})
  21. public String getUsers(ModelMap modelMap) {
  22. // 查询user表中所有记录
  23. List<UserEntity> userList = userRepository.findAll();
  24. // 将所有记录传递给要返回的jsp页面,放在userList当中
  25. modelMap.addAttribute("userList", userList);
  26. // 返回pages目录下的admin/users.jsp页面
  27. return "admin/users";
  28. }
  29. // get请求,访问添加用户 页面
  30. @RequestMapping(value = "/admin/users/add", method = RequestMethod.GET)
  31. public String addUser() {
  32. // 返回 admin/addUser.jsp页面
  33. return "admin/addUser";
  34. }
  35. // post请求,处理添加用户请求,并重定向到用户管理页面
  36. @RequestMapping(value = "/admin/users/addP", method = RequestMethod.POST)
  37. public String addUserPost(@ModelAttribute("user") UserEntity userEntity) {
  38. // 注意此处,post请求传递过来的是一个UserEntity对象,里面包含了该用户的信息
  39. // 通过@ModelAttribute()注解可以获取传递过来的'user',并创建这个对象
  40. // 数据库中添加一个用户,该步暂时不会刷新缓存
  41. //userRepository.save(userEntity);
  42. System.out.println(userEntity.getFirstName());
  43. System.out.println(userEntity.getLastName());
  44. // 数据库中添加一个用户,并立即刷新缓存
  45. userRepository.saveAndFlush(userEntity);
  46. // 重定向到用户管理页面,方法为 redirect:url
  47. return "redirect:/admin/users";
  48. }
  49. // 查看用户详情
  50. // @PathVariable可以收集url中的变量,需匹配的变量用{}括起来
  51. // 例如:访问 localhost:8080/admin/users/show/1 ,将匹配 id = 1
  52. @RequestMapping(value = "/admin/users/show/{id}", method = RequestMethod.GET)
  53. public String showUser(@PathVariable("id") Integer userId, ModelMap modelMap) {
  54. // 找到userId所表示的用户
  55. UserEntity userEntity = userRepository.findOne(userId);
  56. // 传递给请求页面
  57. modelMap.addAttribute("user", userEntity);
  58. return "admin/userDetail";
  59. }
  60. // 更新用户信息 页面
  61. @RequestMapping(value = "/admin/users/update/{id}", method = RequestMethod.GET)
  62. public String updateUser(@PathVariable("id") Integer userId, ModelMap modelMap) {
  63. // 找到userId所表示的用户
  64. UserEntity userEntity = userRepository.findOne(userId);
  65. // 传递给请求页面
  66. modelMap.addAttribute("user", userEntity);
  67. return "admin/updateUser";
  68. }
  69. // 更新用户信息 操作
  70. @RequestMapping(value = "/admin/users/updateP", method = RequestMethod.POST)
  71. public String updateUserPost(@ModelAttribute("userP") UserEntity user) {
  72. // 更新用户信息
  73. userRepository.updateUser(user.getNickname(), user.getFirstName(),
  74. user.getLastName(), user.getPassword(), user.getId());
  75. userRepository.flush(); // 刷新缓冲区
  76. return "redirect:/admin/users";
  77. }
  78. // 删除用户
  79. @RequestMapping(value = "/admin/users/delete/{id}", method = RequestMethod.GET)
  80. public String deleteUser(@PathVariable("id") Integer userId) {
  81. // 删除id为userId的用户
  82. userRepository.delete(userId);
  83. // 立即刷新
  84. userRepository.flush();
  85. return "redirect:/admin/users";
  86. }
  87. }

MainController

  1. package com.dmrf.controller;
  2. import com.dmrf.model.ManagerEntity;
  3. import com.dmrf.repository.ManagerRepository;
  4. import org.springframework.beans.factory.annotation.Autowired;
  5. import org.springframework.stereotype.Controller;
  6. import org.springframework.web.bind.annotation.ModelAttribute;
  7. import org.springframework.web.bind.annotation.RequestMapping;
  8. import org.springframework.web.bind.annotation.RequestMethod;
  9. @Controller
  10. public class MainController {
  11. // 自动装配数据库接口,不需要再写原始的Connection来操作数据库
  12. @Autowired
  13. ManagerRepository managerRepository;
  14. @RequestMapping(value = "/", method = RequestMethod.GET)
  15. public String index() {
  16. return "admin/login";
  17. }
  18. @RequestMapping(value = "/admin/manager/signupP", method = RequestMethod.POST)
  19. public String addManagerPost(@ModelAttribute("manager") ManagerEntity managerEntity) {
  20. // 注意此处,post请求传递过来的是一个ManagerEntity对象,里面包含了该用户的信息
  21. // 通过@ModelAttribute()注解可以获取传递过来的'manager',并创建这个对象
  22. // 数据库中添加一个用户,该步暂时不会刷新缓存
  23. // userRepository.save(userEntity);
  24. System.out.println(managerEntity.getNickname());
  25. System.out.println(managerEntity.getPassword());
  26. // 存库
  27. managerRepository.saveAndFlush(managerEntity);
  28. // 重定向到首页
  29. return "admin/blogs";
  30. }
  31. @RequestMapping(value = "/admin/signupP", method = RequestMethod.GET)
  32. public String SignUp() {
  33. System.out.println("signup");
  34. return "admin/signup";
  35. }
  36. @RequestMapping(value = "/admin/loginP", method = RequestMethod.POST)
  37. public String Login(@ModelAttribute("manager") ManagerEntity managerEntity) {
  38. System.out.println(managerEntity.getNickname());
  39. System.out.println(managerEntity.getPassword());
  40. // 找到userId所表示的用户
  41. ManagerEntity managerEntity1 = managerRepository.queryManager(managerEntity.getNickname(), managerEntity.getPassword());
  42. if(managerEntity1 == null) {return "error";}
  43. return "admin/blogs";
  44. }
  45. @RequestMapping(value = "/hello", method = RequestMethod.GET)
  46. public String hello(){
  47. return "hello";
  48. }
  49. }

4.2.2 model

BlogEntity

  1. package com.dmrf.model;
  2. import org.springframework.format.annotation.DateTimeFormat;
  3. import javax.persistence.*;
  4. import java.util.Date;
  5. /**
  6. * Created by dmrf on 2018/5/10.
  7. */
  8. @Entity
  9. @Table(name = "blog", schema = "springdemo", catalog = "")
  10. public class BlogEntity {
  11. private int id;
  12. private String title;
  13. private String content;
  14. @DateTimeFormat(pattern = "yyyy-MM-dd")
  15. private Date pubDate;
  16. private UserEntity userByUserId;
  17. @Id
  18. @Column(name = "id", nullable = false)
  19. public int getId() {
  20. return id;
  21. }
  22. public void setId(int id) {
  23. this.id = id;
  24. }
  25. @Basic
  26. @Column(name = "title", nullable = false, length = 100)
  27. public String getTitle() {
  28. return title;
  29. }
  30. public void setTitle(String title) {
  31. this.title = title;
  32. }
  33. @Basic
  34. @Column(name = "content", nullable = true, length = 255)
  35. public String getContent() {
  36. return content;
  37. }
  38. public void setContent(String content) {
  39. this.content = content;
  40. }
  41. @Basic
  42. @Column(name = "pub_date", nullable = false)
  43. public Date getPubDate() {
  44. return pubDate;
  45. }
  46. public void setPubDate(Date pubDate) {
  47. this.pubDate = pubDate;
  48. }
  49. @Override
  50. public boolean equals(Object o) {
  51. if (this == o) return true;
  52. if (o == null || getClass() != o.getClass()) return false;
  53. BlogEntity that = (BlogEntity) o;
  54. if (id != that.id) return false;
  55. if (title != null ? !title.equals(that.title) : that.title != null) return false;
  56. if (content != null ? !content.equals(that.content) : that.content != null) return false;
  57. if (pubDate != null ? !pubDate.equals(that.pubDate) : that.pubDate != null) return false;
  58. return true;
  59. }
  60. @Override
  61. public int hashCode() {
  62. int result = id;
  63. result = 31 * result + (title != null ? title.hashCode() : 0);
  64. result = 31 * result + (content != null ? content.hashCode() : 0);
  65. result = 31 * result + (pubDate != null ? pubDate.hashCode() : 0);
  66. return result;
  67. }
  68. @ManyToOne
  69. @JoinColumn(name = "user_id", referencedColumnName = "id", nullable = false)
  70. public UserEntity getUserByUserId() {
  71. return userByUserId;
  72. }
  73. public void setUserByUserId(UserEntity userByUserId) {
  74. this.userByUserId = userByUserId;
  75. }
  76. }

ManagerEntity

  1. package com.dmrf.model;
  2. import javax.persistence.*;
  3. import java.util.Objects;
  4. //@NamedQuery(name = "ManagerEntity.queryManager", query = "SELECT mg FROM ManagerEntity mg WHERE mg.nickname AND mg.password")
  5. @Entity
  6. @Table(name = "manager", schema = "springdemo", catalog = "")
  7. public class ManagerEntity {
  8. private int id;
  9. private String nickname;
  10. private String password;
  11. @Id
  12. @Column(name = "id", nullable = false)
  13. public int getId() {
  14. return id;
  15. }
  16. public void setId(int id) {
  17. this.id = id;
  18. }
  19. @Basic
  20. @Column(name = "nickname", nullable = false, length = 45)
  21. public String getNickname() {
  22. return nickname;
  23. }
  24. public void setNickname(String nickname) {
  25. this.nickname = nickname;
  26. }
  27. @Basic
  28. @Column(name = "password", nullable = false, length = 45)
  29. public String getPassword() {
  30. return password;
  31. }
  32. public void setPassword(String password) {
  33. this.password = password;
  34. }
  35. @Override
  36. public boolean equals(Object o) {
  37. if (this == o) return true;
  38. if (o == null || getClass() != o.getClass()) return false;
  39. ManagerEntity that = (ManagerEntity) o;
  40. return id == that.id &&
  41. Objects.equals(nickname, that.nickname) &&
  42. Objects.equals(password, that.password);
  43. }
  44. @Override
  45. public int hashCode() {
  46. return Objects.hash(id, nickname, password);
  47. }
  48. }

UserEntity

  1. package com.dmrf.model;
  2. import javax.persistence.*;
  3. import java.util.Collection;
  4. /**
  5. * Created by dmrf on 2018/5/10.
  6. */
  7. @Entity
  8. @Table(name = "user", schema = "springdemo", catalog = "")
  9. public class UserEntity {
  10. private int id;
  11. private String nickname;
  12. private String password;
  13. private String firstName;
  14. private String lastName;
  15. private Collection<BlogEntity> blogsById;
  16. @Id
  17. @Column(name = "id", nullable = false)
  18. public int getId() {
  19. return id;
  20. }
  21. public void setId(int id) {
  22. this.id = id;
  23. }
  24. @Basic
  25. @Column(name = "nickname", nullable = false, length = 45)
  26. public String getNickname() {
  27. return nickname;
  28. }
  29. public void setNickname(String nickname) {
  30. this.nickname = nickname;
  31. }
  32. @Basic
  33. @Column(name = "password", nullable = false, length = 45)
  34. public String getPassword() {
  35. return password;
  36. }
  37. public void setPassword(String password) {
  38. this.password = password;
  39. }
  40. @Basic
  41. @Column(name = "first_name", nullable = true, length = 45)
  42. public String getFirstName() {
  43. return firstName;
  44. }
  45. public void setFirstName(String firstName) {
  46. this.firstName = firstName;
  47. }
  48. @Basic
  49. @Column(name = "last_name", nullable = true, length = 45)
  50. public String getLastName() {
  51. return lastName;
  52. }
  53. public void setLastName(String lastName) {
  54. this.lastName = lastName;
  55. }
  56. @Override
  57. public boolean equals(Object o) {
  58. if (this == o) return true;
  59. if (o == null || getClass() != o.getClass()) return false;
  60. UserEntity that = (UserEntity) o;
  61. if (id != that.id) return false;
  62. if (nickname != null ? !nickname.equals(that.nickname) : that.nickname != null) return false;
  63. if (password != null ? !password.equals(that.password) : that.password != null) return false;
  64. if (firstName != null ? !firstName.equals(that.firstName) : that.firstName != null) return false;
  65. if (lastName != null ? !lastName.equals(that.lastName) : that.lastName != null) return false;
  66. return true;
  67. }
  68. @Override
  69. public int hashCode() {
  70. int result = id;
  71. result = 31 * result + (nickname != null ? nickname.hashCode() : 0);
  72. result = 31 * result + (password != null ? password.hashCode() : 0);
  73. result = 31 * result + (firstName != null ? firstName.hashCode() : 0);
  74. result = 31 * result + (lastName != null ? lastName.hashCode() : 0);
  75. return result;
  76. }
  77. @OneToMany(mappedBy = "userByUserId")
  78. public Collection<BlogEntity> getBlogsById() {
  79. return blogsById;
  80. }
  81. public void setBlogsById(Collection<BlogEntity> blogsById) {
  82. this.blogsById = blogsById;
  83. }
  84. }

4.2.3 repository

BlogRepository

  1. package com.dmrf.repository;
  2. import com.dmrf.model.BlogEntity;
  3. import org.springframework.data.jpa.repository.JpaRepository;
  4. import org.springframework.data.jpa.repository.Modifying;
  5. import org.springframework.data.jpa.repository.Query;
  6. import org.springframework.data.repository.query.Param;
  7. import org.springframework.stereotype.Repository;
  8. import org.springframework.transaction.annotation.Transactional;
  9. import java.util.Date;
  10. /**
  11. * Created by dmrf on 2018/5/10.
  12. */
  13. @Repository
  14. public interface BlogRepository extends JpaRepository<BlogEntity, Integer> {
  15. // 修改博文操作
  16. @Modifying
  17. @Transactional
  18. @Query("update BlogEntity blog set blog.title=:qTitle, blog.userByUserId.id=:qUserId," +
  19. " blog.content=:qContent, blog.pubDate=:qPubDate where blog.id=:qId")
  20. void updateBlog(@Param("qTitle") String title, @Param("qUserId") int userId, @Param("qContent") String content,
  21. @Param("qPubDate") Date pubDate, @Param("qId") int id);
  22. }

ManagerRepository

  1. package com.dmrf.repository;
  2. import com.dmrf.model.ManagerEntity;
  3. import org.springframework.data.jpa.repository.JpaRepository;
  4. import org.springframework.data.jpa.repository.Modifying;
  5. import org.springframework.data.jpa.repository.Query;
  6. import org.springframework.data.repository.query.Param;
  7. import org.springframework.stereotype.Repository;
  8. import org.springframework.transaction.annotation.Transactional;
  9. /**
  10. * Created by dmrf on 2018/5/10.
  11. */
  12. @Repository
  13. public interface ManagerRepository extends JpaRepository<ManagerEntity, Integer> {
  14. @Modifying // 说明该方法是修改操作
  15. @Transactional // 说明该方法是事务性操作
  16. // 定义查询
  17. // @Param注解用于提取参数
  18. @Query("update ManagerEntity us set us.nickname=:qNickname, us.password=:qPassword where us.id=:qId")
  19. public void updateManager(@Param("qNickname") String nickname, @Param("qPassword") String password, @Param("qId") Integer id);
  20. @Query("SELECT mg FROM ManagerEntity mg WHERE mg.nickname=:qNickname AND mg.password=:qPassword")
  21. public ManagerEntity queryManager(@Param("qNickname") String nickname, @Param("qPassword") String password);
  22. }

UserRepository

  1. package com.dmrf.repository;
  2. import com.dmrf.model.UserEntity;
  3. import org.springframework.data.jpa.repository.JpaRepository;
  4. import org.springframework.data.jpa.repository.Modifying;
  5. import org.springframework.data.jpa.repository.Query;
  6. import org.springframework.data.repository.query.Param;
  7. import org.springframework.stereotype.Repository;
  8. import org.springframework.transaction.annotation.Transactional;
  9. /**
  10. * Created by dmrf on 2018/5/10.
  11. */
  12. @Repository
  13. public interface UserRepository extends JpaRepository<UserEntity, Integer> {
  14. @Modifying // 说明该方法是修改操作
  15. @Transactional // 说明该方法是事务性操作
  16. // 定义查询
  17. // @Param注解用于提取参数
  18. @Query("update UserEntity us set us.nickname=:qNickname, us.firstName=:qFirstName, us.lastName=:qLastName, us.password=:qPassword where us.id=:qId")
  19. public void updateUser(@Param("qNickname") String nickname, @Param("qFirstName") String firstName,
  20. @Param("qLastName") String qLastName, @Param("qPassword") String password, @Param("qId") Integer id);
  21. }

五、测试

5.1 注册测试

5.2 登录测试

5.3 添加用户测试

5.4 删除用户测试

5.5 查看用户详情测试

5.6 添加博客测试

5.7 删除博客测试

5.8 查看博客详情测试

六、总结

6.1 对mvc模式的理解和感悟

MVC 模式代表 Model-View-Controller(模型-视图-控制器) 模式。这种模式用于应用程序的分层开发。

  • Model(模型):模型代表一个存取数据的对象或 JAVA POJO。它也可以带有逻辑,在数据变化时更新控制器

  • View(视图):视图代表模型包含的数据的可视化

  • Controller(控制器):控制器作用于模型和视图上。它控制数据流向模型对象,并在数据变化时更新视图。它使视图与模型分离开

在本项目中使用mvc模式,具体的model为三个Entity,controller为三个controller,view则是不同的jsp页面。具体机制是Event(事件)导致Controller改变Model或View,或者同时改变两者。只要 Controller改变了Model的数据或者属性,所有依赖的View都会自动更新。类似的,只要Controller改变了View,View会从潜在的Model中获取数据来刷新自己。通过这种模式,我们可以将系统的不同模块分离开来,对每一个功能模块分别进行开发和修改,各个模块之间层次分明,利于维护和团队交接开发。

上传的附件 cloud_download 基于JSP实现的博客管理系统.7z ( 895.62kb, 30次下载 )
error_outline 下载需要12点积分

发送私信

如果没有为想要的东西努力,就别为自己失去的东西哭泣

16
文章数
16
评论数
最近文章
eject