netty:http+xml 的 demo

最新推荐文章于 2022-09-21 09:34:23 发布
原创 最新推荐文章于 2022-09-21 09:34:23 发布 · 519 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_38062410/article/details/79073166
netty5.0版本的，简单的一个例子，用于学习交流，废话不多说，直接上代码；

一，pom文件

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.dingw</groupId>
  <artifactId>testNetty-Http-Xml</artifactId>
  <packaging>war</packaging>
  <version>1.0-SNAPSHOT</version>
  <name>testNetty-Http-Xml Maven Webapp</name>
  <url>http://maven.apache.org</url>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.10</version>
      <scope>test</scope>
    </dependency>
    <dependency>
      <groupId>javax.servlet</groupId>
      <artifactId>servlet-api</artifactId>
      <version>2.3</version>
      <scope>provided</scope>
    </dependency>
    <dependency>
      <groupId>io.netty</groupId>
      <artifactId>netty-all</artifactId>
      <version>5.0.0.Alpha2</version>
    </dependency>
    <dependency>
      <groupId>com.google.protobuf</groupId>
      <artifactId>protobuf-java</artifactId>
      <version>3.0.0-alpha-2</version>
    </dependency>
    <dependency>
      <groupId>com.jcraft</groupId>
      <artifactId>jzlib</artifactId>
      <version>1.1.3</version>
      <scope>runtime</scope>
    </dependency>
    <dependency>
      <groupId>javax.servlet.jsp</groupId>
      <artifactId>jsp-api</artifactId>
      <version>2.2.1-b03</version>
    </dependency>
    <dependency>
      <groupId>com.barchart.udt</groupId>
      <artifactId>barchart-udt-core</artifactId>
      <version>2.3.0</version>
    </dependency>

    <!-- https://mvnrepository.com/artifact/org.jibx/jibx-bind -->
    <dependency>
      <groupId>org.jibx</groupId>
      <artifactId>jibx-bind</artifactId>
      <version>1.2.2</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.jibx.schema.org.jibx/org.jibx.schema.org.jibx.sampleschema.address -->
    <dependency>
      <groupId>org.jibx.schema.org.jibx</groupId>
      <artifactId>org.jibx.schema.org.jibx.sampleschema.address</artifactId>
      <version>1.1.4</version>
    </dependency>
    <!-- https://mvnrepository.com/artifact/org.jibx/maven-jibx-plugin -->
    <dependency>
      <groupId>org.jibx</groupId>
      <artifactId>maven-jibx-plugin</artifactId>
      <version>1.3.1</version>
    </dependency>

      <!-- https://mvnrepository.com/artifact/com.thoughtworks.xstream/xstream -->
      <dependency>
          <groupId>com.thoughtworks.xstream</groupId>
          <artifactId>xstream</artifactId>
          <version>1.4.10</version>
      </dependency>

      <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.11</version>
      <scope>test</scope>
  </dependency>

  </dependencies>
  <build>
    <finalName>netty</finalName>
  </build>
</project>
一.实体类(这里XML与javabean之间的转换用的XStream)
package com.dingw.bean;

import com.thoughtworks.xstream.annotations.XStreamAlias;

/**
 * @Author Dingwei
 * @Date 2018/1/14 22:11
 * @ClassName Address
 * @Description
 */
@XStreamAlias("billTo")
public class Address {
    private String street1;

    private String street2;

    private String city;

    private String state;

    private String postCode;

    private String country;

    public String getStreet1() {
        return street1;
    }

    public void setStreet1(String street1) {
        this.street1 = street1;
    }

    public String getStreet2() {
        return street2;
    }

    public void setStreet2(String street2) {
        this.street2 = street2;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    public String getState() {
        return state;
    }

    public void setState(String state) {
        this.state = state;
    }

    public String getPostCode() {
        return postCode;
    }

    public void setPostCode(String postCode) {
        this.postCode = postCode;
    }

    public String getCountry() {
        return country;
    }

    public void setCountry(String country) {
        this.country = country;
    }

    @Override
    public String toString() {
        return "Address [street1=" + street1 + ", street2=" + street2 + ", city=" + city + ", state=" + state
                + ", postCode=" + postCode + ", country=" + country + "]";
    }
}
package com.dingw.bean;

import com.thoughtworks.xstream.annotations.XStreamAsAttribute;

import java.util.List;

/**
 * @Author Dingwei
 * @Date 2018/1/14 22:09
 * @ClassName Customer
 * @Description
 */
public class Customer {
    @XStreamAsAttribute
    private long customerNumber;

