使用XML开发JavaWeb,识别相关的Bean

最新推荐文章于 2022-11-28 17:17:00 发布
最新推荐文章于 2022-11-28 17:17:00 发布
阅读量388 收藏
点赞数 2
分类专栏： JavaWeb 文章标签： java xml
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_57037182/article/details/124187892
版权

       再开发JavaWeb中，使用servlet的时候，如果方法过多，需要写出许多相同重复的代码。这样不利用代码的简洁性。

因此我们可以利用xml配置的方式，加上反射技术，可以减少大量重复的代码。

之前我们的代码是这样：代码不仅不美观，也不简洁，这只是一个servlet中的代码，如果多个servlet，重复的代码实在是太多了。

@WebServlet("/fruit.do")
public class FruitServlet extends ViewBaseServlet {
    private FruitDAO fruitDAO = new FruitDAOImpl();
    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //设置编码
        request.setCharacterEncoding("UTF-8");

        String operate = request.getParameter("operate");
        if(StringUtil.isEmpty(operate)){
            operate = "index" ;
        }

        switch(operate){
            case "index":
                index(request,response);
                break;
            case "add":
                add(request,response);
                break;
            case "del":
                del(request,response);
                break;
            case "edit":
                edit(request,response);
                break;
            case "update":
                update(request,response);
                break;
            default:
                throw new RuntimeException("operate值非法!");
        }
    }

    private void update(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //1.设置编码
        request.setCharacterEncoding("utf-8");

        //2.获取参数
        String fidStr = request.getParameter("fid");
        Integer fid = Integer.parseInt(fidStr);
        String fname = request.getParameter("fname");
        String priceStr = request.getParameter("price");
        int price = Integer.parseInt(priceStr);
        String fcountStr = request.getParameter("fcount");
        Integer fcount = Integer.parseInt(fcountStr);
        String remark = request.getParameter("remark");

        //3.执行更新
        fruitDAO.updateFruit(new Fruit(fid,fname, price ,fcount ,remark ));

        //4.资源跳转
        //super.processTemplate("index",request,response);
        //request.getRequestDispatcher("index.html").forward(request,response);
        //此处需要重定向，目的是重新给IndexServlet发请求，重新获取furitList，然后覆盖到session中，这样index.html页面上显示的session中的数据才是最新的
        response.sendRedirect("fruit.do");
    }


}

现在我们引入一个前端控制器，利用反射技术，来帮助我们找到所要调用的方法

1.在application中配置bean

<beans>
    <!-- 这个bean标签的作用是 将来servletpath中涉及的名字对应的是fruit，那么就要FruitController这个类来处理 -->
    <bean id="fruit" class="com.atguigu.fruit.controllers.FruitController"/>
</beans>

2.配置DispatcherServlet类，这样如果controller类非常多，也可以使代码简洁。

@WebServlet("*.do")
public class DispatcherServlet extends HttpServlet {

    private Map<String,Object> beanMap = new HashMap<>();

    public DispatcherServlet(){
    }

    public void init(){
  
            InputStream inputStream = getClass().getClassLoader().getResourceAsStream("applicationContext.xml");
            //1.创建DocumentBuilderFactory
            DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
            //2.创建DocumentBuilder对象
            DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder() ;
            //3.创建Document对象
            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 beanId =  beanElement.getAttribute("id");
                    String className = beanElement.getAttribute("class");
                    Class controllerBeanClass = Class.forName(className);
                    Object beanObj = controllerBeanClass.newInstance() ;
                    Method setServletContextMethod = controllerBeanClass.getDeclaredMethod("setServletContext",ServletContext.class);
                    setServletContextMethod.invoke(beanObj , this.getServletContext());

                    beanMap.put(beanId , beanObj) ;
                }
            }
        } 
    }

    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //设置编码
        request.setCharacterEncoding("UTF-8");
        //假设url是：  http://localhost:8080/pro15/hello.do
        //那么servletPath是：    /hello.do
        // 我的思路是：
        // 第1步： /hello.do ->   hello   或者  /fruit.do  -> fruit
        // 第2步： hello -> HelloController 或者 fruit -> FruitController
        String servletPath = request.getServletPath();
        servletPath = servletPath.substring(1);
        int lastDotIndex = servletPath.lastIndexOf(".do") ;
        servletPath = servletPath.substring(0,lastDotIndex);

        Object controllerBeanObj = beanMap.get(servletPath);

        String operate = request.getParameter("operate");
        if(StringUtil.isEmpty(operate)){
            operate = "index" ;
        }

            Method method = controllerBeanObj.getClass().getDeclaredMethod(operate,HttpServletRequest.class,HttpServletResponse.class);
            if(method!=null){
                method.setAccessible(true);
                method.invoke(controllerBeanObj,request,response);
            }else{
                throw new RuntimeException("operate值非法!");
            }
        } 
    }
}

如果我们在controller层中，将

 private FruitService fruitService = null ;
我们将无法获取fruitService 实例，一直报空的错误。

因此，我们将继续修改代码，使DAO层和service层的bean 也配置到xml文件中。

