whslowly
whslowly

3.Dubbo源码阅读-服务消费者发出请求与提供者返回响应过程

Dubbo的分支: 3.0
服务消费者发出请求与提供者返回响应的过程，包括了代理与传输部分，主要的内容都在第2篇里面都说过了，这篇就算补充下吧。
举个例子：消费者使用dubbo协议调用HelloService.sayHello(String name)为例，分为：

  1. Dubbo为消费者端生成、注入代理对象；
  2. 消费者发起网络调用请求；
  3. 提供者收到请求，执行调用，返回响应结果；
  4. 消费者收到响应结果，处理后，返回给上层调用方。

Dubbo为消费者端生成、注入代理对象

我们以SpringMVC模式，用源码来看下代理的实际内容是什么。

  1. 提供侧-定义服务接口api：HelloService

    public interface HelloService {
    String sayHello(String name);
}

  2. 消费侧-业务中定义的Controller：HelloController

    @Controller
public class HelloController {

    @Autowired
    private HelloService helloService;

    @GetMapping("/sayHello")
    public String sayHello(){
        return helloService.sayHello("张三");
    }

}

  3. 消费侧-Spring容器向HelloController注入的HelloService实现对象，是由Dubbo框架动态生成的，源码为：

    public class proxy1 implements ClassGenerator.DC, Destroyable, EchoService, HelloService {
    public static Method[] methods;
    private InvocationHandler handler;

    public proxy1() {
    }

    public proxy1(InvocationHandler invocationHandler) {
        this.handler = invocationHandler;
    }

    public String sayHello(String string) {
        Object[] objectArray = new Object[] { string };
        Object object = this.handler.invoke(this, methods[0], objectArray);
        return (String) object;
    }

    public Object $echo(Object object) {
        Object[] objectArray = new Object[] { object };
        Object object2 = this.handler.invoke(this, methods[1], objectArray);
        return object2;
    }

    public void $destroy() {
        Object[] objectArray = new Object[] {};
        Object object = this.handler.invoke(this, methods[2], objectArray);
    }

}

  4. 消费侧-到这可以看出，controller实际调用的是代理对象proxy1.sayHello()，sayHello内部实际调用的是InvocationHandler.invoker(...)。每次在创建代理对象时，都会使用有参构造器，传入一个InvocationHandler对象。

  5. 消费侧-InvocationHandler的源码

    public class InvokerInvocationHandler implements InvocationHandler {
    private final Invoker invoker;
    private URL url;

    public InvokerInvocationHandler(Invoker handler) {
        this.invoker = handler;
        this.url = invoker.getUrl();
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        String methodName = method.getName();
        Class[] parameterTypes = method.getParameterTypes();
        if (parameterTypes.length == 0) {
            if ("toString".equals(methodName)) {
                return invoker.toString();
            } else if ("$destroy".equals(methodName)) {
                invoker.destroy();
                return null;
            } else if ("hashCode".equals(methodName)) {
                return invoker.hashCode();
            }
        } else if (parameterTypes.length == 1 && "equals".equals(methodName)) {
            return invoker.equals(args[0]);
        }
        RpcInvocation rpcInvocation = new RpcInvocation(method, invoker.getInterface().getName(), protocolServiceKey, args);
        RpcContext.setRpcContext(url);

        return invoker.invoke(rpcInvocation).recreate();
    }
}

  6. 消费侧-构造InvokerInvocationHandler时，会传入一个Invoker，这个Invoker实际为ClusterInvoker类型，代表HelloService服务的所有提供者invoker集群。这个ClusterInvoker有多个实现类，比如FailoverClusterInvoker、FailfastClusterInvoker、BroadcastClusterInvoker等等，假如此处是FailfastClusterInvoker，那么最后实际调用的是FailfastClusterInvoker.invoke()，也就是父类AbstractClusterInvoker.invoke()。

    public abstract class AbstractClusterInvoker implements ClusterInvoker {

    @Override
    public Result invoke(final Invocation invocation) throws RpcException {
        //省略...
        //使用路由器Router从ClusterInvoker.directory存储的所有的invoker中，路由出符合路由规则的一批invoker。
        List> invokers = list(invocation);
        //上面选出了方向正确的一批invoker，现在需要负载均衡选一个执行了。此处初始化负载均衡器LoadBalance。
        LoadBalance loadbalance = initLoadBalance(invokers, invocation);
        RpcUtils.attachInvocationIdIfAsync(getUrl(), invocation);
        //使用负载均衡器选一个invoker，发起调用，返回响应。
        return doInvoke(invocation, invokers, loadbalance);
    }

    protected List> list(Invocation invocation) throws RpcException {
        //获取Directory，调用list方法
        return getDirectory().list(invocation);
    }

}

  7. 消费侧-假如FailfastClusterInvoker中的directory为StaticDirectory类型，即实际调用的是StaticDirectory.list

    public class StaticDirectory extends AbstractDirectory {

    private final List> invokers;

    public StaticDirectory(URL url, List> invokers, RouterChain routerChain) {
        //省略...
        this.invokers = invokers;
    }

    //AbstractDirectory.list最终会调用子类的doList
    @Override
    protected List> doList(Invocation invocation) throws RpcException {
        List> finalInvokers = invokers;
        if (routerChain != null) {
            try {
                //路由器链依次执行路由，最终过滤出符合所有路由规则的Invoker集合
                finalInvokers = routerChain.route(getConsumerUrl(), invocation);
            } catch (Throwable t) {
                logger.error("Failed to execute router: " + getUrl() + ", cause: " + t.getMessage(), t);
            }
        }
        return finalInvokers == null ? Collections.emptyList() : finalInvokers;
    }

}

  8. 消费侧-过滤出一批符合路由规则的invoker后，会构建负载均衡器LoadBalance，然后调用FailfastClusterInvoker.doInvoke。

