weixin_34219944
weixin_34219944

[Curator] Tree Cache 的使用与分析

为什么80%的码农都做不了架构师？>>>   hot3.png

Tree Cache

使用zk路径下所有节点数据作为缓存。这个类会监控ZK的一个路径，路径下所有的节点变动，数据变动都会被响应。 还可以通过注册自定义监听器来更细节的控制这些数据变动操作。

1. 关键 API

org.apache.curator.framework.recipes.cache.TreeCache

org.apache.curator.framework.recipes.cache.TreeCacheListener

org.apache.curator.framework.recipes.cache.TreeCacheEvent

org.apache.curator.framework.recipes.cache.ChildData

2. 机制说明

与Path Cache类似

  • Builder模式
    • TreeCache属性较多，所以提供了一个TreeCache.Builder
  • Path Cache是一层结构
    • 按cache的name，挂载到path下
  • TreeCache
    • 顾名思义，内部是一个树结构
    • 所以有一个内部类TreeCache.TreeNode封装树节点信息

TreeCache使用一个内部类TreeNode来维护这个一个树结构。并将这个树结构与ZK节点进行了映射。

3. 用法

3.1 创建

public TreeCache(CuratorFramework client,
                         String path,
                         boolean cacheData)
  • cacheData
    • 如果设置true,是否需要缓存数据

3.2 使用

还是一样的套路，在使用前需要调用start()；用完之后需要调用close()方法。

随时都可以调用getCurrentData()获取当前缓存的状态和数据。

也可以通过getListenable()获取监听器容器，并在此基础上增加自定义监听器：

public void addListener(NodeCacheListener listener)

不过与Path Cache，以及Node Cache不一样的是：

  • 多了一个getCurrentChildren()方法
    • 返回path下多个子节点的缓存数据
    • 封装成一个Map返回
    • 没有很精准的进行数据同步
      • 可以当作一份快照使用

4. 错误处理

TreeCache实例自带一个ConnectionStateListener处理链接状态的变化，并处理数据变动情况

5. 源码分析

5.1 类定义

public class TreeCache implements Closeable{}
  • 实现了java.io.Closeable

5.1.1 TreeCache.Builder

org.apache.curator.framework.recipes.cache.TreeCache.Builder

public static final class Builder{}

5.1.2 TreeCache.TreeNode

org.apache.curator.framework.recipes.cache.TreeCache.TreeNode

private final class TreeNode implements Watcher, BackgroundCallback{}

5.2 成员变量

public class TreeCache implements Closeable
{
    private static final Logger LOG = LoggerFactory.getLogger(TreeCache.class);
    private final boolean createParentNodes;
    private final TreeCacheSelector selector;
    
    private static final AtomicReferenceFieldUpdater nodeStateUpdater =
            AtomicReferenceFieldUpdater.newUpdater(TreeNode.class, NodeState.class, "nodeState");

    private static final AtomicReferenceFieldUpdater childDataUpdater =
            AtomicReferenceFieldUpdater.newUpdater(TreeNode.class, ChildData.class, "childData");

    private static final AtomicReferenceFieldUpdater childrenUpdater =
            AtomicReferenceFieldUpdater.newUpdater(TreeNode.class, ConcurrentMap.class, "children");
            
    private final AtomicLong outstandingOps = new AtomicLong(0);

    private final AtomicBoolean isInitialized = new AtomicBoolean(false);

    private final TreeNode root;
    private final CuratorFramework client;
    private final ExecutorService executorService;
    private final boolean cacheData;
    private final boolean dataIsCompressed;
    private final int maxDepth;
    private final ListenerContainer listeners = new ListenerContainer();
    private final ListenerContainer errorListeners = new ListenerContainer();
    private final AtomicReference treeState = new AtomicReference(TreeState.LATENT);

    private final ConnectionStateListener connectionStateListener = new ConnectionStateListener()
    {
        @Override
        public void stateChanged(CuratorFramework client, ConnectionState newState)
        {
            handleStateChange(newState);
        }
    };

    static final ThreadFactory defaultThreadFactory = ThreadUtils.newThreadFactory("TreeCache");
}

可以看出，定义了很多变量。（所以额外的使用了Builder模式）

  • LOG
    • 私有常量
    • 静态内部类也要使用日志
  • createParentNodes
    • 是否需要创建父节点
    • 默认情况下，不会自动创建path的父节点
  • selector
    • org.apache.curator.framework.recipes.cache.TreeCacheSelector
    • 默认使用org.apache.curator.framework.recipes.cache.DefaultTreeCacheSelector
    • 用于区分哪些节点作为缓存使用
  • nodeStateUpdater
    • java.util.concurrent.atomic.AtomicReferenceFieldUpdater
    • 为TreeNode的nodeState属性提供原子操作
  • childDataUpdater
    • java.util.concurrent.atomic.AtomicReferenceFieldUpdater
    • 为TreeNode的childData属性提供原子操作
  • childrenUpdater
    • java.util.concurrent.atomic.AtomicReferenceFieldUpdater
    • 为TreeNode的children属性提供原子操作
  • outstandingOps
    • 记录未完成回调处理的任务数量
  • isInitialized
    • 是否已初始化
    • 是否已发出INITIALIZED事件
  • root
    • 树结构的根节点
    • 也可看作一个哨兵
  • client
  • executorService
    • 线程池
    • 老套路，操作异步处理。类似Path Cache
  • cacheData
    • 是否缓存数据
  • dataIsCompressed
    • 数据是否压缩
  • maxDepth
    • 树结构的最大深度
  • listeners
    • 监听器容器
    • TreeCacheListener缓存监听器
  • errorListeners
    • 监听器容器
    • UnhandledErrorListener监听器单独一个容器
    • 和TreeCacheListener监听器分开，利于对不同种类的监听器单独管理
  • treeState
    • AtomicReference
    • 内部枚举
      • LATENT
      • STARTED
      • CLOSED
  • defaultThreadFactory
    • 老套路，线程工厂。类似Path Cache
  • connectionStateListener
    • zk链接状态监听器
    • 老套路，回调状态机，异步处理事件

5.2.1 TreeNode

private final class TreeNode implements Watcher, BackgroundCallback
{

