netty https 客户端 + 服务端 代码案例实现

最新推荐文章于 2024-09-05 08:00:00 发布
最新推荐文章于 2024-09-05 08:00:00 发布
阅读量1.5k 收藏 3
点赞数
分类专栏： netty 文章标签： https ssl java netty
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_22185423/article/details/126272585
版权

netty https 客户端 + 服务端 代码案例实现

最近在写微信扫码交易挡板的时候遇到如下问题，由于微信的撤销、退款交易需要用到.p12格式的证书（客户端在交易请求的时候用到了），一直看不懂微信demo中的 “ sslContext.init(kmf.getKeyManagers(), null, new SecureRandom());” 这行代码啥意思，现在才了解到HTTPS的单认证，双认证的含义，主要是微信这里和网上其他的认证不通，这个是服务端的单认证模式（网上其他大多数是客户端认证模式）

HTTPS 认证

1. SSL单向认证的过程总结如下:

SSL单向认证的过程总结如下:
1.SSL客户端向服务端传送客户端SSL协议的版本号、支持的加密算法种类、产生的随机数,以及其他可选信息;
2.服务端返回握手应答,向客户端传送确认SSL协议的版本号、加密算法的种类随机数以及其他相关信息;
3.服务端向客户端发送自己的公钥;
4.客户端对服务端的证书进行认证,服务端的合法性校验包括:证书是否过期、发行服务器证书的CA是否可靠、发行者证书的公钥能否正确解开服务器证书的“发行者的数字签名”、服务器证书上的域名是否和服务器的实际域名相匹配等;
5.客户端随机产生一个用于后面通讯的“对称密码”,然后用服务端的公钥对其加密,将加密后的“预主密码”传给服务端;
6.服务端将用自己的私钥解开加密的“预主密码”,然后执行一系列步骤来产生主密码;
7.客户端向服务端发岀信息,指明后面的数据通讯将使用主密码为对称密钥,同时通知服务器客户端的握手过程结束;
8.服务端向客户端发出信息,指明后面的数据通讯将使用主密码为对称密钥,同时通知客户端服务器端的握手过程结束；
9.SSL的握手部分结束,SSL安全通道建立,客户端和服务端开始使用相同的对称密钥对数据进行加密,然后通过 Socket进行传输。

注释：
对于第4点，微信正好相反，.p12证书是微信发布给客户的，即服务端需要的是服务端对客户端的认证，sslContext.init(kmf.getKeyManagers(), null, new SecureRandom())，这个是客户端的代码，第二个参数是null，表示客户端不需要验证服务端，即在写服务端的代码的时候，第二个要写参数，验证的是客户端（即客户端用的证书是否是微信发布的）

2. 双向认证

SSL双向认证相比单向认证,多了一步服务端发送认证请求消息给客户端,客户端发送自签名证书给服务端进行安全认证的过程

https单双向的认证可自行百度更详细的说明，下面开始具体的代码和步骤

引用的步骤主要是如下链接（其他人的） “Netty进行SSL认证” 链接: link
上面的步骤是双向认证的，现我粘贴如下并加入部分注解

3. 证书准备

第一步:   生成Netty服务端私钥和证书仓库命令，用于将客户端的证书保存到服务端的授信证书仓库中 
   （这部生成的是服务端的证书仓库，仓库里面服务端的私钥信息，后面的步骤会吧客户端的公钥放在这个仓库中，服务端用仓库的公钥验证客户端的证书的正确性）
   
 keytool -genkey -alias securechat -keysize 2048 -validity 365 -keyalg RSA -dname "CN=localhost" -keypass sNetty -storepass sNetty -keystore sChat.jks
 
第二步：生成Netty服务端自签名证书 用于颁给使用者 从 证书仓库中导出证书（从服务端的证书仓库中（即里面的私钥信息）导出公钥证书，这个cer公钥证书导入客户端的证书仓库中，客户端用于验证服务端的证书信息）
 