```java
public class FailfastClusterInvoker extends AbstractClusterInvoker {

    @Override
    public Result doInvoke(Invocation invocation, List> invokers, LoadBalance loadbalance) throws RpcException {
        //负载均衡器选出一个invoker
        Invoker invoker = select(loadbalance, invocation, invokers, null);
        try {
            //设置调用上下文，发起调用
            return invokeWithContext(invoker, invocation);
        } catch (Throwable e) {
            //省略...
        }
    }
}
```

  1. 消费侧-invokeWithContext(invoker, invocation);会调用AbstractInvoker.invoke方法

    public abstract class AbstractInvoker implements Invoker {
    @Override
    public Result invoke(Invocation inv) throws RpcException {
        //如果是异步执行会生成并附着调用id
        RpcUtils.attachInvocationIdIfAsync(getUrl(), invocation);
        //所有调用都是封装为异步结果
        AsyncRpcResult asyncResult;
        try {
            asyncResult = (AsyncRpcResult) doInvoke(invocation);
        } catch (InvocationTargetException e) { // biz exception
            //省略
        } catch (RpcException e) {
            //省略
        } catch (Throwable e) {
            //省略
        }

        //如果是同步调用，阻塞等待响应结果返回
        waitForResultIfSync(asyncResult, invocation);
        return asyncResult;
    }

}

  2. 消费侧-doInvoke是抽象方法，由具体的子类负责实现，因为HelloService是使用dubbo协议暴露，所以这里对应的子类Invoker为DubboInvoker，也就是调用DubboInvoker.doInvoke

    public class DubboInvoker extends AbstractInvoker {
    //客户端，类似于连接池
    private final ExchangeClient[] clients;

    @Override
    protected Result doInvoke(final Invocation invocation) throws Throwable {
        RpcInvocation inv = (RpcInvocation) invocation;

        ExchangeClient currentClient;
        if (clients.length == 1) {
            currentClient = clients[0];
        } else {
            //多个会轮询
            currentClient = clients[index.getAndIncrement() % clients.length];
        }
        try {
            //单程，也就是无需服务提供方返回响应结果，直观来说就是方法无返回值。
            boolean isOneway = RpcUtils.isOneway(getUrl(), invocation);
            //获取超时时间
            int timeout = calculateTimeout(invocation, methodName);
            invocation.put(TIMEOUT_KEY, timeout);
            if (isOneway) {
                //单程
                boolean isSent = getUrl().getMethodParameter(methodName, Constants.SENT_KEY, false);
                //把请求发过去就可以了
                currentClient.send(inv, isSent);
                return AsyncRpcResult.newDefaultAsyncResult(invocation);
            } else {
                //需要服务提供方返回响应结果，直观来说就是方法有返回值。
                //获取线程执行器
                ExecutorService executor = getCallbackExecutor(getUrl(), inv);
                //创建CompletableFuture，发送请求，强转响应结果的类型
                CompletableFuture appResponseFuture =
                        currentClient.request(inv, timeout, executor).thenApply(obj -> (AppResponse) obj);
                AsyncRpcResult result = new AsyncRpcResult(appResponseFuture, inv);
                result.setExecutor(executor);
                return result;
            }
        } catch (TimeoutException e) {
        } catch (RemotingException e) {
        }
    }
}

  3. 消费侧-从这里可以看到，真正的网络传输发生在currentClient.send()和currentClient.request()方法。

消费者发起网络调用请求

  1. 消费侧-currentClient.send()和currentClient.request()方法的底层实现是使用Netty4客户端来发送请求。实际上提供测返回的响应结果也是调用这个方法发送给消费侧的。

    final class NettyChannel extends AbstractChannel {

    @Override
    public void send(Object message, boolean sent) throws RemotingException {
        boolean success = true;
        int timeout = 0;
        try {
            //netty channel发送请求数据到提供侧
            ChannelFuture future = channel.writeAndFlush(message);
            if (sent) {
                timeout = getUrl().getPositiveParameter(TIMEOUT_KEY, DEFAULT_TIMEOUT);
                success = future.await(timeout);
            }
            Throwable cause = future.cause();
            if (cause != null) {
                throw cause;
            }
        } catch (Throwable e) {
        }
        if (!success) {
            throw new RemotingException("xxx");
        }
    }
}

  2. 消费侧-currentClient.request()方法在发送请求的时候，会调用DefaultFuture.newFuture创建DefaultFuture，DefaultFuture会将request.id和对应的DefaultFuture存储在DefaultFuture.FUTURES中。在拿到响应后，根据response.id来匹配对应的DefaultFuture，set响应结果。

    public class DefaultFuture extends CompletableFuture {

    private static final Map CHANNELS = new ConcurrentHashMap<>();
    private static final Map FUTURES = new ConcurrentHashMap<>();

    private DefaultFuture(Channel channel, Request request, int timeout) {
        this.channel = channel;
        this.request = request;
        this.id = request.getId();
        this.timeout = timeout > 0 ? timeout : channel.getUrl().getPositiveParameter(TIMEOUT_KEY, DEFAULT_TIMEOUT);
        // put into waiting map.
        FUTURES.put(id, this);
        CHANNELS.put(id, channel);
    }
}
 


    提供者收到请求，执行调用，返回响应结果
    

      

    1.  
      提供侧-Dubbo默认使用Netty通讯，按照Netty的使用方法，想要知道收到请求后做了什么，要看下Netty服务端的初始化过程。
       
      public class NettyServer extends AbstractServer implements RemotingServer {

    //缓存的处于alive状态下的worker channel。
    private Map channels;
    private ServerBootstrap bootstrap;
    private io.netty.channel.Channel channel;

    @Override
    protected void doOpen() throws Throwable {
        bootstrap = new ServerBootstrap();

        bossGroup = NettyEventLoopFactory.eventLoopGroup(1, "NettyServerBoss");
        workerGroup = NettyEventLoopFactory.eventLoopGroup(
                getUrl().getPositiveParameter(IO_THREADS_KEY, Constants.DEFAULT_IO_THREADS),
                "NettyServerWorker");

        //Netty服务端使用的IO处理器
        final NettyServerHandler nettyServerHandler = new NettyServerHandler(getUrl(), this);
        channels = nettyServerHandler.getChannels();

        bootstrap.group(bossGroup, workerGroup)
                .channel(NettyEventLoopFactory.serverSocketChannelClass())
                .option(ChannelOption.SO_REUSEADDR, Boolean.TRUE)
                .childOption(ChannelOption.TCP_NODELAY, Boolean.TRUE)
                .childOption(ChannelOption.ALLOCATOR, PooledByteBufAllocator.DEFAULT)
                .childHandler(new ChannelInitializer() {
                    @Override
                    protected void initChannel(SocketChannel ch) throws Exception {
                        int idleTimeout = UrlUtils.getIdleTimeout(getUrl());
                        NettyCodecAdapter adapter = new NettyCodecAdapter(getCodec(), getUrl(), NettyServer.this);
                        //省略ssl代码
                        ch.pipeline()
                                .addLast("decoder", adapter.getDecoder())
                                .addLast("encoder", adapter.getEncoder())
                                .addLast("server-idle-handler", new IdleStateHandler(0, 0, idleTimeout, MILLISECONDS))
                                .addLast("handler", nettyServerHandler);
                    }
                });

        ChannelFuture channelFuture = bootstrap.bind(getBindAddress());
        channelFuture.syncUninterruptibly();
        channel = channelFuture.channel();
    }

    //省略...

}

       
      2. 

    2.  
      提供侧-Netty服务端使用的IO处理器为NettyServerHandler。具体的业务逻辑是由构造器传入的handler来处理的。handler是在暴露服务时，根据要暴露的协议，传入的对应handler。dubbo协议对应 DubboProtocol.requestHandler
       
      @io.netty.channel.ChannelHandler.Sharable
