爱睡觉的Boy_ed44
爱睡觉的Boy_ed44

网络编程-IO&Netty

IO&Netty代码地址：https://github.com/806040464/thinking-in-netty

手写Rpc&Web容器代码地址：https://github.com/806040464/rpc-tomcat-custom

JAVAIO

BIO

basic IO（block IO），主要用于文件IO与网络IO，JDK1.4 之前，我们建立网络连接的时候只能采用 BIO，使用ServerSocket与Socket进行通信，客户端发送请求后会一直等待服务端响应，是阻塞式IO。java.io.与java.net.包

NIO

java.nio 全称 Java Non-Blocking IO，java.nio.*包

BIO 以流的方式处理数据，而 NIO 以块的方式处理数据，效率要高

NIO 是非阻塞式的，这一点跟 BIO 也很不相同，可以提升资源利用效率

核心部分：

  • Channel通道

  • Buffer缓冲区

  • Selector选择器

NIO 基于 Channel和 Buffer进行操作，数据总是从通道读取到缓冲区中，或者从缓冲区写入到通道中。Selector用于监听多个通道的事件（Accpet、Connect、Read、Write），一个线程就可以处理大量客户端连接

Selector多路复用选择器.png
Java NIO.png

IO对比

IO 的方式通常分为几种：同步阻塞的 BIO、同步非阻塞的 NIO、异步非阻塞的 AIO

  • BIO 方式适用于连接数目比较小且固定的架构

  • NIO 方式适用于连接数目多且连接比较短（轻操作）的架构，如聊天服务器

  • AIO 方式使用于连接数目多且连接比较长（重操作）的架构，如文件服务器

BIO NIO AIO
IO方式 同步阻塞 同步非阻塞（多路复用） 异步非阻塞
API使用难度 简单 复杂 复杂
可靠性 差 好 好
吞吐量 低 高 高

C/S通信（NIO）

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.nio.charset.StandardCharsets;

public class Client {
    public static void main(String[] args) throws Exception {
        start();
    }

    public static void start() throws IOException {
        //开启网络通道
        SocketChannel socketChannel = SocketChannel.open();
        //设置非阻塞
        socketChannel.configureBlocking(false);
        InetSocketAddress address = new InetSocketAddress("127.0.0.1", 9999);
        //连接服务器
        if (!socketChannel.connect(address)) {
            //重试连接
            while (!socketChannel.finishConnect()) {
                System.out.println("Client：金莲连不上，做点别的事");
            }
        }
        ByteBuffer byteBuffer = ByteBuffer.wrap("你好，金莲，大郎在家吗？".getBytes(StandardCharsets.UTF_8));
        //发送消息
        socketChannel.write(byteBuffer);
        try {
            Thread.sleep(10000);
        } catch (InterruptedException e) {
            throw new RuntimeException(e);
        }
    }
}

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SelectionKey;
import java.nio.channels.Selector;
import java.nio.channels.ServerSocketChannel;
import java.nio.channels.SocketChannel;
import java.util.Iterator;

public class Server {
    public static void main(String[] args) throws IOException {
        start();
    }

    public static void start() throws IOException {
        System.out.println("服务端启动");
        System.out.println("服务端初始化端口：9999");
        //开启socket通道监听
        ServerSocketChannel serverSocketChannel = ServerSocketChannel.open();
        //开启选择器
        Selector selector = Selector.open();
        //设置为非阻塞
        serverSocketChannel.configureBlocking(false);
        //绑定端口
        serverSocketChannel.bind(new InetSocketAddress(9999));
        //注册到选择器，选择器监听ACCEPT事件
        serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
        while (true) {
            if (0 == selector.select(1000)) {
                System.out.println("Server:西门庆没找我，我去找王妈妈做点兼职");
                continue;
            }

            Iterator iterator = selector.selectedKeys().iterator();
            while (iterator.hasNext()) {
                SelectionKey key = iterator.next();
                if (key.isAcceptable()) {
                    SocketChannel clientSocketChannel = serverSocketChannel.accept();
                    clientSocketChannel.configureBlocking(false);
                    clientSocketChannel.register(selector, SelectionKey.OP_READ, ByteBuffer.allocate(1024));
                }
                if (key.isReadable()) {
                    SocketChannel channel = (SocketChannel) key.channel();
                    ByteBuffer byteBuffer = (ByteBuffer) key.attachment();
                    System.out.println("客户端发来数据：" + new String(byteBuffer.array()).trim());
                    channel.read(byteBuffer);
                    System.out.println("客户端发来数据：" + new String(byteBuffer.array()).trim());
                }
                //将当前key移除，防止重复处理
                iterator.remove();
            }
        }
    }
}

网络聊天室1.0（Java NIO）

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.SocketChannel;
import java.nio.charset.StandardCharsets;

public class Client {
    private final String HOST = "127.0.0.1";
    private final int PORT = 9999;
    private String userName;
    private SocketChannel socketChannel;