keytool -export -alias securechat -keystore sChat.jks -storepass sNetty -file sChat.cer
 
 第三步：生成客户端的私钥和证书仓库，用于将服务端的证书保存到客户端的授信证书仓库中 （步骤同第一步一样，只不过这个是客户端的证书仓库而已）
 
    keytool -genkey -alias smcc -keysize 2048 -validity 365  -keyalg RSA -dname "CN=localhost" -keypass sNetty  -storepass sNetty -keystore cChat.jks
 
第四步:生成客户端自签名证书（步骤同第二步一样，这个cer公钥证书导入服务端的证书仓库中，服务端用于验证客户端的证书信息）
 
  keytool -export -alias smcc -keystore cChat.jks -storepass sNetty -file cChat.cer
 
第五步：将Netty服务端证书导入到客户端的证书仓库中
 
keytool -import -trustcacerts -alias securechat -file sChat.cer -storepass sNetty -keystore cChat.jks
 
第六步:将客户端的自签名证书导入到服务端的信任证书仓库中：
 
   keytool -import -trustcacerts -alias smcc -file cChat.cer -storepass sNetty -keystore sChat.jks
 
 即上面的6部后，我们只要使用两个证书即可，即sChat.jks，cChat.jks
sChat.jks 中有服务端的私钥证书 + 客户端的公钥证书；这个证书用在服务端
cChat.jks 中有客户端的私钥证书 + 服务端的公钥证书；这个证书用在客户端
 
 -keysize 2048 密钥长度2048位（这个长度的密钥目前可认为无法被暴力破解）
-validity 365 证书有效期365天
-keyalg RSA 使用RSA非对称加密算法
-dname "CN=localhost" 设置Common Name为localhost
-keypass sNetty密钥的访问密码为sNetty
-storepass sNetty密钥库的访问密码为sNetty（其实这两个密码也可以设置一样，通常都设置一样，方便记）
-keystore sChat.jks 指定生成的密钥库文件为sChata.jks

4. 代码

4.1 公共代码

package edu.mi.oneway;
 
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.security.KeyStore;
 
import javax.net.ssl.KeyManagerFactory;
import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManagerFactory;
 
public final class SecureChatSslContextFactory {
 
    private static final String PROTOCOL = "TLS";
 
    private static SSLContext SERVER_CONTEXT;//服务器安全套接字协议
 
    private static SSLContext CLIENT_CONTEXT;//客户端安全套接字协议
 