public class NettyServerHandler extends ChannelDuplexHandler {
    //
    private final Map channels = new ConcurrentHashMap();
    private final URL url;
    private final ChannelHandler handler;

    /**
     * Netty server handler
     * @param url     url
     * @param handler 由协议决定实际的handler对象，如果是dubbo协议，handler为DubboProtocol.requestHandler。
     *                接口实现里都是由实际的handler来处理业务逻辑。
     */
    public NettyServerHandler(URL url, ChannelHandler handler) {
        this.url = url;
        this.handler = handler;
    }

    @Override
    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
        NettyChannel channel = NettyChannel.getOrAddChannel(ctx.channel(), url, handler);
        handler.received(channel, msg);
    }


    @Override
    public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
        super.write(ctx, msg, promise);
        NettyChannel channel = NettyChannel.getOrAddChannel(ctx.channel(), url, handler);
        handler.sent(channel, msg);
    }
}

       
      3. 

    3.  
      提供侧-DubboProtocol.requestHandler源码
       
      public class DubboProtocol extends AbstractProtocol {

    //dubbo协议的IO请求处理器
    private ExchangeHandler requestHandler = new ExchangeHandlerAdapter() {

        @Override
        public CompletableFuture reply(ExchangeChannel channel, Object message) throws RemotingException {
            //message为DecodeableRpcInvocation类型
            Invocation inv = (Invocation) message;
            //根据暴露的Protocol，拿到Exporter，再拿到DubboInvoker
            Invoker invoker = getInvoker(channel, inv);
            //invoker实际为invoker filter chain责任链，
            //最核心的那个invoker是AbstractProxyInvoker的匿名实现类对象，
            //它的实现会调用serviceImpl的Wrapper类对象，最终调用serviceImpl对象返回结果。
            Result result = invoker.invoke(inv);
            return result.thenApply(Function.identity());
        }

        //NettyServerHandler.received实际调用该方法
        @Override
        public void received(Channel channel, Object message) throws RemotingException {
            if (message instanceof Invocation) {
                reply((ExchangeChannel) channel, message);
            } else {
                super.received(channel, message);
            }
        }
    };

    Invoker getInvoker(Channel channel, Invocation inv) throws RemotingException {
        DubboExporter exporter = (DubboExporter) exporterMap.get(serviceKey);
        return exporter.getInvoker();
    }
}
 

    4.  
      提供侧-HelloServiceImpl的Wrapper类
       
      public class JavassistProxyFactory extends AbstractProxyFactory {

    @Override
    @SuppressWarnings("unchecked")
    public  T getProxy(Invoker invoker, Class[] interfaces) {
        //Proxy.getProxy(interfaces)生成的动态代理类源码详见Proxy类头注释
        //动态代理类调用有参构造器创建代理类对象
        return (T) Proxy.getProxy(interfaces).newInstance(new InvokerInvocationHandler(invoker));
    }

    @Override
    public  Invoker getInvoker(T proxy, Class type, URL url) {
        //为proxy(HelloServiceImpl)生成通用的包装类对象，具体的Wrapper类源码参见Wrapper.makeWrapper的注释
        final Wrapper wrapper = Wrapper.getWrapper(proxy.getClass().getName().indexOf('$') < 0 ? proxy.getClass() : type);
        //这个Invoker的生成过程很像jdk动态代理的形式
        //每个协议类型都会生成一个对应的invoker，如url开头为registry://xxx，或者dubbo://xxx等
        return new AbstractProxyInvoker(proxy, type, url) {
            @Override
            protected Object doInvoke(T proxy, String methodName,
                                      Class[] parameterTypes,
                                      Object[] arguments) throws Throwable {
                //调用serviceImpl包装类的invokeMethod方法
                return wrapper.invokeMethod(proxy, methodName, parameterTypes, arguments);
            }
        };
    }
}

       
      5. 

    5.  
      提供侧-Wrapper源码，其中传入的object为Spring生成的HelloServiceImpl对象。
       
      public class Wrapper1 extends Wrapper implements ClassGenerator.DC {
    public static String[] pns;
    public static Map pts;
    public static String[] mns;
    public static String[] dmns;
    public static Class[] mts0;

    public String[] getPropertyNames() {
        return pns;
    }

    public boolean hasProperty(String string) {
        return pts.containsKey(string);
    }

    public Class getPropertyType(String string) {
        return (Class) pts.get(string);
    }

    public String[] getMethodNames() {
        return mns;
    }

    public String[] getDeclaredMethodNames() {
        return dmns;
    }

    public void setPropertyValue(Object object, String string, Object object2) {
        try {
            HelloServiceImpl helloServiceImpl = (HelloServiceImpl) object;
        } catch (Throwable throwable) {
            throw new IllegalArgumentException(throwable);
        }
        throw new NoSuchPropertyException(new StringBuffer().append("Not found property \"")
                .append(string)
                .append("\" field or setter method in class org.apache.dubbo.demo.provider.HelloServiceImpl.")
                .toString());
    }

    public Object getPropertyValue(Object object, String string) {
        try {
            HelloServiceImpl helloServiceImpl = (HelloServiceImpl) object;
        } catch (Throwable throwable) {
            throw new IllegalArgumentException(throwable);
        }
        throw new NoSuchPropertyException(new StringBuffer().append("Not found property \"")
                .append(string)
                .append("\" field or getter method in class org.apache.dubbo.demo.provider.HelloServiceImpl.")
                .toString());
    }

    public Object invokeMethod(Object object, String string, Class[] classArray, Object[] objectArray) throws InvocationTargetException {
        HelloServiceImpl helloServiceImpl;
        try {
            helloServiceImpl = (HelloServiceImpl) object;
        } catch (Throwable throwable) {
            throw new IllegalArgumentException(throwable);
        }
        try {
            if ("sayHello".equals(string) && classArray.length == 0) {
                return helloServiceImpl.sayHello();
            }
        } catch (Throwable throwable) {
            throw new InvocationTargetException(throwable);
        }
        throw new NoSuchMethodException(new StringBuffer().append("Not found method \"")
                .append(string)
                .append("\" in class org.apache.dubbo.demo.provider.HelloServiceImpl.")
                .toString());
    }
}

       
      6. 

    6. 到此供应侧就得到了响应结果，调用前面说的NettyClient.send()方法将响应发回给消费侧。
      7. 


      消费者收到响应结果，处理后，返回给上层调用方
      

        

      1.  
        消费侧-收到响应后，会根据response.id去DefaultFuture.FUTURES中获取对应的DefaultFuture。然后执行CompletableFuture.complete方法，set响应结果。
         
        public class DefaultFuture extends CompletableFuture {

    private static final Map FUTURES = new ConcurrentHashMap<>();

    public static void sent(Channel channel, Request request) {
        DefaultFuture future = FUTURES.get(request.getId());
        if (future != null) {
            future.doSent();
        }
    }

    public static void received(Channel channel, Response response) {
        received(channel, response, false);
    }

    public static void received(Channel channel, Response response, boolean timeout) {
        try {
            DefaultFuture future = FUTURES.remove(response.getId());
            if (future != null) {
                Timeout t = future.timeoutCheckTask;
                if (!timeout) {
                    // decrease Time
                    t.cancel();
                }
                future.doReceived(response);
            } else {
                logger.warn("The timeout response finally returned at "
                        + (new SimpleDateFormat("yyyy-MM-dd HH:mm:ss.SSS").format(new Date()))
                        + ", response status is " + response.getStatus()
                        + (channel == null ? "" : ", channel: " + channel.getLocalAddress()
                        + " -> " + channel.getRemoteAddress()) + ", please check provider side for detailed result.");
            }
        } finally {
            CHANNELS.remove(response.getId());
        }
    }

    private void doReceived(Response res) {
        if (res == null) {
            throw new IllegalStateException("response cannot be null");
        }
        if (res.getStatus() == Response.OK) {
            this.complete(res.getResult());
        } else if (res.getStatus() == Response.CLIENT_TIMEOUT || res.getStatus() == Response.SERVER_TIMEOUT) {
            this.completeExceptionally(new TimeoutException(res.getStatus() == Response.SERVER_TIMEOUT, channel, res.getErrorMessage()));
        } else {
            this.completeExceptionally(new RemotingException(channel, res.getErrorMessage()));
        }

        // the result is returning, but the caller thread may still waiting
        // to avoid endless waiting for whatever reason, notify caller thread to return.
        if (executor != null && executor instanceof ThreadlessExecutor) {
            ThreadlessExecutor threadlessExecutor = (ThreadlessExecutor) executor;
            if (threadlessExecutor.isWaiting()) {
                threadlessExecutor.notifyReturn(new IllegalStateException("The result has returned, but the biz thread is still waiting" +
                        " which is not an expected state, interrupt the thread manually by returning an exception."));
            }
        }
    }
}
 

      2. 到此大概的调用和响应过程就说完了。
        3. 







        



        


        


        




        

        你可能感兴趣的:(3.Dubbo源码阅读-服务消费者发出请求与提供者返回响应过程)
        

        

        

          

        • 斤斤计较的婚姻到底有多难？
