最近项目中需要用到 ListView 下拉刷新的功能，一开始想图省事，在网上直接找一个现成的，可是尝试了网上多个版本的下拉刷新之后发现效果都不怎么理想。有些是因为功能不完整或有 Bug，有些是因为使用起来太复杂，十全十美的还真没找到。因此我也是放弃了在网上找现成代码的想法，自己花功夫编写了一种非常简单的下拉刷新实现方案，现在拿出来和大家分享一下。相信在阅读完本篇文章之后，大家都可以在自己的项目中一分钟引入下拉刷新功能。

一

首先讲一下实现原理。这里我们将采取的方案是使用组合 View 的方式，先自定义一个布局继承自 LinearLayout，然后在这个布局中加入下拉头和 ListView 这两个子元素，并让这两个子元素纵向排列。初始化的时候，让下拉头向上偏移出屏幕，这样我们看到的就只有 ListView 了。然后对 ListView 的 touch 事件进行监听，如果当前 ListView 已经滚动到顶部并且手指还在向下拉的话，那就将下拉头显示出来，松手后进行刷新操作，并将下拉头隐藏。原理示意图如下：

那我们现在就来动手实现一下，新建一个项目起名叫 PullToRefreshTest，先在项目中定义一个下拉头的布局文件 pull_to_refresh.xml，代码如下所

在这个布局中，我们包含了一个下拉指示箭头，一个下拉状态文字提示，和一个上次更新的时间。当然，还有一个隐藏的旋转进度条，只有正在刷新的时候我们才会将它显示出来。

布局中所有引用的字符串我们都放在 strings.xml 中，如下所示

PullToRefreshTest
	下拉可以刷新
	释放立即刷新
	正在刷新…
	暂未更新过
	上次更新于%1$s前
	刚刚更新
	时间有问题

二

然后新建一个 RefreshableView 继承自 LinearLayout，代码如下所示：

public class RefreshableView extends LinearLayout implements OnTouchListener {
 
	/**
	 * 下拉状态
	 */
	public static final int STATUS_PULL_TO_REFRESH = 0;
 
	/**
	 * 释放立即刷新状态
	 */
	public static final int STATUS_RELEASE_TO_REFRESH = 1;
 
	/**
	 * 正在刷新状态
	 */
	public static final int STATUS_REFRESHING = 2;
 
	/**
	 * 刷新完成或未刷新状态
	 */
	public static final int STATUS_REFRESH_FINISHED = 3;
 
	/**
	 * 下拉头部回滚的速度
	 */
	public static final int SCROLL_SPEED = -20;
 
	/**
	 * 一分钟的毫秒值，用于判断上次的更新时间
	 */
	public static final long ONE_MINUTE = 60 * 1000;
 
	/**
	 * 一小时的毫秒值，用于判断上次的更新时间
	 */
	public static final long ONE_HOUR = 60 * ONE_MINUTE;
 
	/**
	 * 一天的毫秒值，用于判断上次的更新时间
	 */
	public static final long ONE_DAY = 24 * ONE_HOUR;
 
	/**
	 * 一月的毫秒值，用于判断上次的更新时间
	 */
	public static final long ONE_MONTH = 30 * ONE_DAY;
 
	/**
	 * 一年的毫秒值，用于判断上次的更新时间
	 */
	public static final long ONE_YEAR = 12 * ONE_MONTH;
 
	/**
	 * 上次更新时间的字符串常量，用于作为SharedPreferences的键值
	 */
	private static final String UPDATED_AT = "updated_at";
 
	/**
	 * 下拉刷新的回调接口
	 */
	private PullToRefreshListener mListener;
 
	/**
	 * 用于存储上次更新时间
	 */
	private SharedPreferences preferences;
 
	/**
	 * 下拉头的View
	 */
	private View header;
 
	/**
	 * 需要去下拉刷新的ListView
	 */
	private ListView listView;
 
	/**
	 * 刷新时显示的进度条
	 */
	private ProgressBar progressBar;
 
	/**
	 * 指示下拉和释放的箭头
	 */
	private ImageView arrow;
 
	/**
	 * 指示下拉和释放的文字描述
	 */
	private TextView description;
 
	/**
	 * 上次更新时间的文字描述
	 */
	private TextView updateAt;
 
	/**
	 * 下拉头的布局参数
	 */
	private MarginLayoutParams headerLayoutParams;
 
	/**
	 * 上次更新时间的毫秒值
	 */
	private long lastUpdateTime;
 
	/**
	 * 为了防止不同界面的下拉刷新在上次更新时间上互相有冲突，使用id来做区分
	 */
	private int mId = -1;
 
	/**
	 * 下拉头的高度
	 */
	private int hideHeaderHeight;
 
	/**
	 * 当前处理什么状态，可选值有STATUS_PULL_TO_REFRESH, STATUS_RELEASE_TO_REFRESH,
	 * STATUS_REFRESHING 和 STATUS_REFRESH_FINISHED
	 */
	private int currentStatus = STATUS_REFRESH_FINISHED;;
 
	/**
	 * 记录上一次的状态是什么，避免进行重复操作
	 */
	private int lastStatus = currentStatus;
 
	/**
	 * 手指按下时的屏幕纵坐标
	 */
	private float yDown;
 
	/**
	 * 在被判定为滚动之前用户手指可以移动的最大值。
	 */
	private int touchSlop;
 
	/**
	 * 是否已加载过一次layout，这里onLayout中的初始化只需加载一次
	 */
	private boolean loadOnce;
 
	/**
	 * 当前是否可以下拉，只有ListView滚动到头的时候才允许下拉
	 */
	private boolean ableToPull;
 
	/**
	 * 下拉刷新控件的构造函数，会在运行时动态添加一个下拉头的布局。
	 * 
	 * @param context
	 * @param attrs
	 */
	public RefreshableView(Context context, AttributeSet attrs) {
		super(context, attrs);
		preferences = PreferenceManager.getDefaultSharedPreferences(context);
		header = LayoutInflater.from(context).inflate(R.layout.pull_to_refresh, null, true);
		progressBar = (ProgressBar) header.findViewById(R.id.progress_bar);
		arrow = (ImageView) header.findViewById(R.id.arrow);
		description = (TextView) header.findViewById(R.id.description);
		updateAt = (TextView) header.findViewById(R.id.updated_at);
		touchSlop = ViewConfiguration.get(context).getScaledTouchSlop();
		refreshUpdatedAtValue();
		setOrientation(VERTICAL);
		addView(header, 0);
	}
 
	/**
	 * 进行一些关键性的初始化操作，比如：将下拉头向上偏移进行隐藏，给ListView注册touch事件。
	 */
	@Override
	protected void onLayout(boolean changed, int l, int t, int r, int b) {
		super.onLayout(changed, l, t, r, b);
		if (changed && !loadOnce) {
			hideHeaderHeight = -header.getHeight();
			headerLayoutParams = (MarginLayoutParams) header.getLayoutParams();
			headerLayoutParams.topMargin = hideHeaderHeight;
			listView = (ListView) getChildAt(1);
			listView.setOnTouchListener(this);
			loadOnce = true;
		}
	}
 
	/**
	 * 当ListView被触摸时调用，其中处理了各种下拉刷新的具体逻辑。
	 */
	@Override
	public boolean onTouch(View v, MotionEvent event) {
		setIsAbleToPull(event);
		if (ableToPull) {
			switch (event.getAction()) {
			case MotionEvent.ACTION_DOWN:
				yDown = event.getRawY();
				break;
			case MotionEvent.ACTION_MOVE:
				float yMove = event.getRawY();
				int distance = (int) (yMove - yDown);
				// 如果手指是下滑状态，并且下拉头是完全隐藏的，就屏蔽下拉事件
				if (distance <= 0 && headerLayoutParams.topMargin <= hideHeaderHeight) {
					return false;
				}
				if (distance < touchSlop) {
					return false;
				}
				if (currentStatus != STATUS_REFRESHING) {
					if (headerLayoutParams.topMargin > 0) {
						currentStatus = STATUS_RELEASE_TO_REFRESH;
					} else {
						currentStatus = STATUS_PULL_TO_REFRESH;
					}
					// 通过偏移下拉头的topMargin值，来实现下拉效果
					headerLayoutParams.topMargin = (distance / 2) + hideHeaderHeight;
					header.setLayoutParams(headerLayoutParams);
				}
				break;
			case MotionEvent.ACTION_UP:
			default:
				if (currentStatus == STATUS_RELEASE_TO_REFRESH) {
					// 松手时如果是释放立即刷新状态，就去调用正在刷新的任务
					new RefreshingTask().execute();
				} else if (currentStatus == STATUS_PULL_TO_REFRESH) {
					// 松手时如果是下拉状态，就去调用隐藏下拉头的任务
					new HideHeaderTask().execute();
				}
				break;
			}
			// 时刻记得更新下拉头中的信息
			if (currentStatus == STATUS_PULL_TO_REFRESH
					|| currentStatus == STATUS_RELEASE_TO_REFRESH) {
				updateHeaderView();
				// 当前正处于下拉或释放状态，要让ListView失去焦点，否则被点击的那一项会一直处于选中状态
				listView.setPressed(false);
				listView.setFocusable(false);
				listView.setFocusableInTouchMode(false);
				lastStatus = currentStatus;
				// 当前正处于下拉或释放状态，通过返回true屏蔽掉ListView的滚动事件
				return true;
			}
		}
		return false;
	}
 
	/**
	 * 给下拉刷新控件注册一个监听器。
	 * 
	 * @param listener
	 *            监听器的实现。
	 * @param id
	 *            为了防止不同界面的下拉刷新在上次更新时间上互相有冲突， 请不同界面在注册下拉刷新监听器时一定要传入不同的id。
	 */
	public void setOnRefreshListener(PullToRefreshListener listener, int id) {
		mListener = listener;
		mId = id;
	}
 
	/**
	 * 当所有的刷新逻辑完成后，记录调用一下，否则你的ListView将一直处于正在刷新状态。
	 */
	public void finishRefreshing() {
		currentStatus = STATUS_REFRESH_FINISHED;
		preferences.edit().putLong(UPDATED_AT + mId, System.currentTimeMillis()).commit();
		new HideHeaderTask().execute();
	}
 
	/**
	 * 根据当前ListView的滚动状态来设定 {@link #ableToPull}
	 * 的值，每次都需要在onTouch中第一个执行，这样可以判断出当前应该是滚动ListView，还是应该进行下拉。
	 * 
	 * @param event
	 */
	private void setIsAbleToPull(MotionEvent event) {
		View firstChild = listView.getChildAt(0);
		if (firstChild != null) {
			int firstVisiblePos = listView.getFirstVisiblePosition();
			if (firstVisiblePos == 0 && firstChild.getTop() == 0) {
				if (!ableToPull) {
					yDown = event.getRawY();
				}
				// 如果首个元素的上边缘，距离父布局值为0，就说明ListView滚动到了最顶部，此时应该允许下拉刷新
				ableToPull = true;
			} else {
				if (headerLayoutParams.topMargin != hideHeaderHeight) {
					headerLayoutParams.topMargin = hideHeaderHeight;
					header.setLayoutParams(headerLayoutParams);
				}
				ableToPull = false;
			}
		} else {
			// 如果ListView中没有元素，也应该允许下拉刷新
			ableToPull = true;
		}
	}
 
