动态代理实现mvp

关注

原创最新推荐文章于 2026-03-31 03:45:39 发布 408 阅读 AI 写同款· GEO 优化 ›

冒险岛脚本函数大全：cm.sendYesNo和cm.warp的20个实战用法本文深入解析了冒险岛脚本中cm.sendYesNo和cm.warp两个核心函数的20个实战应用场景。从基础的确认对话框交互、条件判断，到复杂的装备强化系统、动态传送与副本入口逻辑，文章通过大量代码示例展示了如何组合运用这两个函数，实现从简单NPC到复杂任务系统的进阶脚本开发，并分享了状态管理、错误处理与性能优化等最佳实践。阅读详情

就不说啥是mvp了，也不说啥是静态代理动态代理了，直接撸代码吧~

一、创造轮子

1.定义View父类接口

public interface BaseView
{
}

2.定义父类Presenter，持有V的引用

public class BasePresenter<V extends BaseView>
{
    private static final String TAG = "BasePresenter";
    private V baseView;

    public void onBindView(V view)
    {
        this.baseView = view;
    }

    public void onUnbindView()
    {
        this.baseView = null;
    }

    public void onDestroyPersenter()
    {
        Log.e(TAG, "-------> onDestroyPersenter");
    }

    public void onSaveInstanceState(Bundle outState)
    {
        Log.e(TAG, "-------> onSaveInstanceState");
    }

    public V getView()
    {
        return baseView;
    }
}

3.定义允许子类继承父类的注解

@Inherited
@Retention(RetentionPolicy.RUNTIME)
public @interface CreatePresenter
{
    Class<? extends BasePresenter> value();
}

4.创建操作Presenter接口

public interface IPresenterFactory<V extends BaseView, P extends BasePresenter<V>>
{
    /**
     * 创建Presenter
     */
    P createPresenter();
}

5.对接口IPresenterFactory的实现

public class PresenterFactory<V extends BaseView, P extends BasePresenter<V>> implements IPresenterFactory<V, P>
{
    /**
     * 需要创建的Presenter的类型
     */
    private final Class<P> mPresenterClass;

    public PresenterFactory(Class<P> presenterclass)
    {
        this.mPresenterClass = presenterclass;
    }

    public static <V extends BaseView, P extends BasePresenter<V>> PresenterFactory<V, P> createFactory(Class<?> viewClazz)
    {
        CreatePresenter annotation = viewClazz.getAnnotation(CreatePresenter.class);
        Class<P> aClass = null;
        if (null != annotation)
        {
            aClass = (Class<P>) annotation.value();
        }
        return aClass == null ? null : new PresenterFactory<V, P>(aClass);
    }

    @Override
    public P createPresenter()
    {
        try
        {
            return mPresenterClass.newInstance();
        }
        catch (Exception e)
        {
            throw new RuntimeException("Presenter create failed!");
        }
    }
}

6.创建代理Presenter接口，持有对IPresenterFactory的引用

public interface IPresenterProxy<V extends BaseView, P extends BasePresenter<V>>
{
    /**
     * 设置创建Presenter的工厂
     */
    void setPresenterFactory(IPresenterFactory<V, P> presenterFactory);

    /**
     * 获取Presenter的工厂类
     */
    IPresenterFactory<V, P> getPresenterFactory();

    /**
     * 获取创建的Presenter
     */
    P getPresenter();
}

7.对接口IPresenterProxy的实现

public class PresenterProxy<V extends BaseView, P extends BasePresenter<V>> implements IPresenterProxy<V, P>
{
    /**
     * 获取onSaveInstanceState中bundle的key
     */
    private static final String PRESENTER_KEY = "presenter_key";

    /**
     * Presenter工厂类
     */
    private IPresenterFactory<V, P> mFactory;
    private P mPresenter;
    private Bundle mBundle;
    private boolean mIsBindView;

    public PresenterProxy(IPresenterFactory<V, P> mFactory)
    {
        this.mFactory = mFactory;
    }

    /**
     * 设置Presenter的工厂类,这个方法只能在创建Presenter之前调用,也就是调用getPresenter()之前，如果Presenter已经创建则不能再修改
     * @param presenterfactory IWanPresenterFactory类型
     */
    @Override
    public void setPresenterFactory(IPresenterFactory<V, P> presenterfactory)
    {
        if (null != mPresenter)
        {
            throw new IllegalArgumentException("setPresenterFactory() can only be called before getPresenter() be called");
        }
        this.mFactory = presenterfactory;
    }

    /**
     * 获取Presenter工厂类
     * @return
     */
    @Override
    public IPresenterFactory<V, P> getPresenterFactory()
    {
        return mFactory;
    }