    volatile NodeState nodeState = NodeState.PENDING;
    volatile ChildData childData;
    final TreeNode parent;
    final String path;
    volatile ConcurrentMap children;
    final int depth;

    TreeNode(String path, TreeNode parent)
    {
        this.path = path;
        this.parent = parent;
        this.depth = parent == null ? 0 : parent.depth + 1;
    }
}
  • 实现了org.apache.zookeeper.Watcher接口
  • 实现了org.apache.curator.framework.api.BackgroundCallback接口
  • nodeState
    • org.apache.curator.framework.recipes.cache.TreeCache.NodeState
    • 节点状态
      • PENDING 等待处理
      • LIVE 有效
      • DEAD 无效
  • childData
    • org.apache.curator.framework.recipes.cache.ChildData
    • 节点数据
  • parent
    • 父节点
  • path
    • 对应的zk节点路径
  • children
    • java.util.concurrent.ConcurrentMap
    • 子节点列表
  • depth
    • 当前节点所处深度（层级）

5.3 构造器

public TreeCache(CuratorFramework client, String path)
{
    this(client, path, true, false, Integer.MAX_VALUE, Executors.newSingleThreadExecutor(defaultThreadFactory), false, new DefaultTreeCacheSelector());
}

TreeCache(CuratorFramework client, String path, boolean cacheData, boolean dataIsCompressed, int maxDepth, final ExecutorService executorService, boolean createParentNodes, TreeCacheSelector selector)
{
    this.createParentNodes = createParentNodes;
    this.selector = Preconditions.checkNotNull(selector, "selector cannot be null");
    this.root = new TreeNode(validatePath(path), null);
    this.client = Preconditions.checkNotNull(client, "client cannot be null");
    this.cacheData = cacheData;
    this.dataIsCompressed = dataIsCompressed;
    this.maxDepth = maxDepth;
    this.executorService = Preconditions.checkNotNull(executorService, "executorService cannot be null");
}

可以发现：

  • 默认处理线程池是一个单线程线程池
  • 默认缓存节点数据
  • 默认不对数据进行压缩
  • 默认不控制树的深度
  • 默认不创建父节点
  • 使用默认的DefaultTreeCacheSelector
  • 初始化了root节点信息

除了两个构造器，还有Builder的build方法来创建TreeCache

private final CuratorFramework client;
private final String path;
private boolean cacheData = true;
private boolean dataIsCompressed = false;
private ExecutorService executorService = null;
private int maxDepth = Integer.MAX_VALUE;
private boolean createParentNodes = false;
private TreeCacheSelector selector = new DefaultTreeCacheSelector();

public TreeCache build()
{
    ExecutorService executor = executorService;
    if ( executor == null )
    {
        executor = Executors.newSingleThreadExecutor(defaultThreadFactory);
    }
    return new TreeCache(client, path, cacheData, dataIsCompressed, maxDepth, executor, createParentNodes, selector);
}

创建过程也没有特殊的设定，各属性默认值也都一致

5.4 启动

使用之前需要调用start()方法

public TreeCache start() throws Exception
{
    Preconditions.checkState(treeState.compareAndSet(TreeState.LATENT, TreeState.STARTED), "already started");
    if ( createParentNodes )
    {
        client.createContainers(root.path);
    }
    client.getConnectionStateListenable().addListener(connectionStateListener);
    if ( client.getZookeeperClient().isConnected() )
    {
        root.wasCreated();
    }
    return this;
}
  1. 原子更新状态
  2. 如果需要创建父节点，则创建
  3. 在链接上增加监听器
  4. 如果链接是已连接，则调用root.wasCreated()从root节点开始逐个同步数据

org.apache.curator.framework.recipes.cache.TreeCache.TreeNode#wasCreated:

void wasCreated() throws Exception
{
    refresh();
}

private void refresh() throws Exception
{
    if ((depth < maxDepth) && selector.traverseChildren(path))
    {
        outstandingOps.addAndGet(2);
        doRefreshData();
        doRefreshChildren();
    } else {
        refreshData();
    }
}
private void refreshData() throws Exception
{
    outstandingOps.incrementAndGet();
    doRefreshData();
}
  1. 如果深度（树层级）允许，则下探（开始两个任务）
    1. 刷新当前节点数据
    2. 刷新下层节点列表
  2. 如果无需下探，则仅刷新当前结点的数据
  • 每次调用doXxxxx方法，则创建一个任务
    • 使用outstandingOps跟踪任务数量
刷新节点数据
private void doRefreshData() throws Exception
{
    if ( dataIsCompressed )
    {
        client.getData().decompressed().usingWatcher(this).inBackground(this).forPath(path);
    }
    else
    {
        client.getData().usingWatcher(this).inBackground(this).forPath(path);
    }
}
  • 根据是否使用数据压缩，调用不同的获取数据的方法
  • 都使用了回掉处理
    • TreeNode本身已经实现了Watcher, BackgroundCallback两个接口，所以回调/监听对象都是this

回调： org.apache.curator.framework.recipes.cache.TreeCache.TreeNode#processResult：

