heartxkl
heartxkl

参考Netty权威指南：Netty4版本的私有协议栈

1、pom文件

 
        
            io.netty
            netty-all
            4.1.19.Final
        
        
            org.msgpack
            msgpack
            0.6.7
        

        
            com.google.protobuf
            protobuf-java
            2.5.0
        
        
            org.projectlombok
            lombok
            1.14.8
        

        
            org.jibx
            jibx-bind
            1.3.1
        

        
            
            
            
        

        
            org.jboss.marshalling
            jboss-marshalling-serial
            1.4.11.Final

重点关注：jboss-marshalling-serial包，一开始我导的不是这个，是上面注释的jboss-marshalling，

结果导致Server无法向Client发送消息。

原因是下面的MarshallingCodeCFactory类，获取marshallerFactory是返回null，没获取到！

MarshallerFactory marshallerFactory = Marshalling.getProvidedMarshallerFactory("serial");


编解码工具类

package com.xkl.learn.privateprotocol.tool;

import java.io.IOException;

import org.jboss.marshalling.MarshallerFactory;
import org.jboss.marshalling.Marshalling;
import org.jboss.marshalling.MarshallingConfiguration;

import io.netty.handler.codec.marshalling.DefaultMarshallerProvider;
import io.netty.handler.codec.marshalling.DefaultUnmarshallerProvider;
import io.netty.handler.codec.marshalling.MarshallerProvider;
import io.netty.handler.codec.marshalling.UnmarshallerProvider;

/**
 * Created by xiekunliang on 2018/2/6.
 */
public class MarshallingCodeCFactory
{
    public static NettyMarshallingDecoder buildMarshallingDecoder() throws IOException
    {
        MarshallerFactory marshallerFactory = Marshalling.getProvidedMarshallerFactory("serial");
        MarshallingConfiguration configuration = new MarshallingConfiguration();
        configuration.setVersion(5);
        UnmarshallerProvider provider = new DefaultUnmarshallerProvider(marshallerFactory, configuration);
        NettyMarshallingDecoder decoder = new NettyMarshallingDecoder(provider, 1024 << 2);
        return decoder;
    }

    public static NettyMarshallingEncoder buildMarshallingEncoder()
    {
        MarshallerFactory marshallerFactory = Marshalling.getProvidedMarshallerFactory("serial");
        MarshallingConfiguration configuration = new MarshallingConfiguration();
        configuration.setVersion(5);

        MarshallerProvider provider = new DefaultMarshallerProvider(marshallerFactory, configuration);
        NettyMarshallingEncoder encoder = new NettyMarshallingEncoder(provider);
        return encoder;
    }
}
package com.xkl.learn.privateprotocol.tool;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.marshalling.MarshallerProvider;
import io.netty.handler.codec.marshalling.MarshallingEncoder;

/**
 * Created by xiekunliang on 2018/2/5.
 * 编码器
 */
public class NettyMarshallingEncoder extends MarshallingEncoder
{

    /**
     * Creates a new encoder.
     *
     * @param provider the {@link MarshallerProvider} to use
     */
    public NettyMarshallingEncoder(MarshallerProvider provider)
    {
        super(provider);
    }

