hprose spring集成 -- 让hproseservlet 使用spring的 bean

最新推荐文章于 2023-02-04 21:12:50 发布
最新推荐文章于 2023-02-04 21:12:50 发布
阅读量1.8k 收藏 1
点赞数 1
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/shuaizai88/article/details/55255240
版权 
使用第一添加springcontextutil到项目中，这样没有session 和 servlet环境我们只根据bean id我们也可以获取到 spring 维护的 bean
package com.eluotuo.common.spring;

import org.springframework.beans.BeansException;
import org.springframework.beans.factory.NoSuchBeanDefinitionException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.stereotype.Component;

import com.eluotuo.common.util.Logger;

/**
 * spring上下文配置
 * @author Mingchenchen
 *
 */
@Component
public class SpringContextUtil implements ApplicationContextAware {
    private static Logger logger = Logger.getLogger(SpringContextUtil.class);
    private static ApplicationContext applicationContext = null;

    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException
    {
        logger.info("------SpringContextUtil setApplicationContext-------");
        SpringContextUtil.applicationContext = applicationContext;
    }

    public static ApplicationContext getApplicationContext() {
        return applicationContext;
    }

    /**
     * 注意 bean name默认 = 类名(首字母小写)
     * 例如: A8sClusterDao = getBean("k8sClusterDao")
     * @param name
     * @return
     * @throws BeansException
     */
    public static Object getBean(String name) throws BeansException {
        return applicationContext.getBean(name);
    }

    /**
     * 根据类名获取到bean
     * @param <T>
     * @param clazz
     * @return
     * @throws BeansException
     */
    @SuppressWarnings("unchecked")
    public static <T> T getBeanByName(Class<T> clazz) throws BeansException {
        try {
            char[] cs=clazz.getSimpleName().toCharArray();
            cs[0] += 32;//首字母大写到小写
            System.out.println(applicationContext.getBean(String.valueOf(cs)));
            return (T) applicationContext.getBean(String.valueOf(cs));
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        } 
    }

    public static boolean containsBean(String name) {
        return applicationContext.containsBean(name);
    }

    public static boolean isSingleton(String name) throws NoSuchBeanDefinitionException {
        return applicationContext.isSingleton(name);
    }

}


接着把web.xml 里面配置的 hprose的servlet改为我重写过的。

package hprose.server;

import hprose.common.FilterHandler;
import hprose.common.HproseFilter;
import hprose.common.HproseMethods;
import hprose.common.InvokeHandler;
import hprose.io.HproseClassManager;
import hprose.io.HproseMode;
import hprose.util.StrUtil;

import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.eluotuo.common.spring.SpringContextUtil;

public class HproseServletForSpring extends  HttpServlet
{

    /**
     * serialVersionUID
     */
    private static final long serialVersionUID = 1L;

    protected final HproseHttpService service = new HproseHttpService();