    public Client() {
        try {
            //开启网络通道
            this.socketChannel = SocketChannel.open();
            InetSocketAddress address = new InetSocketAddress(HOST, PORT);
            //设置非阻塞
            this.socketChannel.configureBlocking(false);
            //连接服务器
            if (!socketChannel.connect(address)) {
                //重试连接
                while (!socketChannel.finishConnect()) {
                    System.out.println("Client：还没连接上服务器，干点别的");
                }
            }
            this.userName = socketChannel.getLocalAddress().toString();
            System.out.println("Client" + userName + "is Ready!");
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 向服务器发送消息
     *
     * @param msg
     */
    public void sendMsg(String msg) {
        try {
            if ("bye".equalsIgnoreCase(msg)) {
                socketChannel.close();
            }
            msg = userName + "说：" + msg;
            ByteBuffer byteBuffer = ByteBuffer.wrap(msg.getBytes(StandardCharsets.UTF_8));
            socketChannel.write(byteBuffer);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 从服务端接收消息
     */
    public void receiveMsg() {
        try {
            ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
            int read = socketChannel.read(byteBuffer);
            if (read > 0) {
                String msg = new String(byteBuffer.array()).trim();
                System.out.println(msg);
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
}

import java.io.IOException;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.channels.*;
import java.nio.charset.StandardCharsets;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.Iterator;

public class Server {
    private ServerSocketChannel serverSocketChannel;
    private Selector selector;
    private static final int PORT = 9999;

    public static void main(String[] args) {
        Server server = new Server();
        server.start();
    }

    public Server() {
        try {
            System.out.println("服务端启动");
            System.out.println("服务端初始化端口：9999");
            //开启socket监听通道
            this.serverSocketChannel = ServerSocketChannel.open();
            //开启选择器
            this.selector = Selector.open();
            //设置非阻塞
            this.serverSocketChannel.configureBlocking(false);
            //绑定端口
            this.serverSocketChannel.bind(new InetSocketAddress(PORT));
            //注册选择器，选择器监听ACCEPT事件
            this.serverSocketChannel.register(selector, SelectionKey.OP_ACCEPT);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    public void start() {
        try {
            while (true) {
                if (0 == selector.select(1000)) {
                    System.out.println("没有客户端连接，我去搞点兼职");
                    try {
                        Thread.sleep(1000);
                    } catch (InterruptedException e) {
                        throw new RuntimeException(e);
                    }
                    continue;
                }
                Iterator iterator = selector.selectedKeys().iterator();
                if (iterator.hasNext()) {
                    SelectionKey key = iterator.next();
                    if (key.isAcceptable()) {
                        SocketChannel clientSocketChannel = serverSocketChannel.accept();
                        clientSocketChannel.configureBlocking(false);
                        clientSocketChannel.register(selector, SelectionKey.OP_READ);
                        System.out.println(clientSocketChannel.getRemoteAddress().toString() + "上线了");
                    }
                    if (key.isReadable()) {
                        readMsg(key);
                    }
                    //将当前key移除，防止重复处理
                    iterator.remove();
                }
            }
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }

    /**
     * 读取客户端发来的消息并广播
     *
     * @param key
     * @throws IOException
     */
    private void readMsg(SelectionKey key) throws IOException {
        SocketChannel clientSocketChannel = (SocketChannel) key.channel();
        ByteBuffer byteBuffer = ByteBuffer.allocate(1024);
        int read = clientSocketChannel.read(byteBuffer);
        if (read > 0) {
            String msg = new String(byteBuffer.array()).trim();
            //打印消息
            printInfo(msg);
            //全员广播消息，除发送客户端外
            broadcast(clientSocketChannel, msg);
        }
    }

    private void broadcast(SocketChannel clientSocketChannel, String msg) throws IOException {
        System.out.println("服务器广播消息");
        for (SelectionKey selectionKey : selector.keys()) {
            SelectableChannel targetChannel = selectionKey.channel();
            if (targetChannel instanceof SocketChannel && targetChannel != clientSocketChannel) {
                SocketChannel destChannel = (SocketChannel) targetChannel;
                ByteBuffer wrap = ByteBuffer.wrap(msg.getBytes(StandardCharsets.UTF_8));
                destChannel.write(wrap);
            }
        }
    }

    private void printInfo(String msg) {
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        System.out.println("[" + sdf.format(new Date()) + "]->" + msg);
    }
}

Netty

Netty 是一个利用 Java 开发的高级网络的能力，隐藏其背后的复杂性而提供一个易于使用的 API 的客户端/服务器框架

Netty提供异步的、事件驱动的网络应用程序框架和工具，用以快速开发高性能、高可靠性的网络服务器和客户端程序。也就是说，Netty 是一个基于NIO的客户、服务器端编程框架，使用Netty 可以快速和简单的开发出一个网络应用

线程模型

Netty线程模型.png

API 默认的pipeline里的handler有哪些？排序是按添加顺序，是否支持类似order注解定义，Handler如何跳过执行下一个或者说Handler间如何通知？

  • ChannelInboundHandler之间的传递，通过调用 ctx.fireChannelRead(msg) 实现；调用ctx.write(msg) 将传递到ChannelOutboundHandler

  • ChannelOutboundHandler 在注册的时候需要放在最后一个ChannelInboundHandler之前，否则将无法传递到ChannelOutboundHandler

  • 流水线pipeline中ChannelOutboundHandler不能放到最后，否则不生效

  • ctx.write()方法执行后，需要调用flush()方法才能令它立即执行，writeAndFlush()

C/S通信（Netty实现）

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;

public class NettyClient {

    public static void main(String[] args) throws InterruptedException {
        //创建线程组
        NioEventLoopGroup group = new NioEventLoopGroup();
        //创建客户端启动助手
        Bootstrap bootstrap = new Bootstrap();
        bootstrap.group(group)
                .channel(NioSocketChannel.class)
                .handler(new ChannelInitializer() {
                    @Override
                    protected void initChannel(SocketChannel ch) throws Exception {
                        ch.pipeline().addLast(new LoggingHandler(LogLevel.INFO));
                        ch.pipeline().addLast(new NettyClientHandler());
                    }
                });
        System.out.println("客户端启动完成");
        ChannelFuture channelFuture = bootstrap.connect("127.0.0.1", 9999).sync();
        channelFuture.channel().closeFuture().sync();
    }
}

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;

import java.nio.charset.StandardCharsets;

/**
 * 客户端业务类
 */
public class NettyClientHandler extends ChannelInboundHandlerAdapter {
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        ctx.writeAndFlush(Unpooled.copiedBuffer("天王盖地虎".getBytes(StandardCharsets.UTF_8)));
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf byteBuf = (ByteBuf) msg;
        System.out.println("Server msg:" + byteBuf.toString(StandardCharsets.UTF_8));
    }

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

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;

public class NettyServer {
    public static void main(String[] args) throws InterruptedException {
        //创建线程组，处理客户端连接
        NioEventLoopGroup bossGroup = new NioEventLoopGroup();
        //创建线程组，处理业务操作
        NioEventLoopGroup workerGroup = new NioEventLoopGroup();
        //创建服务端启动助手配置参数
        ServerBootstrap serverBootstrap = new ServerBootstrap();
        serverBootstrap.group(bossGroup, workerGroup)
                //使用NioServerSocketChannel作为服务器端通道的实现
                .channel(NioServerSocketChannel.class)
                //设置线程队列中等待连接的个数
                .option(ChannelOption.SO_BACKLOG, 128)
                //保持活动连接状态
                .childOption(ChannelOption.SO_KEEPALIVE, true)
                //创建初始化通道
                .childHandler(new ChannelInitializer() {
                    @Override
                    protected void initChannel(SocketChannel channel) throws Exception {
                        channel.pipeline().addLast(new LoggingHandler(LogLevel.INFO));
                        //Pipeline链中添加自定义的handler类
                        channel.pipeline().addLast(new NettyServerHandler());
                    }
                });
        System.out.println("服务端启动中 init port：9999");
        //绑定端口 bind方法是异步的
        //sync方法是同步阻塞的
        ChannelFuture channelFuture = serverBootstrap.bind(9999).sync();
        System.out.println("服务端启动成功");
        //关闭通道，关闭线程组
        channelFuture.channel().closeFuture().sync();
    }
}

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;

import java.nio.charset.StandardCharsets;

/**
 * 服务端业务类
 */
public class NettyServerHandler extends ChannelInboundHandlerAdapter {
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ByteBuf byteBuf = (ByteBuf) msg;
        System.out.println("client msg:" + byteBuf.toString(StandardCharsets.UTF_8));
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        ctx.writeAndFlush(Unpooled.copiedBuffer("宝塔镇河妖".getBytes(StandardCharsets.UTF_8)));
    }

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

网络聊天室V2.0

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

import java.util.Scanner;

/**
 * 客户端
 */
public class ChatNettyClient {
    private final String host;
    private final int port;

    public static void main(String[] args) throws InterruptedException {
        ChatNettyClient chatNettyClient = new ChatNettyClient("127.0.0.1", 9999);
        chatNettyClient.run();
    }

    public ChatNettyClient(String host, int port) {
        this.host = host;
        this.port = port;
    }

    public void run() throws InterruptedException {
        NioEventLoopGroup group = new NioEventLoopGroup();
        try {
            Bootstrap bootstrap = new Bootstrap();
            bootstrap.group(group)
                    .channel(NioSocketChannel.class)
                    .handler(new ChannelInitializer() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline().addLast("decoder", new StringDecoder());
                            ch.pipeline().addLast("encoder", new StringEncoder());
//                            ch.pipeline().addLast(new ChatClientHandler());
                            ch.pipeline().addLast(new NettyChatClientHandler());
                        }
                    });
            ChannelFuture channelFuture = bootstrap.connect(host, port).sync();
            System.out.println("------" + channelFuture.channel().localAddress().toString() + "------");
            Scanner scanner = new Scanner(System.in);
            while (scanner.hasNextLine()) {
                String msg = scanner.nextLine();
                channelFuture.channel().writeAndFlush(msg + "\r\n");
            }
            channelFuture.channel().closeFuture().sync();
        } finally {
            group.shutdownGracefully();
        }
    }
}

import io.netty.channel.Channel;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;

import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

/**
 * 客户端业务类
 */
public class ChatClientHandler extends ChannelInboundHandlerAdapter {
    public static List channels = new CopyOnWriteArrayList<>();

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        System.out.println(msg.toString());
    }

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

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.string.StringDecoder;
import io.netty.handler.codec.string.StringEncoder;

/**
 * 服务端
 */
public class ChatNettyServer {
    private int port;

    public static void main(String[] args) throws InterruptedException {
        ChatNettyServer chatNettyServer = new ChatNettyServer(9999);
        chatNettyServer.run();
    }

    public ChatNettyServer(int port) {
        this.port = port;
    }

    public void run() throws InterruptedException {
        NioEventLoopGroup bossGroup = new NioEventLoopGroup();
        NioEventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .option(ChannelOption.SO_BACKLOG, 128)
                    .childOption(ChannelOption.SO_KEEPALIVE, true)
                    .childHandler(new ChannelInitializer() {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception {
                            ch.pipeline().addLast("decoder", new StringDecoder());
                            ch.pipeline().addLast("encoder", new StringEncoder());
                            ch.pipeline().addLast(new ChatServerHandler());
//                            ch.pipeline().addLast(new NettyChatServerHandler());
                        }
                    });
            System.out.println("聊天室服务端启动");
            ChannelFuture channelFuture = serverBootstrap.bind(port).sync();
            channelFuture.channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
            System.out.println("聊天室服务端关闭");
        }
    }
}

import io.netty.channel.Channel;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;

import java.util.List;
import java.util.concurrent.CopyOnWriteArrayList;

/**
 * 服务端业务类
 */
public class ChatServerHandler extends ChannelInboundHandlerAdapter {
    public static List channels = new CopyOnWriteArrayList<>();

    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception {
        Channel channel = ctx.channel();
        channels.add(channel);
        System.out.println(channel.remoteAddress().toString() + "上线了");
    }

    @Override
    public void channelInactive(ChannelHandlerContext ctx) throws Exception {
        Channel channel = ctx.channel();
        channels.remove(channel);
        System.out.println(channel.remoteAddress().toString() + "下线了");
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        Channel channel = ctx.channel();
        System.out.println(msg.toString());
        for (Channel channel1 : channels) {
            if (channel != channel1) {
                channel1.writeAndFlush(channel.remoteAddress().toString() + "说：" + msg.toString());
            }
        }
    }

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

手写RPC

调用流程

手写RPC调用流程.png

核心代码

  1. 客户端创建动态代理，拦截方法调用，将对应方法调用相关信息通过netty发送至服务端进行反射调用后结果返回，达到远程过程调用的需要
import com.zoe.custom.ClassInfo;
import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.codec.serialization.ClassResolvers;
import io.netty.handler.codec.serialization.ObjectDecoder;
import io.netty.handler.codec.serialization.ObjectEncoder;

import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;

/**
 * @description java.lang.reflect.Proxy#newProxyInstance(java.lang.ClassLoader, java.lang.Class[], java.lang.reflect.InvocationHandler)创建动态代理
 * 拦截方法调用，将对应方法调用相关信息通过netty发送至服务端进行反射调用后结果返回，达到远程过程调用的需要
 * @date 2022/10/7 16:48
 */
public class RpcProxy {

    public static Object create(Class cls) {
        InvocationHandler invocation = new InvocationHandler() {
            @Override
            public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
                //封装类方法信息
                ClassInfo classInfo = new ClassInfo();
                classInfo.setClassName(cls.getName());
                classInfo.setMethodName(method.getName());
                classInfo.setTypes(method.getParameterTypes());
                classInfo.setParameters(args);

                //netty发送类方法信息进行服务端调用
                NioEventLoopGroup group = new NioEventLoopGroup();
                ResultHandler resultHandler = new ResultHandler();
                try {
                    Bootstrap bootstrap = new Bootstrap();
                    bootstrap.group(group)
                            .channel(NioSocketChannel.class)
                            .handler(new ChannelInitializer() {
                                @Override
                                protected void initChannel(SocketChannel socketChannel) throws Exception {
                                    socketChannel.pipeline().addLast("encoder", new ObjectEncoder());
                                    socketChannel.pipeline().addLast("decoder", new ObjectDecoder(Integer.MAX_VALUE, ClassResolvers.cacheDisabled(null)));
                                    socketChannel.pipeline().addLast(resultHandler);
                                }
                            });
                    ChannelFuture channelFuture = bootstrap.connect("127.0.0.1", 9999).sync();
                    channelFuture.channel().writeAndFlush(classInfo).sync();
                    channelFuture.channel().closeFuture().sync();
                } finally {
                    group.shutdownGracefully();
                }
                return resultHandler.getResponse();
            }
        };

        //创建代理对象
        Object proxyInstance = Proxy.newProxyInstance(cls.getClassLoader(), new Class[]{cls}, invocation);
        return proxyInstance;
    }
}
  1. 服务端接收类方法信息后，反射调用本地对应实现类方法
import com.zoe.custom.ClassInfo;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;
import org.reflections.Reflections;

import java.lang.reflect.Method;
import java.util.Set;

/**
 * @description 服务端接收类方法信息后，反射调用对应实现类方法
 * @date 2022/10/7 17:20
 */
public class InvokeHandler extends ChannelInboundHandlerAdapter {
    /**
     * 查找接口实现类
     *
     * @param ctx
     * @param msg
     * @throws Exception
     */
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        ClassInfo classInfo = (ClassInfo) msg;
        Class cls = null;
        try {
            cls = getImplClass(classInfo);
        } catch (Exception e) {
            ctx.writeAndFlush(e.getMessage());
            return;
        }
        Method method = cls.getMethod(classInfo.getMethodName(), classInfo.getTypes());
        Object classInstance = cls.newInstance();
        Object result = method.invoke(classInstance, classInfo.getParameters());
        ctx.writeAndFlush(result);
    }

    /**
     * 读取客户端发来的数据并通过反射调用实现类的方法
     *
     * @param classInfo
     * @return
     * @throws Exception
     */
    private Class getImplClass(ClassInfo classInfo) throws Exception {
        String className = classInfo.getClassName();
        Class interfaceClass = Class.forName(className);
        String interfacePath = className.substring(0, className.lastIndexOf("."));
        interfacePath = interfacePath.substring(0, interfacePath.lastIndexOf("."));
        Reflections reflections = new Reflections(interfacePath);
        Set implSet = reflections.getSubTypesOf(interfaceClass);
        Class cls;
        if (0 == implSet.size()) {
            throw new RuntimeException("未找到实现类");
        } else if (1 < implSet.size()) {
            throw new RuntimeException("找到实现类不止一个，不知道使用哪个");
        } else {
            cls = implSet.iterator().next();
        }
        return cls;
    }

}
  1. Netty传递封装类方法信息和调用结果
import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioServerSocketChannel;
import io.netty.handler.codec.serialization.ClassResolvers;
import io.netty.handler.codec.serialization.ObjectDecoder;
import io.netty.handler.codec.serialization.ObjectEncoder;
import lombok.AllArgsConstructor;

/**
 * @description 服务端netty接收客户端发送相关类方法信息
 * @date 2022/10/7 17:19
 */
@AllArgsConstructor
public class RpcServer {
    private int port;

    public void start() throws Exception {
        NioEventLoopGroup bossGroup = new NioEventLoopGroup();
        NioEventLoopGroup workerGroup = new NioEventLoopGroup();
        try {
            ServerBootstrap serverBootstrap = new ServerBootstrap();
            serverBootstrap.group(bossGroup, workerGroup)
                    .channel(NioServerSocketChannel.class)
                    .option(ChannelOption.SO_BACKLOG, 128)
                    .childOption(ChannelOption.SO_KEEPALIVE, true)
                    .childHandler(new ChannelInitializer() {
                        @Override
                        protected void initChannel(SocketChannel socketChannel) throws Exception {
                            socketChannel.pipeline().addLast("encoder", new ObjectEncoder());
                            socketChannel.pipeline().addLast("decoder", new ObjectDecoder(Integer.MAX_VALUE, ClassResolvers.cacheDisabled(null)));
                            socketChannel.pipeline().addLast(new InvokeHandler());
                        }
                    });
            ChannelFuture channelFuture = serverBootstrap.bind(port).sync();
            System.out.println("......RPC Server is ready......");
            channelFuture.channel().closeFuture().sync();
        } finally {
            bossGroup.shutdownGracefully();
            workerGroup.shutdownGracefully();
        }
    }
}

你可能感兴趣的:(网络编程-IO&Netty)

  • 网络编程基础 记得开心一点啊 网络
    目录♫什么是网络编程♫Socket套接字♪什么是Socket套接字♪数据报套接字♪流套接字♫数据报套接字通信模型♪数据报套接字通讯模型♪DatagramSocket♪DatagramPacket♪实现UDP的服务端代码♪实现UDP的客户端代码♫流套接字通信模型♪流套接字通讯模型♪ServerSocket♪Socket♪实现TCP的服务端代码♪实现TCP的客户端代码♫什么是网络编程网络编程，指网络上
  • 【仿RabbitMQ消息队列项目day2】使用muduo库中基于protobuf的应用层协议进行通信 月夜星辉雪 rabbitmq网络分布式c++后端服务器linux
    一.什么是muduo?muduo库是⼀个基于非阻塞IO和事件驱动的C++高并发TCP网络编程库。简单来理解，它就是对原生的TCP套接字的封装，是一个比socket编程接口更好用的编程库。二.使用muduo库完成一个英译汉翻译服务TranslateServer.hpp:#pragmaonce#include#include#include#include#include"muduo/net/TcpC
  • 《Android进阶之光》— Android 书籍 王睿丶 Android永无止境《Android进阶之光》Android书籍Androidphoenix移动开发
    文章目录第1章Android新特性1第2章MaterialDesign48第3章View体系与自定义View87第4章多线程编程165第5章网络编程与网络框架204第6章设计模式271第7章事件总线308第8章函数响应式编程333第9章注解与依赖注入框架382第10章应用架构设计422第11章系统架构与MediaPlayer框架460出版年:2017-7简介：《Android进阶之光》是一本And
  • Java-网络 胡净 java网络开发语言
    Java中的网络编程主要涉及使用Socket类进行网络通信，以及理解各种网络协议。以下是一些关键概念和示例代码，帮助您入门。1.网络协议Java支持多种网络协议，最常用的包括：TCP（传输控制协议）：面向连接的协议，确保数据的可靠传输。UDP（用户数据报协议）：无连接的协议，适用于对速度要求高但对可靠性要求低的应用。网络通信模型通常指的是OSI（开放系统互联）模型，它将网络通信分为七个层次。每一层
  • 网络编程--python 电子海鸥 网络编程网络python开发语言
    网络编程1、介绍(一)、概述网络编程也叫套接字编程,Socket编程,就是用来实现网络互联的不同计算机上运行的程序间可以进行数据交互(二)、三要素IP地址:设备(电脑,手机,IPad,耳机…)在网络中的唯一标识.端口号:程序在设备上的唯一标识.协议:通信(传输)规则(三)、ip概述设备(电脑,手机,IPad,耳机…)在网络中的唯一标识分类按照代数划分:IPv4:4字节,十进制来表示,例如:192.
  • java unix网络编程_《UNIX网络编程 卷2：进程间通信(第2版)》PDF 下载 weixin_39688019 javaunix网络编程
    图书目录：第一部分简介第1章简介1.1概述1.2进程、线程与信息共享1.3IPC对象的持续性1.4名字空间1.5fork、exec和exit对IPC对象的影响1.6出错处理：包裹函数1.7Unix标准1.8书中IPC例子索引表1.9小结习题第2章PosixIPC2.1概述2.2IPC名字2.3创建与打开IPC通道2.4IPC权限2.5小结习题第3章SystemVIPC3.1概述3.2key_t键和
  • 9.10网络编程（day7） Heart14 网络jvmjava
    #include#includetypedefstruct{intgh;charname[20];doublesalary;}Worker;intdo_insert(sqlite3*ppDb){Workerwork;printf("请输入插入的工号：");scanf("%d",&work.gh);printf("请输入插入的姓名：");scanf("%s",work.name);printf("请
  • socket网络编程 jdq_summer socket网络编程socket网络编程
    TCP实现网络通信：服务器端一、创建服务器套接字（CREATE）。二、服务器套接字进行信息绑定（BIND），并开始监听连接（LISTEN）。三、接受来自客户端的连接请求（ACCEPT），并创建接收进程。四、开始数据传输(SEND、RECEIVE)。五、关闭套接字（CLOSESOCKET）。客户机端一、创建客户机套接字（CREATE）。二、与远程服务器进行连接（CONNECT），如被接受则创建接收进
  • 网络编程9.3 江亭棠 网络算法
    使用UDP实现多个客户端与服务器的通信，并在使用connect函数后只有一个客户端能与服务器通信服务器：#include#defineSERPORT9999#defineSERIP"192.168.0.126"intmain(intargc,constchar*argv[]){//1、创建旧的套接字intoldfd=socket(AF_INET,SOCK_DGRAM,0);if(oldfd==-1
  • 网络编程9.4 江亭棠 网络linux
    1、多进程多线程并发服务器，再实现一遍（重点模型）。多进程并发服务器：#include#defineSERPORT9999#defineSERIP"192.168.0.162"#defineBACKLOG10voidhande(intsss){if(sss==SIGCHLD){while(waitpid(-1,NULL,WNOHANG)!=-1);}}intmain(intargc,constch
  • 网络编程 9.10 Tangver 数据库
    完成代码剩余功能typedefstruct{intgh;charname[20];doublesalary;}Worker;intdo_insert(sqlite3*ppDb){Workerwork;printf("请输入插入的工号:");scanf("%d",&work.gh);printf("请输入插入的姓名:");scanf("%s",work.name);printf("请输入插入的薪水:
  • 用 Python 写网络编程（三） TesterHome
    本文在2021.02.14首发于TesterHome社区，作者是资深游戏测试开发工程师陈子昂。用Python写网络编程共四篇，今天给大家分享其中第三篇。原文链接：https://testerhome.com/topics/27910前言今天是一个特别的节日，1946年情人节，世界上第一台计算机ENIAC在米国的宾夕法尼亚大学被new了，标志着新的时代到来。计算机陪伴人类已经走过了75个年头，所以今
  • 网络编程 UDP发送数据 稻田里展望者 Java网络编程udp网络网络协议
    UDP通信原理不可靠的网络协议,在通信的两端各建立一个Socket对象(发送和接收数据)发送数据的步骤1.创建发送端的Socket对象(DatagramSocket)2.创建数据,并把数据打包3.调用DatagramSocket对象的方法发送数据4.关闭发送端//创建发送端的Socket对象(DatagramSocket)DatagramSocketds=newDatagramSocket();/
  • java的socket实现一个九宫棋游戏 睡不醒的小泽
    前言一个简单的socket小作品=v=一个机酱在大三实验课中接触到很基础的JAVA语言socket编程。至于你问为什么嵌入式的机酱会弄些Java吗？emmmmm，可能是当初C语言版的不够好玩吧，另外如果碰巧有用，欢迎抱走的yoo在之前的笔记《网络基础知识和网络编程》中有讲解过关于网络编程的一些基本知识，以及一些LinuxC的socket编程，希望粗浅了解socket内部肌理的同学，右转咱的学习笔记
  • 【Python】已解决ModuleNotFoundError: No module named ‘requests’ 屿小夏 python开发语言
    文章目录一、分析问题背景二、可能出错的原因三、错误代码示例四、正确代码示例五、注意事项已解决ModuleNotFoundError:Nomodulenamed‘requests’一、分析问题背景在使用Python进行网络编程或数据抓取时，requests库因其简洁易用的特性而受到广泛欢迎。然而，当尝试导入requests模块时，有时会遇到“ModuleNotFoundError:Nomodulen
  • Java 学习路线：适合小白的超细学习路线及实例代码 Dreams°123 后端javaeclipsejvmspringtomcatideintellij-idea
    Java学习路线：适合小白的超细学习路线及实例代码一、入门基础1.1、Java基础语法1.2、面向对象编程(OOP)二、核心Java编程2.1、数据结构和算法基础2.2、输入输出(I/O)三、进阶Java编程3.1、多线程编程3.2、网络编程四、高级应用4.1、数据库编程4.2、Web开发4.3、框架与库五、实践项目与进阶学习（留作业啦）5.1、实践项目5.2、持续学习一、入门基础1.1、Java
  • C++ 用libcurl库进行http通讯网络编程 马小瑄
    一、LibCurl基本编程框架二、一些基本的函数三、curl_easy_setopt函数部分选项介绍四、curl_easy_perform函数说明（error状态码）五、libcurl使用的HTTP消息头六、获取http应答头信息七、多线程问题八、什么时候libcurl无法正常工作九、关于密码十、HTTP验证十一、代码示例1.基本的httpGET/POST操作2获取html网页3网页下载保存实例4
  • #include ＜netinet/in.h＞ 姜太公钓鲸233 c++socket
    #include，这是一个标准的网络编程头文件，用于定义IP地址、协议以及与网络接口相关的数据结构和常量。它主要用于在基于IPv4和IPv6的网络编程中。#include的作用头文件包含了处理网络地址的定义和一些网络协议的相关常量，用于支持基于IP（特别是IPv4和IPv6）的网络编程。它提供了一些关键的数据结构和宏，如：常见的结构和宏：structsockaddr_in：用于表示IPv4地址的结
  • 【多线程服务器】多线程下网络编程 gma999 c++服务器
    目录多线程模型-非阻塞IO+oneloopperthreadoneloopperthread线程池oneloopperthread与线程池结合目前主流多线程模型Reactor模式+线程池Proactor模式Master-Worker模型多线程编程的实现线程抢占问题Happens-Before关系Linux下多线程编程常用函数线程的创建线程销毁多线程下的I/ORAII与文件描述符管理RAII与for
  • io_uring异步IO 天夏123 php开发语言
    io_uring介绍io_uring是一个Linux内核的异步I/O框架，它提供了高性能的异步I/O操作，io_uring的目标是通过减少系统调用和上下文切换的开销来提高I/O操作的性能。在网络编程中，我们通常使用epollIO多路复用来处理网络IO，然而epoll也并不是异步网络IO，仅仅是内核提供了IO复用机制，epoll回调通知的是数据可以读取或者写入了，具体的读写操作仍然需要用户去做，而不
  • Java网络编程：IO，NIO与Netty 坚持是一种态度 javajava网络编程NettyJavaIONIONIO与Netty
    Java网络编程：IO，NIO与NettyJava网络编程：IO，NIO与NettyJavaI/O相关概念同步与异步阻塞与非阻塞OIONIOAIOreactor模型proactor模型JavaIO应用场景Netty简介NIO与Netty生产使用Java网络编程：IO，NIO与Netty新公司新项目，项目需要在硬件和软件平台进行信息传递，具体来说使用Netty。硬件和软件使用socket连接，硬件作
  • Http协议、TCP协议、WebSocket协议 俗人浮生
    网络编程大家都不陌生，但平时我们只是知道怎么用，对个中的网络协议倒是没花多少工夫去学习，所以，我们今天特意来对网络协议相关的知识加以总结记录。1）网络七层协议，从上到下依次为：7应用层6表示层5会话层4传输层3网络层2数据链路层1物理层2）Http协议对应于应用层，TCP协议对应于传输层，Http协议是建立在TCP协议基础之上的3）属于应用层的常用协议：Http（超文本传输协议）、FTP（文件传输
  • 2024上学期--实验室学习计划 m0_66357705 javascript前端vue.js
    阶段周次学习内容实践内容时间安排新增内容/重点基础巩固1-2周Java基础，多线程，TCP/IP网络编程相关练习和小的编程项目每天学习2小时，实践1小时Java20及以上版本新特性学习框架深入学习3-6周Spring，SpringBoot相关练习和小的编程项目每天学习3小时，实践1.5小时学习SpringCloud和微服务架构基础前端技术提升7-8周Vue2，Vue3相关练习和小的编程项目每天学习
  • 网络编程（setsockopt、超时检测） 敲代码的鹏鹏 网络服务器运维
    【1】setsockopt：设置套接字属性set:设置sock：套接字option：属性intsetsockopt(intsockfd,intlevel,intoptname,void*optval,socklen_toptlen)功能：获得/设置套接字属性参数：sockfd：套接字描述符level：协议层optname：选项名optval:选项值optlen:选项值大小返回值:成功0失败-1so
  • 力扣刷题记录（一）剑指Offer（第二版） 乘凉~ 求职过程记录leetcode链表算法
    1、本栏用来记录社招找工作过程中的内容，包括基础知识学习以及面试问题的记录等，以便于后续个人回顾学习；暂时只有2023年3月份，第一次社招找工作的过程；2、个人经历：研究生期间课题是SLAM在无人机上的应用，有接触SLAM、Linux、ROS、C/C++、DJIOSDK等；3、参加工作后（2021-2023年）岗位是嵌入式软件开发，主要是服务器开发，Linux、C/C++、网络编程、docker容
  • java tcp 客户端绑定端口_Java利用TCP协议实现客户端与服务器通信(附通信源码) Mrs.Wong javatcp客户端绑定端口
    进行TCP协议网络程序的编写，关键在于ServerSocket套接字的熟练使用，TCP通信中所有的信息传输都是依托ServerSocket类的输入输出流进行的。上一篇博客和大家分享了在网络编程中要注意的基础知识，关于IP、TCP、UDP以及端口和套接字的一些概念，想了解的小伙伴可以看我的这篇文章“盘点那些进行网络编程必须要知道的基础知识”，那么今天大灰狼就来和大家分享一下如何使用TCP/IP进行网
  • 客户端绑定本地端口与服务器建立连接的详细实现 醉心编码 通信软件c/c++技术类服务器TCP数据结构网络
    客户端绑定本地端口与服务器建立连接的详细实现一、网络编程基础1.1TCP/IP协议1.2套接字（Socket）1.3客户端与服务器模型二、客户端程序的设计2.1需求分析2.2流程设计三、具体代码实现3.1伪代码3.2C代码实现四、代码详解4.1初始化套接字库4.2创建套接字4.3绑定本地端口4.4准备服务器地址和端口信息：4.5连接到服务器**：在网络编程中，客户端与服务器之间的通信是一个非常重要
  • LINUX-网络编程 小林's freesky 网络编程网络
    NCP-NetworkControlProtocol-不能互联不同类型的计算机不能互联不同操作系统的计算机TCP-TransfermControlProtocol-可以互联不同类型的、不同操作系统的计算机传输协议TCP/UDPOSI开放模型(尚未有理论实现)应用层|表示层|->高层:数据加密&格式转换会话层|[传输层]:建立主机端到端的链接，为会话层和网络层提供端到端可靠的和透明的数据传输服务，确
  • 探索PyQt：常用函数与代码示例 零 度° pythonpython
    引言PyQt是一个用于创建跨平台GUI应用程序的Python绑定库，它提供了对Qt库的全面访问。在本文中，我们将深入探讨PyQt中的一些常用函数，并通过参数解释和代码示例来帮助您更好地理解它们的用法。PyQt5简介PyQt5是Qtv5的Python绑定，它允许您使用Python语言来创建图形用户界面(GUI)。它包括了Qt的大部分模块，如核心功能、GUI组件、网络编程、多线程等。常用函数与参数解释
  • python实现rpc例子_【转】Python中实现远程调用（RPC、RMI）简单例子 weixin_39781186 python实现rpc例子
    远程调用使得调用远程服务器的对象、方法的方式就和调用本地对象、方法的方式差不多，因为我们通过网络编程把这些都隐藏起来了。远程调用是分布式系统的基础。远程调用一般分为两种，远程过程调用(RPC)和远程方法调用(RMI)。RPCRPC属于函数级别的远程调用，其多是通过HTTP传输数据，数据形式有XML、JSON、序列化数据等。在此，用python做一个xml-rpc的示例。先给服务器端server.p
  • 分享100个最新免费的高匿HTTP代理IP mcj8089 代理IP代理服务器匿名代理免费代理IP最新代理IP
      推荐两个代理IP网站：   1. 全网代理IP：http://proxy.goubanjia.com/   2. 敲代码免费IP：http://ip.qiaodm.com/     120.198.243.130:80,中国/广东省 58.251.78.71:8088,中国/广东省 183.207.228.22:83,中国/
  • mysql高级特性之数据分区 annan211 java数据结构mongodb分区mysql
    mysql高级特性 1 以存储引擎的角度分析，分区表和物理表没有区别。是按照一定的规则将数据分别存储的逻辑设计。器底层是由多个物理字表组成。 2 分区的原理 分区表由多个相关的底层表实现，这些底层表也是由句柄对象表示，所以我们可以直接访问各个分区。存储引擎管理分区的各个底层 表和管理普通表一样(所有底层表都必须使用相同的存储引擎)，分区表的索引只是
  • JS采用正则表达式简单获取URL地址栏参数 chiangfai js地址栏参数获取
    GetUrlParam:function GetUrlParam(param){ var reg = new RegExp("(^|&)"+ param +"=([^&]*)(&|$)"); var r = window.location.search.substr(1).match(reg); if(r!=null
  • 怎样将数据表拷贝到powerdesigner (本地数据库表) Array_06 powerDesigner
    ================================================== 1、打开PowerDesigner12，在菜单中按照如下方式进行操作 file->Reverse Engineer->DataBase 点击后，弹出 New Physical Data Model 的对话框 2、在General选项卡中 Model name:模板名字，自
  • logbackのhelloworld 飞翔的马甲 日志logback
    一、概述 1.日志是啥？ 当我是个逗比的时候我是这么理解的：log.debug()代替了system.out.print(); 当我项目工作时，以为是一堆得.log文件。 这两天项目发布新版本，比较轻松，决定好好地研究下日志以及logback。 传送门1：日志的作用与方法： http://www.infoq.com/cn/articles/why-and-how-log 上面的作
  • 新浪微博爬虫模拟登陆 随意而生 新浪微博
    转载自：http://hi.baidu.com/erliang20088/item/251db4b040b8ce58ba0e1235     近来由于毕设需要，重新修改了新浪微博爬虫废了不少劲，希望下边的总结能够帮助后来的同学们。      现行版的模拟登陆与以前相比，最大的改动在于cookie获取时候的模拟url的请求
  • synchronized 香水浓 javathread
        Java语言的关键字，可用来给对象和方法或者代码块加锁，当它锁定一个方法或者一个代码块的时候，同一时刻最多只有一个线程执行这段代码。当两个并发线程访问同一个对象object中的这个加锁同步代码块时，一个时间内只能有一个线程得到执行。另一个线程必须等待当前线程执行完这个代码块以后才能执行该代码块。然而，当一个线程访问object的一个加锁代码块时，另一个线程仍然
  • maven 简单实用教程 AdyZhang maven
    1. Maven介绍  1.1. 简介 java编写的用于构建系统的自动化工具。目前版本是2.0.9，注意maven2和maven1有很大区别，阅读第三方文档时需要区分版本。 1.2. Maven资源 见官方网站；The 5 minute test，官方简易入门文档；Getting Started Tutorial，官方入门文档；Build Coo
  • Android 通过 intent传值获得null aijuans android
    我在通过intent 获得传递兑现过的时候报错，空指针,我是getMap方法进行传值，代码如下 1 2 3 4 5 6 7 8 9 public void getMap(View view){            Intent i =
  • apache 做代理 报如下错误：The proxy server received an invalid response from an upstream baalwolf response
    网站配置是apache＋tomcat,tomcat没有报错，apache报错是： The proxy server received an invalid response from an upstream server. The proxy server could not handle the request GET /. Reason: Error reading fr
  • Tomcat6 内存和线程配置 BigBird2012 tomcat6
    1、修改启动时内存参数、并指定JVM时区 （在windows server 2008 下时间少了8个小时） 在Tomcat上运行j2ee项目代码时，经常会出现内存溢出的情况，解决办法是在系统参数中增加系统参数：  window下， 在catalina.bat最前面 set JAVA_OPTS=-XX:PermSize=64M -XX:MaxPermSize=128m -Xms5
  • Karam与TDD bijian1013 KaramTDD
    一.TDD         测试驱动开发（Test-Driven Development,TDD）是一种敏捷（AGILE）开发方法论，它把开发流程倒转了过来，在进行代码实现之前，首先保证编写测试用例，从而用测试来驱动开发（而不是把测试作为一项验证工具来使用）。         TDD的原则很简单： a.只有当某个
  • [Zookeeper学习笔记之七]Zookeeper源代码分析之Zookeeper.States bit1129 zookeeper
    public enum States { CONNECTING, //Zookeeper服务器不可用，客户端处于尝试链接状态 ASSOCIATING, //？？？ CONNECTED, //链接建立，可以与Zookeeper服务器正常通信 CONNECTEDREADONLY, //处于只读状态的链接状态，只读模式可以在
  • 【Scala十四】Scala核心八：闭包 bit1129 scala
    Free variable A free variable of an expression is a variable that’s used inside the expression but not defined inside the expression. For instance, in the function literal expression (x: Int) => (x
  • android发送json并解析返回json ronin47 android
    package com.http.test; import org.apache.http.HttpResponse; import org.apache.http.HttpStatus; import org.apache.http.client.HttpClient; import org.apache.http.client.methods.HttpGet; import
  • 一份IT实习生的总结 brotherlamp PHPphp资料php教程php培训php视频
    今天突然发现在不知不觉中自己已经实习了 3 个月了，现在可能不算是真正意义上的实习吧，因为现在自己才大三，在这边撸代码的同时还要考虑到学校的功课跟期末考试。让我震惊的是，我完全想不到在这 3 个月里我到底学到了什么，这是一件多么悲催的事情啊。同时我对我应该 get 到什么新技能也很迷茫。所以今晚还是总结下把，让自己在接下来的实习生活有更加明确的方向。最后感谢工作室给我们几个人这个机会让我们提前出来
  • 据说是2012年10月人人网校招的一道笔试题-给出一个重物重量为X,另外提供的小砝码重量分别为1，3，9。。。3^N。 将重物放到天平左侧，问在两边如何添加砝码 bylijinnan java
    public class ScalesBalance { /** * 题目： * 给出一个重物重量为X,另外提供的小砝码重量分别为1，3，9。。。3^N。 （假设N无限大，但一种重量的砝码只有一个） * 将重物放到天平左侧，问在两边如何添加砝码使两边平衡 * * 分析： * 三进制 * 我们约定括号表示里面的数是三进制，例如 47=(1202
  • dom4j最常用最简单的方法 chiangfai dom4j
    要使用dom4j读写XML文档,需要先下载dom4j包,dom4j官方网站在 http://www.dom4j.org/目前最新dom4j包下载地址:http://nchc.dl.sourceforge.net/sourceforge/dom4j/dom4j-1.6.1.zip 解开后有两个包,仅操作XML文档的话把dom4j-1.6.1.jar加入工程就可以了,如果需要使用XPath的话还需要
  • 简单HBase笔记 chenchao051 hbase
     一、Client-side write buffer 客户端缓存请求 描述：可以缓存客户端的请求，以此来减少RPC的次数，但是缓存只是被存在一个ArrayList中，所以多线程访问时不安全的。 可以使用getWriteBuffer()方法来取得客户端缓存中的数据。 默认关闭。 二、Scan的Caching 描述： next( )方法请求一行就要使用一次RPC,即使
  • mysqldump导出时出现when doing LOCK TABLES daizj mysqlmysqdump导数据
    　　执行　mysqldump -uxxx -pxxx -hxxx -Pxxxx database tablename > tablename.sql　 导出表时，会报 mysqldump: Got error: 1044: Access denied for user 'xxx'@'xxx' to database 'xxx' when doing LOCK TABLES 解决
  • CSS渲染原理 dcj3sjt126com Web
      从事Web前端开发的人都与CSS打交道很多，有的人也许不知道css是怎么去工作的，写出来的css浏览器是怎么样去解析的呢？当这个成为我们提高css水平的一个瓶颈时，是否应该多了解一下呢？          一、浏览器的发展与CSS           
  • 《阿甘正传》台词 dcj3sjt126com
    Part Ⅰ: 《阿甘正传》Forrest Gump经典中英文对白 Forrest: Hello! My names Forrest. Forrest Gump. You wanna Chocolate? I could eat about a million and a half othese. My momma always said life was like a box ochocol
  • Java处理JSON dyy_gusi json
    Json在数据传输中很好用，原因是JSON 比 XML 更小、更快，更易解析。 在Java程序中，如何使用处理JSON，现在有很多工具可以处理，比较流行常用的是google的gson和alibaba的fastjson，具体使用如下： 1、读取json然后处理 class ReadJSON { public static void main(String[] args)
  • win7下nginx和php的配置 geeksun nginx
    1.  安装包准备 nginx :  从nginx.org下载nginx-1.8.0.zip php： 从php.net下载php-5.6.10-Win32-VC11-x64.zip， php是免安装文件。 RunHiddenConsole: 用于隐藏命令行窗口   2. 配置 # java用8080端口做应用服务器，nginx反向代理到这个端口即可 p
  • 基于2.8版本redis配置文件中文解释 hongtoushizi redis
    转载自： http://wangwei007.blog.51cto.com/68019/1548167        在Redis中直接启动redis-server服务时, 采用的是默认的配置文件。采用redis-server   xxx.conf 这样的方式可以按照指定的配置文件来运行Redis服务。下面是Redis2.8.9的配置文
  • 第五章 常用Lua开发库3-模板渲染 jinnianshilongnian nginxlua
    动态web网页开发是Web开发中一个常见的场景，比如像京东商品详情页，其页面逻辑是非常复杂的，需要使用模板技术来实现。而Lua中也有许多模板引擎，如目前我在使用的lua-resty-template，可以渲染很复杂的页面，借助LuaJIT其性能也是可以接受的。   如果学习过JavaEE中的servlet和JSP的话，应该知道JSP模板最终会被翻译成Servlet来执行；而lua-r
  • JZSearch大数据搜索引擎 颠覆者 JavaScript
    系统简介： 大数据的特点有四个层面：第一，数据体量巨大。从TB级别，跃升到PB级别；第二，数据类型繁多。网络日志、视频、图片、地理位置信息等等。第三，价值密度低。以视频为例，连续不间断监控过程中，可能有用的数据仅仅有一两秒。第四，处理速度快。最后这一点也是和传统的数据挖掘技术有着本质的不同。业界将其归纳为4个“V”——Volume，Variety，Value，Velocity。大数据搜索引
  • 10招让你成为杰出的Java程序员 pda158 java编程框架
    如果你是一个热衷于技术的  Java 程序员， 那么下面的 10 个要点可以让你在众多 Java 开发人员中脱颖而出。 　　 1. 拥有扎实的基础和深刻理解 OO 原则 　　对于 Java 程序员，深刻理解 Object Oriented Programming（面向对象编程）这一概念是必须的。没有 OOPS 的坚实基础，就领会不了像 Java 这些面向对象编程语言
  • tomcat之oracle连接池配置 小网客 oracle
    tomcat版本7.0 配置oracle连接池方式： 修改tomcat的server.xml配置文件： <GlobalNamingResources> <Resource name="utermdatasource" auth="Container" type="javax.sql.DataSou
  • Oracle 分页算法汇总 vipbooks oraclesql算法.net
        这是我找到的一些关于Oracle分页的算法，大家那里还有没有其他好的算法没？我们大家一起分享一下！ -- Oracle 分页算法一 select * from ( select page.*,rownum rn from (select * from help) page -- 20 = (currentPag
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他