如何使获取的fruitService不为空呢，我们需要获取xml文件中的bean,并进行组装。

1.xml文件

 <bean id="fruitDAO" class="com.atguigu.fruit.dao.impl.FruitDAOImpl"/>
    <bean id="fruitService" class="com.atguigu.fruit.service.impl.FruitServiceImpl">
        <!-- property标签用来表示属性；name表示属性名；ref表示引用其他bean的id值-->
        <property name="fruitDAO" ref="fruitDAO"/>
    </bean>
    <bean id="fruit" class="com.atguigu.fruit.controllers.FruitController">
        <property name="fruitService" ref="fruitService"/>
    </bean>
</beans>

2.我们新建一个ClassPathXmlApplicationContext 类，将获取bean的代码封装称一个类，简化servlert中的代码

public class ClassPathXmlApplicationContext implements BeanFactory {

    private Map<String,Object> beanMap = new HashMap<>();

    public ClassPathXmlApplicationContext(){
            InputStream inputStream = getClass().getClassLoader().getResourceAsStream("applicationContext.xml");
            //1.创建DocumentBuilderFactory
            DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
            //2.创建DocumentBuilder对象
            DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder() ;
            //3.创建Document对象
            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 beanId =  beanElement.getAttribute("id");
                    String className = beanElement.getAttribute("class");
                    Class beanClass = Class.forName(className);
                    //创建bean实例
                    Object beanObj = beanClass.newInstance() ;
                    //将bean实例对象保存到map容器中
                    beanMap.put(beanId , beanObj) ;
                    //到目前为止，此处需要注意的是，bean和bean之间的依赖关系还没有设置
                }
            }
            //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);
                        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 propertyField = beanClazz.getDeclaredField(propertyName);
                            propertyField.setAccessible(true);
                            propertyField.set(beanObj,refObj);
                        }
                    }
                }
            }
        } 
    }


    @Override
    public Object getBean(String id) {
        return beanMap.get(id);
    }
}

3. DispatcherServlet配置

@WebServlet("*.do")
public class DispatcherServlet extends ViewBaseServlet{

    private BeanFactory beanFactory ;

    public DispatcherServlet(){
    }

    public void init() throws ServletException {
        super.init();
        beanFactory = new ClassPathXmlApplicationContext();
    }

    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //设置编码
        request.setCharacterEncoding("UTF-8");
        //假设url是：  http://localhost:8080/pro15/hello.do
        //那么servletPath是：    /hello.do
        // 我的思路是：
        // 第1步： /hello.do ->   hello   或者  /fruit.do  -> fruit
        // 第2步： hello -> HelloController 或者 fruit -> FruitController
        String servletPath = request.getServletPath();
        servletPath = servletPath.substring(1);
        int lastDotIndex = servletPath.lastIndexOf(".do") ;
        servletPath = servletPath.substring(0,lastDotIndex);

        Object controllerBeanObj = beanFactory.getBean(servletPath);

        String operate = request.getParameter("operate");
        if(StringUtil.isEmpty(operate)){
            operate = "index" ;
        }

        try {
            Method[] methods = controllerBeanObj.getClass().getDeclaredMethods();
            for(Method method : methods){
                if(operate.equals(method.getName())){
                    //1.统一获取请求参数

                    //1-1.获取当前方法的参数，返回参数数组
                    Parameter[] parameters = method.getParameters();
                    //1-2.parameterValues 用来承载参数的值
                    Object[] parameterValues = new Object[parameters.length];
                    for (int i = 0; i < parameters.length; i++) {
                        Parameter parameter = parameters[i];
                        String parameterName = parameter.getName() ;
                        //如果参数名是request,response,session 那么就不是通过请求中获取参数的方式了
                        if("request".equals(parameterName)){
                            parameterValues[i] = request ;
                        }else if("response".equals(parameterName)){
                            parameterValues[i] = response ;
                        }else if("session".equals(parameterName)){
                            parameterValues[i] = request.getSession() ;
                        }else{
                            //从请求中获取参数值
                            String parameterValue = request.getParameter(parameterName);
                            String typeName = parameter.getType().getName();

                            Object parameterObj = parameterValue ;

                            if(parameterObj!=null) {
                                if ("java.lang.Integer".equals(typeName)) {
                                    parameterObj = Integer.parseInt(parameterValue);
                                }
                            }

                            parameterValues[i] = parameterObj ;
                        }
                    }
                    //2.controller组件中的方法调用
                    method.setAccessible(true);
                    Object returnObj = method.invoke(controllerBeanObj,parameterValues);

                    //3.视图处理
                    String methodReturnStr = (String)returnObj ;
                    if(methodReturnStr.startsWith("redirect:")){        //比如：  redirect:fruit.do
                        String redirectStr = methodReturnStr.substring("redirect:".length());
                        response.sendRedirect(redirectStr);
                    }else{
                        super.processTemplate(methodReturnStr,request,response);    // 比如：  "edit"
                    }
                }
            }

        } 
    }
}

