为客户端添加拥有业务逻辑的Handler

最新推荐文章于 2024-05-25 12:01:51 发布
最新推荐文章于 2024-05-25 12:01:51 发布
阅读量284 收藏 3
点赞数
文章标签： java
原文链接：https://my.oschina.net/fhd/blog/260733
版权

为什么80%的码农都做不了架构师？>>>   hot3.png

以HelloWord为例，客户端的LogicalHandler可以拦截出站的请求消息以检查调用sayHello服务操作的输入参数。如果参数name值为“老板”则修改为“刘诗诗”。示例如下：

服务端：

HelloWord.java

package ch03.ts;

import javax.jws.WebMethod;
import javax.jws.WebParam;
import javax.jws.WebService;
import javax.xml.ws.Holder;

@WebService
public interface HelloWord {

    @WebMethod
    void sayHello(@WebParam(name="name") String name,
            @WebParam(name="wh",mode=WebParam.Mode.INOUT) Holder<String> wh,
            @WebParam(name="hf",mode=WebParam.Mode.OUT) Holder<String> hf);
}

HelloWordImpl.java

package ch03.ts;

import javax.jws.WebService;
import javax.xml.ws.Holder;

@WebService(endpointInterface = "ch03.ts.HelloWord")
public class HelloWordImpl implements HelloWord {

    @Override
    public void sayHello(String name, Holder<String> wh, Holder<String> hf) {
        System.out.println(name + "!" + wh.value);
        wh.value = "你们好";
        hf.value = "同学们";
    }
}

HelloWordPublisher.java

package ch03.ts;

import javax.xml.ws.Endpoint;

public class HelloWordPublisher {
    public static void main(String[] args) {
        Endpoint.publish("http://localhost:7654/ts", new HelloWordImpl());
    }
}

客户端：

HelloWord.java

package hw4;

import javax.jws.WebMethod;
import javax.jws.WebParam;
import javax.jws.WebService;
import javax.xml.bind.annotation.XmlSeeAlso;
import javax.xml.ws.Action;
import javax.xml.ws.Holder;
import javax.xml.ws.RequestWrapper;
import javax.xml.ws.ResponseWrapper;

/**
 * This class was generated by the JAX-WS RI.
 * JAX-WS RI 2.2.4-b01
 * Generated source version: 2.2
 */
@WebService(name = "HelloWord", targetNamespace = "http://ts.ch03/")
@XmlSeeAlso({
    ObjectFactory.class
})
public interface HelloWord {
    /**
     * @param wh
     * @param name
     * @param hf
     */
    @WebMethod
    @RequestWrapper(localName = "sayHello", targetNamespace = "http://ts.ch03/", 
        className = "hw4.SayHello")
    @ResponseWrapper(localName = "sayHelloResponse", targetNamespace = "http://ts.ch03/", 
        className = "hw4.SayHelloResponse")
    @Action(input = "http://ts.ch03/HelloWord/sayHelloRequest", 
        output = "http://ts.ch03/HelloWord/sayHelloResponse")
    public void sayHello(
        @WebParam(name = "name", targetNamespace = "")
        String name,
        @WebParam(name = "wh", targetNamespace = "", mode = WebParam.Mode.INOUT)
        Holder<String> wh,
        @WebParam(name = "hf", targetNamespace = "", mode = WebParam.Mode.OUT)
        Holder<String> hf);
}

HelloWordImplService.java（注意：这里添加了注解 @HandlerChain(file="handler-chain1.xml")）：

package hw4;

import java.net.MalformedURLException;
import java.net.URL;
import javax.jws.HandlerChain;
import javax.xml.namespace.QName;
import javax.xml.ws.Service;
import javax.xml.ws.WebEndpoint;
import javax.xml.ws.WebServiceClient;
import javax.xml.ws.WebServiceException;
import javax.xml.ws.WebServiceFeature;

/**
 * This class was generated by the JAX-WS RI.
 * JAX-WS RI 2.2.4-b01
 * Generated source version: 2.2
 */
@WebServiceClient(name = "HelloWordImplService", targetNamespace = "http://ts.ch03/", 
    wsdlLocation = "http://localhost:7654/ts?wsdl")
@HandlerChain(file = "handler-chain1.xml")
public class HelloWordImplService extends Service{

