DRY原则:Don't Repeat Yourself (摘自wikipedia


OOA和OOD的作用及其区别 http://blog.sina.com.cn/s/blog_72ed42d401015y5c.html


站在为程序员提供第3方服务SDK的高度来写代码


1.抽象方法和非抽象方法

如果在类中定义了抽象方法,就是强制非抽象子类去实现。这样写的好处就是可以提醒子类需要复

写哪些方法,但是抽象方法不易过多,不需要强制实现的方法不要抽象化。


如果在类中定义了非抽象方法,可以给一个默认的实现,子类可以选择不复写,采用父类默认的实

现,也可以复写自定义实现。

应用场景:

  抽取了一个带ListView的BaseListFragment,后来又有需求,需要一个带头的ListView的

Fragment,那么,就没有必要再写一个类继承BaseListFragement了,况且继承了ListView的初始化已经

完成了,没法再加一个头。

  所以直接在BaseListFragment里定义一个方法返回头视图,默认将方法返回值至为null,在listView

初始化的时候,将方法返回值添加到listview的头部,不为空就添加到头部。


2.关于抽象的方法在哪儿被调的问题

  既然抽了方法,肯定在父类里的某个地方要让其执行。  

  如果父类有自己的生命周期方法,会自动执行一些方法,在这些方法里可以抽出方法。

  如果父类没有自己的生命周期方法,那么调用抽取的方法的父类方法要记得手动去调用。


3.关于怎么抽取的问题

  情景1:抽象适配器,适配器的的抽象方法调用适配器所在父类的方法,父类的这个方法再抽象让

      子类去实现。如我的开源中国带indicator的框架就是这么抽取的。

      这种方式就是实现了方法的抽象和转移,将内部的抽象转移成父类的抽象


4.关于电脑模型

  其实编程和现实是息息相关的,如电脑和各个零部件就是抽取的具体体现,各个零部件相互配合,但

  是又没有焊死在一起,这就是降低了耦合度。


  程序的框架包括界面框架、网络加载框架,框架在抽取的时候应该降低它们之间的依赖性。


    


如果要写出资深的重构代码,必需要“精通”以下的知识:

   0.封装

      封装就是一个类A调用另外的一个类C时,不会直接调用,间接调用B,再用B去调用C。

      比如在程序里通过要开启很多个对象,如service,广播等。如果直接开启会造成很大的耦合。

      实例:模块加载器

      1)定义加载器接口:

            

public interface IDxTestInstanceLoader extends IAreaModuleLifeMethods{
    void load();
    void unload();
    void attach(Context context);
}

     2)实现加载器接口,创建实例。

       比如实现load接口,可以开启服务,也可以开启广播,也可以开启线程。

     



      3)定义加载器管理者

 

DxTestInstanceManager  IAreaModuleLifeMethods{
    Context List = ArrayList<>(Arrays.(IDxTestInstanceLoader[]{
            TrafficStatTestInstanceLoader()ShareScreenLoader()
    }))DxTestInstanceManager = DxTestInstanceManager()(){}


    DxTestInstanceManager (){
        }

    (IDxTestInstanceLoader dxTestInstanceLoader){
        .add(dxTestInstanceLoader)}

    (){
        (IDxTestInstanceLoader item : ){
            item.attach()item.load()}
    }

    (){
        (IDxTestInstanceLoader item : ){
            item.unload()}
    }

    TrafficStatTestInstanceLoader (){
        (.size() > ){
            (TrafficStatTestInstanceLoader) .get()}
        }

    (Context context) {
        .= context}

    () {
        IDxTestInstanceLoader iDxTestInstanceLoader = .get()(iDxTestInstanceLoader != ){
            iDxTestInstanceLoader.onResetSettingFiles()}
    }

    () {
        IDxTestInstanceLoader iDxTestInstanceLoader = .get()(iDxTestInstanceLoader != ){
            iDxTestInstanceLoader.onDeviceServiceDestroyed()}
    }

    () {
        IDxTestInstanceLoader iDxTestInstanceLoader = .get()(iDxTestInstanceLoader != ){
            iDxTestInstanceLoader.onDeviceUpdateStepPassed()}
    }
}

  


  1.接口

    情景1:对几个列表按时间字段进行排序,但是几个列表的实体类之间没有任何的继承关系,得到

       时间的方法也不一样,所以对于每一个列表都要定义一个比较器。

       关于重构的一些思想_第1张图片

       我在想,同样比较的是时间,为什么要定义3个比较器呢?

        于是,我定义了一个接口:

       

    public interface     DateInterface {
         String getDate();
    }

        让每个列表的实体类都去实现这个接口:

      

public class BidRecordSQL extends Entity implements DateInterface{
    //...
    @Override
    public String getDate() {
       return investTime;
    }
}
public class BaseDepositsHistoryDomain extends Entity implements DateInterface{
    //...
    @Override
    public String getDate() {
       return investTime;
    }
}

       然后定义一个时间比较器:

    

/**
 * 时间比较器-降序排序
 * Created by Zhang on 2016/2/15.
 */