    @Override
    public void init(ServletConfig config) throws ServletException {
        super.init(config);
        String param = config.getInitParameter("mode");
        if (param != null) {
            param = param.toLowerCase();
            if (param.equals("propertymode")) {
                service.setMode(HproseMode.PropertyMode);
            }
            else if (param.equals("fieldmode")) {
                service.setMode(HproseMode.FieldMode);
            }
            else if (param.equals("membermode")) {
                service.setMode(HproseMode.MemberMode);
            }
        }
        param = config.getInitParameter("debug");
        if (param != null) {
            param = param.toLowerCase();
            if (param.equals("true")) {
                service.setDebugEnabled(true);
            }
        }
        param = config.getInitParameter("crossDomain");
        if (param != null) {
            param = param.toLowerCase();
            if (param.equals("true")) {
                service.setCrossDomainEnabled(true);
            }
        }
        param = config.getInitParameter("origin");
        if (param != null) {
            String[] origins = StrUtil.split(param, ',', 0);
            for (int i = 0, n = origins.length; i < n; ++i) {
                service.addAccessControlAllowOrigin(origins[i]);
            }
        }
        param = config.getInitParameter("p3p");
        if (param != null) {
            param = param.toLowerCase();
            if (param.equals("true")) {
                service.setP3pEnabled(true);
            }
        }
        param = config.getInitParameter("get");
        if (param != null) {
            param = param.toLowerCase();
            if (param.equals("false")) {
                service.setGetEnabled(false);
            }
        }
        param = config.getInitParameter("event");
        if (param != null) {
            try {
                Class<?> type = Class.forName(param);
                if (HproseServiceEvent.class.isAssignableFrom(type)) {
                    service.setEvent((HproseServiceEvent) SpringContextUtil.getBeanByName(type));
                }
            }
            catch (Exception ex) {
                throw new ServletException(ex);
            }
        }
        param = config.getInitParameter("filter");
        if (param != null) {
            try {
                String[] classNames = StrUtil.split(param, ',', 0);
                for (int i = 0, n = classNames.length; i < n; ++i) {
                    Class<?> type = Class.forName(classNames[i]);
                    if (HproseFilter.class.isAssignableFrom(type)) {
                        service.addFilter((HproseFilter) SpringContextUtil.getBeanByName(type));
                    }
                }
            }
            catch (Exception ex) {
                throw new ServletException(ex);
            }
        }
        param = config.getInitParameter("beforeFilter");
        if (param != null) {
            try {
                String[] classNames = StrUtil.split(param, ',', 0);
                for (int i = 0, n = classNames.length; i < n; ++i) {
                    Class<?> type = Class.forName(classNames[i]);
                    if (FilterHandler.class.isAssignableFrom(type)) {
                        service.beforeFilter.use((FilterHandler) SpringContextUtil.getBeanByName(type));
                    }
                }
            }
            catch (Exception ex) {
                throw new ServletException(ex);
            }
        }
        param = config.getInitParameter("afterFilter");
        if (param != null) {
            try {
                String[] classNames = StrUtil.split(param, ',', 0);
                for (int i = 0, n = classNames.length; i < n; ++i) {
                    Class<?> type = Class.forName(classNames[i]);
                    if (FilterHandler.class.isAssignableFrom(type)) {
                        service.afterFilter.use((FilterHandler) SpringContextUtil.getBeanByName(type));
                    }
                }
            }
            catch (Exception ex) {
                throw new ServletException(ex);
            }
        }
        param = config.getInitParameter("invoke");
        if (param != null) {
            try {
                String[] classNames = StrUtil.split(param, ',', 0);
                for (int i = 0, n = classNames.length; i < n; ++i) {
                    Class<?> type = Class.forName(classNames[i]);
                    if (InvokeHandler.class.isAssignableFrom(type)) {
                        service.use((InvokeHandler) SpringContextUtil.getBeanByName(type));
                    }
                }
            }
            catch (Exception ex) {
                throw new ServletException(ex);
            }
        }
        HproseMethods methods = service.getGlobalMethods();
        param = config.getInitParameter("class");
        if (param != null) {
            try {
                String[] classNames = StrUtil.split(param, ',', 0);
                for (int i = 0, n = classNames.length; i < n; ++i) {
                    String[] name = StrUtil.split(classNames[i], '|', 3);
                    Class<?> type = Class.forName(name[0]);
                    Object obj = SpringContextUtil.getBeanByName(type);
                    System.out.println(11);
                    Class<?> ancestorType;
                    switch (name.length) {
                        case 1:
                            methods.addInstanceMethods(obj, type);
                            break;
                        case 2:
                            for (ancestorType = Class.forName(name[1]);
                                    ancestorType.isAssignableFrom(type);
                                    type = type.getSuperclass()) {
                                methods.addInstanceMethods(obj, type);
                            }
                            break;
                        case 3:
                            if (name[1].equals("")) {
                                methods.addInstanceMethods(obj, type, name[2]);
                            }
                            else {
                                for (ancestorType = Class.forName(name[1]);
                                        ancestorType.isAssignableFrom(type);
                                        type = type.getSuperclass()) {
                                    methods.addInstanceMethods(obj, type, name[2]);
                                }
                            }
                            break;
                    }
                }
            }
            catch (Exception ex) {
                throw new ServletException(ex);
            }
        }
        param = config.getInitParameter("staticClass");
        if (param != null) {
            try {
                String[] classNames = StrUtil.split(param, ',', 0);
                for (int i = 0, n = classNames.length; i < n; ++i) {
                    String[] name = StrUtil.split(classNames[i], '|', 2);
                    Class<?> type = Class.forName(name[0]);
                    if (name.length == 1) {
                        methods.addStaticMethods(type);
                    }
                    else {
                        methods.addStaticMethods(type, name[1]);
                    }
                }
            }
            catch (ClassNotFoundException ex) {
                throw new ServletException(ex);
            }
        }
        param = config.getInitParameter("type");
        if (param != null) {
            try {
                String[] classNames = StrUtil.split(param, ',', 0);
                for (int i = 0, n = classNames.length; i < n; ++i) {
                    String[] name = StrUtil.split(classNames[i], '|', 2);
                    HproseClassManager.register(Class.forName(name[0]), name[1]);
                }
            }
            catch (ClassNotFoundException ex) {
                throw new ServletException(ex);
            }
        }
        param = config.getInitParameter("topic");
        if (param != null) {
            try {
                String[] topics = StrUtil.split(param, ',', 0);
                for (int i = 0, n = topics.length; i < n; ++i) {
                    String[] item = StrUtil.split(topics[i], '|', 3);
                    switch (item.length) {
                        case 1:
                            service.publish(item[0]);
                            break;
                        case 2:
                            service.publish(item[0],
                                    Integer.parseInt(item[1], 10));
                            break;
                        case 3:
                            service.publish(item[0],
                                    Integer.parseInt(item[1], 10),
                                    Integer.parseInt(item[1], 10));
                            break;
                    }
                }
            }
            catch (Exception ex) {
                throw new ServletException(ex);
            }
        }
        setGlobalMethods(methods);
    }