白心之岂必有为

          很多人私聊我会问到在哪个人群当中斤斤计较的人最多？我都会回答他，一般婚姻出现问题的斤斤计较的人士会非常多，以我多年经验，在婚姻落的一塌糊涂的人当中，斤斤计较的人数占比在20～30%以上，也就是说10个婚姻出现问题的斤斤计较的人有2-3个有多不减。在婚姻出问题当中，有大量的心理不平衡的、尖酸刻薄的怨妇。在婚姻中仅斤斤计较有两种类型：第一种是物质上的，另一种是精神上的。在物质与精神上抠门已经严重的影响
          

          • 

        • QQ群采集助手，精准引流必备神器
2401_87347160
其他经验分享

          功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
          

          • 

        • 机器学习与深度学习间关系与区别
ℒℴѵℯ心·动ꦿ໊ོ꫞
人工智能学习深度学习python

          一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
          

          • 

        • 随笔 | 仙一般的灵气
海思沧海

          仙岛今天，我看了你全部，似乎已经进入你的世界我不知道，这是否是梦幻，还是你仙一般的灵气吸引了我也许每一个人都要有一份属于自己的追求，这样才能够符合人生的梦想，生活才能够充满着阳光与快乐我不知道，我为什么会这样的感叹，是在感叹自己的人生，还是感叹自己一直没有孜孜不倦的追求只感觉虚度了光阴，每天活在自己的梦中，活在一个不真实的世界是在逃避自己，还是在逃避周围的一切有时候我嘲笑自己，嘲笑自己如此的虚无，
          

          • 

        • 一百九十四章. 自相矛盾