public class DescendingDateComparator implements Comparator {
    @Override
    public int compare(DateInterface lhs, DateInterface rhs) {
        return -1 * lhs.getDate().compareTo(rhs.getDate());
    }
}

      然后,使用Collections工具类对List进行排序:

    关于重构的一些思想_第2张图片   

  使用接口,本质的作用是让原本看似不相干的实体类之间产生了关系。也就是定义相同的行为,getDate, 然后比较器针对接口编程,而不是某个具体的类。

  

  情景2:ViewPager装了多个Fragment,只想在viewpager滑动到哪一页,就更新哪一页的数据。

     一般人的做法就是在每个Fragment定义一个加载数据的方法,然后在onPageChange方法里根据

     position得到对应的Fragment,然后调用fragment的对应方法。

      如果让每一个Fragment实现一个懒加载数据的接口,那么在onPageChange就不需要根据posit       ion去if-else了,直接将fragment强转成接口,调用接口的方法即可。


  定义接口,方便明确业务,而且如果更换方法名,所有实现了接口的类都会自动更换,避免了手动更换的麻烦。

 


  2.反射

  情景1:字段过滤器

  

public interface IPropertyFilter {
      boolean apply(Object object, String name, Object value);
}


public interface IGetFieldMap {
    Map getFieldMap();           //所有字段名,拼出map。
    Map getFieldMap(String ...fieldNames);              //根据字段名,拼出map。
    Map getFieldMapExcept(String ...exceptFieldNames);   //除了指定的几个字段名,拼出map。
    Map getFieldMap(List fieldNames);           //根据字段名,拼出map。
    Map getFieldMap(IPropertyFilter propertyFilter);    //根据过滤器,拼出map。
}
public class BaseRequestBean implements IGetFieldMap {
    @Override
    public Map getFieldMap() {
        return getFieldMap(new IPropertyFilter() {
            @Override
            public boolean apply(Object object, String name, Object value) {
                return true;
            }
        });
    }

    @Override
    public Map getFieldMap(String... fieldNames) {
        return getFieldMap(Arrays.asList(fieldNames));
    }

    @Override
    public Map getFieldMapExcept(final String... exceptFieldNames) {
        return getFieldMap(new IPropertyFilter() {
            @Override
            public boolean apply(Object object, String name, Object value) {
                for (String item : exceptFieldNames){
                    if(name.equals(item)){
                        return false;
                    }
                }
                return true;
            }
        });
    }

    @Override
    public Map getFieldMap(List fieldNames) {
        Map result = new HashMap();
        Class mClass = getClass();
        Field[] declaredFields = mClass.getDeclaredFields();
        for (Field field : declaredFields) {
            String fieldName = field.getName();
            if (!field.isAccessible()) {
                field.setAccessible(true);
            }
            try {
                Object fieldValue = field.get(this);
                if (fieldValue == null) continue;
                if (!fieldNames.conta×××(fieldName)) continue;

                result.put(fieldName, fieldValue);
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
        return result;
    }

    @Override
    public Map getFieldMap(IPropertyFilter propertyFilter) {
        Map result = new HashMap();
        Class mClass = getClass();
        Field[] declaredFields = mClass.getDeclaredFields();
        for (Field field : declaredFields) {
            String fieldName = field.getName();
            if (!field.isAccessible()) {
                field.setAccessible(true);
            }
            try {
                Object fieldValue = field.get(this);
                if (!propertyFilter.apply(this, fieldName, fieldValue))  continue;

                result.put(fieldName, fieldValue);
            } catch (IllegalAccessException e) {
                e.printStackTrace();
            }
        }
        return result;
    }

}

 

  情景2:打印Build类里所有的字段

  https://blog.csdn.net/xiaoxian8023/article/details/24109185

  

  情景3:引用hide类并调用其方法

  https://blog.csdn.net/pshiping2014/article/details/79549680

  

  linux工程师说将一个key存储到build里了,但是查看Build类发现可以通过SystemProperties这个类来获取,但是这个类是hide类,所以只能用反射去拿。

 


  3.注解

  4.泛型

   Java泛型详解

   http://blog.csdn.net/jinuxwu/article/details/6771121

   

   获取泛型的Class 

   http://www.cnblogs.com/onlysun/p/4539472.html

 

 4-5.枚举(优化代码可读性)

   http://blog.csdn.net/lmj623565791/article/details/79278864

 


  5.自定义

   自定义View或者类有多种形式:

   1)完全自定义(复写onDraw 、onLayout)