	/**
	 * 更新下拉头中的信息。
	 */
	private void updateHeaderView() {
		if (lastStatus != currentStatus) {
			if (currentStatus == STATUS_PULL_TO_REFRESH) {
				description.setText(getResources().getString(R.string.pull_to_refresh));
				arrow.setVisibility(View.VISIBLE);
				progressBar.setVisibility(View.GONE);
				rotateArrow();
			} else if (currentStatus == STATUS_RELEASE_TO_REFRESH) {
				description.setText(getResources().getString(R.string.release_to_refresh));
				arrow.setVisibility(View.VISIBLE);
				progressBar.setVisibility(View.GONE);
				rotateArrow();
			} else if (currentStatus == STATUS_REFRESHING) {
				description.setText(getResources().getString(R.string.refreshing));
				progressBar.setVisibility(View.VISIBLE);
				arrow.clearAnimation();
				arrow.setVisibility(View.GONE);
			}
			refreshUpdatedAtValue();
		}
	}
 
	/**
	 * 根据当前的状态来旋转箭头。
	 */
	private void rotateArrow() {
		float pivotX = arrow.getWidth() / 2f;
		float pivotY = arrow.getHeight() / 2f;
		float fromDegrees = 0f;
		float toDegrees = 0f;
		if (currentStatus == STATUS_PULL_TO_REFRESH) {
			fromDegrees = 180f;
			toDegrees = 360f;
		} else if (currentStatus == STATUS_RELEASE_TO_REFRESH) {
			fromDegrees = 0f;
			toDegrees = 180f;
		}
		RotateAnimation animation = new RotateAnimation(fromDegrees, toDegrees, pivotX, pivotY);
		animation.setDuration(100);
		animation.setFillAfter(true);
		arrow.startAnimation(animation);
	}
 
	/**
	 * 刷新下拉头中上次更新时间的文字描述。
	 */
	private void refreshUpdatedAtValue() {
		lastUpdateTime = preferences.getLong(UPDATED_AT + mId, -1);
		long currentTime = System.currentTimeMillis();
		long timePassed = currentTime - lastUpdateTime;
		long timeIntoFormat;
		String updateAtValue;
		if (lastUpdateTime == -1) {
			updateAtValue = getResources().getString(R.string.not_updated_yet);
		} else if (timePassed < 0) {
			updateAtValue = getResources().getString(R.string.time_error);
		} else if (timePassed < ONE_MINUTE) {
			updateAtValue = getResources().getString(R.string.updated_just_now);
		} else if (timePassed < ONE_HOUR) {
			timeIntoFormat = timePassed / ONE_MINUTE;
			String value = timeIntoFormat + "分钟";
			updateAtValue = String.format(getResources().getString(R.string.updated_at), value);
		} else if (timePassed < ONE_DAY) {
			timeIntoFormat = timePassed / ONE_HOUR;
			String value = timeIntoFormat + "小时";
			updateAtValue = String.format(getResources().getString(R.string.updated_at), value);
		} else if (timePassed < ONE_MONTH) {
			timeIntoFormat = timePassed / ONE_DAY;
			String value = timeIntoFormat + "天";
			updateAtValue = String.format(getResources().getString(R.string.updated_at), value);
		} else if (timePassed < ONE_YEAR) {
			timeIntoFormat = timePassed / ONE_MONTH;
			String value = timeIntoFormat + "个月";
			updateAtValue = String.format(getResources().getString(R.string.updated_at), value);
		} else {
			timeIntoFormat = timePassed / ONE_YEAR;
			String value = timeIntoFormat + "年";
			updateAtValue = String.format(getResources().getString(R.string.updated_at), value);
		}
		updateAt.setText(updateAtValue);
	}
 
	/**
	 * 正在刷新的任务，在此任务中会去回调注册进来的下拉刷新监听器。
	 * 
	 * @author guolin
	 */
	class RefreshingTask extends AsyncTask {
 
		@Override
		protected Void doInBackground(Void... params) {
			int topMargin = headerLayoutParams.topMargin;
			while (true) {
				topMargin = topMargin + SCROLL_SPEED;
				if (topMargin <= 0) {
					topMargin = 0;
					break;
				}
				publishProgress(topMargin);
				sleep(10);
			}
			currentStatus = STATUS_REFRESHING;
			publishProgress(0);
			if (mListener != null) {
				mListener.onRefresh();
			}
			return null;
		}
 
		@Override
		protected void onProgressUpdate(Integer... topMargin) {
			updateHeaderView();
			headerLayoutParams.topMargin = topMargin[0];
			header.setLayoutParams(headerLayoutParams);
		}
 
	}
 
	/**
	 * 隐藏下拉头的任务，当未进行下拉刷新或下拉刷新完成后，此任务将会使下拉头重新隐藏。
	 * 
	 * @author guolin
	 */
	class HideHeaderTask extends AsyncTask {
 
		@Override
		protected Integer doInBackground(Void... params) {
			int topMargin = headerLayoutParams.topMargin;
			while (true) {
				topMargin = topMargin + SCROLL_SPEED;
				if (topMargin <= hideHeaderHeight) {
					topMargin = hideHeaderHeight;
					break;
				}
				publishProgress(topMargin);
				sleep(10);
			}
			return topMargin;
		}
 
		@Override
		protected void onProgressUpdate(Integer... topMargin) {
			headerLayoutParams.topMargin = topMargin[0];
			header.setLayoutParams(headerLayoutParams);
		}
 
		@Override
		protected void onPostExecute(Integer topMargin) {
			headerLayoutParams.topMargin = topMargin;
			header.setLayoutParams(headerLayoutParams);
			currentStatus = STATUS_REFRESH_FINISHED;
		}
	}
 