    private String firstName;

    private String lastName;

    private List<String> middleNames;

    public long getCustomerNumber() {
        return customerNumber;
    }

    public void setCustomerNumber(long customerId) {
        this.customerNumber = customerId;
    }

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public List<String> getMiddleNames() {
        return middleNames;
    }

    public void setMiddleNames(List<String> middleNames) {
        this.middleNames = middleNames;
    }

    @Override
    public String toString() {
        return "Customer [customerNumber=" + customerNumber + ", firstName=" + firstName + ", lastName=" + lastName
                + ", middleNames=" + middleNames + "]";
    }

}
package com.dingw.bean;

import com.thoughtworks.xstream.annotations.XStreamAlias;
import com.thoughtworks.xstream.annotations.XStreamAsAttribute;

/**
 * @Author Dingwei
 * @Date 2018/1/14 22:06
 * @ClassName Order
 * @Description
 */
@XStreamAlias("order")
public class Order {
    @XStreamAsAttribute
    private long orderNumber;

    private Customer customer;

    private Address billTo;

    private Shipping shipping;

    private Address shipTo;
    @XStreamAsAttribute
    private Float total;

    public long getOrderNumber() {
        return orderNumber;
    }

    public void setOrderNumber(long orderId) {
        this.orderNumber = orderId;
    }

    public Customer getCustomer() {
        return customer;
    }

    public void setCustomer(Customer customer) {
        this.customer = customer;
    }

    public Address getBillTo() {
        return billTo;
    }

    public void setBillTo(Address billTo) {
        this.billTo = billTo;
    }

    public Shipping getShipping() {
        return shipping;
    }

    public void setShipping(Shipping shipping) {
        this.shipping = shipping;
    }

    public Address getShipTo() {
        return shipTo;
    }

    public void setShipTo(Address shipTo) {
        this.shipTo = shipTo;
    }

    public Float getTotal() {
        return total;
    }

    public void setTotal(Float total) {
        this.total = total;
    }

    @Override
    public String toString() {
        return "Order [orderNumber=" + orderNumber + ", customer=" + customer + ", billTo=" + billTo + ", shipping="
                + shipping.toString() + ", shipTo=" + shipTo + ", total=" + total + "]";
    }

}
package com.dingw.bean;

/**
 * @Author Dingwei
 * @Date 2018/1/14 22:13
 * @ClassName Shipping
 * @Description
 */
public enum Shipping {
    STANDARD_MALL,PRIORITY_MALL,INTERNATIONAL_MAIL,DOMESTIC_EXPRESS,
    INTERANATIONAL_EXPRESS
}
package com.dingw.bean;

/**
 * @Author Dingwei
 * @Date 2018/1/15 9:54
 * @ClassName OrderFactory
 * @Description
 */
public class OrderFactory {
    public static Order create(long orderID) {
        Order order = new Order();
        order.setOrderNumber(orderID);
        order.setTotal(9999.999f);
        Address address = new Address();
        address.setCity("南京市");
        address.setCountry("中国");
        address.setPostCode("123321");
        address.setState("江苏省");
        address.setStreet1("龙眠大道");
        order.setBillTo(address);
        Customer customer = new Customer();
        customer.setCustomerNumber(orderID);
        customer.setFirstName("李");
        customer.setLastName("林峰");
        order.setCustomer(customer);
        order.setShipping(Shipping.INTERNATIONAL_MAIL);
        order.setShipTo(address);
        return order;
    }
}

二.客户端启动类
package com.dingw.bean;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.*;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.HttpRequestEncoder;
import io.netty.handler.codec.http.HttpResponseDecoder;

import java.net.InetSocketAddress;

/**
 * @Author Dingwei
 * @Date 2018/1/15 9:51
 * @ClassName HttpXmlClient
 * @Description
 */
public class HttpXmlClient {
    public void connect(int port) throws Exception {
        EventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap b = new Bootstrap();
            b.group(group).channel(NioSocketChannel.class).option(ChannelOption.TCP_NODELAY, true)
                    .handler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        public void initChannel(SocketChannel ch) throws Exception {
                            // xml解码器
                            ch.pipeline().addLast("http-decoder", new HttpResponseDecoder());
                            ch.pipeline().addLast("http-aggregator", new HttpObjectAggregator(65536));
                            ch.pipeline().addLast("xml-decoder", new HttpXmlResponseDecoder(Order.class, true));
                            ch.pipeline().addLast("http-encoder", new HttpRequestEncoder());
                            // xml编码器
                            ch.pipeline().addLast("xml-encoder", new HttpXmlRequestEncoder());
                            ch.pipeline().addLast("xmlClientHandler", new HttpXmlClientHandle());
                        }
                    });
            ChannelFuture f = b.connect(new InetSocketAddress(port)).sync();
            f.channel().closeFuture().sync();
        } finally {
            group.shutdownGracefully();
        }
    }

    public static void main(String[] args) throws Exception {
        int port = 8080;
        if (args != null && args.length > 0) {
            try {
                port = Integer.valueOf(args[0]);
            } catch (NumberFormatException e) {
            }
        }
        new HttpXmlClient().connect(port);
    }
}
三.客户端handler
package com.dingw.bean;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.handler.codec.http.FullHttpResponse;