   2)组合自定义

   3)包裹自定义(在自定义属性绑定需要操作的子View的id,在onFinishInflate方法里find处理相关的逻辑,Google的很多框架级的原生组件用的就是这个)

    如DrawerLayout,抽屉控件等。

   4)工具类中封装view,利用已有的view实现统一的业务接口。

   5)复写Android自定义的类(要求研究源码,然后才能随心所欲的复写哈。)

    实际场景1:使用ArrayAdapter这个类填充Spinner,如果ArrayAdapter的泛型是一个对象的话,最终Spinner显示的是对象的哈希值。而我真正想展示在

          Spinner上的只是ArrayAdapter泛型的某个字段而已。

    最笨的解决方法就是遍历List,得到想要展示的字符串集合List,再将List设置给适配器。但是这样一来的话,在spinner里点击事件

    里往往又会用到List,这样就容易造成混乱。

    


    于是研究了一下ArrayAdapter这个类的源码,看看它的view是如何生成的。

      public View getView(int position, View convertView, ViewGroup parent) {
    return createViewFromResource(mInflater, position, convertView, parent, mResource);
}

private View createViewFromResource(LayoutInflater inflater, int position, View convertView,
        ViewGroup parent, int resource) {
    View view;
    TextView text;

    if (convertView == null) {
        view = inflater.inflate(resource, parent, false);
    } else {
        view = convertView;
    }

    try {
        if (mFieldId == 0) {
            //  If no custom field is assigned, assume the whole resource is a TextView
            text = (TextView) view;
        } else {
            //  Otherwise, find the TextView field within the layout
            text = (TextView) view.findViewById(mFieldId);
        }
    } catch (ClassCastException e) {
        Log.e("ArrayAdapter", "You must supply a resource ID for a TextView");
        throw new IllegalStateException(
                "ArrayAdapter requires the resource ID to be a TextView", e);
    }

    T item = getItem(position);
    if (item ×××tanceof CharSequence) {
        text.setText((CharSequence)item);
    } else {
        text.setText(item.toString());
    }

    return view;
}

   通过源码发现,如果ArrayAdapter的泛型是字符串,那么spinner展示的是字符串;如果ArrayAdapter的泛型是一个对象的话,返回的是这个对象的toString方法的返回值。

   解决方案1:复写ArrayAdapter的getView的相关方法。

      此解决方案的核心是将ArrayAdapter展示Spinner内容部分的具体代码抽象化成方法,从而使ArrayAdapter亦抽象化。

     但是此方式有一个弊端:每有一个泛型类,就得新建一个对应的Adapter类,太浪费资源。 

/**
 * Created by 陈章 on 2017/12/19.
 * 适配器
 */
public abstract  class CZArrayAdapter extends ArrayAdapter{
    public CZArrayAdapter(Context context,  List objects) {
        super(context, android.R.layout.simple_spinner_item, objects);
    }
    
    @NonNull
    @Override
    public View getView(int position, View convertView, ViewGroup parent) {
        return createViewFromResource(LayoutInflater.from(getContext()), position, convertView, parent);
    }

    @Override
    public View getDropDownView(int position, View convertView, ViewGroup parent) {
        return createViewFromResource(LayoutInflater.from(getContext()), position, convertView, parent);
    }

    protected abstract String getText(T t);

    private View createViewFromResource(LayoutInflater inflater, int position, View convertView,
                                        ViewGroup parent) {
        T item = (T) getItem(position);
        View view;
        TextView text;

        if (convertView == null) {
            view = inflater.inflate(android.R.layout.simple_spinner_item, parent, false);
        } else {
            view = convertView;
        }
        text = (TextView) view;
        text.setText(getText(item));
        return view;
    }

}

  

 解决方案2:复写ArrayAdapter的getView的泛型类的toString方法

      复写泛型类的toString方法,返回想在spinner上展示的字段。如果泛型类的toString方法没有在其它地方有特殊的引用,这种解决方法是最快最简单的。 


  

  6.其它,肯定有,尚未总结。  

     

怎么解耦的问题:

      不解耦的弊端,比如我之前将有关android源码的探索全部全部放到一篇文章里,后来博客系统出现了点问题。差点导致那篇博客损毁。所以不解耦很明显有2个缺点:

        1)一损俱损:一个地方出现问题,会导致另外一个地方也出现问题。

        2)查阅不方便:将所有的内容写到一篇博客,就像将所有的代码写在一个类中。这样这个类看起来就比较麻烦。



  1.解耦

    1)View的解耦:一般如详情页面、带有Banner图的页面,里面的View可能会有很多。可以将

     大的View细分为小的View。

     

public abstract class BasePart {
   /**
    * 获取当前模块的View对象
    * @return
    */
   public abstract View getView();
   
   /**
    * 处理逻辑和数据
    * @param t
    */
   public abstract void setData(T t);

   /**
    * startActivity with bundle
    *
    * @param clazz
    * @param bundle
    */
   protected void readyGo(Class clazz, Bundle bundle) {
      Intent intent = new Intent(CommonHelper.context(), clazz);
      intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);    //Calling startActivity() from outside of an Activity  context requires the FLAG_ACTIVITY_NEW_TASK flag.
      if (null != bundle) {
         intent.putExtras(bundle);
      }
      CommonHelper.context().startActivity(intent);
   }
}

  只要在activity里initview()的时候,new PartView(),将子View添加到Activity的ContainerView中

 ,请求到数据之后再partView.setData();


  但是PartView是一个很简单的类,如果需要Activity的参数(如调用Activity的方法等),可以在构造函数里传入Activity.