public void processResult(CuratorFramework client, CuratorEvent event) throws Exception
    {
        LOG.debug("processResult: {}", event);
        Stat newStat = event.getStat();
        switch ( event.getType() )
        {
        case EXISTS:
            Preconditions.checkState(parent == null, "unexpected EXISTS on non-root node");
            if ( event.getResultCode() == KeeperException.Code.OK.intValue() )
            {
                nodeStateUpdater.compareAndSet(this, NodeState.DEAD, NodeState.PENDING);
                wasCreated();
            }
            break;
        case CHILDREN:
            if ( event.getResultCode() == KeeperException.Code.OK.intValue() )
            {
                ChildData oldChildData = childData;
                if ( oldChildData != null && oldChildData.getStat().getMzxid() == newStat.getMzxid() )
                {
                    // Only update stat if mzxid is same, otherwise we might obscure
                    // GET_DATA event updates.
                    childDataUpdater.compareAndSet(this, oldChildData, new ChildData(oldChildData.getPath(), newStat, oldChildData.getData()));
                }

                if ( event.getChildren().isEmpty() )
                {
                    break;
                }

                ConcurrentMap childMap = children;
                if ( childMap == null )
                {
                    childMap = Maps.newConcurrentMap();
                    if ( !childrenUpdater.compareAndSet(this, null, childMap) )
                    {
                        childMap = children;
                    }
                }

                // Present new children in sorted order for test determinism.
                List newChildren = new ArrayList();
                for ( String child : event.getChildren() )
                {
                    if ( !childMap.containsKey(child) && selector.acceptChild(ZKPaths.makePath(path, child)) )
                    {
                        newChildren.add(child);
                    }
                }

                Collections.sort(newChildren);
                for ( String child : newChildren )
                {
                    String fullPath = ZKPaths.makePath(path, child);
                    TreeNode node = new TreeNode(fullPath, this);
                    if ( childMap.putIfAbsent(child, node) == null )
                    {
                        node.wasCreated();
                    }
                }
            }
            else if ( event.getResultCode() == KeeperException.Code.NONODE.intValue() )
            {
                wasDeleted();
            }
            break;
        case GET_DATA:
            if ( event.getResultCode() == KeeperException.Code.OK.intValue() )
            {
                ChildData toPublish = new ChildData(event.getPath(), newStat, event.getData());
                ChildData oldChildData;
                if ( cacheData )
                {
                    oldChildData = childDataUpdater.getAndSet(this, toPublish);
                }
                else
                {
                    oldChildData = childDataUpdater.getAndSet(this, new ChildData(event.getPath(), newStat, null));
                }

                boolean added;
                if (parent == null) {
                    // We're the singleton root.
                    added = nodeStateUpdater.getAndSet(this, NodeState.LIVE) != NodeState.LIVE;
                } else {
                    added = nodeStateUpdater.compareAndSet(this, NodeState.PENDING, NodeState.LIVE);
                    if (!added) {
                        // Ordinary nodes are not allowed to transition from dead -> live;
                        // make sure this isn't a delayed response that came in after death.
                        if (nodeState != NodeState.LIVE) {
                            return;
                        }
                    }
                }

                if ( added )
                {
                    publishEvent(TreeCacheEvent.Type.NODE_ADDED, toPublish);
                }
                else
                {
                    if ( oldChildData == null || oldChildData.getStat().getMzxid() != newStat.getMzxid() )
                    {
                        publishEvent(TreeCacheEvent.Type.NODE_UPDATED, toPublish);
                    }
                }
            }
            else if ( event.getResultCode() == KeeperException.Code.NONODE.intValue() )
            {
                wasDeleted();
            }
            break;
        default:
            // An unknown event, probably an error of some sort like connection loss.
            LOG.info(String.format("Unknown event %s", event));
            // Don't produce an initialized event on error; reconnect can fix this.
            outstandingOps.decrementAndGet();
            return;
        }

        if ( outstandingOps.decrementAndGet() == 0 )
        {
            if ( isInitialized.compareAndSet(false, true) )
            {
                publishEvent(TreeCacheEvent.Type.INITIALIZED);
            }
        }
    }
}

  • 状态机 这里先来看看在启动时获取数据的逻辑：

  • GET_DATA

    1. 如果成功获取了zk节点数据
      1. 构建新的ChildData
      2. 如果需要对数据进行缓存
        1. 使用AtomicReferenceFieldUpdater原子化操作覆盖当前结点的数据
      3. 如果不需要对数据进行缓存
        1. 则使用一个不含数据的ChildData覆盖当前结点的数据
      4. 检查当前结点是否已经加入到缓存中
        • 通过判断节点状态来实现
      5. 如果发现为节点已经DEAD无效了，则只是覆盖更新数据，而再不处理，直接返回
      6. 如果当前结点是第一次被添加到树中
        1. 触发NODE_ADDED事件
      7. 如果已经在树中，则判断数据是否有更新
        1. 如果数据有更新，则触发NODE_UPDATED事件
    2. 如果发现zk节点已经不存在了
      1. 则进行删除书节点操作wasDeleted()

  • 当任务计数器outstandingOps为0时，说明同步任务全部完成

    • 更新isInitialized状态
    • 触发了INITIALIZED事件

org.apache.curator.framework.recipes.cache.TreeCache.TreeNode#wasDeleted:

void wasDeleted() throws Exception
{
    ChildData oldChildData = childDataUpdater.getAndSet(this, null);
    client.clearWatcherReferences(this);
    ConcurrentMap childMap = childrenUpdater.getAndSet(this,null);
    if ( childMap != null )
    {
        ArrayList childCopy = new ArrayList(childMap.values());
        childMap.clear();
        for ( TreeNode child : childCopy )
        {
            child.wasDeleted();
        }
    }

    if ( treeState.get() == TreeState.CLOSED )
    {
        return;
    }

    NodeState oldState = nodeStateUpdater.getAndSet(this, NodeState.DEAD);
    if ( oldState == NodeState.LIVE )
    {
        publishEvent(TreeCacheEvent.Type.NODE_REMOVED, oldChildData);
    }

    if ( parent == null )
    {
        // Root node; use an exist query to watch for existence.
        client.checkExists().usingWatcher(this).inBackground(this).forPath(path);
    }
    else
    {
        // Remove from parent if we're currently a child
        ConcurrentMap parentChildMap = parent.children;
        if ( parentChildMap != null )
        {
            parentChildMap.remove(ZKPaths.getNodeFromPath(path), this);
        }
    }
}
  1. 将当前节点数据清空
  2. 清除节点上的监听器
  3. 制空子节点列表
    1. 调用每一个节点的wasDeleted()
    • 树结构从上到下的清理动作
  4. 如果整个树状态都已经关闭，则不需要在处理了
  5. 如果树状态正常，只是清理某个分支则：
    1. 则将当前结点状态更新为DEAD无效
    2. 触发NODE_REMOVED事件
    3. 如果父节点为空（自身就是根节点）
      1. 则对zk节点进行检查（检查树对应的zk节点根节点是否还存在）
    4. 如果父节点不为空（树中的某个分支节点）
      1. 则将自己从父节点的子节点列表中移除
刷新子节点列表
private void doRefreshChildren() throws Exception
{
    client.getChildren().usingWatcher(this).inBackground(this).forPath(path);
}