    //服务端使用
    public static SSLContext getServerContext(String pkPath){
        if(SERVER_CONTEXT!=null) return SERVER_CONTEXT;
        InputStream in =null;
 
        try{
            //密钥管理器
            KeyManagerFactory kmf = null;
            if(pkPath!=null){
                //密钥库KeyStore
               // KeyStore.getDefaultType()
                KeyStore ks = KeyStore.getInstance("JKS");
                //加载服务端证书
                in = new FileInputStream(pkPath);
                //加载服务端的KeyStore  ；sNetty是生成仓库时设置的密码，用于检查密钥库完整性的密码
                ks.load(in, "sNetty".toCharArray());
 
                kmf = KeyManagerFactory.getInstance("SunX509");
                //初始化密钥管理器
                kmf.init(ks, "sNetty".toCharArray());
            }
            //获取安全套接字协议（TLS协议）的对象
            SERVER_CONTEXT= SSLContext.getInstance(PROTOCOL);
            //初始化此上下文
            //参数一：认证的密钥（服务端的私钥）
            // 参数二：对等信任认证 （客户端的公约，已导入到sChat.jks证书仓库中了）
            // 参数三：伪随机数生成器 。 ，
            
            //1、客户端认证服务端的 单认证模式(服务端不用验证客户端，所以第二个参数为null)
            SERVER_CONTEXT.init(kmf.getKeyManagers(), null, null);

            //2、如果要服务端的单认证或双认证模式，使用如下代码,(服务端需要验证客户端，所以第二个参数不能为null)) 
            //SERVER_CONTEXT.init(kmf.getKeyManagers(),  tf.getTrustManagers(), null);
            
            //tf.getTrustManagers()的获取如下:
            /*
            TrustManagerFactory tf = null;
            if (pkPath!= null) {
                //密钥库KeyStore
                KeyStore tks = KeyStore.getInstance("JKS");
                //加载客户端证书
                tIN = new FileInputStream(pkPath);    //（客户端的公约，已导入到sChat.jks证书仓库中了）
                tks.load(tIN, "sNetty".toCharArray());
                tf = TrustManagerFactory.getInstance("SunX509");
                // 初始化信任库
                tf.init(tks);
            }
            */
       //SERVER_CONTEXT.init(参数1，参数2，参数3)
       //说明： 参数1 主要是https交换密钥的 加密的私钥信息，
       //       参数2 主要是验证信息，即用参数1的私钥加密后，用参数2的公钥解密，能解开 即验证成功了（秘钥验证成功了）
       //       参数3  生成的密钥随机数
        }catch(Exception e){
            throw new Error("Failed to initialize the server-side SSLContext", e);
        }finally{
            if(in !=null){
                try {
                    in.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
 
        }
        return SERVER_CONTEXT;
    }
 
    //客户端使用
    public static SSLContext getClientContext(String caPath){
        if(CLIENT_CONTEXT!=null) return CLIENT_CONTEXT;
 
        InputStream tIN = null;
        try{
            //信任库
            TrustManagerFactory tf = null;
            if (caPath != null) {
                //密钥库KeyStore
                KeyStore tks = KeyStore.getInstance("JKS");
                //加载客户端证书
                tIN = new FileInputStream(caPath);
                tks.load(tIN, "sNetty".toCharArray());
                tf = TrustManagerFactory.getInstance("SunX509");
                // 初始化信任库
                tf.init(tks);
            }
 
            CLIENT_CONTEXT = SSLContext.getInstance(PROTOCOL);
            //1、设置信任证书，这个原理同服务端的介绍，下面的是单认证模式，为客户端的单认证模式，客户端认证服务端的证书是否正确，cChat.jks 中有服务端的公约了，即可以认证了
            CLIENT_CONTEXT.init(null, tf.getTrustManagers(), null);
 
            //2、如何需要服务端的单认证模式，即服务端认证客户端的证书的正确性（第一个参数不能为null），单客户端不需要认证服务端的正确性，那第二个参数就可以为null
            //CLIENT_CONTEXT.init(kmf.getKeyManagers(),  null, null); 
            //其中kmf.getKeyManagers() 获取如下：
            /*
			if(caPath !=null){
                //密钥库KeyStore
               // KeyStore.getDefaultType()
                KeyStore ks = KeyStore.getInstance("JKS");
                //加载服务端证书
                in = new FileInputStream(caPath );
                //加载服务端的KeyStore  ；sNetty是生成仓库时设置的密码，用于检查密钥库完整性的密码
                ks.load(in, "sNetty".toCharArray());
 
                kmf = KeyManagerFactory.getInstance("SunX509");
                //初始化密钥管理器
                kmf.init(ks, "sNetty".toCharArray());
            }
			*/
         
          //3、如果需要双认证模式，代码如下
          //CLIENT_CONTEXT.init(kmf.getKeyManagers(),  tf.getTrustManagers(), null);
            

        }catch(Exception e){
            e.printStackTrace();
            throw new Error("Failed to initialize the client-side SSLContext");
        }finally{
            if(tIN !=null){
                try {
                    tIN.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
 
        return CLIENT_CONTEXT;
    }
 
}

4.2 客户端

import java.io.BufferedReader;
import java.io.InputStreamReader;
 
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.Channel;
import io.netty.channel.ChannelFuture;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioSocketChannel;
 
public class SecureChatClient {
 
    public void start(String host,int port) throws Exception{
        EventLoopGroup group = new NioEventLoopGroup();
        try{
            Bootstrap b = new Bootstrap();
            b.group(group).channel(NioSocketChannel.class)
                    .handler(new SecureChatClientInitializer());
 
            // Start the connection attempt.
            Channel ch = b.connect(host, port).sync().channel();
            // Read commands from the stdin.
            ChannelFuture lastWriteFuture = null;
            BufferedReader in = new BufferedReader(new InputStreamReader(
                    System.in));
            for (;;) {
                String line = in.readLine();
                if (line == null) {
                    break;
                }
                /**
                 * 所有的输入最后 加上分隔符 用于分割 因为我们使用的是 依照 回车作为分隔符的
                 */
                lastWriteFuture = ch.writeAndFlush(line + "\r\n");
 
                if ("bye".equals(line.toLowerCase())) {
                    ch.closeFuture().sync();
                    break;
                }
            }
 
            // Wait until all messages are flushed before closing the channel.
            if (lastWriteFuture != null) {
                lastWriteFuture.sync();
            }
        }finally{
            group.shutdownGracefully();
        }
    }
 
    public static void main(String[] args) throws Exception {
        new SecureChatClient().start("localhost", 8765);
 
    }
 
}

import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.DelimiterBasedFrameDecoder;
import io.netty.handler.codec.Delimiters;
import io.netty.handler.codec.LengthFieldBasedFrameDecoder;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.handler.ssl.SslHandler;
import io.netty.util.CharsetUtil;
 
import javax.net.ssl.SSLEngine;
import java.nio.ByteOrder;
 
public class SecureChatClientInitializer extends ChannelInitializer<SocketChannel> {
 
    @Override
    protected void initChannel(SocketChannel ch) throws Exception {
        ChannelPipeline pipeline = ch.pipeline();
        String cChatPath = System.getProperty("user.dir") + "\\src\\main\\resources\\cChat.jks";
 
        SSLEngine engine = SecureChatSslContextFactory.getClientContext(cChatPath)
                .createSSLEngine();//创建SSLEngine
        //1、单认证模式，客户端验证
        //   配合使用的是SERVER_CONTEXT.init(kmf.getKeyManagers(), null, null);
        //              CLIENT_CONTEXT.init(null, tf.getTrustManagers(), null);
        engine.setUseClientMode(true);//客户方模式

        //2、单认证模式，服务端验证
        //  配合使用的是SERVER_CONTEXT.init(kmf.getKeyManagers(),  tf.getTrustManagers(), null);
        //             CLIENT_CONTEXT.init(kmf.getKeyManagers(), null, null);
        // engine.setUseClientMode(false);//服务方模式


        //3、双认证模式
        //  配合使用的是SERVER_CONTEXT.init(kmf.getKeyManagers(),  tf.getTrustManagers(), null);
        //             CLIENT_CONTEXT.init(kmf.getKeyManagers(),  tf.getTrustManagers(), null); 
        //engine.setUseClientMode(true);  //也可以不写
        //engine.setNeedClientAuth(true);
        
        pipeline.addLast("ssl", new SslHandler(engine));
 
 
         pipeline.addLast("framer", new DelimiterBasedFrameDecoder(8192, Delimiters.lineDelimiter()));
       // pipeline.addLast(new LengthFieldBasedFrameDecoder(65535, 0, 2, 0, 2, true));
 
        // pipeline.addLast("decoder", new JsonDecoder());
        // pipeline.addLast("encoder", new StringEncoder());
        //pipeline.addLast(new JsonDecoder());
       //pipeline.addLast(new LengthFieldPrepender(2));
        pipeline.addLast("decoder", new StringDecoder(CharsetUtil.UTF_8));
        pipeline.addLast("encoder", new StringEncoder(CharsetUtil.UTF_8));
        //pipeline.addLast(new JsonEncoder());
 
        pipeline.addLast("handler", new SecureChatClientHandler());
 
    }
 
    /*public static void main(String[] args) {
        String s=System.getProperty("user.dir")+"\\src\\main\\resources\\cChat.jks";
        System.out.println(s);
    }*/
}

import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
 
public class SecureChatClientHandler extends SimpleChannelInboundHandler<String> {
 
    @Override
    public void messageReceived(ChannelHandlerContext ctx, String msg) throws Exception {
        System.err.println(msg);
    }
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
}

4.3 服务端

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;
 
public class SecureChatServer {
 
    public void run(int port) throws InterruptedException{
        EventLoopGroup bossGroup = new NioEventLoopGroup();
        EventLoopGroup workGroup = new NioEventLoopGroup();
        try{
            ServerBootstrap b = new ServerBootstrap();
            b.group(bossGroup, workGroup)
                    .channel(NioServerSocketChannel.class)
                    .handler(new LoggingHandler(LogLevel.INFO))
                    .childHandler(new SecureChatServerInitializer());
 
            ChannelFuture cf = b.bind(port).sync();
 
            cf.channel().closeFuture().sync();
 
        }finally{
            bossGroup.shutdownGracefully();
            workGroup.shutdownGracefully();
        }
 
    }
 
    public static void main(String[] args) throws InterruptedException {
        new SecureChatServer().run(8765);
 
    }
 
}

import javax.net.ssl.SSLEngine;
 
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelPipeline;
import io.netty.channel.socket.SocketChannel;
import io.netty.handler.codec.*;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;
import io.netty.handler.ssl.SslHandler;
 
public class SecureChatServerInitializer extends ChannelInitializer<SocketChannel> {
 
    @Override
    protected void initChannel(SocketChannel sc) throws Exception {
        ChannelPipeline pipeline = sc.pipeline();
        String sChatPath = (System.getProperty("user.dir")+ "\\src\\main\\resources\\sChat.jks");
 
        SSLEngine engine = SecureChatSslContextFactory.getServerContext(sChatPath).createSSLEngine();

        // 1、单认证模式，客户端认证模式
        //   配合使用的是SERVER_CONTEXT.init(kmf.getKeyManagers(), null, null);
        //              CLIENT_CONTEXT.init(null, tf.getTrustManagers(), null);
        engine.setUseClientMode(false);//即不需要客户端使用私钥,服务端使用私钥客户端验证，
       
       //2、单认证模式，服务端认证模式
       //  配合使用的是SERVER_CONTEXT.init(kmf.getKeyManagers(),  tf.getTrustManagers(), null);
       //             CLIENT_CONTEXT.init(kmf.getKeyManagers(), null, null);
       // engine.setUseClientMode(true);//设置为true，即需要客户端使用私钥，服务单用公钥验证
        

       //3、双认证模式
       //  配合使用的是SERVER_CONTEXT.init(kmf.getKeyManagers(),  tf.getTrustManagers(), null);
       //             CLIENT_CONTEXT.init(kmf.getKeyManagers(),  tf.getTrustManagers(), null); 
       //engine.setNeedClientAuth(true);  

        pipeline.addLast("ssl", new SslHandler(engine));
        pipeline.addLast("framer", new DelimiterBasedFrameDecoder(8192,Delimiters.lineDelimiter()));
        pipeline.addLast("decoder", new StringDecoder());
        pipeline.addLast("encoder", new StringEncoder());
        pipeline.addLast("handler", new SecureChatServerHandler());
    }
 
 
}


import java.net.InetAddress;
 
import io.netty.channel.Channel;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.channel.group.ChannelGroup;
import io.netty.channel.group.DefaultChannelGroup;
import io.netty.handler.ssl.SslHandler;
import io.netty.util.concurrent.Future;
import io.netty.util.concurrent.GenericFutureListener;
import io.netty.util.concurrent.GlobalEventExecutor;
 
public class SecureChatServerHandler extends SimpleChannelInboundHandler<String> {
 
    static final ChannelGroup channels = new DefaultChannelGroup(GlobalEventExecutor.INSTANCE);
 
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        ctx.pipeline().get(SslHandler.class).handshakeFuture()
                .addListener(new GenericFutureListener<Future<Channel>>() {
 
                    @Override
                    public void operationComplete(Future<Channel> arg0)
                            throws Exception {
                        if(arg0.isSuccess()){
                            ctx.writeAndFlush("Welcome to "+ InetAddress.getLocalHost().getHostName()+ " secure chat service!\n");
                            ctx.writeAndFlush("Your session is protected by "+ ctx.pipeline().get(SslHandler.class).engine().getSession().getCipherSuite()+ " cipher suite.\n");
                            channels.add(ctx.channel());
 
                        }
                    }
                });
 
 
    }
 
 
    @Override
    protected void messageReceived(ChannelHandlerContext ctx, String msg)
            throws Exception {
        for (Channel c : channels) {
            if (c != ctx.channel()) {
                c.writeAndFlush("[" + ctx.channel().remoteAddress() + "] "+ msg + '\n');
            } else {
                c.writeAndFlush("[you] " + msg + '\n');
            }
        }
        if ("bye".equals(msg.toLowerCase())) {
            ctx.close();
        }
    }
 
 
    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause)
            throws Exception {
        cause.printStackTrace();
        ctx.close();
    }
 
}

5. 参考资料

1、原文链接：https://blog.csdn.net/drsbbbl/article/details/117563123
2、https://blog.csdn.net/shenchaohao12321/article/details/90209940

qq_22185423
关注
专栏目录
netty实现https服务器简单demo
wobenqinren的博客
09-03 869
(一）、代码结构（SslServer,HttpsCodecInitializer） （二）、SslServer.java package com.lb.nettyinaction; import java.io.FileInputStream; import java.security.KeyStore; import javax.net.ssl.KeyManagerFactory; import io.netty.bootstrap.ServerBootstrap; import io.n
netty客户端/服务端示例
07-10 416
学习netty，做一些记录，简单的客户端/服务端示例 客户端： public class NettyClient { public static void main(String[] args) throws InterruptedException { EventLoopGroup group = new NioEventLoopGroup(); //创建客户端启动对象,与服务端不同，非ServerBootstrap Bootstrap boo
Netty实现HTTPS客户端
weixin_34348174的博客
06-25 979
2019独角兽企业重金招聘Python工程师标准>>> ...
基础学习之——Netty
最新发布
来北欧写代码
09-05 454
Netty是一个基于Java的网络通信框架，提供了一种简单、高效、可扩展的方式来开发网络服务器和客户端应用程序。以上便是一个基本的Netty入门案例，展示了一个简单的客户端和服务端之间的通信。在上述代码中，我们创建了一个客户端，连接指定的服务器主机和端口号。以下是一个简单的Netty入门案例，展示了一个基本的客户端和服务端之间的通信。在上述代码中，我们创建了一个服务端，监听指定的端口号。在上述代码中，我们分别创建了服务端和客户端的自定义处理器，继承自。是我们自定义的处理器，用于处理接收到的消息。
netty 实现https服务器
热门推荐
huangshanchun的专栏
10-21 1万+
0 概述 netty 通过JDK的SSLEngine，以SslHandler的方式提供对SSL/TLS 安全传输的支持，极大的简化了开发工作。本文主要讲述如何使用netty实现简单的https服务器。 1 SSL单向认证 所谓的单向认证，即客户端只验证服务端的合法性，服务端不会验证客户端。 单向认证过程的总结如下： 1.SSL客户端（浏览器）向服务端传送客户端 SSL协议的版本号、支...
edp协议 netty_Netty实现HTTPS客户端
weixin_28813357的博客
12-30 249
Netty实现HTTPS客户端和上一篇文章的代码是一样的，但也做一下记录SSLContextFactory.java代码packagehttp2;importjavax.net.ssl.KeyManagerFactory;importjavax.net.ssl.SSLContext;importjavax.net.ssl.TrustManagerFactory;importjava.io...
基于Netty实现https代理客户端
qq_43520928的博客
03-20 1633
基于Netty实现https代理客户端
Android使用Netty网络框架实践（客户端、服务端）
10-21
在Android环境中，由于安全和权限限制，我们通常需要在后台服务中运行Netty服务器，而在Activity或Service中创建Netty客户端。通过Handler进行主线程和网络线程之间的数据交互，确保UI更新的及时性和线程安全性。 ...
Netty3客户端服务端hi allen.zip
09-07
在本案例中，"Netty3客户端服务端hi allen.zip" 提供了一个基于 Netty 3 的简单客户端和服务端示例，旨在帮助初学者理解和入门 Netty 3。 首先，我们需要了解 Netty 的核心概念。Netty 是基于 Java NIO（非阻塞I/O...
基于netty的Tcp客户端和服务端收发数据demo
04-11
在实际应用中，Netty客户端会建立到服务端的TCP连接，并通过`ByteBuf`（Netty的缓冲区）发送和接收数据。服务端则监听指定端口，接收到连接请求后，处理来自客户端的数据，并可能返回响应。环保212协议的解析和编码...
NettyDemo包含客户端服务端
01-04
在本示例中，"NettyDemo" 提供了一个完整的解决方案，包括客户端和服务端的实现，适用于 Android 客户端和基于 SpringBoot 的服务器端。 **Netty 客户端 (NettyClientDemo)** 1. **通道初始化**: 在 Netty 中，...
netty服务端及客户端，支持HTTP和WEBSOCKET和SSL 最新版
05-06
本人基于netty开发的服务端，支持spring配置服务器启动模式：http，websocket,ssl等，并支持NIO和OIO方式，项目已应用于生产，可以通过jar形式加入其它项目，业务类实现业务service，启动不依赖于其他应用服务器，内附启动脚本。 已在生产使用，压力已测试，欢迎反馈。 个人原创，部分代码参考网上其他文献。最新版的
netty服务端及客户端，支持HTTP和WEBSOCKET和SSL
06-02
自己基于netty开发的服务端，支持spring配置服务器启动模式：http，websocket,ssl等，并支持NIO和OIO方式，项目已应用于生产，可以通过jar形式加入其它项目，业务类实现业务service，启动不依赖于其他应用服务器，内附启动脚本。 已在生产使用，压力未测试，欢迎反馈。 个人原创，部分代码参考网上其他文献。
netty框架最简单的客户端服务端代码
08-29
详细的netty框架的简单案例,包括客户端服务端
netty框架，服务端、客户端代码示例
11-04
简单的netty框架示例，代码中有完整的注释，代码包含服务端跟客户端代码，RunServer服务端测试类，RunClient客户端测试类
使用Netty实现HTTPS
卓立的博客
06-30 4780
之前的文章理解Https中，介绍了HTTP到HTTPS的演进过程，我们也可以得到一个结论：HTTPS = HTTP + 加密 + 身份认证 + 报文正确性保障。其实也就是在HTTP层和TCP层之间新增一个步骤，通过证书交换通信秘钥并验证客户端服务端身份的合法性（SSL）。所以为了实现HTTPS，必须支持SSL。 为了支持SSL，Java提供了 javax.net.ssl 包，它的SSLContext 和SSLEngine类使得解密和加密相当简单和高效。Netty提供了基于SSLEngine的实现OpenS
在Netty中支持https服务器
fba529635的专栏
08-25 7885
一、生成测试证书      1、安装Openssl           sudo apt-get install openssl      2、生成证书（openssl生成证书 - fengmenghello的日志 - 网易博客）           # 设定相关的目录 　　mkdir -p /etc/ssl 　　mkdir -p /etc/ssl/private 　　chmod
使用netty创建https服务器
Site_Dave的博客
06-03 1759
因需要https服务器,准备用netty3.x版本搭建一个https服务器,但是怎么弄都没有搞好.所以就选了netty4.x版本.(netty3.x最低JDK1.5,netty4.x最低JDK1.6).下面介绍下netty4.x搭建https服务器. 1. HTTPS服务器启动类 如果想启动多个服务器可以采用多个线程启动多个端口号 package best.nettyserver.http...
使用Netty构建HTTPS请求服务器
qq_43302441的博客
07-30 1375
实用程序来生成一个新的密钥库文件（Keystore），其中包含一个自签名的密钥对。的文件，该文件包含了一个有效期为一年、2048位的RSA密钥对，用于。可以查看我们的自签名证书无效。会在当前目录下生成一个名为。当所有信息输入完毕后，
java netty客服端和服务端代码案例
06-06
下面是一个简单的Java Netty客户端和服务端代码案例： 服务端代码： ```java import io.netty.bootstrap.ServerBootstrap; import io.netty.channel.ChannelFuture; import io.netty.channel.ChannelInitializer; ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值