对于别人重构的框架,应该如何去用的问题:

  1.抽象类,肯定是要实现它示实现的方法。写逻辑就是对抽象方法的具体实现。


将一些公共的libs和基类放在依赖库中

  1)出现的问题:将工程的layout下的布局文件写到依赖库里,那么相关的资源color、style看着是

    明明定义了,但就是can't resolve.

  

AndroidStudio里所有项目的公共Library库,不要单独复制,要共有,防止以后要修改。

https://blog.csdn.net/codezjx/article/details/49531887


注意:如果ModuleA依赖了ModuleB,ModuleB有依赖了ModuleC,那么ModuleA的gradle里也要依赖moduleC,否则会报的ModuleB里找不到ModuleC的错误。

        上层的Module如果依赖了下层的Module,上层的module要依赖下层所依赖的所有module。!!!

        

        如果工程有多个module,一定要从子module找起,单独打开某个module集合目录 ,排除依赖没有写的情况 。!!!!!!!!!!!


module里不能有application结点,所以module里的service、receiver这些结点也只能挪到app里定义。


aar的引用

      https://blog.csdn.net/u013440413/article/details/78685192   (app里使用aar)

 

      https://blog.csdn.net/lin_dianwei/article/details/79532078      (module里使用aar)


      注意build.gradle里使用implecation compile api依赖的区别

AndroidStudio 多层级 Module 对 aar 引用问题

        https://www.cnblogs.com/bellkosmos/p/6146349.html



关于多重依赖清单文件重复的问题:

        https://www.cnblogs.com/bluestorm/p/6692789.html


关于依赖多个module,可能有一个致命的问题。各个module及app的compileSdk的版本不一致,可能会导致以下问题:

        Error:Execution failed for task ':app:transformDexArchiveWithExternalLibsDexMergerForDebug'.

        > java.lang.RuntimeException: java.lang.RuntimeException: com.android.builder.dexing.DexArchiveMergerException: Unable to merge dex

        上面这个错误并非是jar包重复,可能是各个module及app的compileSdk的版本不一致导致的。


多层module依赖,打jar包的问题。

       1)moduleA依赖moduleB,moduleC依赖moduleA,如果将moduleA,moduleB打成jar包,给moduleC引用,回报重复类的错误:multidex class。。。

api (project(':moduleA')) {
    //解决重复依赖问题
    exclude module: 'moduleB'
}

            这样即可解决问题。

        接着,如果将moduleC再生成一个jar包,moduleC.jar。引用moduleC.jar,类调用正常,但是一运行就会报错:

Caused by: java.lang.ClassNotFoundException: Didn't find class "com.cz.basetool.ui_work.thread.ThreadManager" on path: DexPathList[[zip file "/data/app/com.example.jl.jiangxihfscj-2/base.apk"],nativeLibraryDirectories=[/vendor/lib, /system/lib]]
                                                                                 at dalvik.system.BaseDexClassLoader.findClass(BaseDexClassLoader.java:56)
                                                                                 at java.lang.ClassLoader.loadClass(ClassLoader.java:511)
                                                                                 at java.lang.ClassLoader.loadClass(ClassLoader.java:469)
                                                                                 at com.juli.basescjmodule.libs.hardware_libary.a.initSystemConfig(SystemUtil.java:45)?
                                                                                 at com.juli.basescjmodule.libs.hardware_libary.a.a(SystemUtil.java:39)?
                                                                                 at com.juli.basescjmodule.libs.base_tool.hardware_service.obu.action.system.SystemActionController.init(SystemActionController.java:38)?
                                                                                 at com.juli.basescjmodule.libs.base_tool.hardware_service.obu.action.system.SystemActionController.init(SystemActionController.java:32)?
                                                                                 at com.juli.basescjmodule.libs.basesdk.JLBaseActionContoller.initSDK(JLBaseActionContoller.java:83)?
                                                                                 at com.example.jiangxisdklibrary.JLScjContoller.initSDK(JLScjContoller.java:30)?
                                                                                 at com.example.jl.jiangxihfscj.ProApplication.onCreate(ProApplication.java:24)?
                                                                                 at android.app.Instrumentation.callApplicationOnCreate(Instrumentation.java:1012)?
                                                                                 at android.app.ActivityThread.handleBindApplication(ActivityThread.java:4553)?
                                                                                 at android.app.ActivityThread.access$1500(ActivityThread.java:151)?
                                                                                 at android.app.ActivityThread$H.handleMessage(ActivityThread.java:1364)?
                                                                                 at android.os.Handler.dispatchMessage(Handler.java:102)?
                                                                                 at android.os.Looper.loop(Looper.java:135)?
                                                                                 at android.app.ActivityThread.main(ActivityThread.java:5254)?
                                                                                 at java.lang.reflect.Method.invoke(Native Method)?
                                                                                 at java.lang.reflect.Method.invoke(Method.java:372)?
                                                                                 at com.android.internal.os.ZygoteInit$MethodAndArgsCaller.run(ZygoteInit.java:902)?
                                                                                 at com.android.internal.os.ZygoteInit.main(ZygoteInit.java:697)?
                                                                             	Suppressed: java.lang.ClassNotFoundException: com.cz.basetool.ui_work.thread.ThreadManager
                                                                                 at java.lang.Class.classForName(Native Method)
                                                                                 at java.lang.BootClassLoader.findClass(ClassLoader.java:781)
                                                                                 at java.lang.BootClassLoader.loadClass(ClassLoader.java:841)
                                                                                 at java.lang.ClassLoader.loadClass(ClassLoader.java:504)
                                                                                 		... 19 more
                                                                              Caused by: java.lang.NoClassDefFoundError: Class not found using the boot class loader; no stack available

         而且在moduleC.jar也找不到这个类,准确的说是找不到moduleA和moduleB的类。

        》》如果moduleC中有UI,将moduleC打成jar包,还会报UI相关找不到的错误。

        


                        

        解决办法:https://www.jianshu.com/p/8f9cf6271c20

                        https://www.cnblogs.com/Jason-Jan/p/9192273.html


                1.fat-aar.gradle:要打哪个module的jar包,就放到哪个module下面。

                2.github上的这个库,有个前提就是gradle插件必须是2.3.3,所以我把

                    gradle要加上buildToolsVersion

                    gradle要将implecation换成compile   

                    

                    工程的gradle插件变为2.3.3