/**
 * @Author Dingwei
 * @Date 2018/1/15 9:53
 * @ClassName HttpXmlClientHandle
 * @Description
 */
public class HttpXmlClientHandle extends SimpleChannelInboundHandler<HttpXmlResponse> {
    @Override
    public void channelActive(ChannelHandlerContext ctx) {
        // 给客户端发送请求消息，HttpXmlRequest包含FullHttpRequest和Order这个了类
        HttpXmlRequest request = new HttpXmlRequest(null, OrderFactory.create(123));
        ctx.writeAndFlush(request);
        System.out.println("客户端：向服务端发送消息完成");
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) {
        cause.getMessage();
        cause.printStackTrace();
        ctx.close();
    }

    @Override
    protected void messageReceived(ChannelHandlerContext ctx, HttpXmlResponse msg) throws Exception {
        System.out.println("接收到服务端的响应");
        System.out.println("The client receive response of http header is : " + msg.getFullHttpResponse().headers().names());
        System.out.println("The client receive response of http body is : " + msg.getResult());
    }
}
四.服务端启动类
package com.dingw.bean;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.HttpRequestDecoder;
import io.netty.handler.codec.http.HttpResponseEncoder;

import java.net.InetSocketAddress;

/**
 * @Author Dingwei
 * @Date 2018/1/15 9:59
 * @ClassName HttpXmlServer
 * @Description
 */
public class HttpXmlServer {
    public void run(final int port) throws Exception {
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline().addLast("http-decoder", new HttpRequestDecoder());
                            ch.pipeline().addLast("http-aggregator", new HttpObjectAggregator(65536));
                            ch.pipeline().addLast("xml-decoder", new HttpXmlRequestDecoder(Order.class, true));
                            ch.pipeline().addLast("http-encoder", new HttpResponseEncoder());
                            ch.pipeline().addLast("xml-encoder", new HttpXmlResponseEncoder());
                            ch.pipeline().addLast("xmlServerHandler", (ChannelHandler) new HttpXmlServerHandler());
                        }
                    });
            ChannelFuture future = b.bind(new InetSocketAddress(port)).sync();
            System.out.println("HTTP订购服务器启动，网址是 :  " + "http://localhost:" + port);
            future.channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }

    public static void main(String[] args) throws Exception {
        int port = 8080;
        if (args.length > 0) {
            try {
                port = Integer.parseInt(args[0]);
            } catch (NumberFormatException e) {
                e.printStackTrace();
            }
        }
        new HttpXmlServer().run(port);
    }
}
五.服务端handler
package com.dingw.bean;

import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.handler.codec.http.DefaultFullHttpResponse;
import io.netty.handler.codec.http.FullHttpResponse;
import io.netty.handler.codec.http.HttpRequest;
import io.netty.handler.codec.http.HttpResponseStatus;
import io.netty.util.CharsetUtil;
import io.netty.util.concurrent.Future;
import io.netty.util.concurrent.GenericFutureListener;

