Java Web中MVC设计模式与IOC

MVC是由Model（模型）、View（视图）、Controller（控制器）三个模块组成

 

视图：用于做数据展示以及和用户交互的一个界面（html页面）

控制层：能够接受客户端的请求，具体的业务功能还是需要借助于模型组件来完成（Controllers中央控制器）

模型层：模型分为很多种：有比较简单的值对象pojo/vo（value object），有业务模型组件（bo），有数据访问层组件（dao）

　　　　业务模型组件（bo），有数据访问层组件（dao）的区别：

　　　　　　　　　　数据访问层组件（dao）：DAO中的一个方法就只考虑一个操作，比如单纯的添加操作，单纯的删除操作

　　　　　　　　　　业务模型组件（bo）：BO中的一个方法可以调用多个DAO中的方法，比如注册方法（向用户积分表添加数据，消息表添加数据，日志表添加记录....）

                                            

 

 IOC:

1）耦合/依赖

　　依赖是指，某个类离不开某个类，耦合是指：层与层之间有依赖　　

　　我们写程序要做到高内聚低耦合。（层与层内部要高度聚合，二层与层之间应该是低耦合的，最好是没有耦合 ）

2）IOC（控制反转） / DI（依赖注入）

　　控制反转（IOC）：

• 之前在Servlet类中，创建service对象，FruitService fruitService = new FruitServiceImpl();（1.如果出现在某个方法中，那么fruitService 的作用域（生命周期）就是方法级别的；

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　2.如果在类中，为成员变量，那么fruitService 的作用域（生命周期）就是类级别的）

• 之后在applicationContext.xml中定义了这个fruitService。然后通过解析XML，产生fruitService实例，存放在beanMap中，这个beanMap在一个BeanFactory中，因此，转移（改变）了之前的　　　　　　service实例、dao实例等等他们的生命周期。控制权从程序员转移到BeanFactory。这个现象我们称之为控制反转　　

DI（依赖注入）

• 之前我们在控制层出现代码：FruitService fruitService = new FruitServiceImpl()；那么，控制层和service层存在耦合。

之后，我们将代码修改成FruitService fruitService = null ;然后，在配置文件中配置:

配置文件（applicationContext.xml）

<?xml version="1.0" encoding="utf-8"?>
<beans>
    <bean id="fruitDAO" class="fruit.dao.impl.FruitDAOImpl"/>
    <bean id="fruitService" class="fruit.servlet.impl.FruitServiceImpl">
        <property name="fruitDAO" ref="fruitDAO"/>
    </bean>
    <bean id="fruit" class="controllers.FruitControllers">
        <property name="fruitService" ref="fruitService"/>
    </bean>
</beans>

xml文件的开头一定要用

<?xml version="1.0" encoding="utf-8"?>

否则会报配置文件的错误，这句话的前面；也不可以有空格

解析XML（ClassPathXmlApplicationContext.class）

 

package myssm.io;

import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Field;
import java.util.HashMap;
import java.util.Map;

public class ClassPathXmlApplicationContext implements BeanFactory{
    private Map<String,Object> beanMap=new HashMap<>();
    public ClassPathXmlApplicationContext(){
        try {
            InputStream inputStream=getClass().getClassLoader().getResourceAsStream("/com/applicationContext.xml");
            DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
            DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
            Document document = documentBuilder.parse(inputStream);
            //4.获取所有的bean节点
            NodeList beanNodeList = document.getElementsByTagName("bean");
            for (int i = 0; i < beanNodeList.getLength(); i++) {
                Node beanNode=beanNodeList.item(i);
                if(beanNode.getNodeType()==Node.ELEMENT_NODE){
                    Element beanElement=(Element)beanNode;
                    String id = beanElement.getAttribute("id");
                    String className=beanElement.getAttribute("class");//controllers1.FruitControllers
                    Class beanClass=Class.forName(className);
                    Object beanObj=beanClass.newInstance();

                    beanMap.put(id,beanObj);
                }
            }
    //5.组装bean之间的依赖关系
            for (int i = 0; i < beanNodeList.getLength(); i++) {
                Node beanNode=beanNodeList.item(i);
                if(beanNode.getNodeType()==Node.ELEMENT_NODE){
                    Element beanElement=(Element)beanNode;
                    String beanId = beanElement.getAttribute("id");
                    NodeList beanChildNodeList=beanElement.getChildNodes();

                    for (int j = 0; j < beanChildNodeList.getLength(); j++) {
                        Node beanChildNode=beanChildNodeList.item(j);
                        //如果是个元素节点&&元素的值是property
                        if(beanChildNode.getNodeType()==Node.ELEMENT_NODE&&"property".equals(beanChildNode.getNodeName())){
                            Element propertyElement=(Element) beanChildNode;

                            String propertyName = propertyElement.getAttribute("name");
                            String propertyRef = propertyElement.getAttribute("ref");//1.找到propertyRef对应的实例
                            Object refObj=beanMap.get(propertyRef);
                            //2.将refObj设置到当前bean对应的实例的property属性上去
                            Object beanObj=beanMap.get(beanId);
                            Class beanClazz=beanObj.getClass();
                            Field propertyFieId=beanClazz.getDeclaredField(propertyName);
                            propertyFieId.setAccessible(true);
                            propertyFieId.set(beanObj,refObj);
                        }
                    }
                }
            }
        } catch (ParserConfigurationException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (SAXException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {//*****
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        }
    }
    @Override
    public Object getBean(String id) {
        return beanMap.get(id);
    }
}

 

 

　　　　　　　　　　

　　　　　　　　

 

　　

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　

标签：xml,Web,beanMap,Node,printStackTrace,MVC,catch,import,设计模式
来源： https://www.cnblogs.com/flsh/p/16264267.html