classpath 'com.android.tools.build:gradle:2.3.3'

                    properties的版本可以不用改,如果改成2.3.3还会报错:

                    https://www.jianshu.com/p/6a0bc5792860

                默认aar的生成位置:

                       

                默认也会生成jar文件,但是引用后发现里面只有R文件:

                

                那么,既然aar都能打出来,是不是改改fat-aar就能搞个fat-jar打个jar呢???????????????????????

                还有一种方法:https://blog.csdn.net/anymyna/article/details/82054020  (将aar转成jar)

                3.怎么混淆:https://www.jianshu.com/p/aa3e78a7a095      (关于混淆的配置,只需要在最上层的merge模块中配置即可

                4.release的aar不出来咋办:

                     执行cleanBuildCache然后执行assembleRelease   

                    

            

将module与主程序解耦

    在module写了一些功能,但是功能需要主程序去辅助完成。这样就矛盾了,module又不能去依赖主程序,怎么调用主程序的东西呢?

    解决办法 1

        在module里定义一个抽象类,module能实现的功能全部实现,实现不了定义成抽象方法,将主程序完成某功能需要的参数回调出去。再在主程序里注入实现:

        主程序要干的事情:

       

IDeviceAction {
    (openOutputDataSender outputDataSender)(openOutputDataSender outputDataSender)(openOutputDataSender outputDataSender)(highVolumeOutputDataSender outputDataSender)(volumeValueOutputDataSender outputDataSender)(OutputDataSender outputDataSender)}

        

         moudle里半实现的抽象类:

BlueToothActionReceiver BroadcastReceiver IDeviceAction{
    String = String = String = (Context contextIntent intent) {
        (intent != && intent.getAction().equals()){
            option = intent.getIntExtra(-)String state = intent.getStringExtra()(option){
                DeviceActionOption.:
                    setGPS(state.equals() ? : OutputDataSender.())DeviceActionOption.:
                    setRecord(state.equals() ? : OutputDataSender.())DeviceActionOption.:
                    setSta(state.equals() ? : OutputDataSender.())DeviceActionOption.:
                    (state.substring()){
                        :      setVolume(OutputDataSender.()):      setVolume(OutputDataSender.()):      String valume = state.substring()value = CodeTool.(valume)setVolume(valueOutputDataSender.())}

                    DeviceActionOption.:
                    getDeviceStatus(OutputDataSender.())}
        }
    }
}


            在module里发广播,这样主程序就能完成未完成的功能。





重构的实例场景

  1)一个网络请求接口(传一个paperid得到试卷的题目)要在程序的多处调用,之前离职的程序员写

   的代码也没有封装:

   

/**
 * 从网络获取ListView的数据
 */
