Android编程至高武学之《如来神掌》第五式~迎佛西天

最新推荐文章于 2020-12-31 04:10:43 发布
最新推荐文章于 2020-12-31 04:10:43 发布
阅读量416 收藏
点赞数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_14830009/article/details/72312536
版权

       上回书Android编程至高武学之《如来神掌》第四式~佛问迦蓝，为众卿家分析了寡人小小框架中最重要的一环，网络请求。这次朕将挥泪告别大家了，临走前，孤还是要请尔等搓一顿的。言归正传，废话少说，出来混迟早要还的，我还是老老实实地讲我的框架中的最后一点，也是最大的一点，xrecylerview，带有刷新和加载更多哦！详情如下：

         

package com.jcodecraeer.xrecyclerview;

import android.content.Context;


import android.support.v7.widget.GridLayoutManager;
import android.support.v7.widget.RecyclerView;
import android.support.v7.widget.StaggeredGridLayoutManager;
import android.util.AttributeSet;
import android.util.Log;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewGroup;


import java.util.ArrayList;
import java.util.List;

public class XRecyclerView extends RecyclerView {

    private  Context mContext;
    private boolean isLoadingData = false;
    private boolean isnomore = false;
    private int mRefreshProgressStyle = ProgressStyle.SysProgress;
    private int mLoadingMoreProgressStyle = ProgressStyle.SysProgress;
    private ArrayList<View> mHeaderViews = new ArrayList<>();
    private ArrayList<View> mFootViews = new ArrayList<>();
    private Adapter mAdapter;
    private Adapter mWrapAdapter;
    private float mLastY = -1;
    private static final float DRAG_RATE = 3;
    private LoadingListener mLoadingListener;
    private ArrowRefreshHeader mRefreshHeader;
    private boolean pullRefreshEnabled = true;
    private boolean loadingMoreEnabled = true;
    private static final int TYPE_REFRESH_HEADER =  -5;
    private static final int TYPE_HEADER =  -4;
    private static final int TYPE_NORMAL =  0;
    private static final int TYPE_FOOTER =  -3;
    private int previousTotal = 0;
    private int mPageCount = 0;

    public XRecyclerView(Context context) {
        this(context, null);
    }

    public XRecyclerView(Context context, AttributeSet attrs) {
        this(context, attrs, 0);
    }

    public XRecyclerView(Context context, AttributeSet attrs, int defStyle) {
        super(context, attrs, defStyle);
        init(context);
    }

    private void init(Context context) {
        mContext = context;
        if(pullRefreshEnabled) {
            ArrowRefreshHeader refreshHeader = new ArrowRefreshHeader(mContext);
            mHeaderViews.add(0, refreshHeader);
            mRefreshHeader = refreshHeader;
            mRefreshHeader.setProgressStyle(mRefreshProgressStyle);
        }
        LoadingMoreFooter footView = new LoadingMoreFooter(mContext);
        footView.setProgressStyle(mLoadingMoreProgressStyle);
        addFootView(footView);
        mFootViews.get(0).setVisibility(GONE);
    }

    public void addHeaderView(View view) {
        if (pullRefreshEnabled && !(mHeaderViews.get(0) instanceof ArrowRefreshHeader)) {
            ArrowRefreshHeader refreshHeader = new ArrowRefreshHeader(mContext);
            mHeaderViews.add(0, refreshHeader);
            mRefreshHeader = refreshHeader;
            mRefreshHeader.setProgressStyle(mRefreshProgressStyle);
        }
        mHeaderViews.add(view);
    }

    public void addFootView(final View view) {
        mFootViews.clear();
        mFootViews.add(view);
    }

    public void loadMoreComplete() {
        isLoadingData = false;
        View footView = mFootViews.get(0);
        if(footView instanceof  LoadingMoreFooter) {
            ( (LoadingMoreFooter) footView ).setState(LoadingMoreFooter.STATE_NORMAL);
        }else{
            footView.setVisibility(View.GONE);
        }
    }