仍然是一个回调自身processResult状态机的方式。

  • 这里看看CHILDREN的逻辑
    1. 如果以及成功获取了ZK子节点列表
      1. 如果子节点列表没有变化（ZK节点没变化，不是说本地列表没变化）
        1. 覆盖更新当前结点的子节点列表
        • 只是更新了Stat信息，后续逻辑会判断data的相等性，如果这里也覆盖了data部分，则会导致后续逻辑任务数据发生了更新，从而导致不必要的GET_DATA事件
      2. 如果子节点列表是空的，自然不需要再做什么处理了
      3. 开始构建children
        • 考虑到了children的并发
          • 先用原子操作
          • 如果失败，说明有其他线程已经更新了，则使用新值
      4. 对节点列表进行梳理排序后，加入子节点列表
        1. 逐个调用子节点的wasCreated
          • 从上到下的加入一个树分支
    2. 如果发现ZK节点不存在了
      1. 则进行删除书节点操作wasDeleted()
        • 参见上一节

5.5 获取缓存

有两个方式来获取缓存

5.5.1 获取指定节点缓存数据

调用：ChildData getCurrentData(String fullPath)

看看源码：

public ChildData getCurrentData(String fullPath)
{
    TreeNode node = find(fullPath);
    if ( node == null || node.nodeState != NodeState.LIVE )
    {
        return null;
    }
    ChildData result = node.childData;
    // Double-check liveness after retreiving data.
    return node.nodeState == NodeState.LIVE ? result : null;
}
  1. 查找到对应的节点
  2. 获取节点数据
  3. Double check

所以，重点在于节点的查找过程：

private TreeNode find(String findPath)
{
    PathUtils.validatePath(findPath);
    LinkedList rootElements = new LinkedList(ZKPaths.split(root.path));
    LinkedList findElements = new LinkedList(ZKPaths.split(findPath));
    while (!rootElements.isEmpty()) {
        if (findElements.isEmpty()) {
            // Target path shorter than root path
            return null;
        }
        String nextRoot = rootElements.removeFirst();
        String nextFind = findElements.removeFirst();
        if (!nextFind.equals(nextRoot)) {
            // Initial root path does not match
            return null;
        }
    }

    TreeNode current = root;
    while (!findElements.isEmpty()) {
        String nextFind = findElements.removeFirst();
        ConcurrentMap map = current.children;
        if ( map == null )
        {
            return null;
        }
        current = map.get(nextFind);
        if ( current == null )
        {
            return null;
        }
    }
    return current;
}
  1. 分离出缓存节点对应路径
    1. 将root.path与findPath的每一层（/分隔）逐一比较
    2. 从findPath中，去掉root.path的部分
  2. 从root节点开始，按剩余的findPath部分逐一查找
  3. 直到最后匹配的节点

5.5.2 获取一组子节点缓存数据

调用:Map getCurrentChildren(String fullPath)

public Map getCurrentChildren(String fullPath)
{
    TreeNode node = find(fullPath);
    if ( node == null || node.nodeState != NodeState.LIVE )
    {
        return null;
    }
    ConcurrentMap map = node.children;
    Map result;
    if ( map == null )
    {
        result = ImmutableMap.of();
    }
    else
    {
        ImmutableMap.Builder builder = ImmutableMap.builder();
        for ( Map.Entry entry : map.entrySet() )
        {
            TreeNode childNode = entry.getValue();
            ChildData childData = childNode.childData;
            // Double-check liveness after retreiving data.
            if ( childData != null && childNode.nodeState == NodeState.LIVE )
            {
                builder.put(entry.getKey(), childData);
            }
        }
        result = builder.build();
    }

    // Double-check liveness after retreiving children.
    return node.nodeState == NodeState.LIVE ? result : null;
}
  1. 查找对应的节点
  2. 逐个获取子节点数据
  • 返回的是一个不可变Map

5.6 关闭缓存

使用完缓存需要调用close()

public void close()
{
    if ( treeState.compareAndSet(TreeState.STARTED, TreeState.CLOSED) )
    {
        client.getConnectionStateListenable().removeListener(connectionStateListener);
        listeners.clear();
        executorService.shutdown();
        try
        {
            root.wasDeleted();
        }
        catch ( Exception e )
        {
            ThreadUtils.checkInterrupted(e);
            handleException(e);
        }
    }
}
  1. 原子化更新状态
  2. 移除链接状态监听器
  3. 清理监听器容器
  4. 关闭线程池
  5. 删除root节点

6. 小结

对比项 Path Cache Node Cache Tree Cache
缓存数量 多个 单个 多个
使用 管理着一组缓存，类似一个CacheManager 单个name的缓存 有层级关系的CacheManager
机制 状态机，事件驱动（对重复操作进行过滤），单线程，任务队列 状态机，回调驱动 状态机，单线程，事件驱动，使用任务计数器跟踪

转载于:https://my.oschina.net/roccn/blog/956654