private void getListData(String p_id) {
    if (!NetWorkStatusUtil.isNetworkAvailable(context)) {
        ToastUtil.showShort(context, "请先链接网络");
        return;
    }
    LoadingDialog.showProgress(this, "题目正在加载中,请稍等...", true);
    String url = HttpConfig.QUESTION;
    RequestParams params = new RequestParams();
    // params.addBodyParameter("token", MD5Encoder.getMD5());
    KLog.e("试卷页面p_id:" + p_id);
    params.addQueryStringParameter("token", MD5Encoder.getMD5());
    params.addQueryStringParameter("p_id", p_id);
    //p_id=2是单选;
    //http://app.haopeixun.org/index.php?g=apps&m=paper&a=getExams&token=75c824f486b5fa5b60330697bdb03842&p_id=8
    //
    HttpUtils httpUtils = new HttpUtils();
    httpUtils.send(HttpMethod.GET, url, params, new RequestCallBack() {

        @Override
        public void onSuccess(ResponseInfo responseInfo) {
            jsonString = responseInfo.result;
            Log.i(TAG, "考题答案: ");
            KLog.json(jsonString);
            if (!TextUtils.isEmpty(jsonString)) {
                JSONObject jsonObject;
                try {
                    jsonObject = new JSONObject(jsonString);
                    int resultCode = Integer.parseInt(jsonObject.getString("result"));
                    KLog.e("结果码:" + resultCode);
                    switch (resultCode) {
                        case 0:
                            if (jsonString.isEmpty()) {
                                showEmptyView();
                                return;
                            }
                            parserData(jsonString);
                            break;
                        default:
                            showEmptyView();
                    }
                } catch (JSONException e) {
                    showEmptyView();
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                } finally {
                    LoadingDialog.dismissProgressDialog();
                }
            }
        }

        @Override
        public void onFailure(HttpException arg0, String arg1) {
            KLog.e(arg1);
            LoadingDialog.dismissProgressDialog();
            ToastUtil.showLong(context, "请求考题失败");
        }
    });
}


private void parserData(String jsonString) {
    // ***********给user赋值******************
    qustionItems.clear();

    try {
        JSONObject jsonObject = new JSONObject(jsonString);
        JSONArray dataArray = jsonObject.getJSONArray("data");
        totalScore = dataArray.length();
        Log.i(TAG, "总共题目数量:" + totalScore);
        for (int i = 0; i < dataArray.length(); i++) {
            QuestionBean questionBean = new QuestionBean();
            JSONObject jsonObject2 = dataArray.getJSONObject(i);
            questionBean.addtime = jsonObject2.getString("addtime");
            questionBean.e_analyze = jsonObject2.getString("e_analyze");
            questionBean.e_answer_count = jsonObject2.getString("e_answer_count");
            // *********
            JSONObject jsonObject3 = jsonObject2.getJSONObject("e_answer");// 题选项对象
            questionBean.eanswer = questionBean.new Eanswer();
            questionBean.eanswer.setA(jsonObject3.getString("A"));
            questionBean.eanswer.setB(jsonObject3.getString("B"));
            String answerC = jsonObject3.optString("C");
            if (answerC != null && !TextUtils.isEmpty(answerC)) {
                questionBean.eanswer.setC(answerC);
            }

            String answerD = jsonObject3.optString("D");
            if (answerD != null && !TextUtils.isEmpty(answerD)) {
                questionBean.eanswer.setD(answerD);
            }

            switch (Integer.parseInt(questionBean.e_answer_count)) {
                case 5:
                    questionBean.eanswer.setE(jsonObject3.getString("E"));
                    break;
                case 6:
                    questionBean.eanswer.setE(jsonObject3.getString("E"));
                    questionBean.eanswer.setF(jsonObject3.getString("F"));
                    break;
                case 7:
                    questionBean.eanswer.setE(jsonObject3.getString("E"));
                    questionBean.eanswer.setF(jsonObject3.getString("F"));
                    questionBean.eanswer.setG(jsonObject3.getString("G"));
                    break;
            }
            // **********

            questionBean.e_classid = jsonObject2.getString("e_classid");
            questionBean.e_exam_type = jsonObject2.getString("e_exam_type");
            questionBean.e_fenzhi = jsonObject2.getString("e_fenzhi");
            questionBean.e_good = jsonObject2.getString("e_good");
            questionBean.e_id = jsonObject2.getString("e_id");
            questionBean.e_probability = jsonObject2.getString("e_probability");
            questionBean.e_result = jsonObject2.getString("e_result");
            questionBean.e_status = jsonObject2.getString("e_status");
            questionBean.e_title = jsonObject2.getString("e_title");
            questionBean.e_typeid = jsonObject2.getString("e_typeid");
            questionBean.examid = jsonObject2.getString("examid");
            questionBean.id = jsonObject2.getString("id");
            questionBean.paperid = jsonObject2.getString("paperid");
            qustionItems.add(questionBean);
            StringBuilder sb = new StringBuilder();
            //sb.append("");
            uAnswerList.add(sb);
        }
    } catch (JSONException e) {
        e.printStackTrace();
    } finally {
        LoadingDialog.dismissProgressDialog();
    }
    showDataView();
    KLog.e("集合大小" + qustionItems.size());
    if (qustionItems.size() > 0) {
        tv_total_questions.setText("1 / 共" + qustionItems.size() + "道题");
    }
    questionPagerAdapter.set(qustionItems, uAnswerList);
    uAnswerStateAdapter.set(getAnswerCard());
}

   同样的接口,我觉得没有必要再往新的activity复制一遍,于是我将这个接口单独封装成一个类

  PaperListRequester中

        在构造PaperListRequester这个类的时候,我将Context和接口需要的参数pid传递进去。定义了