    public void noMoreLoading() {
        isLoadingData = false;
        View footView = mFootViews.get(0);
        isnomore = true;
        if(footView instanceof  LoadingMoreFooter) {
            ( (LoadingMoreFooter) footView ).setState(LoadingMoreFooter.STATE_NOMORE);
        }else{
            footView.setVisibility(View.GONE);
        }
    }

    public void refreshComplete() {
        mRefreshHeader.refreshComplate();
        isLoadingData = false;
    }

    public  void setRefreshHeader(ArrowRefreshHeader refreshHeader){
        mRefreshHeader = refreshHeader;
    }

    public void setPullRefreshEnabled(boolean enabled){
        pullRefreshEnabled = enabled;
    }
    /**
     * 是否可以加载更多
     */
    public boolean setLoadingMoreEnabled(List list, int pageSize){
        loadMoreComplete();
        if (list==null || list.size()==0){
            setLoadingMoreEnabled(false);
            return false;
        }else {
            setLoadingMoreEnabled(list.size()>=pageSize);
            return list.size()>=pageSize;
        }
    }
    /**
     * 是否可以加载更多
     * @param enabled
     */
    public void setLoadingMoreEnabled(boolean enabled){
        loadingMoreEnabled = enabled;
        View footView = mFootViews.get(0);
        if(enabled){
            footView.setVisibility(View.VISIBLE);
            if(footView instanceof  LoadingMoreFooter) {
                ( (LoadingMoreFooter) footView ).setState(LoadingMoreFooter.STATE_NORMAL);
            }
        }else{
            footView.setVisibility(View.VISIBLE);
            if(footView instanceof  LoadingMoreFooter) {
                ( (LoadingMoreFooter) footView ).setState(LoadingMoreFooter.STATE_NOMORE);
            }
        }

    }

    public void setRefreshProgressStyle(int style) {
        mRefreshProgressStyle = style;
        if (mRefreshHeader != null){
            mRefreshHeader.setProgressStyle(style);
        }
    }

    public void setLoadingMoreProgressStyle(int style) {
        mLoadingMoreProgressStyle = style;
        if(mFootViews.size() > 0 && mFootViews.get(0) instanceof LoadingMoreFooter){
            ((LoadingMoreFooter) mFootViews.get(0)).setProgressStyle(style);
        }
    }

    public void setArrowImageView(int resid) {
        if (mRefreshHeader != null){
            mRefreshHeader.setArrowImageView(resid);
        }
    }

    @Override
    public void setAdapter(Adapter adapter) {
        mAdapter  = adapter;
        mWrapAdapter = new WrapAdapter(mHeaderViews, mFootViews, adapter);
        super.setAdapter(mWrapAdapter);
        mAdapter.registerAdapterDataObserver(mDataObserver);
    }

    @Override
    public void onScrollStateChanged(int state) {
        super.onScrollStateChanged(state);


        //isLoadingData =false;
        if (state == RecyclerView.SCROLL_STATE_IDLE && mLoadingListener != null && !isLoadingData && loadingMoreEnabled) {
            if (mRefreshHeader.getState() < ArrowRefreshHeader.STATE_REFRESHING) {
                View footView = mFootViews.get(0);

                if(footView instanceof  LoadingMoreFooter) {
                    ( (LoadingMoreFooter) footView ).setState(LoadingMoreFooter.STATE_LAODING);
                } else{
                    footView.setVisibility(View.VISIBLE);
                }
                isLoadingData = true;
                mLoadingListener.onLoadMore();
            }
        }
    }

