• 【后端】黑马MVC案例详解

    最近刚入门后端，对不起，我背叛了游戏【哭】

    跟着写了一个这样的案例

    网页界面是这样的

     没写删除，里面带有增加行和修改表单数据的功能

     

     web方面就三个页面，里面涉及到了Mybatis，Tomcat，JSP，Servlet，Maven，前端三剑客等知识，东西比较杂，我也是速通选手，掌握不太稳固，所以写个文章巩固一下知识点，以便自己能够更好地理解代码以及运行逻辑。

    项目结构是这样的，需要配置mybatis-config.xml文件，pom.xml需要引入tomcat、Servlet，mybatis，JSP，Maven写个标识就能自动下载了，Maven好方便

    以及Mapper配置文件和web配置文件，不是很复杂。

    我们的代码方面

    一、前端页面

    三个前端页面分别是这样的

    brand：主页面

    1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    2. <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
    3.  
    4. html>
    5. <html lang="en">
    6. <head>
    7.     <meta charset="UTF-8">
    8.     <title>Titletitle>
    9. head>
    10. <body>
    11. <input type="button" value="新增" id="add"><br>
    12. <hr>
    13. <table border="1" cellspacing="0" width="80%">
    14.     <tr>
    15.         <th>序号th>
    16.         <th>品牌名称th>
    17.         <th>企业名称th>
    18.         <th>排序th>
    19.         <th>品牌介绍th>
    20.         <th>状态th>
    21.         <th>操作th>
    22.  
    23.     tr>
    24.  
    25.  
    26.     <c:forEach items="${brands}" var="brand" varStatus="status">
    27. //items：被遍历的容器
    28. //var：遍历产生的临时变量
    29. //varStatus：遍历状态对象
    30. //我们这里是从SelectAllServlet跳转过来的，所以接收了request域，我们只管调brand对象输出数据就行
    31.         <tr align="center">
    32.             <%--<td>${brand.id}td>--%>
    33.             <td>${status.count}td>
    34.             <td>${brand.brandName}td>
    35.             <td>${brand.companyName}td>
    36.             <td>${brand.ordered}td>
    37.             <td>${brand.description}td>
    38.             <c:if test="${brand.status == 1}">//这里是JSP，就是if判断
    39.                 <td>启用td>
    40.             c:if>
    41.             <c:if test="${brand.status != 1}">
    42.                 <td>禁用td>
    43.             c:if>
    44.  
    45.             <td><a href="/brandDemo/selectByIdServlet?id=${brand.id}">修改a> <a href="#">删除a>td>
    46.         tr>
    47.  
    48.     c:forEach>
    49.  
    50. table>
    51.  
    52. <script>
    53.     document.getElementById("add").onclick = function (){
    54.         location.href = "/brandDemo/addBrand.jsp";
    55.     }//这里使用getElementById设置了按钮的点击事件。
    56. script>
    57. body>
    58. html>

     addBrand：新增数据

    1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    2. html>
    3. <html lang="en">
    4.  
    5. <head>
    6.     <meta charset="UTF-8">
    7.     <title>添加品牌title>
    8. head>
    9. <body>
    10. <h3>添加品牌h3>
    11. <form action="/brandDemo/addServlet" method="post">//这里我们提交到addServlet服务，还是以POST形式，然后addServlet再转发到brand.jsp页面
    12.     品牌名称：<input name="brandName"><br>
    13.     企业名称：<input name="companyName"><br>
    14.     排序：<input name="ordered"><br>
    15.     描述信息：<textarea rows="5" cols="20" name="description">textarea><br>
    16.     状态：
    17.     <input type="radio" name="status" value="0">禁用
    18.     <input type="radio" name="status" value="1">启用<br>
    19.  
    20.     <input type="submit" value="提交">
    21. form>
    22. body>
    23. html>

    update：修改数据

    1. <%@ page contentType="text/html;charset=UTF-8" language="java" %>
    2. <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
    3.  
    4. html>
    5. <html lang="en">
    6.  
    7. <head>
    8.     <meta charset="UTF-8">
    9.     <title>修改品牌title>
    10. head>
    11. <body>
    12. <h3>修改品牌h3>
    13. <form action="/brandDemo/updateServlet" method="post">//这里还是一样的，提交到updateServlet服务当中
    14. //这里跟新增表单页面没什么大的不同，但是Servlet方面就要先查询再修改，还是比新增麻烦的
    15.  
    16.     <%--隐藏域，提交id--%>
    17.     <input type="hidden" name="id" value="${brand.id}">
    18.  
    19.     品牌名称：<input name="brandName" value="${brand.brandName}"><br>
    20.     企业名称：<input name="companyName" value="${brand.companyName}"><br>
    21.     排序：<input name="ordered" value="${brand.ordered}"><br>
    22.     描述信息：<textarea rows="5" cols="20" name="description">${brand.description} textarea><br>
    23.     状态：
    24.     <c:if test="${brand.status == 0}">
    25.  
    26.         <input type="radio" name="status" value="0" checked>禁用
    27.         <input type="radio" name="status" value="1">启用<br>
    28.     c:if>
    29.  
    30.     <c:if test="${brand.status == 1}">
    31.  
    32.         <input type="radio" name="status" value="0" >禁用
    33.         <input type="radio" name="status" value="1" checked>启用<br>
    34.     c:if>
    35.  
    36.  
    37.     <input type="submit" value="提交">
    38. form>
    39. body>
    40. html>

    二、mybatis操作方面

    既然处理数据肯定是要学习mybatis的

    操作不难，写几个接口就行

    这里则是使用到mapper的知识，不得不说，javaweb学的东西是真的杂，学的时候天天导包配文件，累。

    BrandMapper:

    1. package com.itheima.mapper;
    2.  
    3. import com.itheima.pojo.Brand;
    4. import org.apache.ibatis.annotations.Insert;
    5. import org.apache.ibatis.annotations.ResultMap;
    6. import org.apache.ibatis.annotations.Select;
    7. import org.apache.ibatis.annotations.Update;
    8.  
    9. import java.util.List;
    10.  
    11. public interface BrandMapper {//这里也没啥好说的，以注解形式操纵数据库，都是一些基础操作语句
    12. //唯一值得注意的是当我们两种模式命名有冲突的时候我们要配置ResultMap
    13. //使得我们Brand查询的时候能找到对应的变量
    14.     /*
    15.     查询所有
    16.     @return
    17.      */
    18.     @Select("select * from tb_brand")
    19.     @ResultMap("brandResultMap")
    20.     List selectAll();
    21.     @Insert("insert into tb_brand values(null,#{brandName},#{companyName},#{ordered},#{description},#{status})")
    22.     void add(Brand brand);
    23.     /**
    24.      * 根据id查询
    25.      * @param id
    26.      * @return
    27.      */
    28.     @Select("select * from tb_brand where id = #{id}")
    29.     @ResultMap("brandResultMap")
    30.     Brand selectById(int id);
    31.     /**
    32.      * 修改
    33.      * @param brand
    34.      */
    35.     @Update("update tb_brand set brand_name = #{brandName},company_name = #{companyName},ordered = #{ordered},description = #{description},status = #{status} where id = #{id}")
    36.     void update(Brand brand);
    37. }

    brand数据类：

    1. package com.itheima.pojo;
    2. public class Brand {
    3.     // id 主键
    4.     private Integer id;
    5.     // 品牌名称
    6.     private String brandName;
    7.     // 企业名称
    8.     private String companyName;
    9.     // 排序字段
    10.     private Integer ordered;
    11.     // 描述信息
    12.     private String description;
    13.     // 状态：0：禁用  1：启用
    14.     private Integer status;
    15.  
    16. //提供了三种构造方法以备不同情况，是一些面向对象的特性，Java学过的都能懂
    17.     public Brand() {
    18.     }
    19.  
    20.     public Brand(Integer id, String brandName, String companyName, String description) {
    21.         this.id = id;
    22.         this.brandName = brandName;
    23.         this.companyName = companyName;
    24.         this.description = description;
    25.     }
    26.  
    27.     public Brand(Integer id, String brandName, String companyName, Integer ordered, String description, Integer status) {
    28.         this.id = id;
    29.         this.brandName = brandName;
    30.         this.companyName = companyName;
    31.         this.ordered = ordered;
    32.         this.description = description;
    33.         this.status = status;
    34.     }
    35.  
    36.     public Integer getId() {
    37.         return id;
    38.     }
    39.  
    40.     public void setId(Integer id) {
    41.         this.id = id;
    42.     }
    43.  
    44.     public String getBrandName() {
    45.         return brandName;
    46.     }
    47.  
    48.     public void setBrandName(String brandName) {
    49.         this.brandName = brandName;
    50.     }
    51.  
    52.     public String getCompanyName() {
    53.         return companyName;
    54.     }
    55.  
    56.     public void setCompanyName(String companyName) {
    57.         this.companyName = companyName;
    58.     }
    59.  
    60.     public Integer getOrdered() {
    61.         return ordered;
    62.     }
    63.  
    64.     public void setOrdered(Integer ordered) {
    65.         this.ordered = ordered;
    66.     }
    67.  
    68.     public String getDescription() {
    69.         return description;
    70.     }
    71.  
    72.     public void setDescription(String description) {
    73.         this.description = description;
    74.     }
    75.  
    76.     public Integer getStatus() {
    77.         return status;
    78.     }
    79.  
    80.     public void setStatus(Integer status) {
    81.         this.status = status;
    82.     }
    83.  
    84.     @Override
    85.     public String toString() {
    86.         return "Brand{" +
    87.                 "id=" + id +
    88.                 ", brandName='" + brandName + '\'' +
    89.                 ", companyName='" + companyName + '\'' +
    90.                 ", ordered=" + ordered +
    91.                 ", description='" + description + '\'' +
    92.                 ", status=" + status +
    93.                 '}';
    94.     }
    95. }

    三、Servlet服务

    这里就是处理数据的大头了

    因为创建工厂类只用一次就能最节省资源，所以我们用一个SqlSessionFactoryUtils静态类来封装好，下次直接调函数就行了，这里还是操作mybatis的东西

    1. package com.itheima.util;
    2.  
    3. import org.apache.ibatis.io.Resources;
    4. import org.apache.ibatis.session.SqlSessionFactory;
    5. import org.apache.ibatis.session.SqlSessionFactoryBuilder;
    6.  
    7. import java.io.IOException;
    8. import java.io.InputStream;
    9.  
    10. public class SqlSessionFactoryUtils {
    11.     private static SqlSessionFactory sqlSessionFactory;//静态对象
    12.     static {
    13.         try{//这里是数据库连接必写的三句
    14.             String resource = "mybatis-config.xml";
    15.             InputStream inputStream = Resources.getResourceAsStream(resource);
    16.             sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);
    17.         }catch (IOException e){
    18.             e.printStackTrace();
    19.         }
    20.     }
    21.     public static  SqlSessionFactory getSqlSessionFactory(){
    22.         return sqlSessionFactory;//用的时候直接调这个方法
    23.     }
    24. }

    随后写BrandService，这里是将对数据的操作全都封装好，免得到时候麻烦

    代码是这样的

    1. package com.itheima.service;
    2.  
    3. import com.itheima.mapper.BrandMapper;
    4. import com.itheima.pojo.Brand;
    5. import com.itheima.util.SqlSessionFactoryUtils;
    6. import org.apache.ibatis.session.SqlSession;
    7. import org.apache.ibatis.session.SqlSessionFactory;
    8.  
    9. import java.util.List;
    10.  
    11. public class BrandService {
    12.     SqlSessionFactory factory = SqlSessionFactoryUtils.getSqlSessionFactory();//这里获取工厂类
    13.     /*
    14.     查询所有
    15.     @return
    16.      */
    17.     public List selectAll(){//查询所有
    18.         //调用BrandMapper.selectAll()
    19.         //2.获取SqlSession
    20.         SqlSession sqlSession = factory.openSession();
    21.         //3.获取BrandMapper
    22.         BrandMapper mapper = sqlSession.getMapper(BrandMapper.class);
    23.         //4.调用方法
    24.         List brands = mapper.selectAll();//这里就是操作数据库，然后封装到一个brands列表里
    25.         sqlSession.close();
    26.         return brands;//返回查询到的值
    27.     }
    28.     /**
    29.      * 添加
    30.      * @param brand
    31.      */
    32.     public void add(Brand brand){//这里是添加
    33.  
    34.         //2. 获取SqlSession
    35.         SqlSession sqlSession = factory.openSession();
    36.         //3. 获取BrandMapper
    37.         BrandMapper mapper = sqlSession.getMapper(BrandMapper.class);
    38.  
    39.         //4. 调用方法
    40.         mapper.add(brand);//往数据库里添加一个brand对象
    41.  
    42.         //提交事务
    43.         sqlSession.commit();
    44.         //释放资源
    45.         sqlSession.close();
    46.     }
    47.     /**
    48.      * 根据id查询
    49.      * @return
    50.      */
    51.     public Brand selectById(int id){//依靠id查询对象
    52.         //调用BrandMapper.selectAll()
    53.         //2. 获取SqlSession
    54.         SqlSession sqlSession = factory.openSession();
    55.         //3. 获取BrandMapper
    56.         BrandMapper mapper = sqlSession.getMapper(BrandMapper.class);
    57.         //4. 调用方法
    58.         Brand brand = mapper.selectById(id);
    59.         sqlSession.close();
    60.         return brand;
    61.     }
    62.     /**
    63.      * 修改
    64.      * @param brand
    65.      */
    66.     public void update(Brand brand){//修改值
    67.         //2. 获取SqlSession
    68.         SqlSession sqlSession = factory.openSession();
    69.         //3. 获取BrandMapper
    70.         BrandMapper mapper = sqlSession.getMapper(BrandMapper.class);
    71.         //4. 调用方法
    72.         mapper.update(brand);
    73.         //提交事务
    74.         sqlSession.commit();
    75.         //释放资源
    76.         sqlSession.close();
    77.     }
    78. }

    然后是Servlet服务类

    通过这些服务我们来操作网页里的数据

    SelectAllServlet：

    1. package com.itheima.web;
    2.  
    3. import com.itheima.pojo.Brand;
    4. import com.itheima.service.BrandService;
    5.  
    6. import javax.servlet.ServletException;
    7. import javax.servlet.annotation.WebServlet;
    8. import javax.servlet.http.HttpServlet;
    9. import javax.servlet.http.HttpServletRequest;
    10. import javax.servlet.http.HttpServletResponse;
    11. import java.io.IOException;
    12. import java.util.List;
    13.  
    14. @WebServlet("/selectAllServlet")//这里我们通过标签访问Servlet
    15. public class SelectAllServlet extends HttpServlet {
    16.     private BrandService service = new BrandService();//先创建一个Brand服务对象
    17.  
    18.     @Override
    19.     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    20.         //1、调用BrandService完成查询
    21.         List brands = service.selectAll();//这里我们直接调用查询
    22.         //2、存入request域中
    23.         req.setAttribute("brands",brands);//存入request域，到时候发出去的就是这个，要查询的话只要调用键查值就行了，request域都是键值对。
    24.         //3、转发到brand.jsp
    25.         req.getRequestDispatcher("/brand.jsp").forward(req,resp);//这里我们调用getrequestDispatcher方法转发到brand.jsp页面中，再通过JSP代码把数据显示出来。
    26.     }
    27.  
    28.     @Override
    29.     protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    30.         this.doGet(req,resp);//这样写能同时响应POST请求和GET请求
    31.     }
    32. }

    AddServlet:

    1. package com.itheima.web;
    2.  
    3. import com.itheima.pojo.Brand;
    4. import com.itheima.service.BrandService;
    5.  
    6. import javax.servlet.ServletException;
    7. import javax.servlet.annotation.WebServlet;
    8. import javax.servlet.http.HttpServlet;
    9. import javax.servlet.http.HttpServletRequest;
    10. import javax.servlet.http.HttpServletResponse;
    11. import java.io.IOException;
    12.  
    13. @WebServlet("/addServlet")
    14. public class AddServlet extends HttpServlet {
    15.     private BrandService service = new BrandService();
    16.  
    17.  
    18.     @Override
    19.     protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    20.  
    21.         //处理POST请求的乱码问题
    22.         request.setCharacterEncoding("utf-8");
    23.  
    24.         //1. 接收表单提交的数据，封装为一个Brand对象
    25.         String brandName = request.getParameter("brandName");
    26.         String companyName = request.getParameter("companyName");
    27.         String ordered = request.getParameter("ordered");
    28.         String description = request.getParameter("description");
    29.         String status = request.getParameter("status");
    30.  
    31.         //封装为一个Brand对象
    32.         Brand brand = new Brand();
    33.         brand.setBrandName(brandName);
    34.         brand.setCompanyName(companyName);
    35.         brand.setOrdered(Integer.parseInt(ordered));
    36.         brand.setDescription(description);
    37.         brand.setStatus(Integer.parseInt(status));
    38.  
    39.         //2. 调用service 完成添加
    40.         service.add(brand);
    41.  
    42.         //3. 转发到查询所有Servlet
    43.         request.getRequestDispatcher("/selectAllServlet").forward(request,response);
    44.     }
    45.  
    46.     @Override
    47.     protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    48.         this.doGet(request, response);
    49.     }
    50. }

    SelectById:

    1. package com.itheima.web;
    2.  
    3. import com.itheima.pojo.Brand;
    4. import com.itheima.service.BrandService;
    5.  
    6. import javax.servlet.ServletException;
    7. import javax.servlet.annotation.WebServlet;
    8. import javax.servlet.http.HttpServlet;
    9. import javax.servlet.http.HttpServletRequest;
    10. import javax.servlet.http.HttpServletResponse;
    11. import java.io.IOException;
    12.  
    13. @WebServlet("/selectByIdServlet")
    14. public class SelectByIdServlet extends HttpServlet {
    15.     private BrandService service = new BrandService();
    16.  
    17.     @Override
    18.     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    19.         //1、接受id
    20.         String id = req.getParameter("id");
    21.         //2、调用service查询
    22.         Brand brand = service.selectById(Integer.parseInt(id));
    23.         //3、存储到request中
    24.         req.setAttribute("brand",brand);
    25.         //4、转发到update.jsp
    26.         req.getRequestDispatcher("/update.jsp").forward(req,resp);
    27.     }
    28.  
    29.     @Override
    30.     protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    31.         this.doGet(req, resp);
    32.     }
    33. }

    Updateservlet:

    1. package com.itheima.web;
    2.  
    3. import com.itheima.pojo.Brand;
    4. import com.itheima.service.BrandService;
    5.  
    6. import javax.servlet.ServletException;
    7. import javax.servlet.annotation.WebServlet;
    8. import javax.servlet.http.HttpServlet;
    9. import javax.servlet.http.HttpServletRequest;
    10. import javax.servlet.http.HttpServletResponse;
    11. import java.io.IOException;
    12.  
    13. @WebServlet("/updateServlet")
    14. public class UpdateServlet extends HttpServlet {
    15.     private BrandService service = new BrandService();
    16.  
    17.     @Override
    18.     protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    19.         //处理POST请求的乱码问题
    20.         req.setCharacterEncoding("utf-8");
    21.         //1、接受表单提交的数据
    22.         String id = req.getParameter("id");
    23.         String brandName = req.getParameter("brandName");
    24.         String companyName = req.getParameter("companyName");
    25.         String ordered = req.getParameter("ordered");
    26.         String description = req.getParameter("description");
    27.         String status = req.getParameter("status");
    28.  
    29.         //封装为一个Brand对象
    30.         Brand brand = new Brand();
    31.         brand.setId(Integer.parseInt(id));
    32.         brand.setBrandName(brandName);
    33.         brand.setCompanyName(companyName);
    34.         brand.setOrdered(Integer.parseInt(ordered));
    35.         brand.setDescription(description);
    36.         brand.setStatus(Integer.parseInt(status));
    37.  
    38.         //2、调用serice完成修改
    39.         service.update(brand);
    40.  
    41.         //3、转发到查询所有Servlet
    42.         req.getRequestDispatcher("/selectAllServlet").forward(req,resp);
    43.     }
    44.  
    45.     @Override
    46.     protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
    47.         this.doGet(req, resp);
    48.     }
    49. }

    代码差不多就这样了，做完发现东西还挺多的，面向对象要写的东西还是挺多的。

     

    下面是逻辑的梳理，说实话梳理逻辑确实是要花上一些时间

    展现brand页面：通过查询tb_brand和JSP以及HTML、CSS来展现出数据库里的数据

    访问顺序：SelectAll.class->brand.jsp

    新增数据：填写表单数据->在数据库中实现添加->addServlet->selectAllServlet->发送到brand.jsp->展现数据

    访问顺序：brand.jsp->AddServlet.class->update.jsp->SelectAllServlet.class->brand.jsp

    修改数据：通过查询当前id所对应的表将其发送到update.jsp0界面->填写修改后的数据->提交表单数据->在数据库中实现修改->查询所有->brand.jsp展现数据

    访问顺序：brand.jsp->SelectByIdServlet->update.jsp->updateServlet->SelectAllServlet->brand.jsp

  • 相关阅读:
    Spring 源码（3）Spring BeanFactory 是怎么创建的？
    python加载图片无法显示原因探究/python内存回收机制作祟
    MySQl数据库————DQL数据查询语言
    vulnhub之tomato（西红柿）
    【C++模拟实现】map、set容器的模拟实现
    IDEA插件开发（8）---Listeners
    【软考中级】网络工程师：7.下一代互联网
    中国口罩及其他防护用品行业市场深度调研与发展趋势报告
    Python---练习：while循环嵌套（用两次while三步走--里外各一次）
    【Java】引用类型数组的理解与操作
  • 原文地址：https://blog.csdn.net/qq_63499305/article/details/130901480