你可能感兴趣的:([Curator] Tree Cache 的使用与分析)

  • 斤斤计较的婚姻到底有多难？ 白心之岂必有为
    很多人私聊我会问到在哪个人群当中斤斤计较的人最多？我都会回答他，一般婚姻出现问题的斤斤计较的人士会非常多，以我多年经验，在婚姻落的一塌糊涂的人当中，斤斤计较的人数占比在20～30%以上，也就是说10个婚姻出现问题的斤斤计较的人有2-3个有多不减。在婚姻出问题当中，有大量的心理不平衡的、尖酸刻薄的怨妇。在婚姻中仅斤斤计较有两种类型：第一种是物质上的，另一种是精神上的。在物质与精神上抠门已经严重的影响
  • QQ群采集助手，精准引流必备神器 2401_87347160 其他经验分享
    功能概述微信群查找与筛选工具是一款专为微信用户设计的辅助工具，它通过关键词搜索功能，帮助用户快速找到相关的微信群，并提供筛选是否需要验证的群组的功能。主要功能关键词搜索：用户可以输入关键词，工具将自动查找包含该关键词的微信群。筛选功能：工具提供筛选机制，用户可以选择是否只显示需要验证或不需要验证的群组。精准引流：通过上述功能，用户可以更精准地找到目标群组，进行有效的引流操作。3.设备需求该工具可以
  • 机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习python
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
  • 随笔 | 仙一般的灵气 海思沧海
    仙岛今天，我看了你全部，似乎已经进入你的世界我不知道，这是否是梦幻，还是你仙一般的灵气吸引了我也许每一个人都要有一份属于自己的追求，这样才能够符合人生的梦想，生活才能够充满着阳光与快乐我不知道，我为什么会这样的感叹，是在感叹自己的人生，还是感叹自己一直没有孜孜不倦的追求只感觉虚度了光阴，每天活在自己的梦中，活在一个不真实的世界是在逃避自己，还是在逃避周围的一切有时候我嘲笑自己，嘲笑自己如此的虚无，
  • 一百九十四章. 自相矛盾 巨木擎天
    唉！就这么一夜，林子感觉就像过了很多天似的，先是回了阳间家里，遇到了那么多不可思议的事情儿。特别是小伙伴们，第二次与自己见面时，僵硬的表情和恐怖的气氛，让自己如坐针毡，打从心眼里难受！还有东子，他现在还好吗？有没有被人欺负？护城河里的小鱼小虾们，还都在吗？水不会真的干枯了吧？那对相亲相爱漂亮的太平鸟儿，还好吧！春天了，到了做窝、下蛋、喂养小鸟宝宝的时候了，希望它们都能够平安啊！虽然没有看见家人，也
  • element实现动态路由+面包屑 软件技术NINI vue案例vue.js前端
    el-breadcrumb是ElementUI组件库中的一个面包屑导航组件，它用于显示当前页面的路径，帮助用户快速理解和导航到应用的各个部分。在Vue.js项目中，如果你已经安装了ElementUI，就可以很方便地使用el-breadcrumb组件。以下是一个基本的使用示例：安装ElementUI（如果你还没有安装的话）:你可以通过npm或yarn来安装ElementUI。bash复制代码npmi
  • 地推话术，如何应对地推过程中家长的拒绝 校师学
    相信校长们在做地推的时候经常遇到这种情况：市场专员反馈家长不接单，咨询师反馈难以邀约这些家长上门，校区地推疲软，招生难。为什么？仅从地推层面分析，一方面因为家长受到的信息轰炸越来越多，对信息越来越“免疫”；而另一方面地推人员的专业能力和营销话术没有提高，无法应对家长的拒绝，对有意向的家长也不知如何跟进，眼睁睁看着家长走远；对于家长的疑问，更不知道如何有技巧地回答，机会白白流失。由于回答没技巧和专业
  • 微服务下功能权限与数据权限的设计与实现 nbsaas-boot 微服务java架构
    在微服务架构下，系统的功能权限和数据权限控制显得尤为重要。随着系统规模的扩大和微服务数量的增加，如何保证不同用户和服务之间的访问权限准确、细粒度地控制，成为设计安全策略的关键。本文将讨论如何在微服务体系中设计和实现功能权限与数据权限控制。1.功能权限与数据权限的定义功能权限：指用户或系统角色对特定功能的访问权限。通常是某个用户角色能否执行某个操作，比如查看订单、创建订单、修改用户资料等。数据权限：
  • 学点心理知识，呵护孩子健康 静候花开_7090
    昨天听了华中师范大学教育管理学系副教授张玲老师的《哪里才是学生心理健康的最后庇护所，超越教育与技术的思考》的讲座。今天又重新学习了一遍，收获匪浅。张玲博士也注意到了当今社会上的孩子由于心理问题导致的自残、自杀及伤害他人等恶性事件。她向我们普及了一个重要的命题，她说心理健康的一些基本命题，我们与我们通常的一些教育命题是不同的，她还举了几个例子，让我们明白我们原来以为的健康并非心理学上的健康。比如如果
  • 《投行人生》读书笔记 小蘑菇的树洞
    《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
  • Long类型前后端数据不一致 igotyback 前端
    响应给前端的数据浏览器控制台中response中看到的Long类型的数据是正常的到前端数据不一致前后端数据类型不匹配是一个常见问题，尤其是当后端使用Java的Long类型（64位）与前端JavaScript的Number类型（最大安全整数为2^53-1，即16位）进行数据交互时，很容易出现精度丢失的问题。这是因为JavaScript中的Number类型无法安全地表示超过16位的整数。为了解决这个问
  • 扫地机类清洁产品之直流无刷电机控制 悟空胆好小 清洁服务机器人单片机人工智能
    扫地机类清洁产品之直流无刷电机控制1.1前言扫地机产品有很多的电机控制，滚刷电机1个，边刷电机1-2个，清水泵电机，风机一个，部分中高端产品支持抹布功能，也就是存在抹布盘电机，还有追觅科沃斯石头等边刷抬升电机，滚刷抬升电机等的，这些电机有直流有刷电机，直接无刷电机，步进电机，电磁阀，挪动泵等不同类型。电机的原理，驱动控制方式也不行。接下来一段时间的几个文章会作个专题分析分享。直流有刷电机会自动持续
  • 店群合一模式下的社区团购新发展——结合链动 2+1 模式、AI 智能名片与 S2B2C 商城小程序源码 说私域 人工智能小程序
    摘要：本文探讨了店群合一的社区团购平台在当今商业环境中的重要性和优势。通过分析店群合一模式如何将互联网社群与线下终端紧密结合，阐述了链动2+1模式、AI智能名片和S2B2C商城小程序源码在这一模式中的应用价值。这些创新元素的结合为社区团购带来了新的机遇，提升了用户信任感、拓展了营销渠道，并实现了线上线下的完美融合。一、引言随着互联网技术的不断发展，社区团购作为一种新兴的商业模式，在满足消费者日常需
  • 2021-08-26 影幽
    在生活中，女人与男人的感悟往往有所不同。人生最大的舞台就是生活，大幕随时都可能拉开，关键是你愿不愿意表演都无法躲避。在生活中，遇事不要急躁，不要急于下结论，尤其生气时不要做决断，要学会换位思考，大事化小小事化了，把复杂的事情尽量简单处理，千万不要把简单的事情复杂化。永远不要扭曲，别人善意，无药可救。昨天是张过期的支票，明天是张信用卡，只有今天才是现金，要善加利用！执着的攀登者不必去与别人比较自己的
  • 高级编程--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
  • 抖音乐买买怎么加入赚钱?赚钱方法是什么 测评君高省
    你会在抖音买东西吗?如果会，那么一定要免费注册一个乐买买，抖音直播间，橱窗，小视频里的小黄车买东西都可以返佣金!省下来都是自己的，分享还可以赚钱乐买买是好省旗下的抖音返佣平台，乐买买分析社交电商的价值，乐买买属于今年难得的副业项目风口机会，2019年错过做好省的搞钱的黄金时期，那么2022年千万别再错过乐买买至于我为何转到高省呢？当然是高省APP佣金更高，模式更好，终端用户不流失。【高省】是一个自
  • 2018-07-23-催眠日作业-#不一样的31天#-66小鹿 小鹿_33
    预言日：人总是在逃避命运的路上，与之不期而遇。心理学上有个著名的名词，叫做自证预言；经济学上也有一个很著名的定律叫做，墨菲定律；在灵修派上，还有一个很著名的法则，叫做吸引力法则。这3个领域的词，虽然看起来不太一样，但是他们都在告诉人们一个现象：你越担心什么，就越有可能会发生什么。同样的道理，你越想得到什么，就应该要积极地去创造什么。无论是自证预言，墨菲定律还是吸引力法则，对人都有正反2个维度的影响
  • 回溯 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等。这些库分别用于数据处理、数学
  • 《庄子.达生9》 钱江潮369
    【原文】孔子观于吕梁，县水三十仞，流沫四十里，鼋鼍鱼鳖之所不能游也。见一丈夫游之，以为有苦而欲死也，使弟子并流而拯之。数百步而出，被发行歌而游于塘下。孔子从而问焉，曰：“吾以子为鬼，察子则人也。请问，‘蹈水有道乎’”曰：“亡，吾无道。吾始乎故，长乎性，成乎命。与齐俱入，与汩偕出，从水之道而不为私焉。此吾所以蹈之也。”孔子曰：“何谓始乎故，长乎性，成乎命？”曰：“吾生于陵而安于陵，故也；长于水而安于
  • Python中os.environ基本介绍及使用方法 鹤冲天Pro #Pythonpython服务器开发语言
    文章目录python中os.environos.environ简介os.environ进行环境变量的增删改查python中os.environ的使用详解1.简介2.key字段详解2.1常见key字段3.os.environ.get()用法4.环境变量的增删改查和判断是否存在4.1新增环境变量4.2更新环境变量4.3获取环境变量4.4删除环境变量4.5判断环境变量是否存在python中os.envi
  • 水泥质量纠纷案代理词 徐宝峰律师
    贵州领航建设有限公司诉贵州纳雍隆庆乌江水泥有限公司产品质量纠纷案代理词尊敬的审判长、审判员：贵州千里律师事务所接受被告贵州纳雍隆庆乌江水泥有限公司的委托，指派我担任其诉讼代理人，参加本案的诉讼活动。下面，我结合本案事实和相关法律规定发表如下代理意见，供合议庭评议案件时参考：原告应当举证证明其遭受的损失与被告生产的水泥质量的因果关系。首先水泥是一种粉状水硬性无机胶凝材料。加水搅拌后成浆体，能在空气中
  • Pyecharts数据可视化大屏：打造沉浸式数据分析体验 我的运维人生 信息可视化数据分析数据挖掘运维开发技术共享
    Pyecharts数据可视化大屏：打造沉浸式数据分析体验在当今这个数据驱动的时代，如何将海量数据以直观、生动的方式展现出来，成为了数据分析师和企业决策者关注的焦点。Pyecharts，作为一款基于Python的开源数据可视化库，凭借其丰富的图表类型、灵活的配置选项以及高度的定制化能力，成为了构建数据可视化大屏的理想选择。本文将深入探讨如何利用Pyecharts打造数据可视化大屏，并通过实际代码案例
  • Goolge earth studio 进阶4——路径修改与平滑 陟彼高冈yu Googleearthstudio进阶教程旅游
    如果我们希望在大约中途时获得更多的城市鸟瞰视角。可以将相机拖动到这里并创建一个新的关键帧。camera_target_clip_7EarthStudio会自动平滑我们的路径，所以当我们通过这个关键帧时，不是一个生硬的角度，而是一个平滑的曲线。camera_target_clip_8路径上有贝塞尔控制手柄，允许我们调整路径的形状。右键单击，我们可以选择“平滑路径”，这是默认的自动平滑算法，或者我们可
  • linux中sdl的使用教程,sdl使用入门 Melissa Corvinus linux中sdl的使用教程
    本文通过一个简单示例讲解SDL的基本使用流程。示例中展示一个窗口，窗口里面有个随机颜色快随机移动。当我们鼠标点击关闭按钮时间窗口关闭。基本步骤如下：1.初始化SDL并创建一个窗口。SDL_Init()初始化SDL_CreateWindow()创建窗口2.纹理渲染存储RGB和存储纹理的区别：比如一个从左到右由红色渐变到蓝色的矩形，用存储RGB的话就需要把矩形中每个点的具体颜色值存储下来；而纹理只是一
  • 18-115 一切思考不能有效转化为行动，都TM是扯淡！ 成长时间线
    7月25号写了一篇关于为什么会断更如此严重的反思，然而，之后日更仅仅维持了一周，又出现了这次更严重的现象。从8月2号到昨天8月6号，5天！又是5天没有更文！虽然这次断更时间和上次一样，那为什么说这次更严重？因为上次之后就分析了问题的原因，以及应该如何解决，按理说应该会好转，然而，没过几天严重断更的现象再次出现，想想，经过反思，问题依然没有解决与改变，这让我有些担忧。到底是哪里出了问题，难道我就真的
  • 山东大学小树林支教调研团青青仓木队——翟晓楠 山东大学青青仓木队
    过了半年，又一次启程，又一次回到支教的初心之地。比起上一次的试探与不安，我更多了一丝稳重与熟练。心境、处境也都随着半个学期的过去而变得不同，半个学期中，身体上的，心理上的，太多的逆境让我变得步履维艰，曲曲折折，弯弯绕绕，我仿佛打不起精神，没有胃口，没有动力。感觉走的不顺畅的时候，支教这个旅程，给了我力量。自告奋勇承担起队长这一职务的我，从组织时的复杂和困难的经历，协调各种问题，从无到有，和校长和队
  • 直返最高等级与直返APP：无需邀请码的返利新体验 古楼
    随着互联网的普及和电商的兴起，直返模式逐渐成为一种流行的商业模式。在这种模式下，消费者通过购买产品或服务，获得一定的返利，并可以分享给更多的人。其中，直返最高等级和直返APP是直返模式中的重要概念和工具。本文将详细介绍直返最高等级的概念、直返APP的使用以及与邀请码的关系。【高省】APP（高佣金领导者）是一个自用省钱佣金高，分享推广赚钱多的平台，百度有几百万篇报道，运行三年，稳定可靠。高省APP，
  • DIV+CSS+JavaScript技术制作网页（旅游主题网页设计与制作）云南大理 STU学生网页设计 网页设计期末网页作业html静态网页html5期末大作业网页设计web大作业
    ️精彩专栏推荐作者主页:【进入主页—获取更多源码】web前端期末大作业：【HTML5网页期末作业(1000套)】程序员有趣的告白方式：【HTML七夕情人节表白网页制作(110套)】文章目录二、网站介绍三、网站效果▶️1.视频演示2.图片演示四、网站代码HTML结构代码CSS样式代码五、更多源码二、网站介绍网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。网站程
  • java观察者模式 3213213333332132 java设计模式游戏观察者模式
    观察者模式——顾名思义，就是一个对象观察另一个对象，当被观察的对象发生变化时，观察者也会跟着变化。 在日常中，我们配java环境变量时，设置一个JAVAHOME变量,这就是被观察者，使用了JAVAHOME变量的对象都是观察者，一旦JAVAHOME的路径改动，其他的也会跟着改动。 这样的例子很多，我想用小时候玩的老鹰捉小鸡游戏来简单的描绘观察者模式。 老鹰会变成观察者，母鸡和小鸡是
  • TFS RESTful API 模拟上传测试 ronin47
           TFS RESTful API 模拟上传测试。 　　 细节参看这里：https://github.com/alibaba/nginx-tfs/blob/master/TFS_RESTful_API.markdown 模拟POST上传一个图片： curl --data-binary @/opt/tfs.png http
  • PHP常用设计模式单例, 工厂, 观察者, 责任链, 装饰, 策略,适配,桥接模式 dcj3sjt126com 设计模式PHP
    // 多态, 在JAVA中是这样用的, 其实在PHP当中可以自然消除, 因为参数是动态的, 你传什么过来都可以, 不限制类型, 直接调用类的方法 abstract class Tiger { public abstract function climb(); } class XTiger extends Tiger { public function climb()
  • hibernate 171815164 Hibernate
    main,save Configuration conf =new Configuration().configure(); SessionFactory sf=conf.buildSessionFactory(); Session sess=sf.openSession(); Transaction tx=sess.beginTransaction(); News a=new
  • Ant实例分析 g21121 ant
            下面是一个Ant构建文件的实例，通过这个实例我们可以很清楚的理顺构建一个项目的顺序及依赖关系，从而编写出更加合理的构建文件。           下面是build.xml的代码： <?xml version="1
  • [简单]工作记录_接口返回405原因 53873039oycg 工作
             最近调接口时候一直报错，错误信息是:       responseCode:405 responseMsg:Method Not Allowed        接口请求方式Post.
  • 关于java.lang.ClassNotFoundException 和 java.lang.NoClassDefFoundError 的区别 程序员是怎么炼成的
       真正完成类的加载工作是通过调用 defineClass来实现的；  而启动类的加载过程是通过调用 loadClass来实现的；  就是类加载器分为加载和定义   protected Class<?> findClass(String name) throws ClassNotFoundExcept
  • JDBC学习笔记-JDBC详细的操作流程 aijuans jdbc
    所有的JDBC应用程序都具有下面的基本流程：　　1、加载数据库驱动并建立到数据库的连接。　　2、执行SQL语句。　　3、处理结果。　　4、从数据库断开连接释放资源。 下面我们就来仔细看一看每一个步骤： 其实按照上面所说每个阶段都可得单独拿出来写成一个独立的类方法文件。共别的应用来调用。 1、加载数据库驱动并建立到数据库的连接：   Html代码  St
  • rome创建rss antonyup_2006 tomcatcmsxmlstrutsOpera
    引用 1.RSS标准 RSS标准比较混乱，主要有以下3个系列 RSS 0.9x / 2.0 : RSS技术诞生于1999年的网景公司(Netscape)，其发布了一个0.9版本的规范。2001年，RSS技术标准的发展工作被Userland Software公司的戴夫 温那(Dave Winer)所接手。陆续发布了0.9x的系列版本。当W3C小组发布RSS 1.0后，Dave W
  • html表格和表单基础 百合不是茶 html表格表单meta锚点
    第一次用html来写东西,感觉压力山大,每次看见别人发的都是比较牛逼的 再看看自己什么都还不会,   html是一种标记语言,其实很简单都是固定的格式   _----------------------------------------表格和表单 表格是html的重要组成部分,表格用在body里面的 主要用法如下; <table> &
  • ibatis如何传入完整的sql语句 bijian1013 javasqlibatis
            ibatis如何传入完整的sql语句？进一步说，String str ="select * from test_table"，我想把str传入ibatis中执行，是传递整条sql语句。         解决办法： <
  • 精通Oracle10编程SQL(14)开发动态SQL bijian1013 oracle数据库plsql
    /* *开发动态SQL */ --使用EXECUTE IMMEDIATE处理DDL操作 CREATE OR REPLACE PROCEDURE drop_table(table_name varchar2) is sql_statement varchar2(100); begin sql_statement:='DROP TABLE '||table_name;
  • 【Linux命令】Linux工作中常用命令 bit1129 linux命令
    不断的总结工作中常用的Linux命令   1.查看端口被哪个进程占用   通过这个命令可以得到占用8085端口的进程号，然后通过ps -ef|grep 进程号得到进程的详细信息   netstat -anp | grep 8085   察看进程ID对应的进程占用的端口号   netstat -anp | grep 进程ID &
  • 优秀网站和文档收集 白糖_ 网站
    集成 Flex, Spring, Hibernate 构建应用程序   性能测试工具-JMeter   Hmtl5-IOCN网站   Oracle精简版教程网站   鸟哥的linux私房菜   Jetty中文文档   50个jquery必备代码片段   swfobject.js检测flash版本号工具
  • angular.extend boyitech AngularJSangular.extendAngularJS API
    angular.extend 复制src对象中的属性去dst对象中. 支持多个src对象. 如果你不想改变一个对象，你可以把dst设为空对象{}: var object = angular.extend({}, object1, object2). 注意: angular.extend不支持递归复制. 使用方法: angular.extend(dst, src); 参数:
  • java-谷歌面试题-设计方便提取中数的数据结构 bylijinnan java
    网上找了一下这道题的解答，但都是提供思路，没有提供具体实现。其中使用大小堆这个思路看似简单，但实现起来要考虑很多。 以下分别用排序数组和大小堆来实现。 使用大小堆： import java.util.Arrays; public class MedianInHeap { /** * 题目：设计方便提取中数的数据结构 * 设计一个数据结构，其中包含两个函数，1.插
  • ajaxFileUpload 针对 ie jquery 1.7+不能使用问题修复版本 Chen.H ajaxFileUploadie6ie7ie8ie9
    jQuery.extend({ handleError: function( s, xhr, status, e ) { // If a local callback was specified, fire it if ( s.error ) { s.error.call( s.context || s, xhr, status, e ); }
  • [机器人制造原则]机器人的电池和存储器必须可以替换 comsci 制造
           机器人的身体随时随地可能被外来力量所破坏,但是如果机器人的存储器和电池可以更换,那么这个机器人的思维和记忆力就可以保存下来,即使身体受到伤害,在把存储器取下来安装到一个新的身体上之后,原有的性格和能力都可以继续维持.....        另外,如果一
  • Oracle Multitable INSERT 的用法 daizj oracle
    转载Oracle笔记-Multitable INSERT 的用法 http://blog.chinaunix.net/uid-8504518-id-3310531.html 一、Insert基础用法 语法：     Insert Into 表名 (字段1,字段2,字段3...）     Values (值1,
  • 专访黑客历史学家George Dyson datamachine on
    20世纪最具威力的两项发明——核弹和计算机出自同一时代、同一群年青人。可是，与大名鼎鼎的曼哈顿计划（第二次世界大战中美国原子弹研究计划）相 比，计算机的起源显得默默无闻。出身计算机世家的历史学家George Dyson在其新书《图灵大教堂》（Turing’s Cathedral）中讲述了阿兰·图灵、约翰·冯·诺依曼等一帮子天才小子创造计算机及预见计算机未来
  • 小学6年级英语单词背诵第一课 dcj3sjt126com englishword
    always 总是 rice 水稻，米饭 before 在...之前 live 生活，居住   usual 通常的 early 早的 begin 开始 month 月份   year 年 last 最后的 east 东方的 high 高的   far 远的 window 窗户 world 世界 than 比...更  
  • 在线IT教育和在线IT高端教育 dcj3sjt126com 教育
    codecademy  http://www.codecademy.com codeschool  https://www.codeschool.com teamtreehouse  http://teamtreehouse.com lynda http://www.lynda.com/ Coursera https://www.coursera.
  • Struts2 xml校验框架所定义的校验文件 蕃薯耀 Struts2 xml校验Struts2 xml校验框架Struts2校验
      >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 2015年7月11日 15:54:59 星期六 http://fa
  • mac下安装rar和unrar命令 hanqunfeng mac
    1.下载：http://www.rarlab.com/download.htm 选择 RAR 5.21 for Mac OS X 2.解压下载后的文件 tar -zxvf rarosx-5.2.1.tar 3.cd rar sudo install -c -o $USER unrar /bin #输入当前用户登录密码 sudo install -c -o $USER rar
  • 三种将list转换为map的方法 jackyrong list
      在本文中，介绍三种将list转换为map的方法： 1） 传统方法 假设有某个类如下    class Movie { private Integer rank; private String description; public Movie(Integer rank, String des
  • 年轻程序员需要学习的5大经验 lampcy 工作PHP程序员
    在过去的7年半时间里，我带过的软件实习生超过一打，也看到过数以百计的学生和毕业生的档案。我发现很多事情他们都需要学习。或许你会说，我说的不就是某种特定的技术、算法、数学，或者其他特定形式的知识吗？没错，这的确是需要学习的，但却并不是最重要的事情。他们需要学习的最重要的东西是“自我规范”。这些规范就是：尽可能地写出最简洁的代码；如果代码后期会因为改动而变得凌乱不堪就得重构；尽量删除没用的代码，并添加
  • 评“女孩遭野蛮引产致终身不育 60万赔偿款1分未得”医腐深入骨髓 nannan408
    先来看南方网的一则报道： 再正常不过的结婚、生子，对于29岁的郑畅来说，却是一个永远也无法实现的梦想。从2010年到2015年，从24岁到29岁，一张张新旧不一的诊断书记录了她病情的同时，也清晰地记下了她人生的悲哀。 　　粗暴手术让人发寒 　　2010年7月，在酒店做服务员的郑畅发现自己怀孕了，可男朋友却联系不上。在没有和家人商量的情况下，她决定堕胎。 　　12月5日，
  • 使用jQuery为input输入框绑定回车键事件 VS 为a标签绑定click事件 Everyday都不同 jspinput回车键绑定clickenter
    假设如题所示的事件为同一个，必须先把该js函数抽离出来，该函数定义了监听的处理：   function search() { //监听函数略...... }   为input框绑定回车事件，当用户在文本框中输入搜索关键字时，按回车键，即可触发search():   //回车绑定 $(".search").keydown(fun
  • EXT学习记录 tntxia ext
      1. 准备   （1） 官网：http://www.sencha.com/   里面有源代码和API文档下载。   EXT的域名已经从www.extjs.com改成了www.sencha.com ，但extjs这个域名会自动转到sencha上。   （2）帮助文档：   想要查看EXT的官方文档的话，可以去这里h
  • mybatis3的mapper文件报Referenced file contains errors xingguangsixian mybatis
    最近使用mybatis.3.1.0时无意中碰到一个问题： The errors below were detected when validating the file "mybatis-3-mapper.dtd" via the file "account-mapper.xml". In most cases these errors can be d
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他