    @Override
    public boolean onTouchEvent(MotionEvent ev) {
        if (mLastY == -1) {
            mLastY = ev.getRawY();
        }
        switch (ev.getAction()) {
            case MotionEvent.ACTION_DOWN:
                mLastY = ev.getRawY();
                break;
            case MotionEvent.ACTION_MOVE:
                final float deltaY = ev.getRawY() - mLastY;
                mLastY = ev.getRawY();
                if ( isOnTop() && pullRefreshEnabled) {
                    mRefreshHeader.onMove(deltaY / DRAG_RATE);
                    if(mRefreshHeader.getVisiableHeight() > 0 && mRefreshHeader.getState() < ArrowRefreshHeader.STATE_REFRESHING ) {
                        Log.i("getVisiableHeight", "getVisiableHeight = " + mRefreshHeader.getVisiableHeight());
                        Log.i("getVisiableHeight", " mRefreshHeader.getState() = " +  mRefreshHeader.getState());
                        return false;
                    }
                }
                break;
            default:
                mLastY = -1; // reset
                if ( isOnTop() && pullRefreshEnabled) {
                    if( mRefreshHeader.releaseAction()) {
                        if (mLoadingListener != null) {
                            mLoadingListener.onRefresh();
                            isLoadingData=true;
                            isnomore = false;
                            previousTotal = 0;
                        }
                    }
                }
                break;
        }
        return super.onTouchEvent(ev);
    }

    private int findMax(int[] lastPositions) {
        int max = lastPositions[0];
        for (int value : lastPositions) {
            if (value > max) {
                max = value;
            }
        }
        return max;
    }

    private int findMin(int[] firstPositions) {
        int min = firstPositions[0];
        for (int value : firstPositions) {
            if (value < min) {
                min = value;
            }
        }
        return min;
    }

    private boolean isOnTop() {
        if (mHeaderViews == null || mHeaderViews.isEmpty()) {
            return false;
        }

        View view = mHeaderViews.get(0);
        if (view.getParent() != null) {
            return true;
        } else {
            return false;
        }
//        LayoutManager layoutManager = getLayoutManager();
//        int firstVisibleItemPosition;
//        if (layoutManager instanceof GridLayoutManager) {
//            firstVisibleItemPosition = ((GridLayoutManager) layoutManager).findFirstVisibleItemPosition();
//        } else if ( layoutManager instanceof StaggeredGridLayoutManager ) {
//            int[] into = new int[((StaggeredGridLayoutManager) layoutManager).getSpanCount()];
//            ((StaggeredGridLayoutManager) layoutManager).findFirstVisibleItemPositions(into);
//            firstVisibleItemPosition = findMin(into);
//        } else {
//            firstVisibleItemPosition = ((LinearLayoutManager) layoutManager).findFirstVisibleItemPosition();
//        }
//        if ( firstVisibleItemPosition <= 1 ) {
//             return true;
//        }
//        return false;
    }

    private final RecyclerView.AdapterDataObserver mDataObserver = new RecyclerView.AdapterDataObserver() {
        @Override
        public void onChanged() {
            mWrapAdapter.notifyDataSetChanged();
        }

        @Override
        public void onItemRangeInserted(int positionStart, int itemCount) {
            mWrapAdapter.notifyItemRangeInserted(positionStart, itemCount);
        }

        @Override
        public void onItemRangeChanged(int positionStart, int itemCount) {
            mWrapAdapter.notifyItemRangeChanged(positionStart, itemCount);
        }

        @Override
        public void onItemRangeChanged(int positionStart, int itemCount, Object payload) {
            mWrapAdapter.notifyItemRangeChanged(positionStart, itemCount, payload);
        }

        @Override
        public void onItemRangeRemoved(int positionStart, int itemCount) {
            mWrapAdapter.notifyItemRangeRemoved(positionStart, itemCount);
        }

        @Override
        public void onItemRangeMoved(int fromPosition, int toPosition, int itemCount) {
            mWrapAdapter.notifyItemMoved(fromPosition, toPosition);
        }
    };

    private class WrapAdapter extends RecyclerView.Adapter<ViewHolder> {

        private RecyclerView.Adapter adapter;

        private ArrayList<View> mHeaderViews;

        private ArrayList<View> mFootViews;

        private int headerPosition = 1;