一个监听器ParseListener,监听内部数据解析的结果。通过一个方法getData,并传递一个监听器返回结果。

   这是调用PaperListRequester这个类请求接口的代码:

 关于重构的一些思想_第3张图片   将请求、解析接口的逻辑封装在PaperListRequester这个类中,一下代码就看得顺眼了。这也是Google及一些开源库常用的工具类封装手法。

   2)工程中有个ActivityA,作用是取一个数据,但是这个取数据的过程,与activity里的handler相关联。代码量也比较多。这时候有个ActivityB,需要和

     ActivityA重复一样的工作,但是ActivityB本身类里逻辑比较复杂,如果直接把ActivityA里的代码粘贴过来,会严重影响这个类的结构。所以这里    

    就需要新建一个类C.java,用来封装ActivityA的逻辑,通过接口返回数据。在ActivityB里调用C,只管请求和取数据,中间的过程交由C.java去实现。

    实现解耦。

   

6.避免过多使用if-else

    如果一个项目中,一个变量因素会影响多个地方的行为或者动作,可以将这此动作定义成接口。然后根据变量定义不同的实例实现接口。

    实战1:比如我的项目里,不同的设备串口号、其它的一些信息不一样

   1-1:抽取接口

**
 * Created by XinYi on 2018/8/7.
 * 获取设备的一些信息,因设备硬件版本不同而不同,需要兼容。
 * 1.移远(28)
 * 2.旗文(06B)
 */

public interface IDeviceContent {
    /**
     * 升麦串口号
     * @return
     */
    String getSmSerialFileName();

    /**
     * OBD串口号
     * @return
     */
    String getObdSerialFileName();

    /**
     * SD卡挂载,扫描的根目录是否正确。
     * @see  SMCardManager.CardChecker#initFilter()
     * @param fileName
     * @return
     */
    boolean isSmScardPath(String fileName);


}

 1-2:根据不同的平台,实现接口,创建不同的实例:

    平台1:

/**
 * Created by XinYi on 2018/8/7.
 * 旗文(06B) 平台
 */

public class QWDeviceContent implements IDeviceContent {
    @Override
    public String getSmSerialFileName() {
        return "/dev/ttyMT2";
    }

    @Override
    public String getObdSerialFileName() {
        return "/dev/ttyM×××";
    }

    @Override
    public boolean isSmScardPath(String fileName) {
        return fileName.conta×××("usbotg");
    }
}

  平台2:

/**
 * Created by XinYi on 2018/8/7.
 * 移远(28)平台
 */

public class YYDeviceContent implements IDeviceContent {
    @Override
    public String getSmSerialFileName() {
        return "/dev/ttyHSL0";
    }

    @Override
    public String getObdSerialFileName() {
        return "/dev/ttyHSL1";
    }

    @Override
    public boolean isSmScardPath(String fileName) {
        return (fileName.conta×××(Constants.SM_SDCARD_QW_PATH) && fileName.length() == 9);
    }
}

  1-3:指定一个实际使用的实例

private void fillDataFromBuilder(Builder builder) {
    this.deviceType = builder.deviceType;
    this.areaId = builder.areaId;
    if(deviceType == DeviceType.TYPE_28){
        deviceContent = new YYDeviceContent();
    }else if(deviceType == DeviceType.TYPE_06B){
        deviceContent = new QWDeviceContent();
    }
}

 这样就避免了每一个方法返回的值都需要根据平台用if-else判断一下,一旦增加一个平台,只需要创建一个平台的实例即可。



避免多个异步接口多层嵌套回调

        实际场景:下面这此设置项,每一项都有一个单独的接口,都是异步回调。这样如果有10多层异步嵌套,将会造成代码阅读性非常差。

        

        于是我想到了“封装”

        #1.定义单项设置器的基类

/**
 * Created by XinYi on 2018/12/20.
 * 单个参数设置基类
 */

public abstract class BaseSingleRecordParamHandler {
    protected String TAG = this.getClass().getSimpleName();

    protected RecordParamsHandleController recordParamsSetController;
    protected   String param;

    /**
     * 设置参数
     */
    abstract void handleSetParam();


    /**
     * 获取参数
     */
    abstract void handleGetParam();

    protected YiYunController.YiYunActionCallBack getYiYunActionCallBack(){
        return new YiYunController.YiYunActionCallBack() {
            @Override
            public void onSuccess(Object obj) {
                BaseSingleRecordParamHandler.this.onSetParamSuccess();
            }

            @Override
            public void onFailure(Exception e) {
                BaseSingleRecordParamHandler.this.onSetParamFailure(e);
            }
        };
    }


    protected BaseSingleRecordParamHandler getNextSingleRecordParamHandler(){
        return recordParamsSetController.getNextSingleRecordParamHandler();
    }

    public void attachRecordParamsSetController(RecordParamsHandleController recordParamsSetController) {
        this.recordParamsSetController = recordParamsSetController;
    }

    public BaseSingleRecordParamHandler setParam(String param) {
        this.param = param;
        return this;
    }