Method method = clazz.getDeclaredMethod(“setUserService”, UserService.class)
第一个参数是方法名，第二个参数是方法参数，传入这两个参数之后，便可以根据方法名和方法参数通过反射获取带有参数的方法method。然后继续执行 method.invoke(Object obj, Object… args)，第一个参数为实例对象，第二个参数为实参。总结：通过反射获取方法名，然后invoke方法注入方法对象和实参。

深夜无法入眠的程序猿
关注
专栏目录
javaWeb面试题(含答案).doc
09-30
JavaWeb面试题涵盖了多个关键知识点，这些都是JavaWeb开发中不可或缺的基础和进阶内容。以下是对这些问题的详细解答： 1. **JSP和Servlet的区别、共同点、各自应用的范围**： - JSP（JavaServer Pages）是Servlet...
servlet优化5-在核心控制器中统一获取参数以及视图处理
weixin_52385232的博客
09-29 157
servlet优化5-在核心控制器中统一获取参数以及视图处理
自定义Spring IOC容器实现依赖注入
AG_jim的博客
07-29 208
自定义SpringIOC容器实现依赖注入。
JavaWeb学习整理笔记
weixin_48861205的博客
10-09 342
javaWeb学习的问题
JavaWeb基础篇中央处理器处理冗余
weixin_44606952的博客
06-26 611
中央处理器使用步骤 1. 根据url定位到controller组件 1.1 创建DispatcherServlet获取servletPath 1.2 创建application.xml配置文件 1.3 将所有的bean节点存储到Map集合 1.4 根据servletPath获得对应的Controller 2. 调用Controller组件中的方法 2.1 获取参数 2.2 执行方法 2.3 视图处理 3. 优化后代码的对比 3.1 优化前代码实现 3.2 优化后代码实现......
java web开发参考资料
09-05
### Java Web开发基础知识点 #### 一、Java Web开发概述 Java Web开发是构建基于Java技术的网络应用程序的过程。它涵盖了从前端用户界面到后端数据处理的各种技术栈。对于那些对Web概念模糊的人来说，本参考资料...
MLDN魔乐JAVAWEB课堂14_WEB安全实现及config对象
09-27
在“MLDN魔乐JAVAWEB课堂14_WEB安全实现及config对象”这个课程中，我们将深入探讨Java Web开发中的安全实践与Spring框架中的`Config`对象的应用。Web安全是任何应用程序的基础，特别是对于处理敏感用户数据的Web...
专题资料（2021-2022年）javaWEB模块物流项目二.doc
07-19
5. **配置ApplicationContext**: 这部分涉及Spring的配置文件，如`ApplicationContext.xml`，用于设置数据库连接池和Bean的注册。`<context:property-placeholder>`标签用来加载数据库配置文件，`<bean id=...
MVC设计模式（2）
weixin_52972575的博客
03-30 1183
M：model V：View C：controller controller 包括了filter，dispatcher filter dispatcher model 包括了controller，service， DAO，POJO controller service DAO POJO dispatcher 初始化时进行操作 init方法 web.xml文件 ...
mvc-servlet优化2-通过反射动态的调用方法
weixin_52385232的博客
09-26 195
mvc-servlet优化2-通过反射动态的调用方法
Listener监听器的应用-水果库存管理系统
weixin_52385232的博客
10-03 142
Listener监听器的应用-水果库存管理系统
springMVC的简单的实现
最新发布
Njhbsj的博客
11-28 408
springmv的简单思想
Javaweb - Fruit
m0_63747223的博客
10-13 264
Javaweb的一个小项目梳理（自用）
详解Java中的Object.getClass()方法
evilcry2012的专栏
11-13 2159
详解Java中的Object.getClass()方法 　　详解Object.getClass()方法，这个方法的返回值是Class类型，Class c = obj.getClass(); 通过对象c，我们可以获取该对象的所有成员方法，每个成员方法都是一个Method对象；我们也可以获取该对象的所有成员变量，每个成员变量都是一个Field对象；同样的，我们也可以获取该对象的构造函数，构造函数则是...
spring中默认标签Bean标签解析二
qq_40708942的博客
05-14 256
回顾一下上一节的入口代码 protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) { // 1、解析bean标签 BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele); if (bdHolder != null) { // 2、如果bdHolder不为空的时候存在默认标签的子节
spring web.xml 难点配置总结【转】
weixin_30687587的博客
09-07 176
web.xml web.xml是所有web项目的根源,没有它,任何web项目都启动不了,所以有必要了解相关的配置. ContextLoderListener,ContextLoaderServlet,DispatcherServlet 区别 本段引用自 :http://blog.csdn.net/feiyu8607/article/details/6532397 web.x...
spring xml配置 bean beans标签及其子标签的全部属性详解
dgh112233的博客
11-03 5491
目录 1、标签的属性 2、标签的属性 3、标签的子标签 4、spring 配置bean的四种方式：注解方式、xml方式（直接映射方式、静态工厂、实例化工厂）。 1、<bean></bean>标签的属性 <bean>可以看做是一个对象，容器初始化的时候，默认会将所有的bean实例化（即创建对象），将这些对象放入容器中统一管理。 id bean的...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值