        public WrapAdapter(ArrayList<View> headerViews, ArrayList<View> footViews, RecyclerView.Adapter adapter) {
            this.adapter = adapter;
            this.mHeaderViews = headerViews;
            this.mFootViews = footViews;
        }

        @Override
        public void onAttachedToRecyclerView(RecyclerView recyclerView) {
            super.onAttachedToRecyclerView(recyclerView);
            RecyclerView.LayoutManager manager = recyclerView.getLayoutManager();
            if(manager instanceof GridLayoutManager) {
                final GridLayoutManager gridManager = ((GridLayoutManager) manager);
                gridManager.setSpanSizeLookup(new GridLayoutManager.SpanSizeLookup() {
                    @Override
                    public int getSpanSize(int position) {
                        return (isHeader(position)||  isFooter(position))
                                ? gridManager.getSpanCount() : 1;
                    }
                });
            }
        }

        @Override
        public void onViewAttachedToWindow(RecyclerView.ViewHolder holder) {
            super.onViewAttachedToWindow(holder);
            ViewGroup.LayoutParams lp = holder.itemView.getLayoutParams();
            if(lp != null
                    && lp instanceof StaggeredGridLayoutManager.LayoutParams
                    &&  (isHeader( holder.getLayoutPosition()) || isFooter( holder.getLayoutPosition())) ) {
                StaggeredGridLayoutManager.LayoutParams p = (StaggeredGridLayoutManager.LayoutParams) lp;
                p.setFullSpan(true);
            }
        }

        public boolean isHeader(int position) {
            return position >= 0 && position < mHeaderViews.size();
        }

        public boolean isFooter(int position) {
            return position < getItemCount() && position >= getItemCount() - mFootViews.size();
        }

        public boolean isRefreshHeader(int position) {
            return position == 0 ;
        }

        public int getHeadersCount() {
            return mHeaderViews.size();
        }

        public int getFootersCount() {
            return mFootViews.size();
        }

        @Override
        public RecyclerView.ViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
            if (viewType == TYPE_REFRESH_HEADER) {
                return new SimpleViewHolder(mHeaderViews.get(0));
            } else if (viewType == TYPE_HEADER) {
                return new SimpleViewHolder(mHeaderViews.get(headerPosition++ ));
            } else if (viewType == TYPE_FOOTER) {
                return new SimpleViewHolder(mFootViews.get(0));
            }
            return adapter.onCreateViewHolder(parent, viewType);
        }

        @Override
        public void onBindViewHolder(RecyclerView.ViewHolder holder, int position) {
            if (isHeader(position)) {
                return;
            }
            int adjPosition = position - getHeadersCount();
            int adapterCount;
            if (adapter != null) {
                adapterCount = adapter.getItemCount();
                if (adjPosition < adapterCount) {
                    adapter.onBindViewHolder(holder, adjPosition);
                    return;
                }
            }
        }

        @Override
        public int getItemCount() {
            if (adapter != null) {
                return getHeadersCount() + getFootersCount() + adapter.getItemCount();
            } else {
                return getHeadersCount() + getFootersCount();
            }
        }

        @Override
        public int getItemViewType(int position) {
            if(isRefreshHeader(position)){
                return TYPE_REFRESH_HEADER;
            }
            if (isHeader(position)) {
                return TYPE_HEADER;
            }
            if(isFooter(position)){
                return TYPE_FOOTER;
            }
            int adjPosition = position - getHeadersCount();;
            int adapterCount;
            if (adapter != null) {
                adapterCount = adapter.getItemCount();
                if (adjPosition < adapterCount) {
                    return adapter.getItemViewType(adjPosition);
                }
            }
            return TYPE_NORMAL;
        }

        @Override
        public long getItemId(int position) {
            if (adapter != null && position >= getHeadersCount()) {
                int adjPosition = position - getHeadersCount();
                int adapterCount = adapter.getItemCount();
                if (adjPosition < adapterCount) {
                    return adapter.getItemId(adjPosition);
                }
            }
            return -1;
        }