巨木擎天

          唉！就这么一夜，林子感觉就像过了很多天似的，先是回了阳间家里，遇到了那么多不可思议的事情儿。特别是小伙伴们，第二次与自己见面时，僵硬的表情和恐怖的气氛，让自己如坐针毡，打从心眼里难受！还有东子，他现在还好吗？有没有被人欺负？护城河里的小鱼小虾们，还都在吗？水不会真的干枯了吧？那对相亲相爱漂亮的太平鸟儿，还好吧！春天了，到了做窝、下蛋、喂养小鸟宝宝的时候了，希望它们都能够平安啊！虽然没有看见家人，也
          

          • 

        • 地推话术，如何应对地推过程中家长的拒绝
校师学

          相信校长们在做地推的时候经常遇到这种情况：市场专员反馈家长不接单，咨询师反馈难以邀约这些家长上门，校区地推疲软，招生难。为什么？仅从地推层面分析，一方面因为家长受到的信息轰炸越来越多，对信息越来越“免疫”；而另一方面地推人员的专业能力和营销话术没有提高，无法应对家长的拒绝，对有意向的家长也不知如何跟进，眼睁睁看着家长走远；对于家长的疑问，更不知道如何有技巧地回答，机会白白流失。由于回答没技巧和专业
          

          • 

        • 微服务下功能权限与数据权限的设计与实现
nbsaas-boot
微服务java架构

          在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
          

          • 

        • 理解Gunicorn：Python WSGI服务器的基石
范范0825
ipythonlinux运维

          理解Gunicorn：PythonWSGI服务器的基石介绍Gunicorn，全称GreenUnicorn，是一个为PythonWSGI（WebServerGatewayInterface）应用设计的高效、轻量级HTTP服务器。作为PythonWeb应用部署的常用工具，Gunicorn以其高性能和易用性著称。本文将介绍Gunicorn的基本概念、安装和配置，帮助初学者快速上手。1.什么是Gunico
          

          • 

        • 学点心理知识，呵护孩子健康
静候花开_7090

          昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
          

          • 

        • 2021年12月19日，春蕾教育集团团建活动感受——黄晓丹
黄错错加油

          感受:1.从陌生到熟悉的过程。游戏环节让我们在轻松的氛围中得到了锻炼，也增长了不少知识。2.游戏过程中，我们贡献的是个人力量，展现的是团队的力量。它磨合的往往不止是工作的熟悉，更是观念上契合度的贴近。3.这和工作是一样的道理。在各自的岗位上，每个人摆正自己的位置、各司其职充分发挥才能，并团结一致劲往一处使，才能实现最大的成功。新知:1.团队精神需要不断地创新。过去，人们把创新看作是冒风险，现在人们
          

          • 

        • 《投行人生》读书笔记
小蘑菇的树洞

          《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
          

          • 

        • Long类型前后端数据不一致
igotyback
前端

          响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
          

          • 

        • swagger访问路径
igotyback
swagger

          Swagger2.x版本访问地址：http://{ip}:{port}/{context-path}/swagger-ui.html{ip}是你的服务器IP地址。{port}是你的应用服务端口，通常为8080。{context-path}是你的应用上下文路径，如果应用部署在根路径下，则为空。Swagger3.x版本对于Swagger3.x版本（也称为OpenAPI3）访问地址：http://{ip
          

          • 

        • 店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码
说私域
人工智能小程序

          摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
          

          • 

        • 2021-08-26
影幽

          在生活中，女人与男人的感悟往往有所不同。人生最大的舞台就是生活，大幕随时都可能拉开，关键是你愿不愿意表演都无法躲避。在生活中，遇事不要急躁，不要急于下结论，尤其生气时不要做决断，要学会换位思考，大事化小小事化了，把复杂的事情尽量简单处理，千万不要把简单的事情复杂化。永远不要扭曲，别人善意，无药可救。昨天是张过期的支票，明天是张信用卡，只有今天才是现金，要善加利用！执着的攀登者不必去与别人比较自己的
          

          • 

        • 消息中间件有哪些常见类型
xmh-sxh-1314
java

          消息中间件根据其设计理念和用途，可以大致分为以下几种常见类型：点对点消息队列（Point-to-PointMessagingQueues）：在这种模型中，消息被发送到特定的队列中，消费者从队列中取出并处理消息。队列中的消息只能被一个消费者消费，消费后即被删除。常见的实现包括IBM的MQSeries、RabbitMQ的部分使用场景等。适用于任务分发、负载均衡等场景。发布/订阅消息模型（Pub/Sub
          

          • 

        • 高级编程--XML+socket练习题
masa010
java开发语言

          1.北京华北2114.8万人上海华东2,500万人广州华南1292.68万人成都华西1417万人（1）使用dom4j将信息存入xml中（2）读取信息，并打印控制台（3）添加一个city节点与子节点（4）使用socketTCP协议编写服务端与客户端，客户端输入城市ID，服务器响应相应城市信息（5）使用socketTCP协议编写服务端与客户端，客户端要求用户输入city对象，服务端接收并使用dom4j
          

          • 

        • 2018-07-23-催眠日作业-#不一样的31天#-66小鹿
小鹿_33

          预言日：人总是在逃避命运的路上，与之不期而遇。心理学上有个著名的名词，叫做自证预言；经济学上也有一个很著名的定律叫做，墨菲定律；在灵修派上，还有一个很著名的法则，叫做吸引力法则。这3个领域的词，虽然看起来不太一样，但是他们都在告诉人们一个现象：你越担心什么，就越有可能会发生什么。同样的道理，你越想得到什么，就应该要积极地去创造什么。无论是自证预言，墨菲定律还是吸引力法则，对人都有正反2个维度的影响
          

          • 

        • 本周第二次约练
2cfbdfe28a51

          中原焦点团队中24初26刘霞2021.12.3约练161次，分享第368天当事人虽然是带着问题来的，但是咨询过程中发现，她是经过自己不断地调整和努力才走到现在的，看到当事人的不容易，找到例外，发现资源，力量感也就随之而来。增强画面感，或者说重温，会给当事人带来更深刻的感受。
          

          • 

        • 回溯 Leetcode 332 重新安排行程