import java.util.ArrayList;
import java.util.List;

import static io.netty.handler.codec.http.HttpHeaderNames.CONNECTION;
import static io.netty.handler.codec.http.HttpHeaderNames.CONTENT_TYPE;
import static io.netty.handler.codec.http.HttpHeaderValues.KEEP_ALIVE;
import static io.netty.handler.codec.http.HttpResponseStatus.INTERNAL_SERVER_ERROR;
import static io.netty.handler.codec.http.HttpVersion.HTTP_1_1;

/**
 * @Author Dingwei
 * @Date 2018/1/15 10:01
 * @ClassName HttpXmlServerHandler
 * @Description
 */
public class HttpXmlServerHandler extends SimpleChannelInboundHandler<HttpXmlRequest> {
    @Override
    public void messageReceived(final ChannelHandlerContext ctx, HttpXmlRequest xmlRequest) throws Exception {
        System.out.println("服务端接收到客户端发送过来的数据");
        HttpRequest request = xmlRequest.getRequest();
        Order order = (Order) xmlRequest.getBody();
        // 输出解码获得的Order对象
        System.out.println("Http server receive request : " + order);
        dobusiness(order);
        System.out.println(order);
        //向客户端发送应答消息
        System.out.println("服务端向客户端：开始响应数据");
        ChannelFuture future = ctx.writeAndFlush(new HttpXmlResponse(null, order));
        System.out.println("服务端向客户端：响应数据完成");
        if (request.headers().get(CONNECTION) != KEEP_ALIVE) {
            future.addListener(new GenericFutureListener<Future<? super Void>>() {
                public void operationComplete(Future future) throws Exception {
                    ctx.close();
                }
            });
        }
    }

    private void dobusiness(Order order) {
        order.getCustomer().setFirstName("狄");
        order.getCustomer().setLastName("仁杰");
        List<String> midNames = new ArrayList<String>();
        midNames.add("李元芳");
        order.getCustomer().setMiddleNames(midNames);
        Address address = order.getBillTo();
        address.setCity("洛阳");
        address.setCountry("大唐");
        address.setState("河南道");
        address.setPostCode("123456");
        order.setBillTo(address);
        order.setShipTo(address);
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        // 在链路没有关闭并且出现异常的时候发送给客户端错误信息
        if (ctx.channel().isActive()) {
            sendError(ctx, INTERNAL_SERVER_ERROR);
        }
    }

    private static void sendError(ChannelHandlerContext ctx, HttpResponseStatus status) {
        FullHttpResponse response = new DefaultFullHttpResponse(HTTP_1_1, status,
                Unpooled.copiedBuffer("失败: " + status.toString() + "\r\n", CharsetUtil.UTF_8));
        response.headers().set(CONTENT_TYPE, "text/plain; charset=UTF-8");
        ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);
    }
}
六.所有的编解码类及请求和响应对象的封装类(都有注解就不区分说明了)
package com.dingw.bean;

import io.netty.handler.codec.http.FullHttpRequest;

/**
 * @Author Dingwei
 * @Date 2018/1/15 9:54
 * @ClassName HttpXmlRequest
 * @Description 封装一个HttpXml请求对象
 */
public class HttpXmlRequest {
    /**
     * 两个成员变量FullHttpRequest和编码对象Object，用于实现和协议栈之间的解耦
     */
    private FullHttpRequest request;
    private Object body;

    public HttpXmlRequest(FullHttpRequest request, Object body) {
        this.request = request;
        this.body = body;
    }

    public final FullHttpRequest getRequest() {
        return request;
    }

    public final void setRequest(FullHttpRequest request) {
        this.request = request;
    }

    public final Object getBody() {
        return body;
    }

    public final void setBody(Object body) {
        this.body = body;
    }

    @Override
    public String toString() {
        return "HttpXmlRequest [request=" + request + ", body =" + body + "]";
    }
}
package com.dingw.bean;