    private final static URL HELLOWORDIMPLSERVICE_WSDL_LOCATION;
    private final static WebServiceException HELLOWORDIMPLSERVICE_EXCEPTION;
    private final static QName HELLOWORDIMPLSERVICE_QNAME = 
        new QName("http://ts.ch03/", "HelloWordImplService");

    static {
        URL url = null;
        WebServiceException e = null;
        try {
            url = new URL("http://localhost:7654/ts?wsdl");
        } catch (MalformedURLException ex) {
            e = new WebServiceException(ex);
        }
        HELLOWORDIMPLSERVICE_WSDL_LOCATION = url;
        HELLOWORDIMPLSERVICE_EXCEPTION = e;
    }

    public HelloWordImplService() {
        super(__getWsdlLocation(), HELLOWORDIMPLSERVICE_QNAME);
    }

    public HelloWordImplService(WebServiceFeature... features) {
        super(__getWsdlLocation(), HELLOWORDIMPLSERVICE_QNAME, features);
    }

    public HelloWordImplService(URL wsdlLocation) {
        super(wsdlLocation, HELLOWORDIMPLSERVICE_QNAME);
    }

    public HelloWordImplService(URL wsdlLocation, 
        WebServiceFeature... features) {
        super(wsdlLocation, HELLOWORDIMPLSERVICE_QNAME, features);
    }

    public HelloWordImplService(URL wsdlLocation, QName serviceName) {
        super(wsdlLocation, serviceName);
    }

    public HelloWordImplService(URL wsdlLocation, QName serviceName, 
        WebServiceFeature... features) {
        super(wsdlLocation, serviceName, features);
    }

    /**
     * @return
     * returns HelloWord
     */
    @WebEndpoint(name = "HelloWordImplPort")
    public HelloWord getHelloWordImplPort() {
        return super.getPort(new QName("http://ts.ch03/", "HelloWordImplPort"),
            HelloWord.class);
    }

    /**
     * 
     * @param features
     * A list of {@link javax.xml.ws.WebServiceFeature} to configure on t
     * he proxy.  Supported features not in the <code>features</code> parameter 
     * will have their default values.
     * @return
     * returns HelloWord
     */
    @WebEndpoint(name = "HelloWordImplPort")
    public HelloWord getHelloWordImplPort(WebServiceFeature... features) {
        return super.getPort(new QName("http://ts.ch03/", "HelloWordImplPort"), 
            HelloWord.class, features);
    }

    private static URL __getWsdlLocation() {
        if (HELLOWORDIMPLSERVICE_EXCEPTION!= null) {
            throw HELLOWORDIMPLSERVICE_EXCEPTION;
        }
        return HELLOWORDIMPLSERVICE_WSDL_LOCATION;
    }
}

SayHello.java：

package hw4;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlType;

/**
 * <p>Java class for sayHello complex type.
 * <p>The following schema fragment specifies the expected content 
 * contained within this class.
 * <pre>
 * &lt;complexType name="sayHello">
 *   &lt;complexContent>
 *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
 *       &lt;sequence>
 *         &lt;element name="name" type="{http://www.w3.org/2001/XMLSchema}string" 
 *            minOccurs="0"/>
 *         &lt;element name="wh" type="{http://www.w3.org/2001/XMLSchema}string" 
 *             minOccurs="0"/>
 *       &lt;/sequence>
 *     &lt;/restriction>
 *   &lt;/complexContent>
 * &lt;/complexType>
 * </pre>
 */
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "sayHello", propOrder = {
    "name",
    "wh"
})
public class SayHello {

    protected String name;
    protected String wh;

    /**
     * Gets the value of the name property.
     * @return
     * possible object is
     * {@link String } 
     */
    public String getName() {
        return name;
    }

    /**
     * Sets the value of the name property.
     * @param value
     * allowed object is
     * {@link String } 
     */
    public void setName(String value) {
        this.name = value;
    }

    /**
     * Gets the value of the wh property.
     * @return
     * possible object is
     * {@link String } 
     */
    public String getWh() {
        return wh;
    }

    /**
     * Sets the value of the wh property.
     * @param value
     * allowed object is
     * {@link String } 
     */
    public void setWh(String value) {
        this.wh = value;
    }
}

SayHelloResponse.java：

package hw4;

import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;
import javax.xml.bind.annotation.XmlType;

