• mvc-ioc实现

    mvc-ioc实现

    1. IOC(Inversion of Control)：控制反转
    2.     1) 耦合/依赖
    3.       依赖指的是某某某离不开某某某
    4.       在软件系统中，层与层之间是存在依赖的。我们也称之为耦合。
    5.       我们系统架构或者是设计的一个原则是： 高内聚低耦合。
    6.       层内部的组成应该是高度聚合的，而层与层之间的关系应该是低耦合的，最理想的情况0耦合（就是没有耦合）
    7.     2) IOC - 控制反转 / DI - 依赖注入

    BeanFactory 接口

    1. public interface BeanFactory {
    2.     Object getBean(String id);
    3. }

    ClassPathXmlApplicationContext 类

    1. public class ClassPathXmlApplicationContext implements BeanFactory {
    2.  
    3.     private Map beanMap = new HashMap<>();
    4.  
    5.     public ClassPathXmlApplicationContext() {
    6.         try {
    7.             InputStream inputStream = getClass().getClassLoader().getResourceAsStream("applicationContext.xml");
    8.             //1.创建DocumentBuilderFactory对象
    9.             DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
    10.             //2.创建DocumentBuilder对象
    11.             DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
    12.             //3.创建Document对象
    13.             Document document = documentBuilder.parse(inputStream);
    14.  
    15.             //4.获取所有的bean节点
    16.             NodeList beanNodeLists = document.getElementsByTagName("bean");
    17.             for (int i = 0; i < beanNodeLists.getLength(); i++) {
    18.                 Node beanNode = beanNodeLists.item(i);
    19.                 //判断该节点的类型是否等于元素节点
    20.                 if (beanNode.getNodeType() == Node.ELEMENT_NODE) {
    21.                     Element beanElement = (Element) beanNode;
    22.                     String beanId = beanElement.getAttribute("id");
    23.                     String className = beanElement.getAttribute("class");
    24.                     Class beanClass = Class.forName(className);
    25.                     //创建bean实例
    26.                     Object beanObj = beanClass.newInstance();
    27.                     //将bean实例对象保存到map容器中
    28.                     beanMap.put(beanId, beanObj);
    29.                     //到目前为止，此处需要注意的是：bean和bean之间的依赖关系还没有设置
    30.                 }
    31.             }
    32.             //5.组装bean之间的依赖关系
    33.             for (int i = 0; i < beanNodeLists.getLength(); i++) {
    34.                 Node beanNode = beanNodeLists.item(i);
    35.                 //判断该节点的类型是否等于元素节点
    36.                 if (beanNode.getNodeType() == Node.ELEMENT_NODE) {
    37.                     Element beanElement = (Element) beanNode;
    38.                     String beanId = beanElement.getAttribute("id");
    39.                     NodeList beanChildNodeList = beanElement.getChildNodes();
    40.                     for (int j = 0; j < beanChildNodeList.getLength(); j++) {
    41.                         Node beanChildNode = beanChildNodeList.item(j);
    42.                         if (beanChildNode.getNodeType() == Node.ELEMENT_NODE && "property".equals(beanChildNode.getNodeName())) {
    43.                             Element propertyElement = (Element) beanChildNode;
    44.                             String propertyName = propertyElement.getAttribute("name");
    45.                             String propertyRef = propertyElement.getAttribute("ref");
    46.                             //1.找到propertyRef对应的实例
    47.                             Object refObj = beanMap.get(propertyRef);
    48.                             //2.将refObj设置到当前bean对应的实例的property属性上去
    49.                             Object beanObj = beanMap.get(beanId);
    50.                             Class beanClass = beanObj.getClass();
    51.                             Field propertyField = beanClass.getDeclaredField(propertyName);
    52.                             propertyField.setAccessible(true);
    53.                             propertyField.set(beanObj, refObj);
    54.                         }
    55.                     }
    56.                 }
    57.             }
    58.         } catch (ParserConfigurationException e) {
    59.             e.printStackTrace();
    60.         } catch (SAXException e) {
    61.             e.printStackTrace();
    62.         } catch (IOException e) {
    63.             e.printStackTrace();
    64.         } catch (IllegalAccessException e) {
    65.             e.printStackTrace();
    66.         } catch (InstantiationException e) {
    67.             e.printStackTrace();
    68.         } catch (ClassNotFoundException e) {
    69.             e.printStackTrace();
    70.         } catch (NoSuchFieldException e) {
    71.             e.printStackTrace();
    72.         }
    73.     }
    74.  
    75.     @Override
    76.     public Object getBean(String id) {
    77.         return beanMap.get(id);
    78.     }
    79. }

    FruitController 类

    1. //FruitServlet 改名为 FruitController
    2. public class FruitController{
    3.  
    4.     private FruitService fruitService = null;
    5.  
    6.     private String update(Integer fid,String fname,Integer price,Integer fcount,String remark){
    7.         //3.执行更新
    8.         fruitService.updateFruit(new Fruit(fid, fname, price, fcount, remark));
    9.         //4.资源跳转
    10.         //super.processTemplate("index",request,response);
    11.         //request.getRequestDispatcher(index.html).forward(request,response);
    12.         //此处需要重定向，目的是重新给IndexServlet发请求，重新获取fruitList，然后覆盖到session
    13.         //这样index.html页面上显示的session中的数据才是最新的
    14.         //response.sendRedirect("fruit.do");
    15.         return "redirect:fruit.do";
    16.     }
    17.  
    18.     private String edit(Integer fid,HttpServletRequest request){
    19.         if (fid != null) {
    20.             Fruit fruit = fruitService.getFruitByFid(fid);
    21.             request.setAttribute("fruit", fruit);
    22.             //super.processTemplate("edit", request, response);
    23.             return "edit";
    24.         }
    25.         return "error";
    26.     }
    27.  
    28.     private String del(Integer fid){
    29.         if (fid != null) {
    30.             fruitService.delFruit(fid);
    31.             //response.sendRedirect("fruit.do");
    32.             return "redirect:fruit.do";
    33.         }
    34.         return "error";
    35.     }
    36.  
    37.     private String add(String fname,Integer price,Integer fcount,String remark){
    38.         Fruit fruit = new Fruit(0, fname, price, fcount, remark);
    39.         fruitService.addFruit(fruit);
    40.         //response.sendRedirect("fruit.do");
    41.         return "redirect:fruit.do";
    42.     }
    43.  
    44.     private String index(String oper,String keyword,Integer pageNo,HttpServletRequest request){
    45.  
    46.         HttpSession session = request.getSession();
    47.  
    48.         if (pageNo == null){
    49.             pageNo = 1;
    50.         }
    51.  
    52.         //如果oper != null 说明是通过表单的查询按钮点击过来的
    53.         //如果oper是空的，说明不是通过表单的查询按钮点击过来的
    54.         if (StringUtil.isNotEmpty(oper) && "search".equals(oper)) {
    55.             //说明是点击表单查询发送过来的请求
    56.             //此时，pageNo应该还原为1，keyword应该从请求参数获取
    57.             pageNo = 1;
    58.             //如果keyword为null，需要设置为空字符串"",否则查询时会拼接成 %null%
    59.             //我们期望的是 %%，就是查询所有的数据
    60.             if (StringUtil.isEmpty(keyword)) {
    61.                 keyword = "";
    62.             }
    63.             //将 keyword 保存(覆盖)到session中
    64.             session.setAttribute("keyword", keyword);
    65.         } else {
    66.             //说明此处不是点击表单查询发送过来的请求(比如点击下面的上一页下一页或者直接在地址栏输入网址)
    67.             //此时keyword应该从session作用域获取
    68.             //如果不是点击的查询按钮，那么查询是基于session中保存的现有的keyword进行查询
    69.             Object keywordobj = session.getAttribute("keyword");
    70.             if (keywordobj != null) {
    71.                 keyword = (String) keywordobj;
    72.             } else {
    73.                 keyword = "";
    74.             }
    75.         }
    76.  
    77.         //重新更新当前页的值
    78.         session.setAttribute("pageNo", pageNo);
    79.  
    80.         List fruitList = fruitService.getFruitList(keyword, pageNo);
    81.         session.setAttribute("fruitList", fruitList);
    82.  
    83.         //总记录条数
    84.         int pageCount = fruitService.getPageCount(keyword);
    85.         /*
    86.         总记录条数      总页数
    87.         1                   1
    88.         5                   1
    89.         6                   2
    90.         10                  2
    91.         11                  3
    92.         fruitCount          (fruitCount+5-1)/5
    93.          */
    94.  
    95.         session.setAttribute("pageCount", pageCount);
    96.  
    97.         //此处的视图名称是index
    98.         //那么thymeleaf会将这个 逻辑视图 名称对应到 物理视图 名称上去
    99.         //        //逻辑视图名称：index
    100.         //物理视图名称：      viw-prefix + 逻辑视图名称 +view-suffix
    101.         //所以真实的视图名称是：   /            index        .html
    102.         //super.processTemplate("index", request, response);
    103.         return "index";
    104.     }
    105. }

    FruitService 接口

    1. public interface FruitService {
    2.     //获取指定页面的库存列表信息
    3.     List getFruitList(String keyword, Integer pageNo);
    4.  
    5.     //添加库存记录信息
    6.     void addFruit(Fruit fruit);
    7.  
    8.     //根据id查看指定库存记录
    9.     Fruit getFruitByFid(Integer fid);
    10.  
    11.     //删除特定库存记录
    12.     void delFruit(Integer fid);
    13.  
    14.     //修改特定库存记录
    15.     void updateFruit(Fruit fruit);
    16.  
    17.     //获取总页数
    18.     Integer getPageCount(String keyword);
    19.  
    20. }

    FruitServiceImpl 类

    1. public class FruitServiceImpl implements FruitService{
    2.  
    3.     private FruitDAO fruitDAO = null;
    4.  
    5.     @Override
    6.     public List getFruitList(String keyword, Integer pageNo) {
    7.         return fruitDAO.getFruitList(keyword,pageNo);
    8.     }
    9.  
    10.     @Override
    11.     public void addFruit(Fruit fruit) {
    12.         fruitDAO.addFruit(fruit);
    13.     }
    14.  
    15.     @Override
    16.     public Fruit getFruitByFid(Integer fid) {
    17.         return fruitDAO.getFruitByFid(fid);
    18.     }
    19.  
    20.     @Override
    21.     public void delFruit(Integer fid) {
    22.         fruitDAO.delFruit(fid);
    23.     }
    24.  
    25.     @Override
    26.     public void updateFruit(Fruit fruit) {
    27.         fruitDAO.updateFruit(fruit);
    28.     }
    29.  
    30.     @Override
    31.     public Integer getPageCount(String keyword) {
    32.         int count = fruitDAO.getFruitCount(keyword);
    33.         int pageCount = (count + 5 - 1) / 5;
    34.         return pageCount;
    35.     }
    36. }

    applicationContext.xml

    1. "1.0" encoding="utf-8"?>
    2.  
    3. <beans>
    4.     <bean id="fruitDAO" class="com.atguigu.fruit.dao.impl.FruitDAOImpl"/>
    5.     <bean id="fruitService" class="com.atguigu.fruit.service.impl.FruitServiceImpl">
    6.         
    7.         <property name="fruitDAO" ref="fruitDAO"/>
    8.     bean>
    9.     
    10.     <bean id="fruit" class="com.atguigu.fruit.controllers.FruitController">
    11.         <property name="fruitService" ref="fruitService"/>
    12.     bean>
    13. beans>
    14.

  • 相关阅读:
    EdgeX Foundry MQTT设备服务
    羊了个羊网页版
    【微服务】CentOS7 虚拟机 安装 Docker
    海康的资料
    深度之眼（二十三）——Python：Sklearn库
    Mybatis练习案例
    Java学习笔记（五）——数组、排序和查找
    Linux操作系统：性能指标监控与通知
    ansible角色部署lamp架构
    自动驾驶技术的基础知识
  • 原文地址：https://blog.csdn.net/weixin_52385232/article/details/127112969