import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelFutureListener;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.http.DefaultFullHttpResponse;
import io.netty.handler.codec.http.FullHttpRequest;
import io.netty.handler.codec.http.FullHttpResponse;
import io.netty.handler.codec.http.HttpResponseStatus;
import io.netty.util.CharsetUtil;

import java.util.List;

import static io.netty.handler.codec.http.HttpHeaderNames.CONTENT_TYPE;
import static io.netty.handler.codec.http.HttpResponseStatus.BAD_REQUEST;
import static io.netty.handler.codec.http.HttpVersion.HTTP_1_1;

/**
 * @Author Dingwei
 * @Date 2018/1/15 10:00
 * @ClassName HttpXmlRequestDecoder
 * @Description 请求消息解码器，HTTP服务器接收到 http+xml请求消息后，需要从HTTP消息体获取请求码流，然后反序列化，得到实体对象和HTTP消息头
 */
public class HttpXmlRequestDecoder extends AbstractHttpXmlDecoder<FullHttpRequest> {
    public HttpXmlRequestDecoder(Class<?> clazz) {
        this(clazz, false);
    }

    public HttpXmlRequestDecoder(Class<?> clazz, boolean isPrint) {
        super(clazz, isPrint);
    }

    @Override
    protected void decode(ChannelHandlerContext arg0, FullHttpRequest arg1, List<Object> arg2) throws Exception {
        // 对HTTP请求消息本身的解码结果进行判断，如果已经解码失败，再对消息体进行二次解码已经没有意义
        if (!arg1.decoderResult().isSuccess()) {
            sendError(arg0, BAD_REQUEST);
            return;
        }
        // 通过HttpsdXmlRequest和反序列化后的Order对象构造HttpXmlRequest实例
        HttpXmlRequest request = new HttpXmlRequest(arg1, decode0(arg0, arg1.content()));
        // 将请求交给下一个解码器处理
        arg2.add(request);
    }

    private static void sendError(ChannelHandlerContext ctx, HttpResponseStatus status) {
        FullHttpResponse response = new DefaultFullHttpResponse(HTTP_1_1, status,
                Unpooled.copiedBuffer("Failure: " + status.toString() + "\r\n", CharsetUtil.UTF_8));
        response.headers().set(CONTENT_TYPE, "text/plain; charset=UTF-8");
        ctx.writeAndFlush(response).addListener(ChannelFutureListener.CLOSE);
    }
}
package com.dingw.bean;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.http.*;

import java.net.InetAddress;
import java.util.List;

/**
 * @Author Dingwei
 * @Date 2018/1/15 9:54
 * @ClassName HttpXmlRequestEncoder
 * @Description 请求消息编码类
 */
public class HttpXmlRequestEncoder extends AbstractHttpXmlEncoder<HttpXmlRequest> {
    @Override
    protected void encode(ChannelHandlerContext ctx, HttpXmlRequest msg, List<Object> out) throws Exception {
        // 调用父类的encode0方法将Order对象转换为xml字符串，并将其封装为ByteBuf
        ByteBuf body = encode0(ctx, msg.getBody());
        FullHttpRequest request = msg.getRequest();
        System.out.println("encode0方法将Order对象转换为xml字符串，并将其封装为ByteBuf"+request);
        // 对请求消息头进行判断，如果业务层自定义和定制了消息头，则使用自定义的，如request为空，则新建一个FullHttpRequest对象，并将设置消息头
        if (request == null) {
            // 在构造方法中，将body设置为请求消息体
            request = new DefaultFullHttpRequest(HttpVersion.HTTP_1_1, HttpMethod.GET, "/do", body);
            HttpHeaders headers = request.headers();
            // 表示请求的服务器网址
            headers.set(HttpHeaderNames.HOST, InetAddress.getLocalHost().getHostAddress());
            // Connection表示客户端与服务连接类型；Keep-Alive表示长连接；CLOSE表示短连接
            // header中包含了值为close的connection，都表明当前正在使用的tcp链接在请求处理完毕后会被断掉。
            // 以后client再进行新的请求时就必须创建新的tcp链接了。
            headers.set(HttpHeaderNames.CONNECTION, HttpHeaderValues.CLOSE);
            // 浏览器支持的压缩编码是 gzip 和 deflate
            headers.set(HttpHeaderNames.ACCEPT_ENCODING,
                    HttpHeaderValues.GZIP.toString() + ',' + HttpHeaderValues.DEFLATE.toString());
            // 浏览器支持的解码集
            headers.set(HttpHeaderNames.ACCEPT_CHARSET, "ISO-8859-1,utf-8;q=0.7,*;q=0.7");
            // 浏览器支持的语言
            headers.set(HttpHeaderNames.ACCEPT_LANGUAGE, "zh");
            // 使用的用户代理是 Netty xml Http Client side
            headers.set(HttpHeaderNames.USER_AGENT, "Netty xml Http Client side");
            // 浏览器支持的 MIME类型,优先顺序为从左到右
            headers.set(HttpHeaderNames.ACCEPT, "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8");
        }
        /**
         * 由于HTTP请求消息体不能为空，也没有使用chunk方式，所以要在Http消息投中设置消息体长度CONTENT_LENGTH
         */
        request.headers().setInt(HttpHeaderNames.CONTENT_LENGTH, body.readableBytes());
        // 将请求消息添加进out中，待后面的编码器对消息进行编码
        out.add(request);
    }

}
package com.dingw.bean;