/**
 * <p>Java class for sayHelloResponse complex type.
 * <p>The following schema fragment specifies the expected content 
 * contained within this class.
 * <pre>
 * &lt;complexType name="sayHelloResponse">
 *   &lt;complexContent>
 *     &lt;restriction base="{http://www.w3.org/2001/XMLSchema}anyType">
 *       &lt;sequence>
 *         &lt;element name="wh" type="{http://www.w3.org/2001/XMLSchema}string" 
 *            minOccurs="0"/>
 *         &lt;element name="hf" type="{http://www.w3.org/2001/XMLSchema}string" 
 *            minOccurs="0"/>
 *       &lt;/sequence>
 *     &lt;/restriction>
 *   &lt;/complexContent>
 * &lt;/complexType>
 * </pre>
 */
@XmlAccessorType(XmlAccessType.FIELD)
@XmlType(name = "sayHelloResponse", propOrder = {
    "wh",
    "hf"
})
public class SayHelloResponse {

    protected String wh;
    protected String hf;

    /**
     * Gets the value of the wh property.
     * @return
     * possible object is
     * {@link String }
     */
    public String getWh() {
        return wh;
    }

    /**
     * Sets the value of the wh property.
     * @param value
     * allowed object is
     * {@link String }
     */
    public void setWh(String value) {
        this.wh = value;
    }

    /**
     * Gets the value of the hf property.
     * @return
     * possible object is
     * {@link String }
     */
    public String getHf() {
        return hf;
    }

    /**
     * Sets the value of the hf property.
     * @param value
     * allowed object is
     * {@link String } 
     */
    public void setHf(String value) {
        this.hf = value;
    }
}

ObjectFactory.java与package-info.java省略。

HelloWordClient1.java：

package hw4;

import javax.xml.ws.Holder;

public class HelloWordClient1 {
    public static void main(String[] args) {
        String name = "老板";
        Holder<String> wh = new Holder<String>();
        wh.value = "你好";
        Holder<String> hf = new Holder<String>();
        HelloWordImplService service = new HelloWordImplService();
        HelloWord port = service.getPort(HelloWord.class);
        port.sayHello(name, wh, hf);
        System.out.println(hf.value + "," + wh.value);
    }
}

ArgHandler.java：

package fibC;

import hw4.SayHello;

import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBElement;
import javax.xml.ws.LogicalMessage;
import javax.xml.ws.handler.LogicalHandler;
import javax.xml.ws.handler.LogicalMessageContext;
import javax.xml.ws.handler.MessageContext;

/**
 * 如果称呼不正确，对称呼进行修正
 * @author fuhd
 */
public class ArgHandler implements LogicalHandler<LogicalMessageContext> {