    @Override
    public P getPresenter()
    {
        if (null != mFactory)
        {
            if (null == mPresenter)
            {
                mPresenter = mFactory.createPresenter();
            }
        }
        return mPresenter;
    }

    /**
     * 绑定Presenter和view
     * @param mvpView
     */
    public void onCreate(V mvpView)
    {
        getPresenter();
        if (null != mPresenter && !mIsBindView && null != mvpView)
        {
            mPresenter.onBindView(mvpView);
            mIsBindView = true;
        }
    }

    /**
     * 销毁Presenter持有的View
     */
    private void onUnbindView()
    {
        if (null != mPresenter && mIsBindView)
        {
            mPresenter.onUnbindView();
            mIsBindView = false;
        }
    }

    /**
     * 销毁Presenter
     */
    public void onDestroy()
    {
        if (null != mPresenter)
        {
            onUnbindView();
            mPresenter.onDestroyPersenter();
            mPresenter = null;
        }
    }

    /**
     * 意外销毁的时候调用
     * @return Bundle，存入回调给Presenter的Bundle和当前Presenter的id
     */
    public Bundle onSaveInstanceState()
    {
        Bundle bundle = new Bundle();
        getPresenter();
        if (null != mPresenter)
        {
            Bundle presenterBundle = new Bundle();
            // 回调Presenter
            mPresenter.onSaveInstanceState(presenterBundle);
            bundle.putBundle(PRESENTER_KEY, presenterBundle);
        }
        return bundle;
    }

    /**
     * 意外关闭恢复Presenter
     * @param savedInstanceState 意外关闭时存储的Bundler
     */
    public void onRestoreInstanceState(Bundle savedInstanceState)
    {
        mBundle = savedInstanceState;
    }
}

8.创建BaseMvpActivity

public abstract class BaseMvpActivity<V extends BaseView, P extends BasePresenter<V>> extends RxAppCompatActivity implements IPresenterProxy<V, P>
{
    private static final String PRESENTER_SAVE_KEY = "presenter_save_key";

    /**
     * 创建被代理对象，传入默认Presenter的工厂
     */
    private PresenterProxy<V, P> mProxy = new PresenterProxy<>(PresenterFactory.<V, P>createFactory(getClass()));
    protected Activity activity;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        if (0 != getContentId())
        {
            setContentView(getContentId());
        }
        activity = this;
        if (null != savedInstanceState)
        {
            mProxy.onRestoreInstanceState(savedInstanceState.getBundle(PRESENTER_SAVE_KEY));
        }
        mProxy.onCreate((V) this);
        initView();
        initData(savedInstanceState);
    }

    @Override
    public void setPresenterFactory(IPresenterFactory<V, P> presenterfactory)
    {
        mProxy.setPresenterFactory(presenterfactory);
    }

    @Override
    public IPresenterFactory<V, P> getPresenterFactory()
    {
        return mProxy.getPresenterFactory();
    }

    @Override
    public P getPresenter()
    {
        return mProxy.getPresenter();
    }

    /**
     * 获取Layout布局
     *
     * @return
     */
    public abstract int getContentId();

    /**
     * 初始化布局资源
     */
    public abstract void initView();

    /**
     * 初始化数据
     *
     * @param savedInstanceState
     */
    public abstract void initData(Bundle savedInstanceState);

    /**
     * @param outState
     */
    @Override
    protected void onSaveInstanceState(Bundle outState)
    {
        super.onSaveInstanceState(outState);
        outState.putBundle(PRESENTER_SAVE_KEY, mProxy.onSaveInstanceState());
    }

    @Override
    protected void onDestroy()
    {
        super.onDestroy();
        mProxy.onDestroy();
    }
}

9.创建BaseMvpFragment

public abstract class BaseMvpFragment<V extends BaseView, P extends BasePresenter<V>> extends RxFragment implements IPresenterProxy<V, P>
{
    private static final String TAG = "BaseMvpFragment";
    private static final String PRESENTER_SAVE_KEY_FRAGMENT = "presenter_save_key_fragment";
    /**
     * 创建被代理对象,传入默认Presenter的工厂
     */
    private PresenterProxy<V, P> mProxy = new PresenterProxy<>(PresenterFactory.<V, P>createFactory(getClass()));
    private View view;
    /**
     * Fragment的View加载完毕的标记
     */
    private boolean isViewCreated;
    /**
     * Fragment对用户可见的标记
     */
    private boolean isDataLoaded;

    @android.support.annotation.Nullable
    @Override
    public View onCreateView(@NonNull LayoutInflater inflater, @android.support.annotation.Nullable ViewGroup container, @android.support.annotation.Nullable Bundle savedInstanceState)
    {
        view = inflater.inflate(getViewLayoutId(), container, false);
        mProxy.onCreate((V) this);
        initView(view);
        Log.e(TAG, "-------> onCreateView");
        return view;
    }