import io.netty.handler.codec.http.FullHttpResponse;

/**
 * @Author Dingwei
 * @Date 2018/1/15 10:14
 * @ClassName HttpXmlResponse
 * @Description 封装一个HttpXml应答对象
 */
public class HttpXmlResponse {
    private FullHttpResponse fullHttpResponse;
    //业务需要发送的应答POJO对象
    private Object result;

    public HttpXmlResponse(FullHttpResponse fullHttpResponse, Object result) {
        this.fullHttpResponse = fullHttpResponse;
        this.result = result;
    }

    public HttpXmlResponse() {
    }

    @Override
    public String toString() {
        return "HttpXmlResponse{" +
                "fullHttpResponse=" + fullHttpResponse +
                ", result=" + result +
                '}';
    }

    public FullHttpResponse getFullHttpResponse() {
        return fullHttpResponse;
    }

    public void setFullHttpResponse(FullHttpResponse fullHttpResponse) {
        this.fullHttpResponse = fullHttpResponse;
    }

    public Object getResult() {
        return result;
    }

    public void setResult(Object result) {
        this.result = result;
    }
}
package com.dingw.bean;

import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.http.DefaultFullHttpResponse;
import io.netty.handler.codec.http.FullHttpResponse;

import java.util.List;

/**
 * @Author Dingwei
 * @Date 2018/1/15 10:09
 * @ClassName HttpXmlResponseDecoder
 * @Description 应答消息解码类
 */
public class HttpXmlResponseDecoder extends AbstractHttpXmlDecoder<FullHttpResponse> {


    protected HttpXmlResponseDecoder(Class<?> clazz) {
        super(clazz,false);
    }
    public HttpXmlResponseDecoder(Class<?> clazz,boolean isPrintlong){
        super(clazz,isPrintlong);
    }

    protected void decode(ChannelHandlerContext ctx, FullHttpResponse msg, List<Object> out) throws Exception {
        System.out.println("应答消息解码类： 开始解码");
        HttpXmlResponse httpXmlResponse = new HttpXmlResponse(msg, decode0(ctx, msg.content()));
        out.add(httpXmlResponse);
        System.out.println("应答消息解码类： 解码完成");
    }
}
package com.dingw.bean;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.http.DefaultFullHttpResponse;
import io.netty.handler.codec.http.FullHttpResponse;

import java.util.List;

import static io.netty.handler.codec.http.HttpHeaderNames.CONTENT_LENGTH;
import static io.netty.handler.codec.http.HttpHeaderNames.CONTENT_TYPE;
import static io.netty.handler.codec.http.HttpResponseStatus.OK;
import static io.netty.handler.codec.http.HttpVersion.HTTP_1_1;

/**
 * @Author Dingwei
 * @Date 2018/1/15 10:02
 * @ClassName HttpXmlResponseEncoder
 * @Description 应答消息编码类
 */