        @Override
        public void unregisterAdapterDataObserver(AdapterDataObserver observer) {
            if (adapter != null) {
                adapter.unregisterAdapterDataObserver(observer);
            }
        }

        @Override
        public void registerAdapterDataObserver(AdapterDataObserver observer) {
            if (adapter != null) {
                adapter.registerAdapterDataObserver(observer);
            }
        }

        private class SimpleViewHolder extends RecyclerView.ViewHolder {
            public SimpleViewHolder(View itemView) {
                super(itemView);
            }
        }
    }

    public void setLoadingListener(LoadingListener listener) {
        mLoadingListener = listener;
    }

    public interface LoadingListener {

        void onRefresh();

        void onLoadMore();
    }
}
       recylerview就不用多说了，大家应该都懂的，不懂的，度娘懂大笑。xrecylerview里面最主要的还是其刷新、加载。主要是有一个自定义的布局，用于展示刷新时间、图标和刷新的提示语的。然后就是通过xrecylerview的手势来判断处理一些刷新时的变化展示了；加载类似的，就几再说了。其实挺简单的，就是代码量有点点多。

       这时就有人要反驳了，既然这么简单，你倒是写一个啊。惭愧啊！我这个人比较懒，现在开源代码这么多，我倒是喜欢二次封装一下下，毕竟自己写的不知道会出啥bug。其实开发中，很多东西能二次封装的就二次封装，毕竟人家有实践经验的，站在巨人的肩上，你将看得更远。

       至于用法呢，很简单，先设置一下：

       

 mRecyclerview.setAdapter(new ConcernFansAdapter(getActivity(), null));
        StaggeredGridLayoutManager layoutManager = new StaggeredGridLayoutManager(1,
                StaggeredGridLayoutManager.VERTICAL);
        layoutManager.setOrientation(StaggeredGridLayoutManager.VERTICAL);
        mRecyclerview.setRefreshProgressStyle(ProgressStyle.BallSpinFadeLoader);
        mRecyclerview.setLoadingMoreProgressStyle(ProgressStyle.BallRotate);
        mRecyclerview.setArrowImageView(R.mipmap.iconfont_downgrey);
        mRecyclerview.setHasFixedSize(true);
        mRecyclerview.setLayoutManager(layoutManager);
        mRefeshLy.setRetryListener(this);

        mRecyclerview.setLoadingListener(this);
        mRecyclerview.setLoadingMoreEnabled(false);
        mRecyclerview.setPullRefreshEnabled(true);
       然后，再实现一下接口中的两个方法就行了：
 
  @Override
    public void onRefresh() {

    }

    @Override
    public void onLoadMore() {

    }
       是不是很简单，两步就搞定！当然，如果您实在是不太理解，或者不怎么会用，那么请观看俺的上一篇博客Android编程至高武学之《如来神掌》第二式~金顶佛灯 。或者直接去下载demo，https://Git.oschina.NET/bjnq/NeiquanDemo，运行后里面直接有用法。
        本回书完，下回寡人将要标新立异，去研究研究新的框架，毕竟人总是要成长的，敬请期待.....