    @Override
    public void onActivityCreated(@android.support.annotation.Nullable Bundle savedInstanceState)
    {
        super.onActivityCreated(savedInstanceState);
        isViewCreated = true;
        prepareRequestData();
    }

    @Override
    public void setUserVisibleHint(boolean isVisibleToUser)
    {
        super.setUserVisibleHint(isVisibleToUser);
        prepareRequestData();
        Log.e(TAG, "----@---> setUserVisibleHint");
    }

    public boolean prepareRequestData()
    {
        return prepareRequestData(false);
    }

    public boolean prepareRequestData(boolean forceUpdate)
    {
        if (getUserVisibleHint() && isViewCreated && (!isDataLoaded || forceUpdate))
        {
            initData();
            isDataLoaded = true;
            return true;
        }
        return false;
    }

    /**
     * 布局
     * @return
     */
    public abstract int getViewLayoutId();

    /**
     * 初始化布局资源
     * @return
     */
    public abstract void initView(View view);

    /**
     * 初始化数据
     * @return
     */
    public abstract void initData();

    @Override
    public void onResume()
    {
        super.onResume();
    }

    @Override
    public void onAttach(Context context)
    {
        super.onAttach(context);
    }

    @Override
    public void onDestroy()
    {
        super.onDestroy();
        mProxy.onDestroy();
        Log.e(TAG, "-------> onDestroy");
    }

    @Override
    public void onDestroyView()
    {
        super.onDestroyView();
        Log.e(TAG, "-------> onDestroyView");
    }

    @Override
    public void onSaveInstanceState(Bundle outState)
    {
        super.onSaveInstanceState(outState);
        outState.putBundle(PRESENTER_SAVE_KEY_FRAGMENT, mProxy.onSaveInstanceState());
    }

    @Override
    public void setPresenterFactory(IPresenterFactory<V, P> presenterfactory)
    {
        mProxy.setPresenterFactory(presenterfactory);
    }

    @Override
    public IPresenterFactory<V, P> getPresenterFactory()
    {
        return mProxy.getPresenterFactory();
    }

    @Override
    public P getPresenter()
    {
        return mProxy.getPresenter();
    }
}

二、使用轮子

1.创建登录View

public interface LoginView extends BaseView
{
    // 获取用户名
    String getUserName();
    // 获取用户密码
    String getPasswd();

    // 登录成功时的回调
    void loginSuccess();
    // 登录失败时的回调
    void loginFailed(String errCode, String errMsg);
}

2.创建登录Presenter

public class LoginPresenter extends BasePresenter<LoginView>
{
    /**
     * 登录
     */
    public void login()
    {
        // 获取用户名和密码
        String userName = getView().getUserName();
        String passwd = getView().getPasswd();

        // 进行网络请求...

        // 网络请求登录失败时：
        // 网络请求登录失败的errCode及errMsg
        String errCode = "-5001";
        String errMsg = "用户名密码错误!";
        getView().loginFailed(errCode, errMsg);

        // 网络请求登录成功时：
        getView().loginSuccess();
    }
}

3.创建登录Activity页面

@CreatePresenter(LoginPresenter.class)
public class LoginActivity extends BaseMvpActivity<LoginView, LoginPresenter> implements LoginView
{
    private EditText user_name;
    private EditText user_password;
    private Button btn_login;

    @Override
    public int getContentId()
    {
        return R.layout.activity_login_layout;
    }

    @Override
    public void initView()
    {
        user_name = this.findViewById(R.id.user_name);
        user_password = this.findViewById(R.id.user_password);
        btn_login = this.findViewById(R.id.btn_login);
    }

    @Override
    public void initData(Bundle savedInstanceState)
    {
        btn_login.setOnClickListener(new View.OnClickListener()
        {
            @Override
            public void onClick(View v)
            {
                if (TextUtils.isEmpty(getUserName()))
                {
                    ToastUtil.showToast("用户名不能为空！");
                    return;
                }
                if (TextUtils.isEmpty(getPasswd()))
                {
                    ToastUtil.showToast("密码不能为空！");
                    return;
                }
                ARouter.getInstance().build(ARouterUtil.MAINACTIVITY).navigation();
                finish();
            }
        });
    }

    @Override
    public String getUserName()
    {
        return user_name.getText().toString().trim();
    }

    @Override
    public String getPasswd()
    {
        return user_password.getText().toString().trim();
    }

    @Override
    public void loginSuccess()
    {
        // 执行页面跳转
    }

    @Override
    public void loginFailed(String errCode, String errMsg)
    {
        // 打印errCode和errMsg
    }
}