本控件源自于网络，然后稍微做了些优化和改动。自定义比较强，可以随意更改其参数，字体大小，颜色，高度……总共2个类，后来我改成了3个类。先看下效果图吧

主要类为WheelView.java，这个就是显示滑轮的控件，继承于View，然后在View的基础上绘制。代码也不多，我贴出来。
已更正：因为使用过程中，发现事件不太合理，我又添加了一些自己的事件。

package org.wheel.widget;
import java.util.ArrayList;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import android.annotation.SuppressLint;
import android.content.Context;
import android.content.res.TypedArray;
import android.graphics.Canvas;
import android.graphics.LinearGradient;
import android.graphics.Paint;
import android.graphics.Rect;
import android.graphics.Shader.TileMode;
import android.os.Handler;
import android.util.AttributeSet;
import android.view.MotionEvent;
import android.view.View;
import com.fenjin.app.humiture.R;
/**
 * WheelView滚轮
 */
@SuppressLint("ClickableViewAccessibility")
public class WheelView extends View {
	/**
	 * 控件宽度
	 */
	private float controlWidth;
	/**
	 * 控件高度
	 */
	private float controlHeight;
	/**
	 * 是否滑动中
	 */
	private boolean isScrolling = false;
	/**
	 * 选择的内容
	 */
	private ArrayList itemList = new ArrayList();
	/**
	 * 设置数据
	 */
	private ArrayList dataList = new ArrayList();
	/**
	 * 按下的坐标
	 */
	private int downY;
	/**
	 * 按下的时间
	 */
	private long downTime = 0;
	/**
	 * 短促移动
	 */
	private long goonTime = 50;
	/**
	 * 短促移动距离
	 */
	private int goonDistence = 100;
	/**
	 * 画线画笔
	 */
	private Paint linePaint;
	/**
	 * 底部画线画笔
	 */
	private Paint bottomlinePaint;
	/**
	 * 底部线条和上面分割线的间距
	 */
	float firstLineAndSecondLineSpace = 50;
	/**
	 * 线的默认颜色
	 */
	private int lineColor = 0xffff0000;
	/**
	 * 底线的默认颜色
	 */
	private int bottomLineColor = 0xffDADADA;
	/**
	 * 线的默认宽度
	 */
	private float lineWidth = 2f;
	/**
	 * 默认字体
	 */
	private float normalFont = 10.0f;
	/**
	 * 选中的时候字体
	 */
	private float selectedFont = 16.0f;
	/**
	 * 单元格高度
	 */
	private int unitHeight = 50;
	/**
	 * 显示多少个内容
	 */
	private int itemNumber = 7;
	/**
	 * 默认字体颜色
	 */
	private int normalColor = 0xff000000;
	/**
	 * 选中时候的字体颜色
	 */
	private int selectedColor = 0xffff0000;
	/**
	 * 蒙板高度
	 */
	private float maskHight = 48.0f;
	/**
	 * 选择监听
	 */
	private OnSelectListener onSelectListener;
	/**
	 * 是否可用
	 */
	private boolean isEnable = true;
	/**
	 * 移动距离
	 */
	private static final int MOVE_NUMBER = 5;
	/**
	 * 是否允许选空
	 */
	private boolean noEmpty = true;
	/**
	 * 正在修改数据，避免ConcurrentModificationException异常
	 */
	private boolean isClearing = false;
	private ExecutorService cachedThreadPool;
	private Handler mHandler = new Handler();
	public WheelView(Context context, AttributeSet attrs, int defStyle) {
		super(context, attrs, defStyle);
		init(context, attrs);
		initData();
	}
	public WheelView(Context context, AttributeSet attrs) {
		super(context, attrs);
		init(context, attrs);
		initData();
	}
	public WheelView(Context context) {
		super(context);
		initData();
	}
	@Override
	public boolean onTouchEvent(MotionEvent event) {
		if (!isEnable)
			return true;
		int y = (int) event.getY();
		switch (event.getAction()) {
		case MotionEvent.ACTION_DOWN:
			isScrolling = true;
			downY = (int) event.getY();
			downTime = System.currentTimeMillis();
			break;
		case MotionEvent.ACTION_MOVE:
			actionMove(y - downY);
			onSelectListener();
			break;
		case MotionEvent.ACTION_UP:
			int move = Math.abs(y - downY);
			// 判断段时间移动的距离
			if (System.currentTimeMillis() - downTime < goonTime
					&& move > goonDistence) {
				goonMove(y - downY);
			} else {
				actionUp(y - downY);
			}
			noEmpty();
			isScrolling = false;
			break;
		default:
			break;
		}
		return true;
	}
	@Override
	protected void onDraw(Canvas canvas) {
		super.onDraw(canvas);
		drawLine(canvas);
		drawList(canvas);
		drawMask(canvas);
	}
	private synchronized void drawList(Canvas canvas) {
		if (isClearing)
			return;
		try {
			for (ItemObject itemObject : itemList) {
				itemObject.drawSelf(canvas);
			}
		} catch (Exception e) {
		}
	}
	@Override
	protected void onLayout(boolean changed, int left, int top, int right,
			int bottom) {
		super.onLayout(changed, left, top, right, bottom);
	}
	@Override
	protected void onMeasure(int widthMeasureSpec, int heightMeasureSpec) {
		super.onMeasure(widthMeasureSpec, heightMeasureSpec);
		controlWidth = getWidth();
		if (controlWidth != 0) {
			setMeasuredDimension(getWidth(), itemNumber * unitHeight);
			controlWidth = getWidth();
		}
	}
	/**
	 * 继续移动一定距离
	 */
	private synchronized void goonMove(final int move) {
		cachedThreadPool.execute(new Runnable() {
			@Override
			public void run() {
				int distence = 0;
				while (distence < unitHeight * MOVE_NUMBER) {
					sleep(5);
					actionThreadMove(move > 0 ? distence : distence * (-1));
					distence += 10;
				}
				actionUp(move > 0 ? distence - 10 : distence * (-1) + 10);
				noEmpty();
			}
		});
	}
	/**
	 * 不能为空，必须有选项
	 */
	private void noEmpty() {
		if (!noEmpty)
			return;
		for (ItemObject item : itemList) {
			if (item.isSelected())
				return;
		}
		int move = (int) itemList.get(0).moveToSelected();
		if (move < 0) {
			defaultMove(move);
		} else {
			defaultMove((int) itemList.get(itemList.size() - 1)
					.moveToSelected());
		}
		for (ItemObject item : itemList) {
			if (item.isSelected()) {
				if (onSelectListener != null)
					onSelectListener.endSelect(item.id, item.itemText);
				break;
			}
		}
	}
	/**
	 * 初始化数据
	 */
	private void initData() {
		isClearing = true;
		itemList.clear();
		for (int i = 0; i < dataList.size(); i++) {
			ItemObject itmItemObject = new ItemObject();
			itmItemObject.id = i;
			itmItemObject.itemText = dataList.get(i);
			itmItemObject.x = 0;
			itmItemObject.y = i * unitHeight;
			itemList.add(itmItemObject);
		}
		isClearing = false;
	}
	/**
	 * 移动的时候
	 * 
	 * @param move
	 */
	private void actionMove(int move) {
		for (ItemObject item : itemList) {
			item.move(move);
		}
		invalidate();
	}
	/**
	 * 移动，线程中调用
	 * 
	 * @param move
	 */
	private void actionThreadMove(int move) {
		for (ItemObject item : itemList) {
			item.move(move);
		}
		updateView();
	}
	/**
	 * 松开的时候
	 * 
	 * @param move
	 */
	private void actionUp(int move) {
		int newMove = 0;
		if (move > 0) {
			for (int i = 0; i < itemList.size(); i++) {
				if (itemList.get(i).isSelected()) {
					newMove = (int) itemList.get(i).moveToSelected();
					if (onSelectListener != null)
						onSelectListener.endSelect(itemList.get(i).id,
								itemList.get(i).itemText);
					break;
				}
			}
		} else {
			for (int i = itemList.size() - 1; i >= 0; i--) {
				if (itemList.get(i).isSelected()) {
					newMove = (int) itemList.get(i).moveToSelected();
					if (onSelectListener != null)
						onSelectListener.endSelect(itemList.get(i).id,
								itemList.get(i).itemText);
					break;
				}
			}
		}
		for (ItemObject item : itemList) {
			item.newY(move + 0);
		}
		slowMove(newMove);
		updateView();
	}
	/**
	 * 缓慢移动
	 * 
	 * @param move
	 */
	private void slowMove(final int move) {
		cachedThreadPool.execute(new Runnable() {
			@Override
			public void run() {
				// TODO Auto-generated method stub
				int m = move > 0 ? move : move * (-1);
				int i = move > 0 ? 1 : (-1);
				// 移动速度
				int speed = 1;
				while (true) {
					m = m - speed;
					if (m <= 0) {
						for (ItemObject item : itemList) {
							item.newY(m * i);
						}
						updateView();
						sleep(2);
						break;
					}
					for (ItemObject item : itemList) {
						item.newY(speed * i);
					}
					updateView();
					sleep(2);
				}
			}
		});
	}
	private void sleep(long time) {
		try {
			Thread.sleep(time);
		} catch (InterruptedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
	/**
	 * 移动到默认位置
	 * 
	 * @param move
	 */
	private void defaultMove(int move) {
		for (ItemObject item : itemList) {
			item.newY(move);
		}
		updateView();
	}
	/**
	 * 滑动监听
	 */
	private void onSelectListener() {
		if (onSelectListener == null)
			return;
		for (ItemObject item : itemList) {
			if (item.isSelected()) {
				onSelectListener.selecting(item.id, item.itemText);
			}
		}
	}
	/**
	 * 绘制线条
	 * 
	 * @param canvas
	 */
	private void drawLine(Canvas canvas) {
		if (linePaint == null) {
			linePaint = new Paint();
			linePaint.setColor(bottomLineColor);
			linePaint.setAntiAlias(true);
			linePaint.setStrokeWidth(lineWidth / 2);
		}
		canvas.drawLine(0, controlHeight / 2 - unitHeight / 2 + 2,
				controlWidth, controlHeight / 2 - unitHeight / 2 + 2, linePaint);
		canvas.drawLine(0, controlHeight / 2 + unitHeight / 2 - 2,
				controlWidth, controlHeight / 2 + unitHeight / 2 - 2, linePaint);
		if (bottomlinePaint == null) {
			bottomlinePaint = new Paint();
			bottomlinePaint.setColor(lineColor);
			bottomlinePaint.setAntiAlias(true);
			bottomlinePaint.setStrokeWidth(lineWidth);
		}
		canvas.drawLine(firstLineAndSecondLineSpace, controlHeight / 2
				- unitHeight / 2 + 2, controlWidth
				- firstLineAndSecondLineSpace, controlHeight / 2 - unitHeight
				/ 2 + 2, bottomlinePaint);
		canvas.drawLine(firstLineAndSecondLineSpace, controlHeight / 2
				+ unitHeight / 2 - 2, controlWidth
				- firstLineAndSecondLineSpace, controlHeight / 2 + unitHeight
				/ 2 - 2, bottomlinePaint);
	}
	/**
	 * 绘制遮盖板
	 * 
	 * @param canvas
	 */
	private void drawMask(Canvas canvas) {
		LinearGradient lg = new LinearGradient(0, 0, 0, maskHight, 0x00f2f2f2,
				0x00f2f2f2, TileMode.MIRROR);
		Paint paint = new Paint();
		paint.setShader(lg);
		canvas.drawRect(0, 0, controlWidth, maskHight, paint);
		LinearGradient lg2 = new LinearGradient(0, controlHeight - maskHight,
				0, controlHeight, 0x00f2f2f2, 0x00f2f2f2, TileMode.MIRROR);
		Paint paint2 = new Paint();
		paint2.setShader(lg2);
		canvas.drawRect(0, controlHeight - maskHight, controlWidth,
				controlHeight, paint2);
	}
	/**
	 * 初始化，获取设置的属性
	 * 
	 * @param context
	 * @param attrs
	 */
	private void init(Context context, AttributeSet attrs) {
		cachedThreadPool = Executors.newCachedThreadPool();
		TypedArray attribute = context.obtainStyledAttributes(attrs,
				R.styleable.WheelView);
		unitHeight = (int) attribute.getDimension(
				R.styleable.WheelView_unitHight, unitHeight);
		normalFont = attribute.getDimension(
				R.styleable.WheelView_normalTextSize, normalFont);
		selectedFont = attribute.getDimension(
				R.styleable.WheelView_selectedTextSize, selectedFont);
		itemNumber = attribute.getInt(R.styleable.WheelView_itemNumber,
				itemNumber);
		normalColor = attribute.getColor(R.styleable.WheelView_normalTextColor,
				normalColor);
		selectedColor = attribute.getColor(
				R.styleable.WheelView_selectedTextColor, selectedColor);
		lineColor = attribute.getColor(R.styleable.WheelView_lineColor,
				lineColor);
		bottomLineColor = attribute.getColor(
				R.styleable.WheelView_bottomLineColor, bottomLineColor);
		lineWidth = attribute.getDimension(R.styleable.WheelView_lineHeight,
				lineWidth);
		firstLineAndSecondLineSpace = attribute.getDimension(
				R.styleable.WheelView_firstLineAndSecondLineSpace,
				firstLineAndSecondLineSpace);
		maskHight = attribute.getDimension(R.styleable.WheelView_maskHight,
				maskHight);
		noEmpty = attribute.getBoolean(R.styleable.WheelView_noEmpty, true);
		isEnable = attribute.getBoolean(R.styleable.WheelView_isEnable, true);
		attribute.recycle();
		controlHeight = itemNumber * unitHeight;
	}
	/**
	 * 设置数据 （第一次）
	 * 
	 * @param data
	 */
	public void setData(ArrayList data) {
		this.dataList = data;
		initData();
	}
	/**
	 * 重置数据
	 * 
	 * @param data
	 */
	public void resetData(ArrayList data) {
		setData(data);
		invalidate();
	}
	/**
	 * 获取返回项 id
	 * 
	 * @return
	 */
	public int getSelected() {
		for (ItemObject item : itemList) {
			if (item.isSelected())
				return item.id;
		}
		return -1;
	}
	/**
	 * 获取返回的内容
	 * 
	 * @return
	 */
	public String getSelectedText() {
		for (ItemObject item : itemList) {
			if (item.isSelected())
				return item.itemText;
		}
		return "";
	}
	/**
	 * 是否正在滑动
	 * 
	 * @return
	 */
	public boolean isScrolling() {
		return isScrolling;
	}
	/**
	 * 是否可用
	 * 
	 * @return
	 */
	public boolean isEnable() {
		return isEnable;
	}
	/**
	 * 设置是否可用
	 * 
	 * @param isEnable
	 */
	public void setEnable(boolean isEnable) {
		this.isEnable = isEnable;
	}
	/**
	 * 设置默认选项
	 * 
	 * @param index
	 */
	public void setDefault(int index) {
		if (index > itemList.size() - 1)
			return;
		float move = itemList.get(index).moveToSelected();
		defaultMove((int) move);
	}
	/**
	 * 获取列表大小
	 * 
	 * @return
	 */
	public int getListSize() {
		if (itemList == null)
			return 0;
		return itemList.size();
	}
	/**
	 * 获取某项的内容
	 * 
	 * @param index
	 * @return
	 */
	public String getItemText(int index) {
		if (itemList == null)
			return "";
		return itemList.get(index).itemText;
	}
	/**
	 * 监听
	 * 
	 * @param onSelectListener
	 */
	public void setOnSelectListener(OnSelectListener onSelectListener) {
		this.onSelectListener = onSelectListener;
	}
	private void updateView() {
		mHandler.post(runnable);
	}
	Runnable runnable = new Runnable() {
		@Override
		public void run() {
			// TODO Auto-generated method stub
			invalidate();
		}
	};
	/**
	 * 单条内容
	 */
	private class ItemObject {
		/**
		 * id
		 */
		public int id = 0;
		/**
		 * 内容
		 */
		public String itemText = "";
		/**
		 * x坐标
		 */
		public int x = 0;
		/**
		 * y坐标
		 */
		public int y = 0;
		/**
		 * 移动距离
		 */
		public int move = 0;
		/**
		 * 字体画笔
		 */
		private Paint textPaint;
		/**
		 * 字体范围矩形
		 */
		private Rect textRect;
		public ItemObject() {
			super();
		}
		/**
		 * 绘制自身
		 * 
		 * @param canvas
		 */
		public void drawSelf(Canvas canvas) {
			if (textPaint == null) {
				textPaint = new Paint();
				textPaint.setAntiAlias(true);
			}
			if (textRect == null)
				textRect = new Rect();
			// 判断是否被选择
			if (isSelected()) {
				textPaint.setColor(selectedColor);
				// 获取距离标准位置的距离
				float moveToSelect = moveToSelected();
				moveToSelect = moveToSelect > 0 ? moveToSelect : moveToSelect
						* (-1);
				// 计算当前字体大小
				float textSize = (float) normalFont
						+ ((float) (selectedFont - normalFont) * (1.0f - (float) moveToSelect
								/ (float) unitHeight));
				textPaint.setTextSize(textSize);
			} else {
				textPaint.setColor(normalColor);
				textPaint.setTextSize(normalFont);
			}
			// 返回包围整个字符串的最小的一个Rect区域
			textPaint.getTextBounds(itemText, 0, itemText.length(), textRect);
			// 判断是否可视
			if (!isInView())
				return;
			// 绘制内容
			canvas.drawText(itemText, x + controlWidth / 2 - textRect.width()
					/ 2, y + move + unitHeight / 2 + textRect.height() / 2,
					textPaint);
		}
		/**
		 * 是否在可视界面内
		 * 
		 * @return
		 */
		public boolean isInView() {
			if (y + move > controlHeight
					|| (y + move + unitHeight / 2 + textRect.height() / 2) < 0)
				return false;
			return true;
		}
		/**
		 * 移动距离
		 * 
		 * @param _move
		 */
		public void move(int _move) {
			this.move = _move;
		}
		/**
		 * 设置新的坐标
		 * 
		 * @param _move
		 */
		public void newY(int _move) {
			this.move = 0;
			this.y = y + _move;
		}
		/**
		 * 判断是否在选择区域内
		 * 
		 * @return
		 */
		public boolean isSelected() {
			if ((y + move) >= controlHeight / 2 - unitHeight / 2 + 2
					&& (y + move) <= controlHeight / 2 + unitHeight / 2 - 2)
				return true;
			if ((y + move + unitHeight) >= controlHeight / 2 - unitHeight / 2
					+ 2
					&& (y + move + unitHeight) <= controlHeight / 2
							+ unitHeight / 2 - 2)
				return true;
			if ((y + move) <= controlHeight / 2 - unitHeight / 2 + 2
					&& (y + move + unitHeight) >= controlHeight / 2
							+ unitHeight / 2 - 2)
				return true;
			return false;
		}
		/**
		 * 获取移动到标准位置需要的距离
		 */
		public float moveToSelected() {
			return (controlHeight / 2 - unitHeight / 2) - (y + move);
		}
	}
	/**
	 * 选择监听
	 */
	public interface OnSelectListener {
		/**
		 * 结束选择
		 * 
		 * @param id
		 * @param text
		 */
		public void endSelect(int id, String text);
		/**
		 * 选中的内容
		 * 
		 * @param id
		 * @param text
		 */
		public void selecting(int id, String text);
	}
}

然后就是一个封装好的，现成的时间控件WheelTimePicker.java，这个类似系统内置的，能有效的显示年，月，日，当然了，你也可以直接用上面的wheelview自定义一个时，分，秒的控件 后面还有一些风格，和布局。

package org.wheel.widget;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Locale;
import android.content.Context;
import android.util.AttributeSet;
import android.view.LayoutInflater;
import android.view.View;
import android.widget.LinearLayout;
import com.fenjin.app.humiture.R;
public class WheelTimePicker extends LinearLayout {
	private Context mContext;
	protected static final int UPDATE_WHEEL = 0x112;
	protected static final int UPDATE_UpdateDay_MSG = 0x113;
	private final int START_YEAR = 1970;
	private final int END_YEAR = 2100;
	private WheelView mWheelYear;
	private WheelView mWheelMonth;
	private WheelView mWheelDay;
	protected int mYear;
	protected int mMonth;
	protected int mDay;
	private Calendar mCalendar;
	private int mDefaultDayWhellIndex = 0;
	private WheelHandler mHandler;
	private OnSelectListener onSelectListener;
	private WheelView.OnSelectListener mYearListener = new WheelView.OnSelectListener() {
		@Override
		public void endSelect(int year, String text) {
			mYear = START_YEAR + year;
			if (onSelectListener != null)
				onSelectListener.onSelected(WheelTimePicker.this, mYear,
						mMonth, mDay);
		}
		@Override
		public void selecting(int id, String text) {
		}
	};
	private WheelView.OnSelectListener mMonthListener = new WheelView.OnSelectListener() {
		@Override
		public void endSelect(int month, String text) {
			mMonth = month;
			mHandler.sendEmptyMessage(UPDATE_UpdateDay_MSG);
			if (onSelectListener != null)
				onSelectListener.onSelected(WheelTimePicker.this, mYear,
						mMonth, mDay);
		}
		@Override
		public void selecting(int id, String text) {
		}
	};
	private WheelView.OnSelectListener mDayListener = new WheelView.OnSelectListener() {
		@Override
		public void endSelect(int day, String text) {
			mDay = day + 1;
			if (onSelectListener != null)
				onSelectListener.onSelected(WheelTimePicker.this, mYear,
						mMonth, mDay);
		}
		@Override
		public void selecting(int day, String text) {
		}
	};
	public WheelTimePicker(Context context) {
		this(context, null);
	}
	public WheelTimePicker(Context context, AttributeSet attrs) {
		super(context, attrs);
	}
	@Override
	protected void onFinishInflate() {
		super.onFinishInflate();
		mHandler = new WheelHandler(this);
		mContext = getContext();
		LayoutInflater.from(mContext).inflate(R.layout.time_picker, this);
		mWheelYear = (WheelView) findViewById(R.id.year);
		mWheelMonth = (WheelView) findViewById(R.id.month);
		mWheelDay = (WheelView) findViewById(R.id.day);
		if (mWheelYear != null)
			mWheelYear.setOnSelectListener(mYearListener);
		if (mWheelMonth != null)
			mWheelMonth.setOnSelectListener(mMonthListener);
		if (mWheelDay != null)
			mWheelDay.setOnSelectListener(mDayListener);
	}
	protected void updateDay(int month) {
		Calendar calendar = Calendar.getInstance();
		calendar.set(Calendar.MONTH, month);
		int maxDay = calendar.getActualMaximum(Calendar.DAY_OF_MONTH);
		mWheelDay.resetData(getDayData(maxDay));
		if (mDay > maxDay) {
			mWheelDay.setDefault(mDefaultDayWhellIndex);
			mDay = mDefaultDayWhellIndex + 1;
		} else {
			mWheelDay.setDefault(mDay - 1);
		}
	}
	/**
	 * set date
	 * 
	 * @param date
	 */
	public void setDate(long date) {
		mCalendar = Calendar.getInstance(Locale.CHINA);
		mCalendar.setTimeInMillis(date);
		mYear = mCalendar.get(Calendar.YEAR);
		mMonth = mCalendar.get(Calendar.MONTH);
		mDay = mCalendar.get(Calendar.DAY_OF_MONTH);
		mWheelYear.setData(getYearData());
		mWheelMonth.setData(getMonthData());
		mWheelDay.setData(getDayData(mCalendar
				.getActualMaximum(Calendar.DAY_OF_MONTH)));
		mHandler.sendEmptyMessage(UPDATE_WHEEL);
	}
	protected void updateWheel() {
		mWheelYear.setDefault(mYear - START_YEAR);
		mWheelMonth.setDefault(mMonth);
		mWheelDay.setDefault(mDay - 1);
	}
	private ArrayList getYearData() {
		ArrayList list = new ArrayList();
		for (int i = START_YEAR; i <= END_YEAR; i++) {
			list.add(i + "年");
		}
		return list;
	}
	private ArrayList getMonthData() {
		ArrayList list = new ArrayList();
		for (int i = 1; i <= 12; i++) {
			list.add(i + "月");
		}
		return list;
	}
	private ArrayList getDayData(int endDay) {
		ArrayList list = new ArrayList();
		for (int i = 1; i <= endDay; i++) {
			list.add(i + "日");
		}
		return list;
	}
	public void setOnSelectListener(OnSelectListener onSelectListener) {
		this.onSelectListener = onSelectListener;
	}
	public interface OnSelectListener {
		public void onSelected(View view, int year, int month, int day);
	}
}

下面是属性值

风格

默认的年，月，日布局

最后就是源码工程，我把它当作一个库使用的。下地地址：WheelLibary

本文链接:https://www.it72.com/7749.htm