public class HttpXmlResponseEncoder extends AbstractHttpXmlEncoder<HttpXmlResponse> {
    protected void encode(ChannelHandlerContext ctx, HttpXmlResponse msg, List<Object> out) throws Exception {
        ByteBuf body = encode0(ctx, msg.getResult());
        FullHttpResponse response = msg.getFullHttpResponse();
        if (response == null) {
            response = new DefaultFullHttpResponse(HTTP_1_1, OK, body);
        } else {
            response = new DefaultFullHttpResponse(msg.getFullHttpResponse().protocolVersion(),
                    msg.getFullHttpResponse().status(), body);
        }
        response.headers().set(CONTENT_TYPE, "text/xml");
        response.headers().setInt(CONTENT_LENGTH, body.readableBytes());
        out.add(response);
        System.out.println("应答消息编码类 编码完成");
    }

}
package com.dingw.bean;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelHandler;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.http.HttpObjectAggregator;
import io.netty.handler.codec.http.HttpRequestDecoder;
import io.netty.handler.codec.http.HttpResponseEncoder;

import java.net.InetSocketAddress;

/**
 * @Author Dingwei
 * @Date 2018/1/15 9:59
 * @ClassName HttpXmlServer
 * @Description
 */
public class HttpXmlServer {
    public void run(final int port) throws Exception {
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup, workerGroup).channel(NioServerSocketChannel.class)
                    .childHandler(new ChannelInitializer<SocketChannel>() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline().addLast("http-decoder", new HttpRequestDecoder());
                            ch.pipeline().addLast("http-aggregator", new HttpObjectAggregator(65536));
                            ch.pipeline().addLast("xml-decoder", new HttpXmlRequestDecoder(Order.class, true));
                            ch.pipeline().addLast("http-encoder", new HttpResponseEncoder());
                            ch.pipeline().addLast("xml-encoder", new HttpXmlResponseEncoder());
                            ch.pipeline().addLast("xmlServerHandler", (ChannelHandler) new HttpXmlServerHandler());
                        }
                    });
            ChannelFuture future = b.bind(new InetSocketAddress(port)).sync();
            System.out.println("HTTP订购服务器启动，网址是 :  " + "http://localhost:" + port);
            future.channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }

    public static void main(String[] args) throws Exception {
        int port = 8080;
        if (args.length > 0) {
            try {
                port = Integer.parseInt(args[0]);
            } catch (NumberFormatException e) {
                e.printStackTrace();
            }
        }
        new HttpXmlServer().run(port);
    }
}
 