    protected void setGlobalMethods(HproseMethods methods) {
    }

    protected void processRequest(HttpServletRequest request, HttpServletResponse response)
            throws ServletException {
        service.handle(new HttpContext(service,
                                       request,
                                      response,
                       this.getServletConfig(),
                    this.getServletContext()));
    }

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException {
        processRequest(request, response);
    }

    @Override
    protected void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException {
        processRequest(request, response);
    }

    @Override
    protected void doOptions(HttpServletRequest request, HttpServletResponse response)
            throws ServletException {
        processRequest(request, response);
    }

    @Override
    public String getServletInfo() {
        return "Hprose Servlet 2.0";
    }
    
}

如果觉得这篇文章帮助到你，给作者打赏点咖啡钱吧。


陕西小伙伴网络科技有限公司
关注
  • 1
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
JAVA发布Hprose服务的简单实例
04-20
一个简单的利用hprose发布java服务的实现
使用Hprose制作一个简单的分布式应用程序
weixin_33826609的博客
11-19 629
2019独角兽企业重金招聘Python工程师标准>>> ...
1、hprose2.X 安装 hprose3.X看另外一篇
wade1010的专栏
02-04 65
核心版本除了提供了客户端的基本实现的基类以外，还提供了 HTTP 客户端和 Socket 客户端。这两个客户端既可以在命令行环境下使用，也可以在 php-fpm 或其他 PHP 环境下使用。提供了纯异步的 HTTP 客户端，Socket 客户端和 WebSocket 客户端。swoole 版本这里就不演示了，因为该版本使用的swoole版本比较低，应该是1.8左右吧，期待hprose3.0后再使用吧。其中 HTTP 客户端支持跟 HTTP、HTTPS 绑定的 Hprose 服务器通讯。
Hprose for php(二）——服务器
half1的专栏
03-14 4695
本文参考了Hprose官方的用户手册，Hprose官网：http://www.hprose.com/  如果你还未自己动手做过Hprose的实践，请先看《Hprose for php(一)——快速入门》 本文将介绍Hprose for php服务器的更多细节 1、发布服务 Hprose提供多种方法发布服务，除了提供跟PHPRPC中相同的add方法以外，还提供了更多方便的
性能工具之Jmeter压测Hprose RPC服务
Mo小泽的技术博客
09-18 2368
概述 Hprose(High Performance Remote Object Service Engine),国人开发的一个远程方法调用的开源框架。它是一个先进的轻量级的跨语言跨平台面向对象的高性能远程动态通讯中间件,它支持众多语言，例如nodeJs, C++,.NET,Java,Delphi,Objective-C,ActionScript,JavaScript,ASP,PHP,Python...
Spring集成Hprose
qq_31071517的博客
10-24 331
参考了网上很多教程，没有现成例子，就自己编写一个，只用Spring容器来管理接口service 用Hprose来发布服务，持久层用mybatis 和mybaits-generat ，这种和springboot稍微不同，可以参考，根据实际业务来；我们的请求是 请求到网关 网关再请求到我们的服务端，服务端暴露接口！ 接口和实现类就不贴了 主要是贴下Hprose发布方法： package com...
hprose unity http server
fish的小技术
02-13 1259
IsCrossDomainEnabled设置： mServer.IsCrossDomainEnabled = true;CrossDomainXmlContent设置： //mServer.CrossDomainXmlContent = // "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n\n<!DOCTYPE cross-domain-policy
Hprose之JAVA服务端与C++客户端
SomeTimes
05-25 2585
.
springboot2.X集成RPC服务Hprose(注解模式)
qq_25073261的博客
04-16 541
服务端(端口9989) 1.新建maven项目，引入hprose-jar <!-- Hprose rpc通讯 --> <dependency> <groupId>org.hprose</groupId> <artifactId>hprose-java</artifactId> <version>2...
hprose-delphi-master
11-28
hprose-delphi-master
springboot整合hprose实现rpc调用源码
06-15
springboot整合hprose实现rpc调用源码
spring整合hprose-demo
10-27
spring集成hprose，不多说自己下载源码看
HPROSE例子 一个服务端，两个客户端
08-18
HPROSE例子 一个服务端，两个客户端 仅供参考 服务器端web.xml配置文件有相关配置说明 HPROSE例子 一个服务端，两个客户端 仅供参考 服务器端web.xml配置文件有相关配置说明
Spring整合hprose的demo
07-20
Spring4.3.9整合hprose java服务器和hprose js客户端的Demo hprose字典的spring_hprose_for_javax.jar一直报noSuchError错,使用源码通过 使用tomcat7以上版本。 访问地址:http://localhost:8080/WebSocketLike/web/1.jsp
spring_mybatis_hprose.zip
10-24
spring mybaits hprose集成使用，从持久层到业务层全部集成，可以参考下！
hprose-java-2.0.3.jar
12-20
hprose-java-2.0.3.jar hprose-java.jar开发工具hprose
Hprose for php-PHP
06-20
Hprose是高性能远程对象服务引擎（High Performance Remote Object Service Engine）的缩写 —— 微服务首选引擎。该项目是Hprose 3.0 for PHP。 它是一个先进的轻量级的跨语言跨平台面向对象的高性能远程动态通讯...
Use-Hprose-In-Angularjs:如何在angularjs示例中使用hprose
05-25
Use-Hprose-In-Angular.js 如何在angularjs示例中使用hprose 如何在Angularjs中使用Hprose作为通讯中间件。 ## 1。 下载hprose-html5 git clone https://github.com/hprose/hprose-html5 OR bower install hprose...
MATLAB算法插值与拟合代码
最新发布
04-15
MATLAB算法插值与拟合代码提取方式是百度网盘分享地址
Hprose for Java 服务器（一）
05-27
<artifactId>hprose-java <version>3.0.8 ``` 在使用Hprose for Java时，需要定义一个接口，并在接口上添加@HproseService注解，表示这是一个Hprose服务。接着，我们可以在接口中定义需要暴露给客户端调用的方法...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值