    @SuppressWarnings({ "unchecked", "rawtypes" })
    @Override
    public boolean handleMessage(LogicalMessageContext context) {
        Boolean b = (Boolean) context.get(MessageContext.MESSAGE_OUTBOUND_PROPERTY);
        if(b){
            System.out.println("ArgHandler.handleMessage");
            LogicalMessage msg = context.getMessage();
            try {
                JAXBContext jaxb_ctx = JAXBContext.newInstance("hw4");
                Object payload = msg.getPayload(jaxb_ctx);
                if(payload instanceof JAXBElement){
                    Object obj = ((JAXBElement)payload).getValue();
                    SayHello sayH = (SayHello)obj;
                    String name1 = sayH.getName();
                    if("老板".equals(name1)){
                        sayH.setName("刘诗诗");
                        ((JAXBElement)payload).setValue(obj);
                        msg.setPayload(payload, jaxb_ctx);
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return true;
    }

    @Override
    public boolean handleFault(LogicalMessageContext context) {
        return true;
    }

    @Override
    public void close(MessageContext context) {
    }
}

handler-chain1.xml：

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<javaee:handler-chains xmlns:javaee="http://java.sun.com/xml/ns/javaee" 
        xmlns:xsd="http://www.w3.org/2001/XMLSchema">
    <javaee:handler-chain>
        <javaee:handler>
            <javaee:handler-class>fibC.ArgHandler</javaee:handler-class>
        </javaee:handler>
    </javaee:handler-chain>        
</javaee:handler-chains>

ArgHandler利用JAXBContext对象实例从LogicalMessage中解析出消息单元。这个消息单元就是出站的SOAP消息。LogicalMessage中还有一个无参数的getPayload方法，该方法返回一个XML源对象，可以从这个源对象中的XML编码为一个Java对象。拥有一个输入参数的getPayload方法中，参数可以是一个类，也可以是一个或多个包名称（注：上面这个例子中，hw4是wsimport生成的工件所在包的名称）。消息单元解析成一个JAXBElement对象，对应XML中描述SayHello对象的元素。SayHello是wsimport生成的工具集合中的一个类。尤其是Java对象类hw4.SayHello对应于服务操作sayHello中一个SOAP请求消息。请求参数修改完之后，通过JAXBElement更新转换参数值，最后通过调用方法setPayload更新消息体内容。


转载于:https://my.oschina.net/fhd/blog/260733

weixin_34208283
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
客户端架构设计
bugstack虫洞栈
09-22 2453
一、前言 在设计客户端的架构之前，我们先思考下我们的目标以及目前已经完成的内容。好！那么你是否还能记得我们最开始设计 UI 组件包的时候，就已经反复提到要将我们的 UI 与业务进行分离，不要将业务流程代码写到 UI 窗口里去。否则你的代码将越来越难以为维护，每新增加一个功能都将会让你从很多的代码中“贴膏药”似的补来补去。 UI 方面：我们已经完成了 UI 包的开发，并使用 Maven 进行打包对外...
SOAPHandler and LogicalHandler
weixin_34186950的博客
10-17 228
As with filters, you may either want to modify the complete message or just modify the body of the message. For either kind of requirement, there are corresponding handler types present in ...
Spring利用InitializingBean定义基于业务队列处理Handler
纸上得来终觉浅，绝知此事要躬行
09-06 307
在各种高效的编程框架中都有Handler身影，将一类业务通过Handler统一输出可以简化业务编程。比如:业务编号、业务持久化处理、业务异常等处理。 定义Handler类 public interface ServiceHandler { ServiceType type(); void execute(String data); void handleException(String data); } 定义类似面向过程编程的需求处理 项目结构： 接口： .
Netty业务逻辑的分离（所有文章集合）
weixin_42030357的博客
11-12 797
原博文，点击这里 文章目录1.Netty的NIO线程常见的阻塞场景2.JDK的线程池还是Netty的非I/O线程池？3.异步的执行结果怎么回到Netty的NIO线程？4.JDK的线程池拒绝策略的坑可能导致阻塞5.使用Netty非I/O线程池的正确姿势 1.Netty的NIO线程常见的阻塞场景 知道一个大前提：Netty的ChannelHandler是业务代码和Netty框架交汇的地方（关于pipeline机制的细节后续专题分析，先知道即可），ChannelHandler里的业务逻辑，正常来说是由NioEve
从零实现一个RPC框架（六）- Netty客户端Handler
gutou__yu的博客
09-23 746
Netty客户端Handler 在 Netty 配置客户端端时，添加的真正处理业务逻辑的 NettyClientHandler 。 概述 NettyClientHandler 继承 ChannelInboundHandlerAdapter，覆写 channelRead、userEventTriggered、exceptionCaught三个方法。 channelRead ：处理服务端返回的数据，交由 CompletableFuture返回（下一篇会讲到 CompletableFuture）给代理方法。 us
Netty13——Handler的调用机制
如不來的博客
08-11 596
一、Handler 的作用  Netty 的主要组件有Channel、EventLoop、ChannelFuture、ChannelHandler、ChannelPipe等。ChannelHandler 充当了处理入站和出站数据的应用程序逻辑的容器。例如，实现ChannelInboundHandler 接口（或ChannelInboundHandlerAdapter），就可以接收入站事件和数据，这些数据会被业务逻辑处理。当要给客户端发送响应时，可以从 ChannelInboundHandler 冲刷数据。业
HTTP协议理解及服务端与客户端的设计实现
热门推荐
严振杰
06-20 2万+
本文主要帮助读者理解 HTTP 的协作原理、HTTP 相关的各层协议，在服务端和客户端的架构设计和一些优化的技巧，本文中主要讲述逻辑思想和协议远离，会使用部分 Java 代码，但会有详细的讲解，非开发应该也读的明白。 个人实现过一款WebServe...
netty学习05-handler介绍
zhaocuit的博客
10-23 940
1. Netty中Handler 从应用程序开发人员的角度来看，Netty的主要组件是ChannelHandler，而ChannelHandler包括入站和出站两种类型。 数据入站，指的是数据从底层的Java NIO channel到Netty的Channel。 数据出站，指的是通过Netty的Channel来操作底层的 Java NIO chanel。 1.1 inbound 入站（...
六、Netty的Handler
夏天
11-05 1491
六、Netty的Handler 文章目录 六、Netty的Handler 1、Handler介绍 2、Handler链式调用 3、Handler编解码器 4、简单实例 5、Log4j整合到Netty 1、Handler介绍 netty的组件设计：Netty的主要组件有Channel、EventLoop、ChannelFuture、ChannelHandler、ChannelPipe等 我们先来复习一下ChannelHandler和ChannelPipeline的关系。示例图如下：我们可以将pi
C++项目——集群聊天服务器项目(十四）客户端业务
mingyuexin235的博客
04-12 1157
今天来继续更新集群聊天服务器项目的客户端功能，主要实现客户端业务，包括添加好友、点对点聊天、创建群组、添加群组、群组聊天业务，接下来我们一起来敲代码吧！
Oracle客户端开发工具Oracle SQL Handler
07-16
Oracle客户端开发工具Oracle SQL Handler
使用jaxws建立webservice客户端并实现soap消息的handler验证示例
09-04
主要介绍了使用jaxws建立webservice客户端并实现soap消息的handler验证示例,需要的朋友可以参考下
jquery下为Event handler传递动态参数的代码
10-28
在jquery cook book里看到一篇给event handler传递动态参数的文章 感觉挺实用的 跟大家分享下
Oracle客户端（Oracle SQL Handler）
08-20
Oracle SQL Handler，是专为 Oracle 数据库开发人员及操作人员精心打造的一款 Oracle 客户端工具： 超智能的SQL编辑器；超方便的表格操作（可以通过修改表格的单元格数据去更新数据 库表）；多种格式的数据导出包括...
Handler 总结
01-20
Handler机制原因，主线程looper.loop()为什么不阻塞主线程？ Handler，Message，looper 和 MessageQueue 构成了安卓的消息机制，handler创建后可以通过 sendMessage 将消息加入消息队列，然后 looper不断的将消息从 ...
java学习和项目总结
2301_79390585的博客
05-24 652
JRE：JRE是Java 运行时环境，主要包括了两个运行需要的组件：JVM 和 Java 核心类库，如果不进行java开发只想运行就可以只下载JRE。而Java语言，它的代码会先通过javac编译成字节码，再通过jvm将字节码转换成机器码（0和1）执行，即解释运行和编译运行配合使用，所以是混合型。在程序运行之前，通过编译器将源程序编译成机器码可运行的二进制，以后执行这个程序时，就不用再进行编译了。JVM：JVM是java进行编译的虚拟机，是Java 能够跨平台运行的核心。特点：执行速度慢、效率低；
Java高级面试精粹：问题与解答集锦（一）
Layla_c的博客
05-23 1404
答案多态是Java中的一个核心概念，它允许不同类的对象对同一消息做出响应，但具体的行为会根据对象的实际类型而有所不同。重载（Overloading）：当多个方法具有相同的名称，但参数列表不同时，这称为方法重载。编译器根据方法调用时传递的参数类型和数量来确定调用哪个方法。重写（Overriding）：当子类有一个与父类同名、同参数列表的方法时，子类可以提供特定的实现来覆盖父类的方法。运行时，Java虚拟机（JVM）会根据对象的实际类型调用相应的方法，这个过程称为动态绑定或晚期绑定。答案。
【java-数据结构19-队列的模拟实现】
2302_80519942的博客
05-21 810
（这个才是重点）同上，没有元素直接返回即可，只有一个元素（全部置空），普通情况（rear等于前驱，rear置为空），
数据访问与Spring Data JPA
最新发布
无远弗届
05-25 499
假设我们要处理一个用户表（users），可以创建一个User@Entity // 标识这是一个实体类 public class User {@Id // 标识这是主键字段 @GeneratedValue(strategy = GenerationType . AUTO) // 主键生成策略 private Long id;// Getter 和 Setter ... }@Entity // 标识这是一个实体类 public class User {
springboot netty handler类的实现
01-06
综上所述，通过在Spring Boot应用程序中实现Netty的handler类，可以实现客户端和服务端之间的消息传递和业务逻辑的处理。同时也可以充分利用Netty的高性能和可维护性来实现应用程序的高效运行。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值