HTTP+XML方式接口数据传输
yingwen_lv625的专栏
11-24 9911
<br />一.客户端<br />1.请求URL；如http://10.46.34.233/fcgi-bin/UIG_SFC_186<br />2.发送请求数据<br />{<br />   组装报文格式发送信息<br />   StringBuffer sendStr = new StringBuffer(1024);<br />   sendStr.append("<?xml version=/"1.0/" encoding=/"GBK/"?>");<br />   sendStr.append("<o
Springboot集成netty,通过udp协议传输xml报文(自己把坑踩了一遍)
weixin_40924712的博客
12-13 1154
Springboot集成Netty用UDP协议传送XML报文（亲自踩过所有坑）
http请求网络解析xml以及JSON的demo
06-05
http请求网络的demo，实现httpUrlConnection与httpClient两种请求方式，并对返回数据进行解析，解析xml和JSON两种格式的数据。
java httpclient post xml demo
02-15 207
jar archive:http://archive.apache.org/dist/httpcomponents/ 基于httpclient 2.0 final的demo(for jdk1.5/1.6): http://alvinalexander.com/java/jwarehouse/commons-httpclient-2.0/src/examples/Pos...
读书笔记：《Netty权威指南》Http+XML协议Demo.zip
最新发布
07-23
读书笔记：《Netty权威指南》Http+XML协议Demo
深入Netty：探索Http与XML协议的实践示例
本压缩包包含了与《Netty权威指南》相关的读书笔记以及一个基于HTTP与XML协议交互的Demo示例，这一Demo示例能够帮助读者更好地理解Netty在实际开发中的应用场景。 HTTP协议（HyperText Transfer Protocol）是互联网...
springboot整合netty的demo
01-22
在SpringBoot项目中，我们可以通过添加对应的依赖来引入Netty，例如在`pom.xml`中加入`spring-boot-starter-webflux`，这个依赖集成了Reactor Netty，它是Spring Framework 5.x对响应式编程的支持，底层就是基于...
netty-all-5.0.0.Alpha3 完整pom.xml配置
08-16
这个“netty-all-5.0.0.Alpha3 完整pom.xml配置”是针对Netty 5.0.0 Alpha3版本的集成配置，包含了该版本所需的全部依赖项，便于开发者在基于Maven的项目中直接引用，避免了手动管理多个jar文件的繁琐过程。...
精选资源
Netty的简单入门demo
08-07
使用之前需要配置pom.xml <groupId>junit <artifactId>junit <version>4.6 <scope>test <!-- https://mvnrepository.com/artifact/io.netty/netty-all --> <groupId>io.netty <artifactId>netty-all ...
解析Xml&Http请求DEMO
12-23
一个简单的使用HTTP请求获得XML文档并解析的例子
接口测试（HTTP + XML）
09-24
提交xml报文到需要测试的接口，显示返回的信息
HTTP + XML 报文的接口开发
TomyGuan的专栏
03-04 5018
好多朋友问我HTTP +XML报文接口怎样做，客户端怎样写，服务端怎样写。我想应该是这样的：服务端：InputStream in = request.getInputStream();        SAXReader saxReader = new SAXReader();        InputStreamReader strInStream = new InputStreamR
Netty实现http+xml 协议开发
qq_38796051的博客
09-21 991
由于HTTP协议的通用性，很多异构系统间的通信交互采用HTTP协议，通过HTTP协议承载业务数据进行消息交互，例如非常流行的HTTP+XML或者。在Java领域，最常用的HTTP协议栈就是基于Servlet规范的Tomcat等Web容器，由于谷歌等业界大佬的强力推荐，Jetty等轻量级的Web容器也得到了广泛的应用，但是，很多基于HTTP的应用都是后台应用，HTTP仅仅是承载数据交换的通道，是一个载体而不是一个容器，在这种场景下，一般不需要类似Tomcat这样的重量型的Web容器。
Netty+HTTP+XML框架开发
qq_40213824的博客
01-04 707
HTTP简单介绍：http是属于应用层的面向对象传输协议，适用于分布式超媒体信息系统。 HTTP的特点： （1）支持client/server模式 （2）简单 （3）灵活 （4）无状态 HTTP请求消息： （1）请求行 （2）请求头 （3）请求体 HTTP响应消息： （1）状态行 （2）消息报头 （3）响应正文 Netty+HTTP+XML实战： 1.对象和工具类准备 package com.netty.wcy20210713.netty02; import com.ne
原生 XMLHttpRequest 请求 Demo
David
07-05 1026
<!DOCTYPE html> <html lang="en" xmlns="http://www.w3.org/1999/xhtml"> <head> <meta charset="utf-8" /> <title>Native Ajax</title> <script> ...
netty-netty实现http+xml协议
面朝大海，春暖花开
02-07 828
netty-netty实现http+xml协议 摘自<netty权威指南> http+xml协议设计 请求响应流程 1.client构造HttpXmlRequest,由http和xml数据组成 2.client发起请求，通过http协议发送http请求 client --------------------------------------------...
netty学习一:用netty构造http服务的小demo
Sam_Deep_Thinking
07-23 3582
概述netty可以支持http、socket、websocket,本文会做一个小demo，简单介绍一下如何用netty搭建一个http服务。netty虽然可以提供http服务，但是相比spring mvc、struts2等框架，netty显得比较底层，很多spring mvc提供的功能，netty统统都没有。步骤编写netty程序的步骤都比较相似： 1、 启动group监听客户端请求 2、编写I
（NIO-框架）--Netty（四）http+xml协议栈的开发
liuyancainiao的博客
07-19 953
书上有关用ant加上JIBX去绑定java class文件和xml文件这段讲的太少了，而且还不全，我又没用过ant还有JIBX，我尝试了很多次才成功实现了ant基于build.xml去绑定二者的功能，为了避免大家和我遇到一样的问题，我把这一部分粘出来，大家可以做个参考 这是build.xml，没用过ant很多东西都是瞎搞出来的，这个build.xml是我去那本书的源码上拷贝了一份，就书上那点屁用...
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值