天煞冥王
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Android编程至高武学之《如来神掌》第三式~佛动山河
天煞冥王的博客
01-16 756
上回书Android编程至高武学之《如来神掌》第二式~金顶佛灯  ，我已经把一个基本的android框架（demo）传授于大家了。当然有大神觉得low的，以后我会还大家一个公道：给你们弄一个复杂一点的框架（MVP+Dagger2+rxjava+retrofit），敬请期待...。目前这个虽然low点（其实不叫low，就是很直白而已），但是对于一般的开发足够了。今天我就先给大家分析下那个框架中的一
Android编程至高武学之《如来神掌》第一式~佛光初现
天煞冥王的博客
09-13 684
学习任何武功秘籍、招式要领，都必须先对该门绝学有一个大体认知。心急吃不了热豆腐。在咱们吃豆腐之前，先看看豆腐大小、形状、颜色、味道。再下嘴之。言归正传，Android就像《如来神掌》一样，先了解其大体学习方向，再学会各个散招，再综合而一，才能一招制敌、一统江山。
Android编程至高武学之《如来神掌》第二式~金顶佛灯
天煞冥王的博客
01-10 878
上回书Android编程至高武学之《如来神掌》第一式~佛光初现，其实就是和大家打个见面招呼 。可能有的人会说“然并卵”、“你过来，我保证不打死你”。然而，大家真的错了，臣妾冤枉至极啊。臣妾再上一章里面给大家列出纲目了，并且铺垫了后面我将要展示的神功内力和招式，直接授予大家。        出来混，迟早要还的，浪费了大家辣么多时间，这次哀家就简单简绍一下本次要讲解的主要内容。项目开发模板。栈管
Android编程至高武学之《如来神掌》第四式~佛问迦蓝
天煞冥王的博客
02-08 530
上回书Android编程至高武学之《如来神掌》第三式~佛动山河，初试牛刀，已经为大家九牛剃了一毛了。今天为大家带来一个比较常用的网络框架。在浩瀚的网络架构中，大家肯定已经有了选择恐惧症，不知道从哪一个下手。说实话，臣妾之前也用过好几个网络框架，从asynctask到okhttp，最终发现还是后者像每天劳累回家给你做饭的媳妇依然辣么好。那么，请别犹豫，寡人今天为大家带来一个最的。废话不多说，上代码：
Android 开发进阶技巧（一）
weixin_45806384的博客
04-27 220
Java数据类处理 开发架构的逻辑控制 静态方法调试 （一般在编译之前） List、Set、Map集合 函数式API 抽象方法接口参数 空指针检查 逻辑、视图分离的开发方法 选用合适IDE （推荐Android Studio） 不同组件之间通讯，交互 模组间的删繁就简 Keil以及Eclipse 的应用 全栈开发技巧（找回栈开发） 内存泄露、溢出与容器化操作 Activity生命周期 进程资源管...
心流：写作、编程和修炼武功的共同法门
a495927的博客
01-24 657
曾经有位朋友对我说，写文章是天下第一的难事。当然在很多人的眼中，这话未必正确。但对于喜欢写作的人来说，能讲出这句话的，基本上可以引为知音了。 　　在我的认知中，写作是很难的事；而在所有的文学体裁中，写小说，尤其是写长篇小说，最不容易。 　　有人说，不对，还有诗歌啊。诗歌才是文学之王。 　　的确，诗歌是语言文学的精华，是让文字歌唱的艺术。一个人，将此时此刻最强烈的内心感受，用恰当的词句表达出来，就是...
天下武功彼此克制，武学之道玄之又玄
闻缺陷则喜何志丹
06-27 993
一老头说：”当日华山论剑，先是他用黯然销魂掌，破了我的七十二路空明拳；然后我改打降龙十八掌，却不防他伸开右手食指中指，竟是六脉神剑商阳剑和中冲剑并用，又胜我一筹。可见天下武功彼此克制，武学之道玄之又玄！”少年听得心驰目眩，正要在问，旁边老太太骂道：mb玩个石头剪子布都说得这般威风。
天龙日梅兰竹菊_第三百一十五章 梅兰竹菊
热门推荐
weixin_28910411的博客
12-31 3万+
第三百一十五章梅兰竹菊自打应下无崖子的承诺以来，楚柏便是一直马不停蹄的赶路！赶到西夏，在见了李秋水之后，又被李秋水拉着前往【缥缈峰】，这一路，风尘仆仆的楚柏，总算是难得空闲下来了；不得不说！【灵鹫宫】的壁画实在太多，楚柏也知一时半会无法将之看完；因此在看过甲一所述的【天山折梅手】后，便是回往宫内，好好地休息了一番；翌日！当楚柏逐渐的从睡熟醒来时，却是发现天色已然大亮，或许是这些时日来一直忙于奔波，...
武学之精要在内外兼修
翔云
09-17 551
写代码犹如习武，十八般武艺（刀、枪、剑、学戟等），就类似编码语言（C/C++、Java、Go、Python等），开始学习时，选择一种兵器，背诵各种招式、口诀、心法，渐渐的小有长进，对这门武功已经学有所成。于是乎，开始修习其他武功或兵器，这个时候，你会发现，武功入门都是轻而易举，多下点工夫，总可以熟练应用。但也慢慢发现，要达到更高的境界，就要去修习高深的内功。这就是计算机的核心原理，诸如《易经经》、《
Web表现层跑完龙套唱主角.pdf
11-07
长期以来，Web 表现层的开发总是被认为是次要的角色，甚至被认为是武学之旁门左道。然而，随着 AJAX 的出现，人们开始重新认识 Web 表现层的价值和重要性。AJAX 的出现使得 Web 表现层不再是一个薄弱的角色，而是一...
[毕业设计]VB Access就业指导与失业保险发放系统(源代码+论文撰写+答辩演示文稿).zip
08-07
[毕业设计]VB Access就业指导与失业保险发放系统(源代码+论文撰写+答辩演示文稿)
微信开发资源ddddddd
08-07
微信开发资源ddddddd
springboot536外卖点餐系统.zip
08-07
从用户的功能要求出发，建立了外卖点餐系统 ，系统中的功能模块主要是实现管理员；首页、个人中心、用户管理、商家管理、菜品分类管理、骑手管理、系统管理、菜品管理、订单管理、配送单管理、商品评价管理，商家；首页、个人中心、菜品管理、订单管理、配送单管理、商品评价管理、我的收藏管理，用户；首页、个人中心、订单管理、配送单管理、商品评价管理、我的收藏管理、骑手；首页、个人中心、订单管理、配送单管理、商品评价管理等功能部分；经过认真细致的研究，精心准备和规划，最后测试成功，系统可以正常使用。分析功能调整与外卖点餐系统实现的实际需求相结合，讨论了JSP开发外卖点餐系统的使用。
19届智能车负压镜头代码适用于mini车全元素
08-07
调试好后可达2.8m/s祝愿道友好运
海康 USB3.0工业相机Python版SDK制作的上位机采集界面（PyQt5）
最新发布
08-08
海康 USB3.0工业相机Python版SDK制作的上位机采集界面（PyQt5）
Python基于flask的服务器进程监视器源代码
08-07
Python基于flask的服务器进程监视器源代码
Authlib-0.15.1-py2.py3-none-any.whl.zip
08-07
Authlib-0.15.1-py2.py3-none-any.whl.zip
江苏省村庄规划建库数据处理简化步骤
08-07
工具一：根据用地用海分类将三调转换为村规的配色和统计表格 注意一下配色字段中存在细化的，就是要手动配色，主要为公服用地和公园 后续根据报批更新编制前配色和编制前统计，根据新增用地、复垦等更新目标年配色和目标年统计 工具三：添加用地用海代码、名称，并赋值 商业用地：YYDYHFLMC和YDYHFLMC统一赋值090100，特殊情况需要手动赋值 交通运输用地： 涉及新增的用地需要手动赋值 公用设施用地： 注意原有的公用设施需要手动赋值，新增也要手动赋值 工具四：导入标准库前的准备（保留字段、融合数据、修复几何） 工具五：更新标准库图层 更新BSM、YSDM、HJSJ（为当前时间） 更新TBMJ、TBDLMJ（均为椭球面积，保留两位小数） 更新规划分区为城镇发展区的（原）用地用海分类代码为202，（原）名称'建制镇用地'（注意一下，有详规的需要按其地类手动赋值，201的地方也注意） 更新新增建设用地： 新增建设用地规划分区代码赋值为510（村庄建设区），应该没其他情况；规划状态为20；建设用地状态为220；城镇村属性为203;项目类型为30，项目名称自己填。 ...............
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值