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);

    }

}

巴特西

Java Web中MVC设计模式与IOC

最新文章

热门文章