    @Override
    public void encode(ChannelHandlerContext ctx, Object msg, ByteBuf out)  {
        try {
            super.encode(ctx, msg, out);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}


package com.xkl.learn.privateprotocol.tool;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.marshalling.MarshallingDecoder;
import io.netty.handler.codec.marshalling.UnmarshallerProvider;

/**
 * Created by xiekunliang on 2018/2/5.
 * 解码器
 */
public class NettyMarshallingDecoder extends MarshallingDecoder
{

    public NettyMarshallingDecoder(UnmarshallerProvider provider, int objectMaxSize) {
        super(provider, objectMaxSize);
    }

    public NettyMarshallingDecoder(UnmarshallerProvider provider) {
        super(provider);
    }
    @Override
    public Object decode(ChannelHandlerContext ctx, ByteBuf in)  {
        try {
            return super.decode(ctx, in);
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

}

业务消息：编码Handler

package com.xkl.learn.privateprotocol;

import java.io.IOException;
import java.util.List;
import java.util.Map;

import com.xkl.learn.privateprotocol.tool.MarshallingCodeCFactory;
import com.xkl.learn.privateprotocol.tool.NettyMarshallingEncoder;

import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.MessageToMessageEncoder;

/**
 * Created by xiekunliang on 2018/2/5.
 */
public class NettyMessageEncoder extends MessageToMessageEncoder
{

    NettyMarshallingEncoder nettyMarshallingEncoder;

    public NettyMessageEncoder() throws IOException
    {
        nettyMarshallingEncoder = MarshallingCodeCFactory.buildMarshallingEncoder();
    }

    @Override
    protected void encode(ChannelHandlerContext ctx, NettyMessage msg, List out) throws Exception
    {
        if (msg == null || msg.getHeader() == null)
        {
            throw new Exception("The encode message is null");
        }
        ByteBuf sendBuf = Unpooled.buffer();
        sendBuf.writeInt(msg.getHeader().getCrcCode());
        sendBuf.writeInt(msg.getHeader().getLength());
        sendBuf.writeLong(msg.getHeader().getSessionID());
        sendBuf.writeByte(msg.getHeader().getType());
        sendBuf.writeByte(msg.getHeader().getPriority());
        sendBuf.writeInt(msg.getHeader().getAttachment().size());
        for (Map.Entry entry : msg.getHeader().getAttachment().entrySet())
        {
            String key = entry.getKey();
            byte[] keyArray = key.getBytes("UTF-8");
            sendBuf.writeInt(keyArray.length);
            sendBuf.writeBytes(keyArray);
            Object value = entry.getValue();
            nettyMarshallingEncoder.encode(ctx, value, sendBuf);
        }

        if (msg.getBody() != null)
        {
            nettyMarshallingEncoder.encode(ctx, msg.getBody(), sendBuf);
        }
        sendBuf.setInt(4, sendBuf.readableBytes());
        out.add(sendBuf);
    }

} 
  

 
  
业务消息：解码Handler
 
  
package com.xkl.learn.privateprotocol;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

import com.xkl.learn.privateprotocol.tool.MarshallingCodeCFactory;
import com.xkl.learn.privateprotocol.tool.NettyMarshallingDecoder;

import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.LengthFieldBasedFrameDecoder;

/**
 * Created by xiekunliang on 2018/2/7.
 */
public class NettyMessageDecoder extends LengthFieldBasedFrameDecoder
{

    NettyMarshallingDecoder marshallingDecoder;

    public NettyMessageDecoder(int maxFrameLength, int lengthFieldOffset, int lengthFieldLength, int lengthAdjustment,
            int initialBytesToStrip) throws IOException
    {
        super(maxFrameLength, lengthFieldOffset, lengthFieldLength, lengthAdjustment, initialBytesToStrip);

        marshallingDecoder = MarshallingCodeCFactory.buildMarshallingDecoder();
    }

    @Override
    protected Object decode(ChannelHandlerContext ctx, ByteBuf in) throws Exception
    {
        ByteBuf frame = (ByteBuf) super.decode(ctx, in);
        if (frame == null)
        {
            System.out.println("解码器返回null");
            return null;
        }

        NettyMessage message = new NettyMessage();
        Header header = new Header();
        header.setCrcCode(frame.readInt());
        header.setLength(frame.readInt());
        header.setSessionID(frame.readLong());
        header.setType(frame.readByte());
        header.setPriority(frame.readByte());

        // 得到附件个数
        int attachSize = frame.readInt();
        if (attachSize > 0)
        {
            Map attachment = new HashMap<>();
            for (int i = 0; i < attachSize; i++)
            {
                int keySize = frame.readInt();
                byte[] keyArray = new byte[keySize];
                frame.readBytes(keyArray);
                String key = new String(keyArray, "UTF-8");
                Object val = marshallingDecoder.decode(ctx, frame);
                attachment.put(key, val);
            }
            header.setAttachment(attachment);
        }
        
        if (frame.readableBytes() > 0)
        {
            message.setBody(marshallingDecoder.decode(ctx, frame));
        }
        message.setHeader(header);
        return message;

    }

}

 
  

 
  
业务消息pojo
 
  
package com.xkl.learn.privateprotocol;
import lombok.Data;

/**
 * 消息s
 */
@Data
public final class NettyMessage
{
    private Header header;

    private Object body;
}
 
  
package com.xkl.learn.privateprotocol;

import java.util.HashMap;
import java.util.Map;

import lombok.Data;

/**
 * Created by xiekunliang on 2018/2/5.
 */
@Data
public class Header
{

    private int crcCode = 0xabef0101;

    // 消息长度
    private int length;

    private long sessionID;

    /**
     * @see MessageType
     */
    private byte type;

    private byte priority;

    private Map attachment = new HashMap<>();
}

 
  
MessageType类
 
  
package com.xkl.learn.privateprotocol;


public interface MessageType
{

    Byte BUSINESS_REQ = 0;

    Byte BUSINESS_RESP = 1;

    Byte BUSINESS_ONE_WAY = 2;

    Byte LOGIN_REQ = 3;

    Byte LOGIN_RESP = 4;

    Byte HEARTBEAT_REQ = 5;

    Byte HEARTBEAT_RESP = 6;
}
 
  
 
  
Client : 握手请求 LoginAuthReqHandler
 
  
package com.xkl.learn.privateprotocol;

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

/**
 * Created by xiekunliang on 2018/2/24.
 */
public class LoginAuthReqHandler extends ChannelInboundHandlerAdapter
{
    @Override
    public void channelActive(ChannelHandlerContext ctx) throws Exception
    {
        NettyMessage message = buildLoginReq();
        ctx.writeAndFlush(message);
        System.out.println("客户端发送握手请求：" + message);
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception
    {
        NettyMessage message = (NettyMessage) msg;
        // 如果是握手应答消息，需要判断是否握手成功
        if (message.getHeader() != null && message.getHeader().getType() == MessageType.LOGIN_RESP)
        {
            if (message.getBody() != null)
            {
                String loginResult = message.getBody().toString();
                if (loginResult.equals("login_ok"))
                {
                    System.out.println("Login is success :" + message);
                    // 透传给后面的Handler处理
                    ctx.fireChannelRead(msg);
                }
                else
                {
                    // 握手失败，关闭连接
                    ctx.close();
                    System.out.println("握手失败，关闭连接");
                }
            }
            else
            {
                // 握手失败，关闭连接
                ctx.close();
                System.out.println("握手失败，关闭连接");
            }
        }
        else
        {
            // 如果不是握手应答消息，直接透传
            ctx.fireChannelRead(msg);
        }
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception
    {
        ctx.flush();
    }

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

    private NettyMessage buildLoginReq()
    {
        NettyMessage message = new NettyMessage();
        Header header = new Header();
        header.setType(MessageType.LOGIN_REQ);
        message.setHeader(header);
        return message;
    }
}

 
  

Server: 握手应答LoginAuthRespHandler
 
  
package com.xkl.learn.privateprotocol;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

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

/**
 * Created by xiekunliang on 2018/2/24.
 */
public class LoginAuthRespHandler extends ChannelInboundHandlerAdapter
{
    // 白名单，暂时简单处理，写死了
    private String[] writeList = { "/127.0.0.1" };

    // 已经登录的IP缓存，防止重复登录
    private Map nodeCheck = new ConcurrentHashMap<>();

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception
    {
        ctx.flush();
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception
    {
        NettyMessage message = (NettyMessage) msg;
        // 如果是握手请求消息
        if (message.getHeader() != null && message.getHeader().getType() == MessageType.LOGIN_REQ)
        {
            System.out.println("receive client login req : " + message);
            NettyMessage loginResp = null;
            String nodeIndex = ctx.channel().remoteAddress().toString().split(":")[0];
            // 判断是否重复登录
            if (nodeCheck.containsKey(nodeIndex))
            {
                loginResp = buildResponse("login_repeat");
            }
            else
            {
                // 判断是否属于白名单中的IP
                boolean tag = false;
                for (String ip : writeList)
                {
                    if (ip.equals(nodeIndex))
                    {
                        tag = true;
                        break;
                    }
                }
                if (tag)
                {
                    nodeCheck.put(nodeIndex, true);
                    loginResp = buildResponse("login_ok");
                }
                else
                {
                    loginResp = buildResponse("login_fail");
                }
                ctx.writeAndFlush(loginResp);
                System.out.println("send login resp is : " + loginResp);
            }
        }
        else
        {
            ctx.fireChannelRead(msg);
        }

    }

    private NettyMessage buildResponse(String result)
    {
        NettyMessage message = new NettyMessage();
        Header header = new Header();
        header.setType(MessageType.LOGIN_RESP);
        message.setHeader(header);
        message.setBody(result);
        return message;
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception
    {
        try
        {
            ctx.fireExceptionCaught(cause);
        }
        finally
        {
            // 异常发生时，把登录缓存清除
            nodeCheck.remove("/127.0.0.1");
        }

    }
}

 
  

 
  
Client: 心跳请求HeartBeatReqHandler
 
  
package com.xkl.learn.privateprotocol;

import java.util.concurrent.ScheduledFuture;
import java.util.concurrent.TimeUnit;
import io.netty.channel.ChannelHandlerContext;
import io.netty.channel.ChannelInboundHandlerAdapter;

public class HeartBeatReqHandler extends ChannelInboundHandlerAdapter
{

    private volatile ScheduledFuture heartBeat;

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception
    {
        // 如果握手成功，主动发送心跳消息
        NettyMessage message = (NettyMessage) msg;
        Header header = message.getHeader();
        if (header != null)
        {
            if (header.getType() == MessageType.LOGIN_RESP)
            {
                if (heartBeat == null)
                {
                    heartBeat = ctx.executor().scheduleAtFixedRate(new HeartBeatTask(ctx),
                            0,
                            5000,
                            TimeUnit.MILLISECONDS);
                }
            }
            else if (header.getType() == MessageType.HEARTBEAT_RESP)
            {
                System.out.println("Client receive server heart beat message :" + message);
            }
            else
            {
                ctx.fireChannelRead(msg);
            }
        }
        else
        {
            ctx.fireExceptionCaught(new Throwable("没有Header"));
        }
    }

    @Override
    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception
    {
        try
        {
            ctx.fireExceptionCaught(cause);
        }
        finally
        {
            closeHeartBeat();
        }

    }

    private void closeHeartBeat()
    {
        if (heartBeat != null)
        {
            heartBeat.cancel(true);
            heartBeat = null;
        }
    }

    private class HeartBeatTask implements Runnable
    {
        final ChannelHandlerContext ctx;

        public HeartBeatTask(final ChannelHandlerContext ctx)
        {
            this.ctx = ctx;
        }

        @Override
        public void run()
        {
            ctx.writeAndFlush(buildHeartBeat());
            System.out.println("Client send heart beat message to server : ----> " + heartBeat);
        }

    }

    private NettyMessage buildHeartBeat()
    {
        NettyMessage heartBeat = new NettyMessage();
        Header header = new Header();
        header.setType(MessageType.HEARTBEAT_REQ);
        heartBeat.setHeader(header);
        heartBeat.setBody(null);
        return heartBeat;
    }

}

 
  
Server: 心跳应答HeartBeatRespHandler
 
  
package com.xkl.learn.privateprotocol;

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


public class HeartBeatRespHandler extends ChannelInboundHandlerAdapter
{
    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception
    {

        NettyMessage message = (NettyMessage) msg;
        if (message.getHeader() != null && message.getHeader().getType() == MessageType.HEARTBEAT_REQ)
        {
            System.out.println("Receive client heart beat message");
            ctx.writeAndFlush(buildHeartBeat());
            System.out.println("Send heart beat message to client");
        } else {
            ctx.fireChannelRead(msg);
        }
    }

    @Override
    public void channelReadComplete(ChannelHandlerContext ctx) throws Exception {
        ctx.flush();
    }

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

    private NettyMessage buildHeartBeat()
    {
        NettyMessage heartBeat = new NettyMessage();
        Header header = new Header();
        header.setType(MessageType.HEARTBEAT_RESP);
        heartBeat.setHeader(header);
        heartBeat.setBody(null);
        return heartBeat;
    }
}

 
  
Client类
 
  
package com.xkl.learn.privateprotocol;

import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

import io.netty.bootstrap.Bootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
import io.netty.channel.EventLoopGroup;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.timeout.ReadTimeoutHandler;

/**
 * Created by xiekunliang on 2018/2/24.
 */
public class NettyClient
{

    private ScheduledExecutorService executorService = Executors.newScheduledThreadPool(1);

    private EventLoopGroup group = new NioEventLoopGroup();

    public static void main(String[] args) throws Exception
    {

        String host = "127.0.0.1";
        int port = 18080;
        new NettyClient().connect(host, port);
    }

    private void connect(String host, int port) throws Exception
    {
        try
        {
            Bootstrap b = new Bootstrap();
            b.group(group)
                    .option(ChannelOption.TCP_NODELAY, true)
                    .channel(NioSocketChannel.class)
                    .handler(new ChannelInitializer()
                    {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception
                        {
                            // NettyMessageDecoder设置了单条消息最大值1MB,可以防止消息过大导致的内存溢出或者畸形码流，引发解码错位或内存分配失败
                            ch.pipeline().addLast(new NettyMessageDecoder(1024 * 1024, 4, 4, -8, 0));
                            ch.pipeline().addLast(new NettyMessageEncoder());
                            ch.pipeline().addLast(new ReadTimeoutHandler(50));
                            ch.pipeline().addLast(new LoginAuthReqHandler());
                            ch.pipeline().addLast(new HeartBeatReqHandler());
                        }
                    });

            ChannelFuture f = b.connect(host, port).sync();
            System.out.println("连接成功-----> " + host + ":" + port);
            f.channel().closeFuture().sync();
        }
        finally
        {

            // 发起重连操作
            executorService.execute(() -> {
                try
                {
                    TimeUnit.SECONDS.sleep(5);
                    connect(host, port);
                }
                catch (Exception e)
                {
                    e.printStackTrace();
                }
            });
        }

    }
}
 
  
 
  
 
  
 
  
 
  

 
  
Server类
 
  
package com.xkl.learn.privateprotocol;

import io.netty.bootstrap.ServerBootstrap;
import io.netty.channel.ChannelFuture;
import io.netty.channel.ChannelInitializer;
import io.netty.channel.ChannelOption;
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.logging.LogLevel;
import io.netty.handler.logging.LoggingHandler;
import io.netty.handler.timeout.ReadTimeoutHandler;

/**
 * Created by xiekunliang on 2018/2/24.
 */
public class NettyServer
{

    public static void main(String[] args) throws Exception
    {
        new NettyServer().bind();
    }

    public void bind() throws Exception
    {
        EventLoopGroup boss = new NioEventLoopGroup();
        EventLoopGroup work = new NioEventLoopGroup();
        try
        {
            ServerBootstrap b = new ServerBootstrap();
            b.group(boss, work)
                    .channel(NioServerSocketChannel.class)
                    .option(ChannelOption.SO_BACKLOG, 1024)
                    .option(ChannelOption.TCP_NODELAY, true)
                    .handler(new LoggingHandler(LogLevel.INFO))
                    .childHandler(new ChannelInitializer()
                    {
                        @Override
                        protected void initChannel(SocketChannel ch) throws Exception
                        {
                            ch.pipeline().addLast(new NettyMessageDecoder(1024 * 1024, 4, 4, -8, 0));
                            ch.pipeline().addLast(new NettyMessageEncoder());
                            ch.pipeline().addLast(new ReadTimeoutHandler(50));
                            ch.pipeline().addLast(new LoginAuthRespHandler());
                            ch.pipeline().addLast(new HeartBeatRespHandler());
                        }
                    });

            ChannelFuture f = b.bind(18080).sync();

            System.out.println("Netty Server start ok! post is 18080");
            f.channel().closeFuture().sync();
        }
        finally
        {
            boss.shutdownGracefully();
            work.shutdownGracefully();
        }

    }

}
 
  
运行测试时要注意：
 
  
1、断开自动重连是否正常。
 
  
2、断连时，心跳是否停止？
 
  
如果没有停止可能原因是在Handler的exceptionCaught方法里关闭了ctx，而没有将异常信息透传过去。
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Netty)

        

            

                
    
                    
  • netty-简易聊天
                        2401_84046645
程序员java开发语言
                        
    publicvoidsend(Stringtext){channel.writeAndFlush(Unpooled.copiedBuffer(text.getBytes()));}publicvoidcloseConnect(){send(“bye”);channel.close();}}classMyHandlerextendsChannelInboundHandlerAdapter{@Over
    
                    
    • 
                    
  • Netty权威指南：Netty总结-高性能与可靠性
                        Ty_1106
Nettyjava网络rpc
                        
    第二十二章高性能之道22.1RPC调用性能模型分析22.1.1传统RPC调用性能差三宗罪：网络传输采用同步阻塞I/O导致经常性阻塞序列化性能差线程模型问题22.1.2I/O通信性能三要素传输：BIO、NIO或者AIO协议：HTTP公有协议，内部私有协议线程：数据报如何读取，Reactor线程模型22.2Netty高性能之道22.2.1异步非阻塞通信I/O多路复用技术22.2.2高效的Reactor
    
                    
    • 
                    
  • netty4源码阅读与分析---netty线程模型
                        红尘之一骑
javaNIOnetty源码阅读与分析
                        
    本文主要说下我自己对netty线程模型的理解，以及这样的线程模型的好处。通俗的来讲，netty的线程模型描述的就是老板和员工的故事。老板(通常情况下是一个老板)负责接活，与客户沟通，协调(netty的accept),谈成后(通道建立)，他需要从员工中选出一位员工来负责处理后续具体的事宜(worker线程，这里我们有16位员工，编号1-16)，员工做事时按照任务的先后顺序进行处理，这样可以避免错乱，
    
                    
    • 
                    
  • 深度长文解析SpringWebFlux响应式框架15个核心组件源码
                        快乐非自愿
javaspring
                        
    SpringWebFlux介绍SpringWebFlux是SpringFramework5.0版本引入的一个响应式Web框架，它与SpringMVC并存，提供了一种全新的编程范式，支持异步非阻塞的Web应用开发。WebFlux完全基于响应式编程模型，支持ReactiveStreams规范，可以在诸如Netty、Undertow以及Servlet3.1+容器上运行。WebFlux的核心控制器是Dis
    
                    
    • 
                    
  • 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连接，硬件作
    
                    
    • 
                    
  • java reactor模式例子_Netty Reactor模式实现原理详解
                        weixin_39923623
javareactor模式例子
                        
    在前面的文章中(Reactor模型详解)，我们讲解了Reactor模式的各种演变形式，本文主要讲解的则是Netty是如何实现Reactor模式的。这里关于Netty实现的Reactor模式，需要说明的是，其实现的模式如下图所示：对于Netty使用的Reactor模式，其主要特点如下：使用一个线程作为mainReactor，专门用于监听客户端的连接事件，当获取到事件之后就将该事件交由Acceptor
    
                    
    • 
                    
  • Netty实战二-实现UDP的单播和广播(1)
                        2401_84048671
程序员udp网络协议网络
                        
    publicclassAnswerHandlerextendsSimpleChannelInboundHandler{/应答的具体内容从常量字符串数组中取得，由nextQuote方法随机获取/privatestaticfinalString[]DICTIONARY={“一个男生暗恋一个女生很久了。一天自习课上，男生偷偷的传了小纸条给女生，上面写着“其实我注意你很久了”。不一会儿，女生传了另一张纸条
    
                    
    • 
                    
  • netty源码解读三（NioEventLoop）
                        orcharddd_real
nettyjavanetty
                        
    NioEventLoop初始化EventExecutor类型的数组数组大小默认为cpu数量的两倍，遍历数组，通过newNioEventLoop(xxx)往数组中添加元素，NioEventLoop继承了EventExecutor；每次需要线程时，执行chooser的next方法从数组中取出一个线程；关键代码打开netty源码，找到example包下的EchoService类，追溯创建boss线程组和
    
                    
    • 
                    
  • Netty源码分析:NioEventLoopGroup
                        HelloWorld_EE
netty源码分析源代码nettyEventLoop
                        
    Netty源码分析:NioEventLoopGroup在工作之余，看到自己公司的超哥（俞超）关于Netty的系列博文，讲解的很好，因此，自己在学习之余也跟了下源代码，来了解Netty，也做了相关的笔记，将形成系列博文，这是第一篇。超哥的博文地址在这里：http://www.jianshu.com/p/c5068caab217Netty版本：4.0.23.Final借用超哥的例子，一般服务端的代码如
    
                    
    • 
                    
  • netty-NioServerSocketChannel和boss NioEventLoopGroup 如何建立关系的
                        一个人的想法
javanetty
                        
    一、EventLoopGroupbossGroup=newNioEventLoopGroup();EventLoopGroupworkerGroup=newNioEventLoopGroup();1、boss或者workerNioEventLoopGroup初始化完成了一个NioEventLoop数组（默认机器核数的2倍）所有NioEventLoop持有了同一个Executor调用execute时
    
                    
    • 
                    
  • 经验笔记：RPC与高性能NIO框架
                        漆黑的莫莫
计算机网络笔记rpcnio
                        
    RPC与高性能NIO框架的经验笔记引言随着互联网技术的发展，分布式系统逐渐成为了现代软件架构的标准之一。在这种架构中，服务之间的通信变得尤为关键，而RPC（远程过程调用）作为一种服务间通信的方式，因其简便的使用方式和高效的性能表现而受到了广泛的关注。在实现RPC的过程中，选择合适的网络通信框架至关重要，尤其是那些基于NIO（非阻塞I/O）的高性能框架，如Netty。本文将首先介绍RPC的概念及其在
    
                    
    • 
                    
  • 基础学习之——Netty
                        北欧人写代码
学习网络服务器
                        
    Netty是一个基于Java的网络通信框架，提供了一种简单、高效、可扩展的方式来开发网络服务器和客户端应用程序。Netty的设计目标是提供一种统一的异步编程模型，使得开发者能够轻松地编写可维护和可重用的代码。Netty的核心组件包括：Channel：网络通信的通道，可以用于读取、写入和关闭操作。EventLoop：负责处理I/O事件，包括接收、发送和处理数据。ChannelHandler：用于处理
    
                    
    • 
                    
  • Springboot-websocket实现及底层原理
                        No.Ada
深入项目底层原理springbootwebsocket后端
                        
    引入依赖SpringBoot中的WebSocket依赖于SpringWebFlux模块，使用了ReactorNetty库来实现底层的WebSocket通信。org.springframework.bootspring-boot-starter-websocket服务端配置/***WebSocket配置类*/@ConfigurationpublicclassWebSocketConfig{/***注
    
                    
    • 
                    
  • 【Netty】实战：基于WebSocket的聊天室
                        马丁的代码日记
netty聊天室网络websockethttp
                        
    本文将使用Netty快速实现一个聊天室应用，该应用基于WebSocket协议，用户可以在浏览器内聊天。实现过程很简单，就几步。一、处理Http请求packagecn.md.netty.websocket.groupchat;importio.netty.channel.*;importio.netty.handler.codec.http.*;importio.netty.handler.ssl.
    
                    
    • 
                    
  • 精通 Spring Cloud Feign：从理论到实战的通信优化之路
                        TopicOnline
springcloud
                        
    一、服务间调用的几种方式使用SpringCloud开发微服务时，在服务消费者调用服务提供者时，底层通过HTTPClient的方式访问。但实际上在服务调用时，有主要以下来实现：使用JDK原生的URLConnection；Apache提供的HTTPClient；Netty提供的异步HTTPClient；Spring提供的RestTemplate。SpringCloud的SpringCloudOpenF
    
                    
    • 
                    
  • Dubbo与Netty
                        蹩脚的小三

                        
    CodecCodecSupportAbstractCodecTransportCodecCodecAdapterDispacherChannelHandlersDispatcherAllDispatcherAllChannelHandlerChannelEventRunnableWrappedChannelHandlerChannelHandlerChannelHandlerAdapterChan
    
                    
    • 
                    
  • netty开发模拟qq斗地主
                        平平无奇的Coding Peasant
nettyqq斗地主
                        
    为什么要搞这样一个项目满足自己的java网络多线程编程的欲望！因为之前一直都是搞web开发，服务器和客户端数据交流人家web服务器早就给你搞好了，比如tomcat,jetty...等等，其实之前脑子里就有想过--是否可以自己开发一个简单的类似tomcat的web服务器，这样做了的话，至少知道其实web开发是建立在网络多线程web服务器之上否则web开发无从谈起！市面上的书籍和互联网上的电子教材以及
    
                    
    • 
                    
  • Netty 知识目录
                        王小工
javajava
                        
    Netty知识结构NettyBootstrap/ServerBootstrapNettyEventLoopGroup/EventLoopNettyChannelNettyChannelPipeline/ChannelHandlerNettyByteBufNettyTCPNettyUDPNettyHTTPNettyWebsocketNettySSL/TLS
    
                    
    • 
                    
  • elasticsearch简单介绍
                        甜美河边的钓鱼人
elasticsearch
                        
    1、elasticsearch简单介绍elasticsearch是基于操作文档的搜索引擎，里面使用了netty，luncen相关技术。它可以用作站内搜索，也可以结合Logstash，kibana等技术进行日志收集分析，使用聚合技术可以进行各种数据的聚合，并且和kibana一起展示条形图，饼图，map地理分布等功能。1.1、elasticsearch的安装因为是练习用的，所以我直接使用windows
    
                    
    • 
                    
  • Netty UDP
                        王小工
javaudp网络协议网络javanio
                        
    Netty在UDP（用户数据报协议，UserDatagramProtocol）通信中的应用非常广泛，特别是在对实时性要求较高、对数据准确性要求相对较低的场景中，如视频传输、语音通信等。以下是对Netty在UDP通信中的详细解析：一、UDP协议简介UDP是一种无连接的协议，它并不在通信双方之间建立连接，而是直接将数据包从发送端发送到接收端。UDP不保证数据包的可靠传输，也不保证数据包的顺序，因此其传
    
                    
    • 
                    
  • 【四、使用Netty编写UDP应用】
                        ThinkLess404
Netty网络编程udp网络协议网络
                        
    编写UDP应用目标创建UDPServer创建ServerHandler创建UDP客户端创建客户端的Handler目标之前的章节我们学习了编码服务端，使用TCP通信，本章我们学习如何使用Netty构建一个UDP应用。创建UDPServerpackagecom.coman404.base;importcom.coman404.base.handler.UDPServerHandler;importio
    
                    
    • 
                    
  • linux部署jar项目报错_linux jar 服务
                        国家级做梦冠军
linux部署jar项目报错
                        
    关于linuxjar服务的搜索结果问题linux重启netty服务一些问题，请大神进linux上部署netty架构的服务时我一般启动的时候用下面脚本nohupjava-jarxxx-xxx.jarstart80808888&关闭的时候杀进程就可以了。今天部署的时候启动服务就报userBind，于是我查...杨冬芳2019-12-0120:26:501161浏览量回答数0问题Linux下Tomcat
    
                    
    • 
                    
  • Spring Cloud全解析：网关之GateWay简介
                        拾光师
springcloudjava
                        
    GateWay简介由于zuul升级为zuul2时，netflix公司内部出现了分歧，所以springcloud自己研发了一套网关gateway，提供一种简单有效的方式来对API进行路由，以及提供一些强大的过滤器功能，如：熔断、限流、重试等，基于WebFlux框架实现的，底层使用了高性能的Reactor模式通信框架Netty特性基于spring5和springboot2构建动态路由：能够匹配任何请求
    
                    
    • 
                    
  • Netty+WebSocket实现高并发网络编程
                        Sunny_yiyi
Java精英阶级JavaWebSocket网络websocket网络协议
                        
    我们来实现一个Netty+WebSocket集成案例，由于Netty+WebSocket集成代码比较麻烦，我们可以利用目前开源的项目netty-websocket-spring-boot-starter轻松实现Netty和WebSocket的集成。我们搭建一个项目，项目叫seckill-message，用于处理通知用户抢单状态。1)pom.xmlorg.yeauty</groupId
    
                    
    • 
                    
  • Spring Boot 一个极简且完整的后台框架
                        搬砖养女人
数据库架构javaspringsqltomcat
                        
    一个完整的极简后台框架，方便做小项目的时候可以快速开发。这里面多贴图片和代码，做个参考吧，代码可以下载下来自己看看，里面这套后台模板不错，喜欢的拿去。先放几张图imageimageimage项目介绍SpringBoot，实现了一个极简单的后台框架image小编提供免费的Java架构学习资料（里面有高可用、高并发、高性能及分布式、Jvm性能调优、Spring源码，MyBatis，Netty,Redi
    
                    
    • 
                    
  • netty编程
                        chenjunxu

                        
    需要导包：netty-all-4.1.25.Final或者导入依赖：io.nettynetty-all4.1.25.Final定义一个server类：publicclassHelloServer{publicstaticvoidmain(String[]args){//定义一对线程组//主线程组,用于接受客户端的连接，但是不做任何处理，跟老板一样，不做事EventLoopGroupbossGrou
    
                    
    • 
                    
  • Simple RPC - 05 从零开始设计一个客户端（下）_ 依赖倒置和SPI
                        小小工匠
【SimpleRPC】rpc网络协议网络
                        
    文章目录Pre概述依赖倒置原则与解耦设计与实现1.定义接口来隔离调用方与实现类2.实现类`DynamicStubFactory`3.调用方与实现类的解耦依赖注入与SPI的解耦依赖注入SPI（ServiceProviderInterface）总结PreSimpleRPC-01框架原理及总体架构初探SimpleRPC-02通用高性能序列化和反序列化设计与实现SimpleRPC-03借助Netty实现异
    
                    
    • 
                    
  • 使用Netty实现 WebSocket至Socket的消息转发服务
                        Leon-aHandler
websocket服务器网络协议nettyspringboot
                        
    业务需求场景：通过网页发送指令至硬件设备，并在连接过程中能够接收来自硬件设备的实时参数信息中转服务器逻辑：服务器内实现了一个websocket服务端和一个socket客户端，设置全局保存的ChannelGroup进行消息的转发。项目框架使用的是Springboot代码地址：https://github.com/Leon-aHandler/Netty-relayDemo
    
                    
    • 
                    
  • Netty Websocket
                        王小工
javawebsocketjavanio
                        
    一、WebSocket协议概述WebSocket是一种在单个TCP连接上进行全双工通信的协议。它允许服务端主动向客户端推送数据，从而实现了实时通信。WebSocket建立在HTTP之上，但与HTTP的轮询（Polling）和长轮询（LongPolling）相比，WebSocket只需一次握手，即可在客户端和服务器之间建立持久的连接，并通过这个连接进行双向数据传输。二、Netty框架简介Netty是
    
                    
    • 
                    
  • Netty 实现 WebSocket 协议
                        最业余的程序猿
nettywebsocket网络协议网络
                        
    要使用Netty框架实现WebSocket服务端与客户端通信，你需要按照以下步骤进行：1、添加依赖首先，在你的项目中引入Netty和其WebSocket支持库的依赖。如果你使用Maven构建项目，可以在pom.xml文件中添加相应的依赖项。Maven:io.nettynetty-all4.1.77.Finalorg.springframework.bootspring-boot-starter-w
    
                    
    • 
                                
  • HQL之投影查询
                                    归来朝歌
HQLHibernate查询语句投影查询
                                    
            在HQL查询中，常常面临这样一个场景，对于多表查询，是要将一个表的对象查出来还是要只需要每个表中的几个字段，最后放在一起显示？ 
针对上面的场景，如果需要将一个对象查出来： 
HQL语句写“from 对象”即可 
Session session = HibernateUtil.openSession();
		
    
                                
    • 
                                
  • Spring整合redis
                                    bylijinnan
redis
                                    
    pom.xml 
 

<dependencies>
		<!-- Spring Data - Redis Library -->
		<dependency>
			<groupId>org.springframework.data</groupId>
			<artifactId>spring-data-redi
    
                                
    • 
                                
  • org.hibernate.NonUniqueResultException: query did not return a unique result: 2
                                    0624chenhong
Hibernate
                                    
    参考：http://blog.csdn.net/qingfeilee/article/details/7052736 
org.hibernate.NonUniqueResultException: query did not return a unique result: 2 
        在项目中出现了org.hiber
    
                                
    • 
                                
  • android动画效果
                                    不懂事的小屁孩
android动画
                                    
    前几天弄alertdialog和popupwindow的时候，用到了android的动画效果，今天专门研究了一下关于android的动画效果，列出来，方便以后使用。 
 
Android 平台提供了两类动画。 一类是Tween动画，就是对场景里的对象不断的进行图像变化来产生动画效果（旋转、平移、放缩和渐变）。 
第二类就是 Frame动画，即顺序的播放事先做好的图像，与gif图片原理类似。 
 

    
                                
    • 
                                
  • js delete 删除机理以及它的内存泄露问题的解决方案
                                    换个号韩国红果果
JavaScript
                                    
    delete删除属性时只是解除了属性与对象的绑定，故当属性值为一个对象时，删除时会造成内存泄露  （其实还未删除） 
举例： 

var person={name:{firstname:'bob'}}
var p=person.name
delete person.name
p.firstname  -->'bob'
// 依然可以访问p.firstname，存在内存泄露
    
                                
    • 
                                
  • Oracle将零干预分析加入网络即服务计划
                                    蓝儿唯美
oracle
                                    
    由Oracle通信技术部门主导的演示项目并没有在本月较早前法国南斯举行的行业集团TM论坛大会中获得嘉奖。但是，Oracle通信官员解雇致力于打造一个支持零干预分配和编制功能的网络即服务（NaaS）平台，帮助企业以更灵活和更适合云的方式实现通信服务提供商（CSP）的连接产品。这个Oracle主导的项目属于TM Forum Live!活动上展示的Catalyst计划的19个项目之一。Catalyst计
    
                                
    • 
                                
  • spring学习——springmvc（二）
                                    a-john
springMVC
                                    
    Spring MVC提供了非常方便的文件上传功能。 
1，配置Spring支持文件上传： 
DispatcherServlet本身并不知道如何处理multipart的表单数据，需要一个multipart解析器把POST请求的multipart数据中抽取出来，这样DispatcherServlet就能将其传递给我们的控制器了。为了在Spring中注册multipart解析器，需要声明一个实现了Mul
    
                                
    • 
                                
  • POJ-2828-Buy Tickets
                                    aijuans
ACM_POJ
                                    
    POJ-2828-Buy Tickets 
http://poj.org/problem?id=2828 
线段树，逆序插入 
 
#include<iostream>#include<cstdio>#include<cstring>#include<cstdlib>using namespace std;#define N 200010struct
    
                                
    • 
                                
  • Java Ant build.xml详解
                                    asia007
build.xml
                                    
    1,什么是antant是构建工具2,什么是构建概念到处可查到，形象来说，你要把代码从某个地方拿来，编译，再拷贝到某个地方去等等操作，当然不仅与此，但是主要用来干这个3,ant的好处跨平台   --因为ant是使用java实现的，所以它跨平台使用简单--与ant的兄弟make比起来语法清晰--同样是和make相比功能强大--ant能做的事情很多，可能你用了很久，你仍然不知道它能有
    
                                
    • 
                                
  • android按钮监听器的四种技术
                                    百合不是茶
androidxml配置监听器实现接口
                                    
    android开发中经常会用到各种各样的监听器,android监听器的写法与java又有不同的地方;  
  
1,activity中使用内部类实现接口 ,创建内部类实例  使用add方法  与java类似 
  
创建监听器的实例 
myLis lis = new myLis(); 
  
使用add方法给按钮添加监听器 
 
    
                                
    • 
                                
  • 软件架构师不等同于资深程序员
                                    bijian1013
程序员架构师架构设计
                                    
            本文的作者Armel Nene是ETAPIX Global公司的首席架构师，他居住在伦敦，他参与过的开源项目包括 Apache Lucene,，Apache Nutch， Liferay 和 Pentaho等。 
        如今很多的公司
    
                                
    • 
                                
  • TeamForge Wiki Syntax & CollabNet User Information Center
                                    sunjing
TeamForgeHow doAttachementAnchorWiki Syntax
                                    
    the CollabNet user information center http://help.collab.net/ 
  
How do I create a new Wiki page? 
A CollabNet TeamForge project can have any number of Wiki pages. All Wiki pages are linked, and
    
                                
    • 
                                
  • 【Redis四】Redis数据类型
                                    bit1129
redis
                                    
    概述 
Redis是一个高性能的数据结构服务器，称之为数据结构服务器的原因是，它提供了丰富的数据类型以满足不同的应用场景，本文对Redis的数据类型以及对这些类型可能的操作进行总结。 
Redis常用的数据类型包括string、set、list、hash以及sorted set.Redis本身是K/V系统，这里的数据类型指的是value的类型，而不是key的类型，key的类型只有一种即string
    
                                
    • 
                                
  • SSH2整合-附源码
                                    白糖_
eclipsespringtomcatHibernateGoogle
                                    
    今天用eclipse终于整合出了struts2+hibernate+spring框架。 
我创建的是tomcat项目，需要有tomcat插件。导入项目以后，鼠标右键选择属性，然后再找到“tomcat”项，勾选一下“Is a tomcat project”即可。具体方法见源码里的jsp图片，sql也在源码里。 
  
  
补充1：项目中部分jar包不是最新版的，可能导
    
                                
    • 
                                
  • [转]开源项目代码的学习方法
                                    braveCS
学习方法
                                    
    转自： 
http://blog.sina.com.cn/s/blog_693458530100lk5m.html 
http://www.cnblogs.com/west-link/archive/2011/06/07/2074466.html 
  
1）阅读features。以此来搞清楚该项目有哪些特性2）思考。想想如果自己来做有这些features的项目该如何构架3）下载并安装d
    
                                
    • 
                                
  • 编程之美-子数组的最大和（二维）
                                    bylijinnan
编程之美
                                    
    package beautyOfCoding;

import java.util.Arrays;
import java.util.Random;

public class MaxSubArraySum2 {

	/**
	 * 编程之美 子数组之和的最大值（二维）
	 */
	private static final int ROW = 5;
	private stat
    
                                
    • 
                                
  • 读书笔记-3
                                    chengxuyuancsdn
jquery笔记resultMap配置ibatis一对多配置
                                    
    1、resultMap配置 
2、ibatis一对多配置 
3、jquery笔记 
 
1、resultMap配置
当<select resultMap="topic_data">
<resultMap id="topic_data">必须一一对应。
(1)<resultMap class="tblTopic&q
    
                                
    • 
                                
  • [物理与天文]物理学新进展
                                    comsci

                                    
     
 
      如果我们必须获得某种地球上没有的矿石,才能够进行某些能量输出装置的设计和建造,而要获得这种矿石,又必须首先进行深空探测,而要进行深空探测,又必须获得这种能量输出装置,这个矛盾的循环,会导致地球联盟在与宇宙文明建立关系的时候,陷入困境 
 
      怎么办呢? 
 
 
    
                                
    • 
                                
  • Oracle 11g新特性:Automatic Diagnostic Repository
                                    daizj
oracleADR
                                    
    Oracle Database 11g的FDI（Fault Diagnosability Infrastructure）是自动化诊断方面的又一增强。 
FDI的一个关键组件是自动诊断库（Automatic Diagnostic Repository-ADR）。 
 
在oracle 11g中，alert文件的信息是以xml的文件格式存在的，另外提供了普通文本格式的alert文件。 
这两份log文
    
                                
    • 
                                
  • 简单排序:选择排序
                                    dieslrae
选择排序
                                    
    
    public void selectSort(int[] array){
        int select;
        
        for(int i=0;i<array.length;i++){
            select = i;
            
            for(int k=i+1;k<array.leng
    
                                
    • 
                                
  • C语言学习六指针的经典程序，互换两个数字
                                    dcj3sjt126com
c
                                    
    示例程序，swap_1和swap_2都是错误的，推理从1开始推到2，2没完成，推到3就完成了 
# include <stdio.h>

void swap_1(int, int);
void swap_2(int *, int *);
void swap_3(int *, int *);

int main(void)
{
	int a = 3;
	int b = 
    
                                
    • 
                                
  • php 5.4中php-fpm 的重启、终止操作命令
                                    dcj3sjt126com
PHP
                                    
    php 5.4中php-fpm 的重启、终止操作命令: 
查看php运行目录命令：which php/usr/bin/php 
查看php-fpm进程数：ps aux | grep -c php-fpm 
查看运行内存/usr/bin/php  -i|grep mem 
重启php-fpm/etc/init.d/php-fpm restart 
在phpinfo()输出内容可以看到php
    
                                
    • 
                                
  • 线程同步工具类
                                    shuizhaosi888
同步工具类
                                    
    同步工具类包括信号量（Semaphore）、栅栏（barrier）、闭锁（CountDownLatch） 
  
闭锁（CountDownLatch） 
public class RunMain {
	public long timeTasks(int nThreads, final Runnable task) throws InterruptedException {
		fin
    
                                
    • 
                                
  • bleeding edge是什么意思
                                    haojinghua
DI
                                    
    不止一次，看到很多讲技术的文章里面出现过这个词语。今天终于弄懂了——通过朋友给的浏览软件，上了wiki。  
我再一次感到，没有辞典能像WiKi一样，给出这样体贴人心、一清二楚的解释了。为了表达我对WiKi的喜爱，只好在此一一中英对照，给大家上次课。 
  
In computer science, bleeding edge is a term that 
    
                                
    • 
                                
  • c中实现utf8和gbk的互转
                                    jimmee
ciconvutf8&gbk编码
                                    
    #include <iconv.h>
#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <string.h>
#include <sys/stat.h>

int code_c
    
                                
    • 
                                
  • 大型分布式网站架构设计与实践
                                    lilin530
应用服务器搜索引擎
                                    
    1.大型网站软件系统的特点？ 
a.高并发，大流量。 
b.高可用。 
c.海量数据。 
d.用户分布广泛，网络情况复杂。 
e.安全环境恶劣。 
f.需求快速变更，发布频繁。 
g.渐进式发展。 
 
2.大型网站架构演化发展历程？ 
a.初始阶段的网站架构。 
应用程序，数据库，文件等所有的资源都在一台服务器上。 
b.应用服务器和数据服务器分离。 
c.使用缓存改善网站性能。 
d.使用应用
    
                                
    • 
                                
  • 在代码中获取Android theme中的attr属性值
                                    OliveExcel
androidtheme
                                    
    Android的Theme是由各种attr组合而成, 每个attr对应了这个属性的一个引用, 这个引用又可以是各种东西. 
  
在某些情况下, 我们需要获取非自定义的主题下某个属性的内容 (比如拿到系统默认的配色colorAccent), 操作方式举例一则: 
int defaultColor = 0xFF000000;
int[] attrsArray = { andorid.r.
    
                                
    • 
                                
  • 基于Zookeeper的分布式共享锁
                                    roadrunners
zookeeper分布式共享锁
                                    
    首先，说说我们的场景，订单服务是做成集群的，当两个以上结点同时收到一个相同订单的创建指令，这时并发就产生了，系统就会重复创建订单。等等......场景。这时，分布式共享锁就闪亮登场了。 
  
共享锁在同一个进程中是很容易实现的，但在跨进程或者在不同Server之间就不好实现了。Zookeeper就很容易实现。具体的实现原理官网和其它网站也有翻译，这里就不在赘述了。 
  
官
    
                                
    • 
                                
  • 两个容易被忽略的MySQL知识
                                    tomcat_oracle
mysql
                                    
    1、varchar(5)可以存储多少个汉字，多少个字母数字？   　　相信有好多人应该跟我一样，对这个已经很熟悉了，根据经验我们能很快的做出决定，比如说用varchar(200)去存储url等等，但是，即使你用了很多次也很熟悉了，也有可能对上面的问题做出错误的回答。   　　这个问题我查了好多资料，有的人说是可以存储5个字符，2.5个汉字（每个汉字占用两个字节的话），有的人说这个要区分版本，5.0
    
                                
    • 
                                
  • zoj 3827 Information Entropy(水题)
                                    阿尔萨斯
format
                                    
     题目链接：zoj 3827 Information Entropy 
 题目大意：三种底，计算和。 
 解题思路：调用库函数就可以直接算了，不过要注意Pi = 0的时候，不过它题目里居然也讲了。。。limp→0+plogb(p)=0，因为p是logp的高阶。 
#include <cstdio>
#include <cstring>
#include <cmath&
    
                                
    •