	/**
	 * 使当前线程睡眠指定的毫秒数。
	 * 
	 * @param time
	 *            指定当前线程睡眠多久，以毫秒为单位
	 */
	private void sleep(int time) {
		try {
			Thread.sleep(time);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
 
	/**
	 * 下拉刷新的监听器，使用下拉刷新的地方应该注册此监听器来获取刷新回调。
	 * 
	 * @author guolin
	 */
	public interface PullToRefreshListener {
 
		/**
		 * 刷新时会去回调此方法，在方法内编写具体的刷新逻辑。注意此方法是在子线程中调用的， 你可以不必另开线程来进行耗时操作。
		 */
		void onRefresh();
 
	}
 
}

这个类是整个下拉刷新功能中最重要的一个类，注释已经写得比较详细了，我再简单解释一下。首先在 RefreshableView 的构造函数中动态添加了刚刚定义的 pull_to_refresh 这个布局作为下拉头，然后在 onLayout 方法中将下拉头向上偏移出了屏幕，再给 ListView 注册了 touch 事件。之后每当手指在 ListView 上滑动时，onTouch 方法就会执行。在 onTouch 方法中的第一行就调用了 setIsAbleToPull 方法来判断 ListView 是否滚动到了最顶部，只有滚动到了最顶部才会执行后面的代码，否则就视为正常的 ListView 滚动，不做任何处理。当 ListView 滚动到了最顶部时，如果手指还在向下拖动，就会改变下拉头的偏移值，让下拉头显示出来，下拉的距离设定为手指移动距离的 1/2，这样才会有拉力的感觉。如果下拉的距离足够大，在松手的时候就会执行刷新操作，如果距离不够大，就仅仅重新隐藏下拉头。

具体的刷新操作会在 RefreshingTask 中进行，其中在 doInBackground 方法中回调了 PullToRefreshListener 接口的 onRefresh 方法，这也是大家在使用 RefreshableView 时必须要去实现的一个接口，因为具体刷新的逻辑就应该写在 onRefresh 方法中，后面会演示使用的方法。

另外每次在下拉的时候都还会调用 updateHeaderView 方法来改变下拉头中的数据，比如箭头方向的旋转，下拉文字描述的改变等。更加深入的理解请大家仔细去阅读 RefreshableView 中的代码。

现在我们已经把下拉刷新的所有功能都完成了，接下来就要看一看如何在项目中引入下拉刷新了。打开或新建 activity_main.xml 作为程序主界面的布局，加入如下代码：

可以看到，我们在自定义的 RefreshableView 中加入了一个 ListView，这就意味着给这个 ListView 加入了下拉刷新的功能，就是这么简单！
然后我们再来看一下程序的主 Activity，打开或新建 MainActivity，加入如下代码：

public class MainActivity extends Activity {
 
	RefreshableView refreshableView;
	ListView listView;
	ArrayAdapter adapter;
	String[] items = { "A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L" };
 
	@Override
	protected void onCreate(Bundle savedInstanceState) {
		super.onCreate(savedInstanceState);
		requestWindowFeature(Window.FEATURE_NO_TITLE);
		setContentView(R.layout.activity_main);
		refreshableView = (RefreshableView) findViewById(R.id.refreshable_view);
		listView = (ListView) findViewById(R.id.list_view);
		adapter = new ArrayAdapter(this, android.R.layout.simple_list_item_1, items);
		listView.setAdapter(adapter);
		refreshableView.setOnRefreshListener(new PullToRefreshListener() {
			@Override
			public void onRefresh() {
				try {
					Thread.sleep(3000);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				refreshableView.finishRefreshing();
			}
		}, 0);
	}
 
}

可以看到，我们通过调用 RefreshableView 的 setOnRefreshListener 方法注册了一个监听器，当 ListView 正在刷新时就会回调监听器的 onRefresh 方法，刷新的具体逻辑就在这里处理。而且这个方法已经自动开启了线程，可以直接在 onRefresh 方法中进行耗时操作，比如向服务器请求最新数据等，在这里我就简单让线程睡眠 3 秒钟。另外在 onRefresh 方法的最后，一定要调用 RefreshableView 中的 finishRefreshing 方法，这个方法是用来通知 RefreshableView 刷新结束了，不然我们的 ListView 将一直处于正在刷新的状态。

不知道大家有没有注意到，setOnRefreshListener 这个方法其实是有两个参数的，我们刚刚也是传入了一个不起眼的 0。那这第二个参数是用来做什么的呢？由于 RefreshableView 比较智能，它会自动帮我们记录上次刷新完成的时间，然后下拉的时候会在下拉头中显示距上次刷新已过了多久。这是一个非常好用的功能，让我们不用再自己手动去记录和计算时间了，但是却存在一个问题。如果当前我们的项目中有三个地方都使用到了下拉刷新的功能，现在在一处进行了刷新，其它两处的时间也都会跟着改变！因为刷新完成的时间是记录在配置文件中的，由于在一处刷新更改了配置文件，导致在其它两处读取到的配置文件时间已经是更改过的了。那解决方案是什么？就是每个用到下拉刷新的地方，给 setOnRefreshListener 方法的第二个参数中传入不同的 id 就行了。这样各处的上次刷新完成时间都是单独记录的，相互之间就不会再有影响。

好了，全部的代码都在这里了，让我们来运行一下，看看效果吧。

效果看起来还是非常不错的。我们最后再来总结一下，在项目中引入 ListView 下拉刷新功能只需三步：

1. 在 Activity 的布局文件中加入自定义的 RefreshableView，并让 ListView 包含在其中。

2. 在 Activity 中调用 RefreshableView 的 setOnRefreshListener 方法注册回调接口。

3. 在 onRefresh 方法的最后，记得调用 RefreshableView 的 finishRefreshing 方法，通知刷新结束。

从此以后，在项目的任何地方，一分钟引入下拉刷新功能妥妥的。

好了，今天的讲解到此结束，有疑问的朋友请在下面留言。

1 前言

滑动对于android来说，是一个必不可少；它不复杂，大家都知道在onTouchEvent中，让它滑动就完事了，说它复杂，其嵌套处理复杂；在本系列文章，最终是为了熟悉嵌套滑动机制；对于滑动，分为下面几篇文章来完成解读：

1. 滑动基础


2. ScrollView滑动源码解读


3. NestedScrollView嵌套滑动源码解读


4. CoordinatorLayout-AppBarLayout-CollapsingToolbarLayout复杂滑动逻辑源码解读

在本章内，主要介绍实现的一些相关基础框架逻辑

1. 平滑处理、滑翔处理


2. View中对滑动的处理效果以及逻辑


3. androidx中的滑动接口、嵌套滑动接口的理解

看到这里，你不再觉得仅仅是在OnTouchEvent中处理滑动事件吧，其实这样想也可以，不过效果什么的全自定义了

2 滑动常量

介绍滑动前，我们需要了解一些滑动常量，这些常量有利于我们实现更流畅的滑动效果

这些常量都是通过ViewConfiguration来获取的，其实例通过下面来获取

ViewConfiguration configuration = ViewConfiguration.get(mContext)

复制代码

• 最小滑动距离：getScaledTouchSlop()


• 最小滑翔速度：getScaledMinimumFlingVelocity()，像素每秒


• 最大滑翔速度：getScaledMaximumFlingVelocity()，像素每秒


• 手指滑动越界最大距离：getScaledOverscrollDistance()


• 滑翔越界最大距离：getScaledOverflingDistance()

这里滑翔的速度，是为了处理惯性的快慢，这个做过的深有体会，总是感觉，快慢不是很舒服；所以我们一一般在滑翔时，获取滑翔距离时，要在最大和最小之间；

3 平滑滑动、滑翔

平滑滑动根据时间进行平缓的滑动，而滑翔需要对移动事件进行跟踪分析之后，再根据时间计算状态进而进行分析；而根据时间进行状态处理，使用Scroller或者OverScroller来处理，OverScroller可以处理回弹效果；对事件跟踪分析，使用VelocityTracker类处理

3.1 VelocityTracker类

这个类有下面用法

实例获取

mVelocityTracker = VelocityTracker.obtain()

复制代码

跟踪事件

mVelocityTracker.addMovement(ev)

复制代码

获取滑翔初始速度

mVelocityTracker.computeCurrentVelocity(1000, mMaximumVelocity);

int xVelocity = (int)mVelocityTracker.getXVelocity(mActivePointerId);

int yVelocity = (int)mVelocityTracker.getYVelocity(mActivePointerId);

复制代码

两个方法要跟着使用，减少误差；另外计算时；computeCurrentVelocity参数意义

1. 多少毫秒，假设n


2. 速度，单位由参数1的数值来确定，也即是像素每n毫秒

数据临时清理

mVelocityTracker.clear();

复制代码

当切换手指时，之前的数据就没有意义了，所以需要清理重新计算

对象回收

mVelocityTracker.recycle();

复制代码

3.2 OverScroller类

Scroller也可以处理，只是不能处理回弹而已；这里就只是解释OverScroller类，它仅仅只是一个状态计算的类，对view并没有进行操作；下面就是一些使用

初始化

mScroller = new OverScroller(getContext());

复制代码

滑动

public void startScroll(int x, int y, int dx, int dy, int duration)

复制代码

单位时间内，x增加dx，y增加dy；默认时间250ms

计算

public boolean computeScrollOffset()

复制代码

计算当前时间对应状态，返回true表示，仍在进行，可通过下面获取当前状态

• getCurrX()：当前x位置


• getCurrY(): 当前y位置


• getCurrVelocity()：当前速度

回弹

public boolean springBack(int startX, int startY, int minX, int maxX, int minY, int maxY)

复制代码

• 当前x值


• 当前y值


• x最小值


• y最小值


• x最大值


• y最大值

如果运用在滑动中，则表示已滑动距离，滑动的最小距离，滑动的最大距离；

滑翔

fling(int startX, int startY, int velocityX, int velocityY,int minX, int maxX, int minY, int maxY, int overX, int overY)

复制代码

• 当前x位置


• 当前y位置


• 当前x速度，像素每秒


• 当前y速度，像素每秒


• x最小取值


• y最小取值


• x最大取值


• y最大取值


• x最大越界距离


• y最大越界距离

有越界范围才有回弹效果

丢弃

mScroller.abortAnimation();

复制代码

完成判断

mScroller.isFinished()

复制代码

3.3 平滑移动

这个只需要调用OverScroller的startScroll方法进行触发，在View的computeScroll方法获取滑动状态调用scrollTo方法即可；

3.4 滑翔

滑翔就分为两种情况了

1. 在手指离开时，未越界，则进行滑翔，如果可以回弹，也会进行回弹，调用OverScroller的fling方法


2. 在手指离开时，已经越界，则进行回弹，调用OverScroller的springBack方法

同样需要在computeScroll根据计算状态，进行具体滑动

4 View类

View类中对于滑动，提供了滑动执行机制、滑动时指示条、滑动时fade蒙层、长按事件处理还有滑动的一些数据判断，这些和androidx中滑动接口ScrollingView

4.1 滑动具体执行

具体执行是通过View的变量mScrollX、mScrollY来完成的，这两个变量在绘制的时候，会对画布进行平移（详见View类中draw方法被调用的地方），进而导致其内绘制内容发生了变化；这个平移对当前view的背景并没有影响，由于在处理背景时再次进行了反方向平移(详见View类中drawBackground方法)；而对这两个变量的操作方法有

• scrollTo(int x, int y):移动到x、y


• scrollBy(int x, int y)：移动范围增加x、y


• overScrollBy方法，此方法会自动处理越界时的处理，并调用onOverScrolled进行实际的移动处理

我称这两个方法为执行者；但是很多滑动控件中都有平滑移动，平滑移动基本都是利用OverScroller或Scroller的滑动方法来完成的；需要回弹用OverScroller，否则使用Scroller即可

protected boolean overScrollBy(int deltaX, int deltaY,

            int scrollX, int scrollY,

            int scrollRangeX, int scrollRangeY,

            int maxOverScrollX, int maxOverScrollY,

            boolean isTouchEvent)

复制代码

overScrollBy方法，返回结果，true标识越界了需要回弹，参数意思如下：

1. x增量值


2. y增量值


3. x当前移动值


4. y当前移动值


5. x当前最大值


6. y当前最大值


7. x最大回弹值


8. y最大回弹值


9. 是手指移动还是滑翔

protected void onOverScrolled(int scrollX, int scrollY,

            boolean clampedX, boolean clampedY)

复制代码

onOverScrolled方法，参数意义如下：

1. 当前x滑动


2. 当前y滑动


3. x是否越界，true表示越界了


4. y是否越界，true表示越界

4.2 长按事件

源码见View类中onTouchEvent方法、isInScrollingContainer方法

长按事件有一定的规则：

• 是在down事件中进行触发发送延时回调长按处理任务，回调执行并不一定需要手指抬起


• 在cancel、move、up事件中取消的

而对于普通非滑动容器内的view，长按事件的延迟时间为ViewConfiguration.getLongPressTimeout()；而如果是滑动容器中，此时会再次触发发送一个触发长按的延期任务，这个延时为ViewConfiguration.getTapTimeout()；我觉得这是考虑到滑动的特殊性增加一点时间，可以更精准的判断是否为长按事件；

是否滑动容器的判断方法，是由ViewGroup的shouldDelayChildPressedState方法来处理的；也就是滑动容器中此方法需要返回true

4.3 fade蒙层

源码详见View.draw方法，绘制分为两种情况，是根据mViewFlags标志来判断的;也即是否需要绘制水平的fade蒙层或者竖直的蒙层；

这个标志可以进行设置，两种方法改变，默认是none

• xml中参数配置

android:requiresFadingEdge="horizontal|vertical|none"

复制代码

• 代码设置

setHorizontalFadingEdgeEnabled(true);

setVerticalFadingEdgeEnabled(true);

复制代码

并不是这个设置了，水平或者竖直，这些地方就以一定出现蒙层，还有其它限制，蒙层分为4个，这四个方法，逻辑是一致的，方法略有区别；

蒙层有一个高度设置，同样有两种方法改变，默认是ViewConfiguration.getScaledFadingEdgeLength()

• xml设置

android:fadingEdgeLength="16dp"

复制代码

• 通过方法设置

setFadingEdgeLength(int length)

复制代码

具体绘制的高度基本是这个高度，除非高度超过了控件本身高度，其变控件高度的一半

蒙层还有一个每个边缘的参数比例，这个在0-1之间；返回的值不在区间会被忽略掉；方法默认实现如下：

    protected float getTopFadingEdgeStrength() {

        return computeVerticalScrollOffset() > 0 ? 1.0f : 0.0f;

    }

    

    protected float getBottomFadingEdgeStrength() {

        return computeVerticalScrollOffset() + computeVerticalScrollExtent() <

                computeVerticalScrollRange() ? 1.0f : 0.0f;

    }

    

    protected float getLeftFadingEdgeStrength() {

        return computeHorizontalScrollOffset() > 0 ? 1.0f : 0.0f;

    }

    

    protected float getRightFadingEdgeStrength() {

        return computeHorizontalScrollOffset() + computeHorizontalScrollExtent() <

                computeHorizontalScrollRange() ? 1.0f : 0.0f;

    }

复制代码

那第二个条件就是：蒙层的比例 * 蒙层高度 > 1.0f 则这个位置边缘会绘制处理

蒙层是一个矩形的线性渐变蒙层，通过线性shade来处理的;渐变是从颜色的完全不透明到完全透明

shader = new LinearGradient(0, 0, 0, 1, color | 0xFF000000, color & 0x00FFFFFF, Shader.TileMode.CLAMP)

复制代码

这个颜色可以通过重写下面方法进行改变，默认是黑色

    public int getSolidColor() {

        return 0;

    }

复制代码

其实这个蒙层在android所有标准控件中，只有时间的控件直接采用了，其它的保留了特性；而且从系统的默认实现来看，这个就是为滑动实现的

4.4 滚动条

由两部分组成，一个是Track（滑道），一个是Thumb（滑块）；滑道可以认为是可以滑动整体，固定的，而滑块只是其中一部分，位置可变动；

有显示和隐藏控制，源码见awakenScrollBars()、onDrawScrollBars方法；

4.4.1 显示

显示受参数控制，即显示位置，且显示位置方向是可以滑动的才可以显示；有两种方式

1. xml中设置

android:scrollbars="vertical|horizontal"

复制代码

2. 代码设置

public void setHorizontalScrollBarEnabled(boolean horizontalScrollBarEnabled)

public void setVerticalScrollBarEnabled(boolean verticalScrollBarEnabled)

复制代码

4.4.2 隐藏

受参数控制，可以通过xml布局中配置，也可以设置；默认为true，如下

android:fadeScrollbars="true"



public void setScrollbarFadingEnabled(boolean fadeScrollbars) 

复制代码

淡出效果，是在显示操作后提交的延迟操作，延时时长，默认为ViewConfiguration.getScrollDefaultDelay()，可以通过两种方式改变

• onDrawScrollBars方法调用不传递时间时，xml中配置可改变

android:scrollbarDefaultDelayBeforeFade="10"

复制代码

• 代码中onDrawScrollBars传递时间控制

淡出效果为alpha变换，时长默认为ViewConfiguration.getScrollBarFadeDuration()；同样可以通过两种方法改变

1. xml配置

android:scrollbarFadeDuration="1000"

复制代码

2. 方法设置

public void setScrollBarFadeDuration(int scrollBarFadeDuration)

复制代码

4.4.3 样式控制

样式也有两种形式的控制

1. 圆形屏幕设备：主要针对是android手表等设备，这个我看不了效果，就不说它的显示控制了


2. 其它设备：绘制的是ScrollBarDrawable图片类型

ScrollBarDrawable是个不对开发者公开的类，那么这里我们只介绍下其属性

• android:scrollbarSize： 竖直时宽度，水平时高度


• scrollbarThumbHorizontal/scrollbarThumbVertical：滑块颜色


• scrollbarTrackVertical/scrollbarTrackHorizonta：滑道颜色


• scrollbarStyle：滑块样式，默认值insideOverlay，还有三个值insideInset，outsideOverlay，outsideInset；insideXXX不考虑padding，也就是会覆盖在padding上，而outside不考虑margin，会覆盖在margin上

4.5 指示条

源码见onDrawScrollIndicators方法

其是否可见，由3个方面控制

1. 指示条显示位置不为none;两种方法设置，xml和代码

android:scrollIndicators="none"



public void setScrollIndicators(@ScrollIndicators int indicators[, @ScrollIndicators int mask])

复制代码

2. 指示条显示位置相应方向可滑动；top：向上滑动，bottom-向下滑动，left向左滑动，right-向右滑动

左右滑动判断;参数为负，表示左，正为右

  public boolean canScrollHorizontally(int direction) {

        final int offset = computeHorizontalScrollOffset();

        final int range = computeHorizontalScrollRange() - computeHorizontalScrollExtent();

        if (range == 0) return false;

        if (direction < 0) {

            return offset > 0;

        } else {

            return offset < range - 1;

        }

    }

复制代码

上下滑动判断；参数为父表示上，为正表示下

  public boolean canScrollVertically(int direction) {

        final int offset = computeVerticalScrollOffset();

        final int range = computeVerticalScrollRange() - computeVerticalScrollExtent();

        if (range == 0) return false;

        if (direction < 0) {

            return offset > 0;

        } else {

            return offset < range - 1;

        }

    }

复制代码

指示条图标，为R.drawable.scroll_indicator_material，不可改变；这是我查找到的图片情况：

<shape xmlns:android="http://schemas.android.com/apk/res/android"

       android:tint="?attr/colorForeground">

    <solid android:color="#1f000000" />

    <size

        android:height="1dp"

        android:width="1dp" />

</shape>

复制代码

指示条位置：以所在位置为其一边，垂直的两边，以及位置[-|+]为图片另外一边

唯一用途，指示你此时可以往哪个方向滑动；我觉得很不实用

4.6 回弹

默认是可以回弹，但是未进行回弹效果处理；对于回弹的开启关闭，可以通过两种方式

1. xml中处理

android:overScrollMode="always"

复制代码

2. 代码设置

public void setOverScrollMode(int overScrollMode)

复制代码

通过下面方法可以获取,为OVER_SCROLL_NEVER时不可回弹

public int getOverScrollMode()

复制代码

回弹长度，按照 2章节中 获取的相应常量设置即可

回弹效果，可以在手指移动、滑翔两个过程中出现；需要通过上述方法判断，进行进行处理；系统提供了默认的回弹效果类EdgeEffect；下面介绍下此类运用

EdgeEffect类

EdgeEffect mEdgeGlowTop = new EdgeEffect(getContext());  // 实例化

mEdgeGlowTop.setColor(color); // 改变回弹颜色

mEdgeGlowTop.onPull(deltaDistance, displacement) // 回弹参数，均为0-1，变化距离以及位置比例

mEdgeGlowTop.isFinished() // 状态判断

mEdgeGlowTop.onRelease() // 释放

mEdgeGlowTop.onAbsorb(velocity) // 放弃



mEdgeGlowTop.setSize(width, height) // 设置绘制的矩形范围，上面onPull传的参数比例，就是依据这个来绘制回弹的图形的

mEdgeGlowTop.draw(canvas) // 绘制，结果表示是否还需要继续处理

复制代码

需要特殊说明的是，这个类绘制的时候，默认绘制方向，以当前视图左上角为起点进行绘制的；所以要onPull的参数传递以及绘制时，要考虑坐标以及旋转的关系，进而达到正确的效果

4.7 嵌套滑动启动关闭配置

这个可以通过xml配置，或者代码设置

android:nestedScrollingEnabled="true"



public void setNestedScrollingEnabled(boolean enabled)

public boolean isNestedScrollingEnabled()

复制代码

4.8 测量

这里就是重写onMeasure方法，有两种情况

1. 继承ViewGroup；需要完全自己重写逻辑


2. 继承ViewGroup子类；可以依赖父类的测量逻辑，在其测量关键方法重写，也可以先进行父类测量

这两种情况都需要对子布局测量传递不限制模式MeasureSpec.UNSPECIFIED，以达到有滑动距离的可能

更具体的逻辑就需要自己来操作；不过在操作的时候，需要特殊注意一个对象，那就是ViewGroup.LayoutParams，也就是容器的布局参数，这个类是容器规定了一些功能，也是子view通过属性来通知父容器的一种重要途径

5 ScrollingView接口

如果你能理解上面的内容，那么这个接口方法就比较好理解了

• computeHorizontalScrollRange()/computeVerticalScrollRange()：相应方向滑动范围，[0, 此方法结果]


• computeHorizontalScrollOffset()/computeVerticalScrollOffset()：相应方向已滑动的距离


• computeHorizontalScrollExtent()/computeVerticalScrollExtent()：滑道的长度，也即容器的宽度或者高度

这些方法，都是进行滑动判断、fade蒙版、指示条、滑动条用到的核心方法；如果不实现，就无法拥有View已实现的效果，并且相应方法肯定是不可用了，比如：

• 是否可滑动判断：canScrollHorizontally，canScrollVertically


• 滚动条隐藏：awakenScrollBars

6 嵌套接口

接口也分为子视图方法和父容器方法；子视图方法用来通知父容器进行处理的，而父容器方法是高速子滑动视图其是否去处理以及处理的结果状态；

6.1 NestedScrollingParent3接口

其继承NestedScrollingParent2，NestedScrollingParent2又继承了NestedScrollingParent；方法如下

1. onStartNestedScroll方法：父容器是否需要处理子view的滑动事件，true表示接受处理


2. onNestedScrollAccepted方法：接受子视图的滑动事件询问


3. onStopNestedScroll方法：得知子视图停止滑动时的通知


4. onNestedScroll方法：子view已经处理滑动后，父容器进行滑动处理


5. onNestedPreScroll方法：子view处理滑动前，父容器进行滑动处理


6. onNestedFling方法：子view需要滑翔时，子view处理，父view进行处理


7. onNestedPreFling方法：子view需要滑翔时，父view进行处理；返回结果表示是否处理


8. getNestedScrollAxes方法：当前父容器在子view滑动时，处理滑动的维度

需要注意的是，嵌套时，手指滑动是可接力完成的，而滑翔一定是互斥完成的

其中涉及一下参数，说明如下：

1. type：表示滑动或者滑翔，ViewCompat.TYPE_TOUCH滑动，ViewCompat.TYPE_NONE_TOUCH滑动


2. consumed:包含x、y两个方向的数组；一般为输出变量，表明当前处理时，消费了多少


3. dxConsumed/dyConsumed:表明传递到父容器时，子视图已经消耗了多少滑动距离


4. dxUnconsumed/dyUnconsumed:表明传递到父容器时，还有多少滑动距离待消耗


5. target：表明从那个子view传递而来


6. dx/dy:此次事件滑动的距离


7. child：包含target的，当前容器的直接子容器


8. axes：滑动的方向，ViewCompat.SCROLL_AXIS_HORIZONTAL,ViewCompat.SCROLL_AXIS_VERTICAL两个值


9. velocityX/velocityY: 滑翔时初始速度

6.2 NestedScrollingChild3

继承了NestedScrollingChild2， NestedScrollingChild2又继承了NestedScrollingChild；方法如下：

1. setNestedScrollingEnabled/isNestedScrollingEnabled: 嵌套滑动是否支持


2. startNestedScroll：通知嵌套滑动开始


3. stopNestedScroll：通知嵌套滑动结束


4. hasNestedScrollingParent：是否存在嵌套处理的直系长辈容器


5. dispatchNestedScroll：自己处理后继续通知滑动事件


6. dispatchNestedPreScroll：自己未处理滑动，通知滑动事件


7. dispatchNestedFling：自己处理后，通知滑翔事件


8. dispatchNestedPreFling：优先自己处理，通知滑翔事件

参数就不解释了，和6.1类似

6.3 辅助类

这两章中的方法在View和ViewGroup均有使用，androidx也提供了辅助类进行默认实现，这两个类就是NestedScrollingParentHelper、NestedScrollingChildHelper；这两个类主要是为了解决版本兼容问题

前言

用本篇文章理论知识和架构原则实践了一个 wanAndroid 项目，其中全部采用 kotlin 编写并抛弃了 Rxjava，因为 kotlin 可以完全替代他，github 本项目中汇总了业界知名的架构文章和一些项目帮你彻底理解架构。后续本项目将持续更新，并完善 wanAndorid 的所有功能。还会用 23 种设计模式在项目中实践，彻底理解设计模式在业务场景中的使用，欢迎持续关注 github

一、什么是架构

1.1 架构介绍

架构究竟是什么？如何更好的理解架构。我们知道中国文字博大精深可以说从文字的组成就能理解其含义。架构也不例外 “架构” 是由 “架” 、“构” 组成。

架：建造、搭设、支撑。 简称：整体结构
构：屋宇、供人居住的木、砖瓦构筑物。 简称：组件

整体结构和组件的组合就形成了架构。以 Android 架构为例子一个 APP 通常是有 class（类）组成，而这些 class 之间如何如何组合、相互之间如何发生作用，则是影响这个 APP 本身的关键点。细分的话可以分为类、接口（连接器）、任务流。所谓类就是组成架构的核心 “砖瓦”，而接口则是这些类之间通讯的路径、通讯的机制、通讯的期望结果。任务流则是描述系统如何使用类和接口完成某一项需求比如：一次网络请求。 上面介绍架构中提到了房屋、木头、砖瓦可见架构和建筑有着彼此的联系。

1.2 建筑学

上世纪 60 年代已经设计软件架构这个概念了，到了 90 年代软件架构这个概念才开始流行起来。而计算机的历史开始于上世纪五十年代相比建筑历史就非常短暂了，建筑工程从石器时代就开始了。人类在几千年的建筑设计实践中积累了大量的经验和教训，建筑设计基本上包含两点，一是建筑风格，二是建筑模式。独特的建筑风格和恰当选择的建筑模式，可以使它成为一个独一无二的建筑。

下图的照片显示了古代玛雅建筑：Chichen-Itza，九个巨大的石级堆垒而上，九十一级台阶（象征着四季的天数）夺路而出，塔顶的神殿耸入云天。所有的数字都如日历般严谨，风格雄浑。难以想象这是石器时代的建筑物。

英国首相丘吉尔说，我们构造建筑物，建筑也构造我们，英国下议院的会议厅较狭窄，无法使所有的下议院议员面向同一个方向入座，而必须分成两侧入座。丘吉尔认为，议员们入座的时候自然会选择与自己政见相同的人同时入座，而这就是英国政党制的起源。

二、架构设计目的

几乎所有的软件设计理念都可以在浩瀚的建筑学历史中找到。许多人认为 “形式必须服从功能”（你认同这种观点吗？欢迎在评论区留下你的看法）。而好的设计既有形式又有功能。比如我们的北京大兴国际机场大兴机场以航站楼为核心向四周延展从空中俯瞰就像是一只展翅欲飞的凤凰，以航站楼核心区为中心，分别向东北、东南、中南、西南、西北五个方向伸出了五条指廊，通往北京大兴国际机场的飞行区。这种从中心向四面八方延伸的设计，使航站楼中心点到最远端登机口的距离只有 600 米左右，旅客步行前往最多只需 8 分钟。

建筑的设计又有一定的目的性，而软件架构设计也同理。软件架构目的性大致可分为可扩展性、可定制化、可伸缩、可维护性：

1. 可扩展性： APP 必须能够在用户的 UV/PV 数量快速增加的情况下，保持软件合理的性能。只有这样在快速的从 0 到 1 的需求迭代中才能后顾无忧。

2. 可定制化： 在同一个软件系统中可能面向的用户群体是不同的、多样的，需要满足根据用户群的不同和市场需求的不同进行定制化。比如一个 APP 中某些功能只针对特定用户开放。

3. 可伸缩性： 在新技术出现的时候，一个软件系统应当允许接入新技术，从而对现有系统进行功能和性能的扩展。

4. 可维护性： 软件系统的维护包括两方面，一是修复现有的 bug，二是将新的迭代需求开发到现有系统中去。一个易于维护的系统可以有效地降低人力和物力。

三、实践一个 APP：玩 Android

针对上面对架构的介绍，相信已经从陌生走向熟悉了。但是最重要的还是实践，伟大的毛主席曾经说过 你要想知道梨子的滋味，就要亲口尝一下。因此借用了 wanAndoird 开放 API 简单实现一个 APP 并概括上述架构的关键点，主要的功能点如下：

• 首页是热搜文章的分类列表

• 项目页面主要包括完整项目

• 文章、项目点击可以查看详情

不知道还有没有印象上文提到了架构 “形式必须服从功能” 当然这不是权威的定义，可以作为参考。我们先不管是形式服从功能还是功能服从形式，可以结构化思维理解下这句话，架构大致可分为：形式、功能所以我们依次按照此两点进行搭建 wanAndroid 项目。

3.1 架构 - 形式

从形式本身而言包括两部分。一是事物外在的形状，二是内在的结构、组合方式。实际上，这两者为同一。内容如何内在组合，对外就自然有某种表现的形状。

我们打开项目的第一眼接触到和看到的就是我们项目的目录结构，更清晰更简洁的目录结构可以使我们更快的上手项目。这里主要分为两部分核心模块、业务功能模块：

核心模块主要有以下职责：

• Dagger 依赖注入处理。
• 扩展功能：各种 utils。
• 基础层的抽象：BaseActivity、BaseViewModel 等
• 第三库处理、网络异常处理等

业务功能模块主要有以下好处：

• 高内聚性
• 清晰的功能结构
• 模块化
• 功能隔离并封装

在主 APP 下进行了 core、features 的划分，业务模块并没有按照模块化的形式进行多 moudle 拆分而是聚合在 features 下，以包的形式进行了聚合，这样做的好处如下：

• 更快的编译速度
• 减少 maven 库的依赖冲突
• 通用功能的重用性
• 包的内聚力

可以看到我们并没有采用按照业务 module 进行模块化划分，因为我之前接触过一个项目拆分了 40 多个 module 可想而知项目一旦庞大起来坏处也就是暴露出来：

• 编译一次项目高达 7/8 分钟，编译速度优化可以看我之前的文章（编译速度优化）
• 项目中的 moudle 依赖纵横交错

当然我并不反对多 module 模块化的存在，因为任何模式都有利有弊，这取决于当前的项目的业务来抉择使用那种形式。此外项目中全部采用 kotlin 编写：

• build.gradle.kts .kts 也是官方推崇的可以使 gradle 更加简化
• buildSrc来处理 gradle 依赖

3.2 架构 - 功能

在玩 Android 中的业务点功能点主要有文章、项目获取，而这些功能点大部分都离不开网络请求和回调处理。这里不再描述 MVC、MVP、MVVM 的区别和如何选择，但是我可以说明一点是任何架构模式都没有最好、最优，只有最适合当前业务的才是好架构。现在 google 官方推崇的架构主要是 MVVM 所有我们主要说下 MVVM。更详细的可以查看官网文档 应用架构指南：

MVVM 架构模式满足上文我们描述符合的架构设计的目的，同时也准守了官方给定的架构原则，架构原则大致有两点如下。可能光看这两个定义可能不太容易理解。所有我们用结构化思维的方式理解下，关注点分离就是将复杂问题做合理的分解，再研究分解的侧面，最后合成整体的解决方案。因此我们在 Activity 或 Fragment 不应该做业务逻辑而是把功能点拆分成需要最小的最优解，最后合并成整体方案。比如 mvvm 我们衍生出 ViewModel、LiveData、Model 等。

1. 关注点分离 Activity 或 Fragment 中的代码应是处理界面和操作系统交互的逻辑应使这些类尽可能保持精简，这样可以避免许多与生命周期相关的问题。
2. 通过模型驱动界面 模型是负责处理应用数据的组件。它们独立于应用中的 View 对象和应用组件，因此不受应用的生命周期以及相关的关注点的影响

MVVM 中每个组件仅依赖于其下一级的组件如：activity-->viewMoudle-->Repository。这时候你可能有疑惑，如果是单向依赖那网络请求的回调怎么处理？这里引出一个概念 “响应式编程” 结合 liveData 做处理其内部是观察者模式，并且关联视图的声明周期如：Activity、Fragment 或 Service。使用 LiveData 的好处如下：

1. 不会发生内存泄漏 观察者会绑定到 Lifecycle 对象，并在其关联的生命周期遭到销毁后进行自我清理。
2. 不会因 Activity 停止而导致崩溃 如果观察者的生命周期处于非活跃状态（如返回栈中的 Activity），则它不会接收任何 LiveData 事件。
3. 不再需要手动处理生命周期 界面组件只是观察相关数据，不会停止或恢复观察。LiveData 将自动管理所有这些操作，因为它在观察时可以感知相关的生命周期状态变化。

3.3 UseCase

UseCase 是 Clean 架构中的一个概念，其中主要用于 UI 和数据层的连接同时也会进行 IO 的切换，这里可以看到本项目抛弃了 Rxjava 因为他完全可以用 Kotlin 来替代。

abstract class UseCase<out Type, in Params> where Type : Any {



  abstract suspend fun run(params: Params): Either<Failure, Type>{



  operator fun invoke(params: Params, onResult: (Either<Failure, Type>) -> Unit = {}) {

      val job = GlobalScope.async(Dispatchers.IO) { run(params) }

      GlobalScope.launch(Dispatchers.Main) { onResult(job.await()) }

  }



  class None

}

复制代码

复制代码

3.4 一个完整网络请求流程

• View：一个网络请求的发送并订阅，处理 UI 数据。
• ViewModel：为 View(Activity/Fragment) 提供数据，并处理业务逻辑。
• LiveData：具有生命周期可观察的数据存储器类，LiveData 存储在 ViewModel 中
• UseCases：用于连接 ViewModel 和 Model，并更新 LiveData。
• Model：可以从网络、数据库或其他 API 获取数据

四、总结

我们可以体会到从架构理论定义到实践的过程相信你有了自己的理解和见解，但这只是一种实现方式，如果在满足架构设计目的和架构原则的情况下你有更好的实践方式或者有任何和架构项目的疑问点都可迎在评论区或者 Github 中留言讨论。这里我也有个疑问点就你认同形式必需服从功能？欢迎留下你的见解。

后续本项目将持续更新，并完善 wanAndorid 的所有功能。还会用 23 种设计模式在项目中实践，彻底理解设计模式在业务场景中的使用，欢迎持续关注。当其他的平台如后端、前端架构的搭建都是殊途同归的。但是我还是有几点建议：

• 业务决定架构
• 不要过度设计
• 面向接口编程
• 形式需服从功能

作者 | 陈同学       责编 | 欧阳姝黎

这里是陈同学，首先来一个简单的自我介绍，和个人的经历分享吧。

我本科和硕士均就读于哈工大，是今年1月毕业。

我经历过3个专业，大一 船舶工程；大二-大四 车辆工程；研一-研三 机械电子工程。

我拿过5个国家级竞赛的奖项 ，我在研究生期间从0开始，在1年时间，自学操作系统，计算机网络 ，C++，数据结构等等，累计学习30+本书，500+博客文章，100+小时的网课，30w+字的资料。

在实习阶段斩获了腾讯、阿里、华为等大厂的实习offer，在正式秋招阶段收割10+offer，包括但不限于

腾讯sp 



字节sp



阿里云 sp 



BAT大满贯



还有华为15a（应届生最高定级）



中兴蓝剑计划（应届生最高定级）



深信服大牛批（应届生最高定级）



vivo sp等等



均是40w+的总包



最高总包约50w



同时保持了一个在4月份以后



面试通过率100%的记录

今天和大家来分享一下，我从40+场面试中总结出来的14个应该避免的面试大坑。

我认为想面试互联网技术岗， 特别是像我一样的非科班同学，应该特别关注。

这些坑都是从我自身的经历以及从身边的同学的经历中总结出来的，我踩过的坑希望大家不要踩

No1.对简历上的每一个字负责

很多同学，包括我以前会犯的一个误区就是， 追求简历上技能点多多益善。

不论是不是自己真正掌握的 ，只要是接触过某个技术，都罗列在简历上。甚至有些技能点， 还蜜汁自信的写上“精通”但是面试官一深问， 就不会了。这就犯了写简历时候的一个大忌。

我们要对简历上的每一个字负责， 每一个写在简历上的技术点都应该是我们烂熟于心，经得起面试官深入追问的。

具体来说就是要避开下面两个坑

1. 技术栈不要贪多把写上去的每一个点深入掌握就好。你在简历上写的内容相当于给面试官划定了一个出题范围。面试的时候面试官并不会特意的刁难你。他们主要还是会从你简历上写好的那些技术点去考你。好好对着自己写的简历一行一行看一遍，这都是你挖的坑。同时谨慎的使用熟练精通这些字眼 。




2. 在描述项目的时候，不要过分夸张，比如把整个团队的活写成你一个人做的。言过其实，很容易会在面试中露馅，简历可以美化包装，但是过分夸张。

No2.技术宽度决定了你是否能够进入一家公司，

技术深度则决定了你offer的等级

对于互联网技术岗的主要问的东西有这样几块计算机学科基础+项目经历+刷题。这3块也就是整个面试的核心了，然后对于不同细分的技术岗位下对于这三块有不同的考察方向比如：

• 对于开发岗可能考察的就是像操作系统计算机网络等等方面的知识




• 对于算法岗考察的就是机器学习深度学习等等方面的内容

所以我觉得只有你先对应岗位必问的那些知识掌握，也就是先cover住技术宽度，才是拿到offer的前提。

在此基础上 如果你能在某一方面比较有优势，比如某一些知识领域比较精通或者做的项目比较有优势或者有大厂实习也就是技术深度达到了这样才能有更好的offer等级。

关于怎么提升宽度和深度，其实说真的短期内宽度是好补的，深度确实要看个人，是代价较高。

所以我的建议是，先把宽度提上来，把你能cover的知识点及原理搞懂是第一步。建议对自己之前的项目和技术积累做一个总结和分类。

然后对已经了解的方面尽可能延伸，对盲区或是一些面试重点考察的地方进行针对性的学习和练习。

No3.如果走技术研发岗，学历、成绩、奖学金 

学生组织活动都不会是决定性的因素

因为面试中只考查计算机基础+刷题+项目，只有在最后的HR面的时候才会问一下你的在校的一些经历、奖学金等等。

当然如果你如果前面的技术面都通过的话，最后的HR面其实问题不大，就算没有太多的学生组织经历、太高的绩点、各种奖学金等等。HR面大概率还是会通过的。

只有你的技术水平才是决定性因素像学历、绩点、奖学金等等这些东西只是一个锦上添花。

如果你的技术很拉跨，一个技术问题都回答不上来，我觉得算是清北，面试官也是大概率不会让你通过的。

互联网算是对学历最宽容的行业之一毕竟程序员是一个技术密集型工种。

学校的作用是抬高找工作的下限，很多大厂会认为一个出身名校的同学的基本功是扎实的，因此会很乐于接纳这样的同学。但是指望名校光环提高自己的上限是不切实际的。

有很多同学会因为自己是双非学校，感到自卑，不敢投递大厂会显得有点畏手畏脚。但我觉得我们完全没有必要妄自菲薄。

说实话，我自己本科专业也和计算机一点不搭边，在面试的时候也和面试官提到这个问题，但面试官给我的答复是只要有能力，没有人会看你的学校或者专业。

No4.心态作为一个很重要的因子存在，

还是会对最后的结果有挺大影响的

这里给大家列出一个公式 是我在某一个帖子看到的

  offer = 心态 * (实力 + 面试技巧) + 运气

实力就是咱们刚才所说的 计算机基础+刷题+项目

秋招对大部分人来说都是一场难熬的经历，会有各种压力源的存在，真的很容易让我们心态崩溃

• 可能有的同学开始准备的时间比较晚，快开始秋招了才开始准备，总暗示自己说什么时间不多了，怎么每天过这么快效率怎么这么低。




• 到笔试了，跟自己说这个算法太难了，肯定做不出来；




• 面试过程中面试官问的东西好多都不会怎么办？




• 面完了又收到拒信，这次面试又凉凉了。




• 周围的XX大佬又收割一个offer了 我还没上岸 太菜了 怎么办

不管是面试前、面试中、面试后的结果 已经周围环境 peer pressure 等等都牵动着我们的神经。

所以这里给大家提供几个调节心态的小建议

• 要正视自己的能力，不轻视，不高估

  不轻视指的是我们都要对自己有信心，机会那么多，千千万万的初中创公司，各种拥有垂直领域稳定份额的二三线公司甚至有些已经上市，除此之外还有银行，投资，金融的IT岗

  不高估就是要清楚自己的能力范围，过高的期望会让你的心理变得脆弱，稍有不顺心态就有崩掉的趋势。因为面试毕竟有太大的偶然性，就算你达到了一定的水平，相应水平的岗位也不是百发百中的




• 遭受到各种拒绝时，一定要沉得住气，坚信一切都会是最好的安排

  在确保自身没有问题（学习方法、知识积累或自身定位）的情况下，坚持下去，这个时候你差的就是一点点运气，该来的总会来。面试过程不要紧张，尤其是前几次，建议先从小公司入手锻炼下面试经验




• 心态实在太差的时候反而要停下你重复而没有效率的工作，去调整一下，可以出去玩一玩，吃吃喝喝




• 面试过程漫长：适当放松，面试很搞人心态的

  过了简历面等 一面 一面过了等二面 二面过了等三面。互联网面试流程少则三面 多则五六七八面。持续时间少则是、一个礼拜 多则一两个月 。在这个过程中建议大家专注于过程 不要太在意结果




• 面试准备过程中 和周围同学多交流 不比较
  主要是要找一个能力和你差不多的同学，最好不要找那种比你强太多的，当你看到别人已经收割很多offer了自己还颗粒无收的时候 容易被搞心态，会怀疑人生。当然也不排除有些人拿到offer后在朋友圈装X、散布焦虑情绪，这种我建议屏蔽或拉黑，同时也希望大家拿到offer后能低调一些，以己度人。求职过程中别和身边的人对比 ，别自我怀疑，专注于过程，别在意结果，反思总结，心态别崩

No5.学会平等交流，别把自己身段放的太低

面试是个双选的过程，他可以拒绝你，你也可以拒绝他。回答的时候不用表现的太卑微，反而会影响自己正常的表达和逻辑，不卑不亢就行。

心态也放稳一点，大胆一点，duck不必害怕，互联网技术岗的面试不会像其他行业 其他岗位比如快销，地产等等那样子会在意你的仪表，谈吐等等，他在意的就是面试官问你的技术会不会。

和面试官谈笑风生就行了，而且1面面试官可能只比我们大几岁，如果进去了还是你mentor呢。

No6.回答问题的时候要有层次感 循序渐进

不要一口气把知道的全部说完，然后还毫无条理。学会一个知识点由浅入深讲解给面试官，并且留有余地给他进一步去问。

一个简单的基础问题可以一步一步有条理有层次的回答，每一层表达完抛个引子，让面试官可以继续问下去，这也算是一个引导的技巧，从而让面试官真正了解你的掌握的深度。

No7.如果真的被问到不会的，就直接说你不会

每个程序员都不是全能的大神，总会有知识漏洞，更何况是我们这些应届生所以面试中碰到不会的问题很正常。

不要觉得自己某个问题到不上来，这场面试就注定凉凉了，坦诚的告诉面试官自己不会，或者礼貌地说这方面可能我还要多学习。

对一个拿不准的问题千万不要猜，即使是二选一的那种问题，猜错了直接完蛋，猜对了被人看出来，再往深问还是完蛋。

另外，像可能，大概是，我觉得这种表达最好不要，一听就是对一个点没把握，有可能会让面试官觉得学习太浮躁不喜欢寻求原理。

那对于自己知道原理（确实是理解了的）但是没用过的东西，就讲讲原理，并承认自己实践不足，表现出好学的态度。

面试一定要真诚。不熟直接说不会，更多的展示自己擅长的一面，千万不懂装懂。

No8.手撕代码题的时候主动的和面试官交流

一般每一轮面试的最后一part保留节目是手撕代码。

关于手撕代码部分，不能面试官出完题，就一个人闷头在那里写。

因为面试官是会代入实际工作时的情景的，如果你写题的时侯和他一点交流也没有，那万一把你招进去了以后对需求交接的时侯是不是也是这样的状态？

这个也是我在面试的时侯听面试官提的意见。

No9.思路比答对题目更重要，题不会没关系，

你要体现你的解题思路和能力

当然纯概念不会就是不会，别瞎说。

这里更多的是比如一些开放性的题目，比如说，手撕代码题，项目中的一些优化 一些系统设计题、智力题。

面试官不一定非得要求有一个标准答案呢，主要是想看看你能不能主动的去拆解问题、主动思考，以及和面试官的交流。

这也是面试中考察的很重要的一部分，就是你解决问题的能力。

对于这种问题，还是要多打开思路，多结合自己已经学过的一些技术点进行思考。

自己能够先给出一个简单的方案，再一步一步的优化，到一个相对合理的方案 这样的回答面试官会非常喜欢。

No10.最好把每场面试录音，记录面经，反思总结

在电话面或者视频面的时候 ,最好利用手机的录音功能把每一场面试录下来哦 这样方便自己的复盘 。

发现自己那些模块比较薄弱，查漏补缺， 反思总结， 针对面试中出现的问题下次不要再出现。

No11.在面试中介绍项目的面试时候，

项目的一些描述要提前准备，而不是临场去组织语言

很多同学在面试中描述项目的时候，都是临场发挥，临场去组织语言。这样会往往会导致你在介绍的时候，不流畅不连贯 ，导致面试官抓不住你的重点。

也就会让它认为你的表达有问题，或者你的项目吗没有太核心能吸引他的东西，所以建议大家专门给自己做的项目整理一个类似演讲稿的稿子。

把项目的流程、项目的背景、项目碰到的问题。自己用到的方案，项目的亮点难点改进点，后续的优化方向等等都写在这个稿子上。

在每次面试前过一遍，这样的在面试中直接按照稿子上的描述去说就行。

面试官其实对你的项目业务流程不感兴趣，更感兴趣的是你项目中

• 自己解决的问题，




• 所采用的方案，




• 为什么采用这个方案，




• 有没有更好的方案，




• 你的方案和别人的方案的对比，




• 你的思考在哪里，




• 你的难点亮点创新点，




• 以及在项目中所涉到的技术点的一些提问,

这里面最好可以涉及一些数据，比如数据量、响应速度等等来量化的表达。

No12.把握好反问环节

面试官最后一般会问你你有什么想问我的，这个其实就是反问环节。

这个其实是面试官想了解你对公司的一个关注度或者对自身发展的一个关注度。

所以大家可以从这些角度去问新人培养机制？进去以后负责哪些业务？学习建议？

表现出自己的好学求知，以及对公司的关注 这也能看出你对工作的一个诚意，以及对发展的一个预期。

最好不要去问那些比如 “我什么时候会有下一面 ” “我刚刚面的怎么样这种话题”。

No13. HR面的时候 看起来像聊人生 

实际是在考察你的价值观

到HR面的时候就不会在有技术问题了，而是一些看起来无关痛痒的聊生活聊兴趣。

比如，家里人都是干嘛的，有没有女朋友，有没有什么兴趣爱好，有没有拿到别的offer，为什么会来我们呢公司等等。

其实这些问题看起来都很无足轻重，实际上是想看看你的稳定性，是不是适合公司的氛围，是不是接受公司的文化等等。

比如，是不是会因为家里条件好，吃不了苦，加不了班，会不会女朋友异地，过几年就会离职跳槽，稳定性差，会不会有更好的offer放弃这家等等。

所以大家在HR面的时候要摸清楚HR真正想考察你的指标是什么避免跳坑里就行了。

对于互联网技术岗来讲 通过了前面的3、4轮的技术面 一般问题都不大，HR面只要不是回答得得太离谱，offer八成是可以到手的

No14.不要把鸡蛋都放在一个篮子里

这句话的意思是， 尽量多拿几个offer，不要只拿一个offer就躺平了，不要把赌注都压在一个offer上。

因为互联网的秋招一般是面试通过了，先发两方，然后过两个月左右到11月份再谈薪资。

如果你最后只拿了一个offer，然后那个公司又只给你开了一个白菜价你就血亏了，都没有别的选择。

尽量多拿一些offer。事实证明，部分企业会根据你手里offer的情况来定薪资，还有一点，万一后面提前去实习发现不太合适，想违约跑路 没有别的offer在手，根本没有选择。

hr们会养备胎，你也可以多拿几个offer ，算是给自己多养几个备胎，抵抗风险。

对于开发人员来说，调用远程服务就像是调用本地服务一样便捷。尤其是在微服务盛行的今天，了解RPC的原理过程是十分有必要的。

作者 | Alex Ellis       译者 | 弯月

出品 | CSDN（ID：CSDNnews）

以下为译文：

计算机之间的通信方式多种多样，其中最常用的一种方法是远程过程调用（Remote Procedure Call，即RPC）。该协议允许一台计算机调用另一个计算机上的程序，就像调用本地程序一样，并负责所有传输和通信。

假设我们需要在一台计算机上编写一些数学程序，并且有一个判断数字是否为质数的程序或函数。在使用这个函数的时候，我们只需传递数字进去，就可以获得答案。这个函数保存在我们的计算机上。

很多时候，程序保存在本地非常方便调用，而且由于这些程序与我们其余的代码在一起，因此调用的时候几乎不会产生延迟。

但是，在有些情况下，将这些程序保留在本地也不见得是好事。有时，我们需要在拥有大量核心和内存的计算机上运行这些程序，这样它就可以检查非常大的数字。但这也不是什么难事，我们可以将主程序也放到大型计算机上运行，即使其余的程序可能并没有这种需求，质数查找函数也可以自由利用计算机上的资源。如果我们想让其他程序重用质数查找函数，该怎么办？我们可以将其转换成一个库，然后在各个程序之间共享，但是每一台运行质数查找库的计算机，都需要大量的内存资源。

如果我们将质数查找函数单独放在一台计算机上，然后在需要检查数字时与该计算机对话，怎么样呢？如此一来，我们就只需提高质数查找函数所在的计算机的性能，而且其他计算机上程序也可以共享这个函数。

这种方式的缺点是更加复杂。计算机可能会出现故障，网络也有可能出问题，而且我们还需要担心数据的来回传递。如果你只想编写一个简单的数学程序，那么可能无需担心网络状况，也不用考虑如何重新发送丢失的数据包，甚至不用担心如何查找运行质数查找函数的计算机。如果你的工作是编写最佳质数查找程序，那么你可能并不关心如何监听请求或检查已关闭的套接字。

这时就可以考虑远程过程调用。我们可以将计算机间通信的复杂性包装起来，然后在通信的任意一侧建立一个简单的接口（stub）。对于编写数学程序的人来说，看上去就像在调用同一台计算机上的函数；而对于编写质数查找程序的人来说，看上去就像是自己的函数被调用了。如果我们将中间部分抽象化，那么两侧都可以专心做好自己的细节，同时仍然可以享受将计算拆分到多台计算机的优势。

RPC调用的主要工作就是处理中间部分。它的一部分必须存在数学程序的计算机上，负责接受并打包参数，然后发送到另一台计算机。此外，在收到响应后，还需要解析响应，并传递回去。而质数查找函数计算机则必须等待请求，解析参数，然后将其传递给函数，此外，还需要获取结果，将其打包，然后再返回结果。这里的关键之处是数学程序和质数查找程序间，以及它们的stub之间都有一个清晰的接口。

更多详细信息，请参见 Andrew D. Birrell和Bruce Jay Nelson1 于1981年发表的论文《Implementing Remote Procedure Calls》。

从头编写RPC

下面，我们来试试看能不能编写一个RPC。

首先，我们来编写基本的数学程序。为了简单起见，我们编写一个命令行工具，接受输入，然后检查是否为质数。它有一个单独的方法is_prime，处理实际的检查。

// basic_math_program.c

#include <stdio.h>

#include <stdbool.h>





// Basic prime checker. This uses the 6k+-1 optimization

// (see https://en.wikipedia.org/wiki/Primality_test)

bool is_prime(int number) {

  // Check first for 2 or 3

  if (number == 2 || number == 3) {

    return true;

  }

  // Check for 1 or easy modulos

  if (number == 1 || number % 2 == 0 || number % 3 == 0) {

    return false;

  }

  // Now check all the numbers up to sqrt(number)

  int i = 5;

  while (i * i <= number) {

    // If we've found something (or something + 2) that divides it evenly, it's not

    // prime.

    if (number % i == 0 || number % (i + 2) == 0) {

      return false;

    }

    i += 6;

  }

  return true;

}





int main(void) {

  // Prompt the user to enter a number.

  printf("Please enter a number: ");

  // Read the user's number. Assume they're entering a valid number.

  int input_number;

  scanf("%d", &input_number);





  // Check if it's prime

  if (is_prime(input_number)) {

    printf("%d is prime\n", input_number);

  } else {

    printf("%d is not prime\n", input_number);

  }





  return 0;

}

这段代码有一些潜在的问题，我们没有处理极端情况。但这里只是为了说明，无伤大雅。

目前一切顺利。下面，我们将代码拆分成多个文件，is_prime 可供同一台计算机上的程序重用。首先，我们为 is_prime 创建一个单独的库：

// is_prime.h

#ifndef IS_PRIME_H

#define IS_PRIME_H





#include <stdbool.h>





bool is_prime(int number);





#endif

// is_prime.c

#include "is_prime.h"





// Basic prime checker. This uses the 6k+-1 optimization

// (see https://en.wikipedia.org/wiki/Primality_test)

bool is_prime(int number) {

  // Check first for 2 or 3

  if (number == 2 || number == 3) {

    return true;

  }

  // Check for 1 or easy modulos

  if (number == 1 || number % 2 == 0 || number % 3 == 0) {

    return false;

  }

  // Now check all the numbers up to sqrt(number)

  int i = 5;

  while (i * i <= number) {

    // If we've found something (or something + 2) that divides it evenly, it's not

    // prime.

    if (number % i == 0 || number % (i + 2) == 0) {

      return false;

    }

    i += 6;

  }

  return true;

}

下面，从主程序中调用：

// basic_math_program_refactored.c

#include <stdio.h>

#include <stdbool.h>





#include "is_prime.h"





int main(void) {

  // Prompt the user to enter a number.

  printf("Please enter a number: ");

  // Read the user's number. Assume they're entering a valid number.

  int input_number;

  scanf("%d", &input_number);





  // Check if it's prime

  if (is_prime(input_number)) {

    printf("%d is prime\n", input_number);

  } else {

    printf("%d is not prime\n", input_number);

  }





  return 0;

}

再试试，运行正常！当然，你也可以加一些测试：

下面，我们需要将这个函数放到其他计算机上。我们需要编写的功能包括：

• 调用程序的 stub：

• 打包参数




• 传输参数




• 接受结果




• 解析结果

• 被调用的 stub：

• 接受参数




• 解析参数




• 调用函数




• 打包结果




• 传输结果

我们的示例非常简单，因为我们只需要打包并发送一个 int 参数，然后接收一个字节的结果。对于调用程序的库，我们需要打包数据、创建套接字、连接到主机（暂定 localhost）、发送数据、等待结果、解析，然后返回。调用程序库的头文件如下所示：

// client/is_prime_rpc_client.h

#ifndef IS_PRIME_RPC_CLIENT_H

#define IS_PRIME_RPC_CLIENT_H





#include <stdbool.h>





bool is_prime_rpc(int number);





#endif

可能有些读者已经发现了，实际上这个接口与上面的函数库一模一样，但关键就在于此！因为调用程序只需要关注业务逻辑，无需关心其他一切。但实现就稍复杂：

// client/is_prime_rpc_client.c





#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <errno.h>

#include <string.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <netdb.h>





#define SERVERPORT "5005"  // The port the server will be listening on.

#define SERVER "localhost"  // Assume localhost for now





#include "is_prime_rpc_client.h"





// Packs an int. We need to convert it from host order to network order.

int pack(int input) {

  return htons(input);

}





// Gets the IPv4 or IPv6 sockaddr.

void *get_in_addr(struct sockaddr *sa) {

  if (sa->sa_family == AF_INET) {

    return &(((struct sockaddr_in*)sa)->sin_addr);

  } else {

    return &(((struct sockaddr_in6*)sa)->sin6_addr);

  }

}





// Gets a socket to connect with.

int get_socket() {

  int sockfd;

  struct addrinfo hints, *server_info, *p;

  int number_of_bytes;





  memset(&hints, 0, sizeof hints);

  hints.ai_family = AF_UNSPEC;

  hints.ai_socktype = SOCK_STREAM;  // We want to use TCP to ensure it gets there

  int return_value = getaddrinfo(SERVER, SERVERPORT, &hints, &server_info);

  if (return_value != 0) {

    fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(return_value));

    exit(1);

  }





  // We end up with a linked-list of addresses, and we want to connect to the

  // first one we can

  for (p = server_info; p != NULL; p = p->ai_next) {

    // Try to make a socket with this one.

    if ((sockfd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1) {

      // Something went wrong getting this socket, so we can try the next one.

      perror("client: socket");

      continue;

    }

    // Try to connect to that socket.

    if (connect(sockfd, p->ai_addr, p->ai_addrlen) == -1) {

      // If something went wrong connecting to this socket, we can close it and

      // move on to the next one.

      close(sockfd);

      perror("client: connect");

      continue;

    }





    // If we've made it this far, we have a valid socket and can stop iterating

    // through.

    break;

  }





  // If we haven't gotten a valid sockaddr here, that means we can't connect.

  if (p == NULL) {

    fprintf(stderr, "client: failed to connect\n");

    exit(2);

  }





  // Otherwise, we're good.

  return sockfd;

}





// Client side library for the is_prime RPC.

bool is_prime_rpc(int number) {





  // First, we need to pack the data, ensuring that it's sent across the

  // network in the right format.

  int packed_number = pack(number);





  // Now, we can grab a socket we can use to connect see how we can connect

  int sockfd = get_socket();





  // Send just the packed number.

  if (send(sockfd, &packed_number, sizeof packed_number, 0) == -1) {

    perror("send");

    close(sockfd);

    exit(0);

  }





  // Now, wait to receive the answer.

  int buf[1];  // Just receiving a single byte back that represents a boolean.

  int bytes_received = recv(sockfd, &buf, 1, 0);

  if (bytes_received == -1) {

    perror("recv");

    exit(1);

  }





  // Since we just have the one byte, we don't really need to do anything while

  // unpacking it, since one byte in reverse order is still just a byte.

  bool result = buf[0];





  // All done! Close the socket and return the result.

  close(sockfd);

  return result;

}

如前所述，这段代码需要打包参数、连接到服务器、发送数据、接收数据、解析，并返回结果。我们的示例相对很简单，因为我们只需要确保数字的字节顺序符合网络字节顺序。

接下来，我们需要在服务器上运行被调用的库。它需要调用我们前面编写的 is_prime 库：

// server/is_prime_rpc_server.c

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <errno.h>

#include <string.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <netdb.h>

#include <arpa/inet.h>

#include <sys/wait.h>

#include <signal.h>

#include "is_prime.h"

#define SERVERPORT "5005"  // The port the server will be listening on.

// Gets the IPv4 or IPv6 sockaddr.

void *get_in_addr(struct sockaddr *sa) {

if (sa->sa_family == AF_INET) {

return &(((struct sockaddr_in*)sa)->sin_addr);

  } else {

return &(((struct sockaddr_in6*)sa)->sin6_addr);

  }

}

// Unpacks an int. We need to convert it from network order to our host order.

int unpack(int packed_input) {

return ntohs(packed_input);

}

// Gets a socket to listen with.

int get_and_bind_socket() {

int sockfd;

struct addrinfo hints, *server_info, *p;

int number_of_bytes;

memset(&hints, 0, sizeof hints);

  hints.ai_family = AF_UNSPEC;

  hints.ai_socktype = SOCK_STREAM;  // We want to use TCP to ensure it gets there

  hints.ai_flags = AI_PASSIVE;  // Just use the server's IP.

int return_value = getaddrinfo(NULL, SERVERPORT, &hints, &server_info);

if (return_value != 0) {

fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(return_value));

exit(1);

  }

// We end up with a linked-list of addresses, and we want to connect to the

// first one we can

for (p = server_info; p != NULL; p = p->ai_next) {

// Try to make a socket with this one.

if ((sockfd = socket(p->ai_family, p->ai_socktype, p->ai_protocol)) == -1) {

// Something went wrong getting this socket, so we can try the next one.

      perror("server: socket");

continue;

    }

// We want to be able to reuse this, so we can set the socket option.

int yes = 1;

if (setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1) {

      perror("setsockopt");

exit(1);

    }

// Try to bind that socket.

if (bind(sockfd, p->ai_addr, p->ai_addrlen) == -1) {

// If something went wrong binding this socket, we can close it and

// move on to the next one.

      close(sockfd);

      perror("server: bind");

continue;

    }

// If we've made it this far, we have a valid socket and can stop iterating

// through.

break;

  }

// If we haven't gotten a valid sockaddr here, that means we can't connect.

if (p == NULL) {

fprintf(stderr, "server: failed to bind\n");

exit(2);

  }

// Otherwise, we're good.

return sockfd;

}

int main(void) {

int sockfd = get_and_bind_socket();

// We want to listen forever on this socket

if (listen(sockfd, /*backlog=*/1) == -1) {

    perror("listen");

exit(1);

  }

printf("Server waiting for connections.\n");

struct sockaddr their_addr;  // Address information of the client

socklen_t sin_size;

int new_fd;

while(1) {

    sin_size = sizeof their_addr;

    new_fd = accept(sockfd, (struct sockaddr *)&their_addr, &sin_size);

if (new_fd == -1) {

      perror("accept");

continue;

    }

// Once we've accepted an incoming request, we can read from it into a buffer.

int buffer;

int bytes_received = recv(new_fd, &buffer, sizeof buffer, 0);

if (bytes_received == -1) {

      perror("recv");

continue;

    }

// We need to unpack the received data.

int number = unpack(buffer);

printf("Received a request: is %d prime?\n", number);

// Now, we can finally call the is_prime library!

bool number_is_prime = is_prime(number);

printf("Sending response: %s\n", number_is_prime ? "true" : "false");

// Note that we don't have to pack a single byte.

// We can now send it back.

if (send(new_fd, &number_is_prime, sizeof number_is_prime, 0) == -1) {

      perror("send");

    }

    close(new_fd);

  }

}

最后，我们更新一下我们的主函数，使用新的RPC库调用：

// client/basic_math_program_distributed.c

#include <stdio.h>

#include <stdbool.h>

#include "is_prime_rpc_client.h"

int main(void) {

// Prompt the user to enter a number.

printf("Please enter a number: ");

// Read the user's number. Assume they're entering a valid number.

int input_number;

scanf("%d", &input_number);

// Check if it's prime, but now via the RPC library

if (is_prime_rpc(input_number)) {

printf("%d is prime\n", input_number);

  } else {

printf("%d is not prime\n", input_number);

  }

return 0;

}

这个 RPC 实际的运行情况如下：

现在运行服务器，就可以运行客户端将质数检查的工作分布到其他计算机上运行！现在，程序调用 is_prime_rpc 时，所有网络业务都在后台进行。我们已经成功分发了计算，客户端实际上是在远程调用程序。

示例有待改进的方面

本文中的实现只是一个示例，虽然实现了一些功能，但只是一个玩具。真正的框架（例如 gRPC3）要复杂得多。我们的实现需要改进的方面包括：

• 可发现性：在上述示例中，我们我们假定服务器在 localhost 上运行。RPC 库怎么知道将 RPC 发送到哪里呢？我们需要通过某种方式来发现可以处理此 RPC 调用的服务器在哪里。




• RPC 的类型：我们的的服务器非常简单，只需处理一个 RPC 调用。如果我们希望服务器提供两个不同的RPC服务，比如 is_prime 和get_factors，那么该怎么办？我们需要一种方法来区分发送到服务器的两种请求。




• 打包：打包整数很容易，打包一个字节更容易。如果我们需要发送一个复杂的数据结构，该怎么办？如果我们需要为了节省带宽而压缩数据，又该怎么办？




• 自动生成代码：我们肯定不希望每次编写新的 RPC，都需要手动编写所有的打包和网络处理代码。理想情况下，我们只需定义一个接口，然后其余的接口都由计算机自动完成，并自动提供 stub。这里，我们需要考虑协议缓冲区等。




• 多种语言：按照上面的思路，如果我们能够自动生成 stub，那么就可以考虑支持多种语言，如此一来，跨服务和跨语言的通信也只需调用一个函数。




• 错误和超时处理：如果 RPC 失败怎么办？如果网络出现故障，服务器停止运行，wifi 掉线，该怎么办？我们需要考虑超时处理。




• 版本控制：假设上述所有功能已全部实现，但你想修改某个正在多台计算机上运行的 RPC，那么该怎么办？




• 其他有关服务器的注意事项：线程、阻塞、多路复用、安全性、加密、授权等等。

计算机科学就是要站在巨人的肩膀上，很多库已经为我们完成了大量工作。

原文链接：https://alexanderell.is/posts/rpc-from-scratch/

声明：本文由CSDN翻译，转载请注明来源。

作者 | 黄国峰       责编 | 欧阳姝黎

摘要

本文介绍了两种常用的代码分支模式：特性分支开发模式、主干开发模式，分别阐述了其优缺点和适用环境；同时剖析了 Google 和腾讯采用主干开发模式的背景和决策因素，捎带分享了这2个巨头的实践，供读者在技术选型中参考。

背景

按之前的写作思路，本文应该叫《Google 工程效能三板斧之三：主干开发》，但我改变了主意，希望能同时提供国内互联网公司的实践，供读者参考，因此文章标题也随之更改。

软件开发过程中，开发人员通过版本管理工具对源码进行存储，追踪目录和文件的修改历史。为了区隔不同状态的源代码，会采用分支进行管理。不同的软件开发模式，对应着不同的分支模式。

软件业界常用的软件分支模式有多种，但本质上可以分为两类：

• 主干开发模式（Trunk Based Development）




• 特性分支开发模式（Feature Branch Development）

两种模式的定义及优缺点分析

特性分支开发模式

特性分支开发模式是指为一个或多个特定的需求/缺陷/任务创建代码分支（branch），在其上完成相应的开发（一般经过增量测试）后，把它合并（merge）到主干/集成分支的开发模式。

通常这种分支生命期会持续一段时间，从几天到几周不等，极少数情况甚至以月算。

特性分支开发模式中常用的有 Git-Flow 模式、Github-Flow 模式和 Gitlab-Flow 模式等。这些模式只有细节上的差异，以 Git-Flow为例：

优点：

• 特性开发周期宽松：因为生命期可以较长，较大的需求特性可以在宽松的时间内完成再合入主干；




• 分支测试的时间宽松：因为生命期可以较长，可以有较多时间对分支进行测试，甚至手工测试；

缺点：

• 分支管理复杂：原因在于大量采用代码分支，且来源分支和合入目标分支各异，操作复杂 —— 以上图为例，可以从master（Tag 1.0.0） 拉出 hotfix 1.0.2 分支，然后合入到 develop 分支，开发阶段结束后合入到 release branches，发布后合入 master，非常复杂，很容易出错；




• 合并冲突多、解决难：分支生命期越长，意味着与主干的代码差异越大，冲突概率越高，冲突的解决难度越大（甚至成为不可能）；




• 迭代速度慢：特性分支生命期长（数天至数周）意味着特性上线速度慢，相应的迭代速度也慢；




• 需要较多测试环境：每个特性分支都需要分配至少1个测试环境，且长期占用（有状态）；

适用环境：

• 对版本迭代速度要求不高




• 测试自动化程度低，或说主要靠人工测试的

主干开发模式

主干开发，是指开发人员直接向主干（习惯上主干分支通常为：trunk 或 master）提交/推送代码。通常，开发团队的成员1天至少1次地将代码提交到主干分支。在到达发布条件时，从主干拉出发布分支（通常为 release），用于发布。若发现缺陷，直接在主干上修复，并根据需要 cherry pick 到对应版本的发布分支。

流程：

优点：

• 分支模型简单高效，开发人员易于掌握不容易出现错误操作




• 避免了分支合并、冲突解决的困扰




• 随时拥有可发布的版本




• 有利于持续集成和持续交付

缺点：

• 基础架构要求高：合入到主干的代码若质量不过关将直接阻塞整个团队的开发工作，因此需要高效的持续集成平台进行把关；




• 自动化测试要求高：需有完备单元测试代码，确保在代码合入主干前能在获得快速和可靠的质量反馈；




• 最好有代码评审：若代码质量要求高，需要配套代码评审（CR）机制，在代码提交到主干时，触发CR，通过 Peer Review 后才能正式合入；




• 最好有特性开关：主干开发频发合入主干的情况下，特性拆分得很小，可能是半成品特性，需要配套特性开关（Feature Toggle），只有当特性整体开发完才通过灰度发布等手段逐步打开；

适用环境：

• 对迭代速度要求高，希望需求快速交付上线




• 基础架构强，持续集成工具高效；




• 团队成员习惯TDD（测试驱动开发），代码自动化测试覆盖率高（至少增量代码的自动化测试覆盖率高）；

为什么 Google 和腾讯采用主干开发模式

互联网巨头 Google 大部分业务开发都采用主干开发模式，国内巨头腾讯也在推行主干开发（试点业务团队大部分已经采用）。

他们采用主干开发的原因在于对主干开发的优点有强烈诉求，而且有能力和资源弥补其缺点：

• 都是互联网企业，竞争激烈，因此对迭代速度要求高；




• 基础架构能力强：都能自研强大的持续集成平台，Google 有自研的 Forge，腾讯有自研的蓝盾；




• 自动化测试能力强：都推行TDD，强调开发负责质量，减少甚至取消手工测试人员（少量必要的手工测试转外包），自动化测试覆盖率高；




• 都有严格的CR机制确保代码质量：Google 极其严苛的可读性认证（Readability）在业界已经是标杆，腾讯是国内少有正在采用类似实践的互联网企业。严格的代码可读性认证和根据此标准执行的严格代码评审制度，能有效的保证合入主干的代码质量不会降低。

主干开发的最大优点是：效率和质量，而这2者是软件和互联网企业的核心诉求。主干开发的缺点，巨头有能力和资源来填平这些坑。

因此，从ROI（Ratio of Investment）的角度来看，Google 和腾讯采用主干开发实属必然。

美中两巨头的实践

Google 在主干开发的实践

我们在之前的文章提到，Google 的工程效能（也叫研发效能）核心理念只有简单的3条：

1. 使用单体代码仓库（参考：Google 工程效能三板斧之一：单体代码仓库）




2. 使用 Bazel 构建（参考：Google 工程效能三板斧之二：使用 Bazel 构建）




3. 主干开发；

其中的第3条，就是本文所述内容。

为了保证主干代码的质量，避免出现工程师合入到主干的代码 break 掉主干的情况，Google 采取了以下实践：

• 代码合入事件触发通过持续集成，确保合入到主干的代码经过充分且必要测试；




• 通过 Bazel 实现相关代码（指依赖变更代码的代码）的精准测试；




• 至少 2 个合资格的 reviewer （代码评审人）的 LGTM（Look Good To Me），才允许代码合入主干；




• 合资格的 reviewer 都是在 Google 内部通过 Readability （代码可读性）认证的员工；

腾讯在主干开发的实践

腾讯某 BG 在2018年开始的“930变革”后，在各试点团队推动主干开发（注：并未全公司普遍采用），具体的举措包括：

1. 以度量牵引：通过对特性分支）的生命期监控和预警，实现非主干分支的生命期缩短，倒逼开发团队采用主干开发；




2. 投大力气统一 BG 内的持续集成工具、开发自动化测试平台；




3. 制定了 7 大编程语言的编码规范，并自研代码静态扫描工具；




4. 并参考 Google 推行代码可读性（Readability）、可测试性（Testability）认证制度；




5. 强力推行 CR （代码评审）制度，确保代码的可读性（命名、代码风格、设计、复杂度）。

效果：

• 质量提升：代码质量从可测量的维度得到明显提升（代码规范率、单元测试覆盖率）；




• 迭代速度提升：试点团队的迭代周期从4周或2周提升至1周；




• 代码从“私有”变“公有”：通过代码评审制度，提高了代码可读性，使代码从个人拥有（只有写代码的人能看懂），变成团队拥有（整个团队都能看懂）；这一点对于企业非常重要，接手过别人代码的程序们都有感受；




• 代码的自动化测试覆盖率提升明显，为未来的重构构筑了一张安全网；

中小企业能参考什么？

中小企业应该选择特性分支开发模式，还是主干开发模式？根据上文，相信大家已经足以自行判断。

有些中小企业的技术决策者非常认可持续集成/持续交付的理念，从而更希望采用主干开发，但对于主干开发的缺点（或说弥补缺点的成本）存在顾虑。

对此，我有如下建议：

• 基础架构要求：可以考虑采用开源软件，如持续集成采用 Jenkins、Travis CI、Gitlab CI等，通过简单部署可以投入使用；同时配合代码静态分析工具（如 SonarQube、CheckStyle），确保代码基本质量过关；




• 自动化测试要求：工具上不存在障碍，现代编程语言（如java、go、c++）都有内建或第三方的单元测试框架；难点只在于成员的开发习惯，可以通过测试覆盖率工具，以增量覆盖率指标保证新增代码都有完备的自动化测试，从而逐步改变团队的研发文化；




• 代码评审要求：开源的Git服务器（如 Gitlab）基本都支持 push hook，配合开源的 Gerrit 等CR工具，可以实现在代码推送（push）或 pull request（合入请求）时触发1个代码评审请求，实现评审通过后，代码才正式合入的功能；剩下的就是研发文化问题了，需要在团队内部推行代码规范、代码可读性等宣导和教育工作；




• 发布时的特性开关：如果要求不高，可以通过代码 hard code 一个常量作为特性开关；如果要求高，也有开源的特性开关（比如：unleash、piranha、flipper）工具可供选择。

参考上述建议，并充分认识到主干开发的成本和困难的情况下，中小企业开发团队也并非不可以考虑主干开发的实践。