    protected void onSetParamSuccess(){
        BaseSingleRecordParamHandler nextSingleRecordParamSetter = recordParamsSetController.getNextSingleRecordParamHandler();
        if(nextSingleRecordParamSetter != null){
            nextSingleRecordParamSetter.handleSetParam();
        }else{
            recordParamsSetController.getParamsSetResultCallBack().onSuccess();
        }
    }

    protected void onSetParamFailure(Exception e){
        recordParamsSetController.getParamsSetResultCallBack().onFailure(e);
    }


    protected void onGetParamSuccess(){
        BaseSingleRecordParamHandler nextSingleRecordParamSetter = recordParamsSetController.getNextSingleRecordParamHandler();
        if(nextSingleRecordParamSetter != null){
            nextSingleRecordParamSetter.handleSetParam();
        }else{
            recordParamsSetController.getParamsGetResultCallBack().onSuccess(recordParamsSetController.getCollectedParams());
        }
    }

    protected void onGetParamFailure(Exception e){
        recordParamsSetController.getParamsGetResultCallBack().onFailure(e);
    }


}

     #2.定义设置控制器

          控制器的好处:

          1)通过调整设置器的add顺序,可以轻松调整单项设置的先后顺序。(想想如果用的是多层嵌套,那将是一场灾难。)

          2)避免了多层嵌套回调

          3)隔离了用户与设置器

        

/**
 * Created by XinYi on 2018/12/20.
 * 记录仪参数设置控制器
 */
public class RecordParamsHandleController {
    private static final String TAG = "RecordParamsHandleContr";
    private int nextSetterIndex = 0;                       //标记当前处理者的索引
    private List singleRecordParamSetterList = new ArrayList<>();
    private static final RecordParamsHandleController ourInstance = new RecordParamsHandleController();
    private ParamsSetResultCallBack paramsSetResultCallBack;
    private ParamsGetResultCallBack paramsGetResultCallBack;
    private String collectedParams = "";


    public static RecordParamsHandleController getInstance() {
        return ourInstance;
    }

    private RecordParamsHandleController() {

    }


    /**
     *
     * @param param   0:参数获取或者设置标志      1:正式参数
     */
    public void init(String param[]){
        nextSetterIndex = 0;
        collectedParams = "";
        //注意下面的add是有顺序的
        singleRecordParamSetterList.clear();
        singleRecordParamSetterList.add(RecordResolutionParamHandler.getInstance(this));
        singleRecordParamSetterList.add(RecordMicParamHandler.getInstance(this));
        singleRecordParamSetterList.add(RecordLoopParamHandler.getInstance(this));
        singleRecordParamSetterList.add(RecordGsensorParamHandler.getInstance(this));
        singleRecordParamSetterList.add(AMapParamHandler.getInstance(this));
        singleRecordParamSetterList.add(ScreenIntensityParamHandler.getInstance(this));
        singleRecordParamSetterList.add(RecordDurationParamHandler.getInstance(this));
        singleRecordParamSetterList.add(ScreenSleepParamHandler.getInstance(this));
        singleRecordParamSetterList.add(ResetTFCardParamHandler.getInstance(this));
        singleRecordParamSetterList.add(ResetSystemParamHandler.getInstance(this));
        singleRecordParamSetterList.add(RecordOsdParamHandler.getInstance(this));

        LogController.d(TAG, "init: len = " + param.length);
        //设置参数
        if(param.length > 1){
            for (int i = 2; i < param.length; i++) {
                LogController.d(TAG, "init: i = " + i);
                singleRecordParamSetterList.get(i-2).setParam(param[i]);
            }
        }
    }

    /**
     * 开始设置参数
     * @param paramsSetResultCallBack
     */
    public void startSetParams(ParamsSetResultCallBack paramsSetResultCallBack){
        this.paramsSetResultCallBack = paramsSetResultCallBack;
        singleRecordParamSetterList.get(0).handleSetParam();
    }


    /**
     * 开始获取参数
     * @param paramsGetResultCallBack
     */
    public void startGetParams(ParamsGetResultCallBack paramsGetResultCallBack){
        this.paramsGetResultCallBack = paramsGetResultCallBack;
        singleRecordParamSetterList.get(0).handleGetParam();
    }

    protected BaseSingleRecordParamHandler getNextSingleRecordParamHandler(){
        nextSetterIndex++;
        if(nextSetterIndex + 1 >singleRecordParamSetterList.size()){
            return null;
        }
        return singleRecordParamSetterList.get(nextSetterIndex);
    }

    public interface  ParamsSetResultCallBack{
        void onSuccess();
        void onFailure(Exception e);
    }

    public interface  ParamsGetResultCallBack{
        void onSuccess(String param);
        void onFailure(Exception e);
    }


    public ParamsSetResultCallBack getParamsSetResultCallBack() {
        return paramsSetResultCallBack;
    }

    public ParamsGetResultCallBack getParamsGetResultCallBack() {
        return paramsGetResultCallBack;
    }

    public void collectParams(String param){
        collectedParams += param;
    }

    public String getCollectedParams() {
        return collectedParams;
    }
}