mmaerd
Leetcode刷题学习记录leetcode算法职场和发展

          重新安排行程Leetcode332学习记录自代码随想录给你一份航线列表tickets，其中tickets[i]=[fromi,toi]表示飞机出发和降落的机场地点。请你对该行程进行重新规划排序。所有这些机票都属于一个从JFK（肯尼迪国际机场）出发的先生，所以该行程必须从JFK开始。如果存在多种有效的行程，请你按字典排序返回最小的行程组合。例如，行程[“JFK”,“LGA”]与[“JFK”,“LGB
          

          • 

        • 每日一题——第九十题
互联网打工人no1
C语言程序设计每日一练c语言

          题目：判断子串是否与主串匹配#include#include#include//////判断子串是否在主串中匹配//////主串///子串///boolisSubstring(constchar*str,constchar*substr){intlenstr=strlen(str);//计算主串的长度intlenSub=strlen(substr);//计算子串的长度//遍历主字符串，对每个可能得
          

          • 

        • Python数据分析与可视化实战指南
William数据分析
pythonpython数据

          在数据驱动的时代，Python因其简洁的语法、强大的库生态系统以及活跃的社区，成为了数据分析与可视化的首选语言。本文将通过一个详细的案例，带领大家学习如何使用Python进行数据分析，并通过可视化来直观呈现分析结果。一、环境准备1.1安装必要库在开始数据分析和可视化之前，我们需要安装一些常用的库。主要包括pandas、numpy、matplotlib和seaborn等。这些库分别用于数据处理、数学
          

          • 

        • 网易严选官方旗舰店，优质商品，卓越服务
高省_飞智666600

          网易严选官方旗舰店是网易旗下的一家电商平台，以提供优质商品和卓越服务而闻名。作为一名SEO优化师，我将为您详细介绍网易严选官方旗舰店，并重点强调其特点和优势。大家好！我是高省APP最大团队&联合创始人飞智导师。相较于其他返利app，高省APP的佣金更高，模式更好，最重要的是，终端用户不会流失！高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几
          

          • 

        • 《庄子.达生9》
钱江潮369

          【原文】孔子观于吕梁，县水三十仞，流沫四十里，鼋鼍鱼鳖之所不能游也。见一丈夫游之，以为有苦而欲死也，使弟子并流而拯之。数百步而出，被发行歌而游于塘下。孔子从而问焉，曰：“吾以子为鬼，察子则人也。请问，‘蹈水有道乎’”曰：“亡，吾无道。吾始乎故，长乎性，成乎命。与齐俱入，与汩偕出，从水之道而不为私焉。此吾所以蹈之也。”孔子曰：“何谓始乎故，长乎性，成乎命？”曰：“吾生于陵而安于陵，故也；长于水而安于
          

          • 

        • 水泥质量纠纷案代理词
徐宝峰律师

          贵州领航建设有限公司诉贵州纳雍隆庆乌江水泥有限公司产品质量纠纷案代理词尊敬的审判长、审判员：贵州千里律师事务所接受被告贵州纳雍隆庆乌江水泥有限公司的委托，指派我担任其诉讼代理人，参加本案的诉讼活动。下面，我结合本案事实和相关法律规定发表如下代理意见，供合议庭评议案件时参考：原告应当举证证明其遭受的损失与被告生产的水泥质量的因果关系。首先水泥是一种粉状水硬性无机胶凝材料。加水搅拌后成浆体，能在空气中
          

          • 

        • 腾讯云技术深度探索：构建高效云原生微服务架构
我的运维人生
云原生架构腾讯云运维开发技术共享

          腾讯云技术深度探索：构建高效云原生微服务架构在当今快速发展的技术环境中，云原生技术已成为企业数字化转型的关键驱动力。腾讯云作为行业领先的云服务提供商，不断推出创新的产品和技术，助力企业构建高效、可扩展的云原生微服务架构。本文将深入探讨腾讯云在微服务领域的最新进展，并通过一个实际案例展示如何在腾讯云平台上构建云原生应用。腾讯云微服务架构概览腾讯云微服务架构基于云原生理念，旨在帮助企业快速实现应用的容
          

          • 

        • 2019-12-22-22:30
涓涓1016

          今天是冬至，写下我的日更，是因为这两天的学习真的是能量的满满，让我看到了自己，未来另外一种可能性，也让我看到了这两年这几年的过程中我所接受那些痛苦的来源。一切的根源和痛苦都来自于人生，家庭，而你的原生家庭，你的爸爸和妈妈，是因为你这个灵魂在那一刻选择他们作为你的爸爸和妈妈来的，所以你得接受他，你得接纳他，他就是因为他的存在而给你的学习和成长带来这些痛苦，那其实是你必然要经历的这个过程，当你去接纳的
          

          • 

        • 第四天旅游线路预览——从换乘中心到喀纳斯湖
陟彼高冈yu
基于Googleearthstudio的旅游规划和预览旅游

          第四天：从贾登峪到喀纳斯风景区入口，晚上住宿贾登峪；换乘中心有4路车，喀纳斯①号车，去喀纳斯湖，路程时长约5分钟；将上面的的行程安排进行动态展示，具体步骤见”Googleearthstudio进行动态轨迹显示制作过程“、“Googleearthstudio入门教程”和“Googleearthstudio进阶教程“相关内容，得到行程如下所示：Day4-2-480p
          

          • 

        • Goolge earth studio 进阶4——路径修改与平滑
陟彼高冈yu
Googleearthstudio进阶教程旅游

          如果我们希望在大约中途时获得更多的城市鸟瞰视角。可以将相机拖动到这里并创建一个新的关键帧。camera_target_clip_7EarthStudio会自动平滑我们的路径，所以当我们通过这个关键帧时，不是一个生硬的角度，而是一个平滑的曲线。camera_target_clip_8路径上有贝塞尔控制手柄，允许我们调整路径的形状。右键单击，我们可以选择“平滑路径”，这是默认的自动平滑算法，或者我们可
          

          • 

        • 从鸡肉高汤到记忆的魔法再到有效提示的艺术
步子哥
人工智能

          还记得小时候那些天马行空的白日梦吗？也许只要按下键盘上的某个神奇组合，电脑就会发出滴滴的声响，一个隐藏的世界突然在你眼前展开，让你获得超凡的能力，摆脱平凡的生活。这听起来像是玩过太多电子游戏的幻想，但实际上，间隔重复系统给人的感觉惊人地相似。在最佳状态下，这些系统就像魔法一样神奇。本文将以一个看似平凡的鸡肉高汤食谱为例，深入浅出地探讨如何编写有效的间隔重复提示，让你像掌握烹饪技巧一样轻松地掌握记忆
          

          • 

        • [黑洞与暗粒子]没有光的世界
comsci

               无论是相对论还是其它现代物理学,都显然有个缺陷,那就是必须有光才能够计算
     但是,我相信,在我们的世界和宇宙平面中,肯定存在没有光的世界....
     那么,在没有光的世界,光子和其它粒子的规律无法被应用和考察,那么以光速为核心的
&nbs
          

          • 

        • jQuery Lazy Load 图片延迟加载
aijuans
jquery

          基于 jQuery 的图片延迟加载插件，在用户滚动页面到图片之后才进行加载。
对于有较多的图片的网页，使用图片延迟加载，能有效的提高页面加载速度。
版本：
jQuery v1.4.4+
jQuery Lazy Load v1.7.2
注意事项：
需要真正实现图片延迟加载，必须将真实图片地址写在 data-original 属性中。若 src
          

          • 

        • 使用Jodd的优点
Kai_Ge
jodd

          1.  简化和统一 controller ，抛弃 extends SimpleFormController ，统一使用 implements Controller 的方式。
2.  简化 JSP 页面的 bind, 不需要一个字段一个字段的绑定。
3.  对 bean 没有任何要求，可以使用任意的 bean 做为 formBean。
 
使用方法简介
          

          • 

        • jpa Query转hibernate Query
120153216
Hibernate

          public List<Map> getMapList(String hql,
Map map) {
org.hibernate.Query jpaQuery = entityManager.createQuery(hql);
if (null != map) {
for (String parameter : map.keySet()) {
jp
          

          • 

        • Django_Python3添加MySQL/MariaDB支持
2002wmj
mariaDB

          现状
首先，[email protected] 中默认的引擎为 django.db.backends.mysql 。但是在Python3中如果这样写的话，会发现 django.db.backends.mysql 依赖 MySQLdb[5] ，而 MySQLdb 又不兼容 Python3 于是要找一种新的方式来继续使用MySQL。 MySQL官方的方案
首先据MySQL文档[3]说，自从MySQL
          

          • 

        • 在SQLSERVER中查找消耗IO最多的SQL
357029540
SQL Server

          返回做IO数目最多的50条语句以及它们的执行计划。
select top 50  
(total_logical_reads/execution_count) as avg_logical_reads, 
(total_logical_writes/execution_count) as avg_logical_writes, 
(tot
          

          • 

        • spring UnChecked 异常 官方定义！
7454103
spring

            如果你接触过spring的 事物管理！那么你必须明白 spring的 非捕获异常！ 即 unchecked 异常！ 因为 spring 默认这类异常事物自动回滚！！
public static boolean isCheckedException(Throwable ex)
{
return !(ex instanceof RuntimeExcep
          

          • 

        • mongoDB 入门指南、示例
adminjun
javamongodb操作

          一、准备工作
1、 下载mongoDB
下载地址：http://www.mongodb.org/downloads
选择合适你的版本
相关文档：http://www.mongodb.org/display/DOCS/Tutorial
2、 安装mongoDB
A、 不解压模式：
将下载下来的mongoDB-xxx.zip打开，找到bin目录，运行mongod.exe就可以启动服务，默
          

          • 

        • CUDA 5 Release Candidate Now Available
aijuans
CUDA

          The CUDA 5 Release Candidate is now available at http://developer.nvidia.com/<wbr></wbr>cuda/cuda-pre-production. Now applicable to a broader set of algorithms, CUDA 5 has advanced fe
          

          • 

        • Essential Studio for WinRT网格控件测评
Axiba
JavaScripthtml5

          Essential Studio for WinRT界面控件包含了商业平板应用程序开发中所需的所有控件，如市场上运行速度最快的grid 和chart、地图、RDL报表查看器、丰富的文本查看器及图表等等。同时，该控件还包含了一组独特的库，用于从WinRT应用程序中生成Excel、Word以及PDF格式的文件。此文将对其另外一个强大的控件——网格控件进行专门的测评详述。
网格控件功能
1、
          

          • 

        • java 获取windows系统安装的证书或证书链
bewithme
windows

           
    有时需要获取windows系统安装的证书或证书链，比如说你要通过证书来创建java的密钥库  。
有关证书链的解释可以查看此处 。
 
public static void main(String[] args) {
SunMSCAPI providerMSCAPI = new SunMSCAPI();
S
          

          • 

        • NoSQL数据库之Redis数据库管理(set类型和zset类型)
bijian1013
redis数据库NoSQL

          4.sets类型
        Set是集合，它是string类型的无序集合。set是通过hash table实现的，添加、删除和查找的复杂度都是O(1)。对集合我们可以取并集、交集、差集。通过这些操作我们可以实现sns中的好友推荐和blog的tag功能。
        sadd：向名称为key的set中添加元
          

          • 

        • 异常捕获何时用Exception，何时用Throwable
bingyingao

          用Exception的情况
try {
       //可能发生空指针、数组溢出等异常
        } catch (Exception e) {
         
          

          • 

        • 【Kafka四】Kakfa伪分布式安装
bit1129
kafka

          在http://bit1129.iteye.com/blog/2174791一文中，实现了单Kafka服务器的安装，在Kafka中，每个Kafka服务器称为一个broker。本文简单介绍下，在单机环境下Kafka的伪分布式安装和测试验证   1. 安装步骤
 
Kafka伪分布式安装的思路跟Zookeeper的伪分布式安装思路完全一样，不过比Zookeeper稍微简单些(不
          

          • 

        • Project Euler
bookjovi
haskell

          Project Euler是个数学问题求解网站，网站设计的很有意思，有很多problem，在未提交正确答案前不能查看problem的overview，也不能查看关于problem的discussion thread，只能看到现在problem已经被多少人解决了，人数越多往往代表问题越容易。
    看看problem 1吧：
Add all the natural num
          

          • 

        • Java-Collections Framework学习与总结-ArrayDeque
BrokenDreams
Collections

                  表、栈和队列是三种基本的数据结构，前面总结的ArrayList和LinkedList可以作为任意一种数据结构来使用，当然由于实现方式的不同，操作的效率也会不同。
        这篇要看一下java.util.ArrayDeque。从命名上看
          

          • 

        • 读《研磨设计模式》-代码笔记-装饰模式-Decorator
bylijinnan
java设计模式

          声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/
import java.io.BufferedOutputStream;
import java.io.DataOutputStream;
import java.io.FileOutputStream;
import java.io.Fi
          

          • 

        • Maven学习(一)
chenyu19891124
Maven私服

              学习一门技术和工具总得花费一段时间，5月底6月初自己学习了一些工具，maven+Hudson+nexus的搭建，对于maven以前只是听说，顺便再自己的电脑上搭建了一个maven环境，但是完全不了解maven这一强大的构建工具，还有ant也是一个构建工具，但ant就没有maven那么的简单方便，其实简单点说maven是一个运用命令行就能完成构建，测试，打包，发布一系列功
          

          • 

        • [原创]JWFD工作流引擎设计----节点匹配搜索算法(用于初步解决条件异步汇聚问题) 补充
comsci
算法工作PHP搜索引擎嵌入式

          本文主要介绍在JWFD工作流引擎设计中遇到的一个实际问题的解决方案，请参考我的博文"带条件选择的并行汇聚路由问题"中图例A2描述的情况(http://comsci.iteye.com/blog/339756),我现在把我对图例A2的一个解决方案公布出来，请大家多指点
节点匹配搜索算法(用于解决标准对称流程图条件汇聚点运行控制参数的算法)
需要解决的问题：已知分支
          

          • 

        • Linux中用shell获取昨天、明天或多天前的日期
daizj
linuxshell上几年昨天获取上几个月

          在Linux中可以通过date命令获取昨天、明天、上个月、下个月、上一年和下一年
# 获取昨天
date -d 'yesterday'  # 或 date -d 'last day'
# 获取明天
date -d 'tomorrow'   # 或 date -d 'next day'
# 获取上个月
date -d 'last month'
# 
          

          • 

        • 我所理解的云计算
dongwei_6688
云计算

                在刚开始接触到一个概念时，人们往往都会去探寻这个概念的含义，以达到对其有一个感性的认知，在Wikipedia上关于“云计算”是这么定义的，它说：
       Cloud computing is a phrase used to describe a variety of computing co
          

          • 

        • YII CMenu配置
dcj3sjt126com
yii

          Adding id and class names to CMenu
We use the id and htmlOptions to accomplish this. Watch.
//in your view
$this->widget('zii.widgets.CMenu', array(
'id'=>'myMenu',
'items'=>$this-&g
          

          • 

        • 设计模式之静态代理与动态代理
come_for_dream
设计模式

          静态代理与动态代理
       代理模式是java开发中用到的相对比较多的设计模式，其中的思想就是主业务和相关业务分离。所谓的代理设计就是指由一个代理主题来操作真实主题，真实主题执行具体的业务操作，而代理主题负责其他相关业务的处理。比如我们在进行删除操作的时候需要检验一下用户是否登陆，我们可以删除看成主业务，而把检验用户是否登陆看成其相关业务
          

          • 

        • 【转】理解Javascript 系列
gcc2ge
JavaScript

          理解Javascript_13_执行模型详解
摘要: 在《理解Javascript_12_执行模型浅析》一文中,我们初步的了解了执行上下文与作用域的概念，那么这一篇将深入分析执行上下文的构建过程，了解执行上下文、函数对象、作用域三者之间的关系。函数执行环境简单的代码:当调用say方法时，第一步是创建其执行环境，在创建执行环境的过程中，会按照定义的先后顺序完成一系列操作:1.首先会创建一个
          

          • 

        • Subsets II
hcx2013
set

          Given a collection of integers that might contain duplicates, nums, return all possible subsets.
Note:
Elements in a subset must be in non-descending order.
The solution set must not conta
          

          • 

        • Spring4.1新特性——Spring缓存框架增强
jinnianshilongnian
spring4

          目录
Spring4.1新特性——综述
Spring4.1新特性——Spring核心部分及其他
Spring4.1新特性——Spring缓存框架增强
Spring4.1新特性——异步调用和事件机制的异常处理
Spring4.1新特性——数据库集成测试脚本初始化
Spring4.1新特性——Spring MVC增强
Spring4.1新特性——页面自动化测试框架Spring MVC T
          

          • 

        • shell嵌套expect执行命令
liyonghui160com

           
 
一直都想把expect的操作写到bash脚本里,这样就不用我再写两个脚本来执行了,搞了一下午终于有点小成就,给大家看看吧.
  系统:centos 5.x
 
1.先安装expect
yum -y install expect
 
2.脚本内容:
cat auto_svn.sh
 
#!/bin/bash

          

          • 

        • Linux实用命令整理
pda158
linux

          0. 基本命令 　　linux 基本命令整理 　
　1. 压缩 解压 　　tar -zcvf a.tar.gz a   #把a压缩成a.tar.gz 　　tar -zxvf a.tar.gz     #把a.tar.gz解压成a 　
　2. vim小结 　　2.1 vim替换 　　:m,ns/word_1/word_2/gc  
          

          • 

        • 独立开发人员通向成功的29个小贴士
shoothao
独立开发

          
概述：本文收集了关于独立开发人员通向成功需要注意的一些东西,对于具体的每个贴士的注解有兴趣的朋友可以查看下面标注的原文地址。
明白你从事独立开发的原因和目的。
保持坚持制定计划的好习惯。
万事开头难，第一份订单是关键。
培养多元化业务技能。
提供卓越的服务和品质。
谨小慎微。
营销是必备技能。
学会组织，有条理的工作才是最有效率的。
“独立
          

          • 

        • JAVA中堆栈和内存分配原理
uule
java

          1、栈、堆
1.寄存器：最快的存储区, 由编译器根据需求进行分配,我们在程序中无法控制.2. 栈：存放基本类型的变量数据和对象的引用，但对象本身不存放在栈中，而是存放在堆（new 出来的对象）或者常量池中（字符串常量对象存放在常量池中。）3. 堆：存放所有new出来的对象。4. 静态域：存放静态成员（static定义的）5. 常量池：存放字符串常量和基本类型常量（public static f
          

          •