泡温泉的咸鱼
泡温泉的咸鱼

android 积累一些关于rxjava的知识点


rxjava在我看来就是一套比较先进的asynctask，用来处理异步请求的一种规范（得益于它的代码思路清晰），在android中可以用来代替asynctask甚至是handler。常与当前流行网络请求框架retrofit2一同使用。


rxjava的采用了观察者模式:Observer/Subscriber(观察者),Observable(主题)。个人喜欢把Observer/Subscriber当做事件的消费者，Observable当做是事件的产生者。


优点：线程切换（android 网络请求与UI刷新），逻辑清晰



android-studio 环境配置:


   compile 'io.reactivex:rxjava:1.0.14'
   compile 'io.reactivex:rxandroid:1.0.1'

Observer/Subscriber(观察者)

 Observer  observer=new Observer() {
            @Override
            public void onCompleted() {
                Log.i("rxjava::","onCompleted::");

            }

            @Override
            public void onError(Throwable e) {
                Log.i("rxjava::","onError::"+e.getMessage());

            }

            @Override
            public void onNext(String s) {

                /**
                 * 被观察者“发给” 观察者的消息
                 * 可以理解成 事件在这里消费
                 */

                Log.i("rxjava::","onNext::"+s);

            }
        };

 Subscriber  subscriber=new Subscriber() {
            @Override
            public void onCompleted() {
                Log.i("rxjava::","onCompleted::");

            }

            @Override
            public void onStart() {
                super.onStart();
                Log.i("rxjava::","onStart::");

            }

            @Override
            public void onError(Throwable e) {
                Log.i("rxjava::","onError::"+e.getMessage());

            }

            @Override
            public void onNext(String s) {
                Log.i("rxjava::","onNext::"+s);

            }
        };

观察者两种写法的区别:

1.Subscriber 对 Observer 接口进行了一些扩展,即Subscriber 里可以重写一个onstart的方法

2.onstart方法：在被观察者“发送”消息之前。我也不知道有什么软用，不能加载进度条（因为不在UI线程）


Observable(被观察者)

 Observable observable = Observable.create(new Observable.OnSubscribe() {
            @Override
            public void call(Subscriber subscriber) {
                //事件中心
                subscriber.onNext("hasaki");

                subscriber.onNext("mianduijifengba");


                subscriber.onCompleted();//此句话要是不调用   观察者里的oncompleted方法就不会调用

            }
        });


Subject:也是一种事件的产生与发送者,可替代Observable

PublishSubject.create(new Observable.OnSubscribe() {
            @Override
            public void call(Subscriber subscriber) {
                subscriber.onNext("nihao");
            }
        }).subscribe(new Subscriber() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(String s) {

                Log.i("TTTTT:::",s+"???");
            }
        });












当然被观察者还可以使用固定的方法来“发送数据给观察者”

just(传入要发送的数据序列并用逗号隔开); 
/**
* 此方法默认在执行结束加上onCompleted();
*/
 Observable observable =  Observable.just("hasaki","mianduijifengba");

from(可传入对象数组); 

        String[]  requestArray={"hasaki","mianduijifengba"};
        /**
         * 此方法默认在执行结束加上onCompleted();
         */
        Observable observable = Observable.from(requestArray);

订阅:“被观察者去订阅观察者”：原因是:流式API设计(什么鬼？) 

 //订阅
 observable.subscribe(subscriber);

取消订阅:(对于异步请求结束后,要解除引用关系,避免内存泄漏)
一般订阅之后都会产生一个Subscription对象


        //订阅
        Subscription subscribe = observable.subscribe(subscriber);

        if(subscribe.isUnsubscribed()){
            //判断是否解除订阅
            Log.i("rxjava","没有解除订阅");

            subscribe.unsubscribe();//解除订阅


        }else{
            Log.i("rxjava","解除订阅");
        }

初级进阶(线程控制)

因为被观察者是"事件的产生者"，而观察者是"事件的消费者",通常在网络请求中，被观察者里开启子线程做网络请求，观察者里要在UI线程中跟新UI，主要运用到两个方法： 

 observable.subscribeOn();//设置被观察者里事件产生所处的线程,即：调用call方法所处的线程
        
 observable.observeOn();//观察者，事件消费所处的线程即：onNext
线程分类: 
Schedulers.immediate()//当前线程，即默认
 
    
Schedulers.newThread()//顾名思义，开启新线程
 
    
 
    
Schedulers.io()//相当于cacheThreadPool  维护一个不定数量的线程池，还可重复利用
 
    
 
    
AndroidSchedulers.mainThread()//android 专利，顾名思义，即主线程。
 
    
 
    
example:开启线程读取数据，UI线程跟新数据::
 
    
 
    
 
    
       String[] requestArray = {"hasaki", "面对疾风吧"};

        Observable.from(requestArray)
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Subscriber() {
                    @Override
                    public void onCompleted() {

                    }

                    @Override
                    public void onError(Throwable e) {

                    }

                    @Override
                    public void onNext(String s) {

                        tv.setText(s);

                    }
                });
 
    
中级进阶(变换) 
    
所谓变换，就是将事件序列中的对象或整个序列进行加工处理，转换成不同的事件或事件序列。
 
    
 
    
1.Map（转换类操作符）单个转换
 
    
什么是转成不同的事件?
 
    
 
    
 
    
说白了就是我要把现金存入支付宝，我的事件队列是现金，我最后想要的事件结果是支付宝里有钱，可是现金不能直接存支付宝，得先变换一下
 
    
，即先存银行卡转成电子货币，最后支付宝转账。（转单个事件）
 
    
 
    
/**
         * 假设字符串格式为现金
         * int格式为电子货币
         * func:字符串转int
         */
        Observable.just("100").map(new Func1() {
            @Override
            public Integer call(String s) {
                //先转电子货币
                return Integer.valueOf(s);
            }
        }).subscribe(new Subscriber() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(Integer integer) {

                Log.i("电子货币转支付宝::", integer + "");

            }
        });
 
    
map的功能:即对象的一对一转换,当被观察者事件产生了，先执行map里的方法，再到观察者消费事件(对象的直接变换) 
    


 
    
func1:提供了一个有形参和返回值的call方法（call方法？秀等麻袋，请自行对比一下之前被观察者里产生事件的call方法，先埋一个坑）
 
    


 
    
 
    
2.flatMap(转换类操作符)
 
    
那转不同的事件序列呢?(也就是转一堆)
 
    
example:假设一天马云爸爸闲的蛋疼，他想看看他的支付宝后台，他想知道每个人的名字，以及每个人都绑定了什么样的银行卡。就是循环打印人名和循环
 
    
打印card名,假设类该这么写：Person类里维护了一个name和card数组,card类里维护了cardname和cardmoney
 
    
 
    
 Person[] persons = {new Person("张三", new Card[]{new Card("工商", "100"), new Card("农行", "200")}),
                new Person("亚索", new Card[]{new Card("工商", "300"), new Card("农行", "400")})
        };

        Observable.from(persons).flatMap(new Func1>() {
            @Override
            public Observable call(Person person) {

                Log.i("rxjava::", person.getName());

                return Observable.from(person.getCards());
            }
        }).subscribe(new Subscriber() {
            @Override
            public void onCompleted() {

            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(Card card) {

                Log.i("rxjava::", card.toString());

            }
        });
 
    
flatMap：对象转新的事件序列，注意func1返回值的变换，他返回的是一个被观察者对象,然后又拿着这个对象去
 
    
请求新的序列。
 
    
 
    
 
    
 
    
 
    
这里的应用环境究竟是什么样的呢，假设你要读取列表中的某个key，然后拿着这key读取新的列表
 
    
会用到吧？我也没用过啊，我是边看别人的博客，写下自己的理解。
 
    
 
    
 
    
我的理解:将一堆事件序列转成一个Observerble再统一发出去
 
    
 
    
flatMap的交叉问题:假设现有一个数组person[3]{校长，老师，学生},经过flatMap要求得到每个人身上的钱，
 
    
也许取的第一个对象是校长，第二个是老师，也许取的第一个对象是校长，第二个对象是学生。也就是说只
 
    
保证铺平序列，不能保证发送序列的顺序。
 
    
问题：我写的例子里，都是正常发送的顺序未发现错乱，也许是数据源基数太小。
 
    
3.contatMap(转换类操作符) 
 
    

      作用类似于flatMap但不会产生交叉问题，也就是正常按发送顺序发送 
    
 
    
 
     
 
    
 
    
 
     
User[]  users=new User[]{new User("张三","22"),new User("李四","23"),new User("老王","24")};

        Observable.from(users).concatMap(new Func1>() {
            @Override
            public Observable call(User user) {
                return Observable.just(user.getFirstName());
            }
        }).subscribe(new Action1() {
            @Override
            public void call(String s) {
                Log.i("YYYYTTT::",s);
            }
        });
 
     
 
    
 
    

      4.scan(转换类操作符) 
    
 
    
 
     
 
    
 
    
 
     
Observable.just(1, 2, 3, 4, 5)
                .scan(new Func2() {
                    @Override
                    public Integer call(Integer integer, Integer integer2) {
                        Log.i("YYYYTTT????", integer+"/"+integer2);
                        return integer + integer2;
                    }
                }).subscribe(new Action1() {
            @Override
            public void call(Integer integer) {
                Log.i("YYYYTTT::", integer+"");
            }
        });
 
     
 
      
 
     
打印结果:: 
     
 
     android 积累一些关于rxjava的知识点_第1张图片 
     
 
    
 
    

      先直接返回第一个结果，然后此结果作为下一个结果的第一个条件参数。 
    
 
    
 
     对一个序列的数据应用一个函数，并将这个函数的结果发射出去作为下个数据应用合格函数时的第一个参数使用。 
     
 
    
 
    
5.filter(过滤操作符)
 
    
 
     
 List  users=new ArrayList();
        users.add(new User("张三", "22"));
        users.add(new User("李四", "24"));
        users.add(new User("老王", "25"));
        users.add(new User("大锤", "22"));
        users.add(new User("大锤", "25"));

        Observable.from(users).filter(new Func1() {
            @Override
            public Boolean call(User user) {
                if (user.getFirstName().equals("张三")){
                    return false;//过滤掉
                }else{
                    return true;//留着
                }
            }
        }).subscribe(new Action1() {
            @Override
            public void call(User user) {
                Log.i("GGGDDD::",user.toString());
            }
        });
 
     
 
      
     
 
    
 
    
 
     
 
    
 
    

      6.take(过滤操作符) 
    
 
    
 
     
 
    
 
    

      //找出数据序列前三个数据 
    
 
    
 
     
        List  users=new ArrayList();
        users.add(new User("张三", "22"));
        users.add(new User("李四", "24"));
        users.add(new User("老王", "25"));
        users.add(new User("大锤", "22"));
        users.add(new User("大锤", "25"));

        Observable.from(users).take(3).subscribe(new Action1() {
            @Override
            public void call(User user) {
                Log.i("GGGDDD::",user.toString());
            }
        });
 
     
 
      
     
 
    
 
    

      //找出第一项数据 first == take(1) 
    
 
    
 
     
        List users = new ArrayList();
        users.add(new User("张三", "22"));
        users.add(new User("李四", "24"));
        users.add(new User("老王", "25"));
        users.add(new User("大锤", "25"));
        users.add(new User("大锤", "25"));

        Observable.from(users).first().subscribe(new Action1() {
            @Override
            public void call(User user) {
                Log.i("GGGDDD::",user.toString());
            }
        });
 
     
 
     
 
    
 
    
 
     
 
    
 
    
 
     
 
    
 
    
 
     
 
    
 
    
 
     
 
    
 
    
 
     
 
    
 
    

      //找出数据序列中最后三条数据 
    
 
    
 
     
        List  users=new ArrayList();
        users.add(new User("张三", "22"));
        users.add(new User("李四", "24"));
        users.add(new User("老王", "25"));
        users.add(new User("大锤", "22"));
        users.add(new User("大锤", "25"));

        Observable.from(users).takeLast(3).subscribe(new Action1() {
            @Override
            public void call(User user) {
                Log.i("GGGDDD::",user.toString());
            }
        });
 
     
 
      
     
 
    
 
    
 
     
 
    
 
    

      //一直读，知道满足条件为止，包含满足条件的那条 
    
 
    
 
     
 
    
 
    
 
     
 
    
 
    
 
     
        List  users=new ArrayList();
        users.add(new User("张三", "22"));
        users.add(new User("李四", "24"));
        users.add(new User("老王", "25"));
        users.add(new User("大锤", "22"));
        users.add(new User("大锤", "25"));

        Observable.from(users).takeUntil(new Func1() {
            @Override
            public Boolean call(User user) {
                if (user.getFirstName().equals("大锤")){
                    return true;//读到此处不再读取
                }else{
                    return  false;
                }

            }
        }).subscribe(new Action1() {
            @Override
            public void call(User user) {
                Log.i("GGGDDD::",user.toString());
            }
        });
 
     
 
      
     
 
    
 
    
7.skip(过滤操作符)
 
    

      忽略掉数据序列中的前多少项 
    
 
    
 
     
 
    
 
    
 
     
        List  users=new ArrayList();
        users.add(new User("张三", "22"));
        users.add(new User("李四", "24"));
        users.add(new User("老王", "25"));
        users.add(new User("大锤", "22"));
        users.add(new User("大锤", "25"));

        Observable.from(users).skip(3).subscribe(new Action1() {
            @Override
            public void call(User user) {
                Log.i("GGGDDD::",user.toString());
            }
        });
 
      
     
//忽略后三项的数据 
    
 
    
 
     
        List  users=new ArrayList();
        users.add(new User("张三", "22"));
        users.add(new User("李四", "24"));
        users.add(new User("老王", "25"));
        users.add(new User("大锤", "22"));
        users.add(new User("大锤", "25"));

        Observable.from(users).skipLast(3).subscribe(new Action1() {
            @Override
            public void call(User user) {
                Log.i("GGGDDD::",user.toString());
            }
        });
 
     
 
      
     
 
    
 
    
 
     
 
    
 
    
8.elementAt(过滤操作符)
 
    

      只获取数据序列中的某一项数据 
    
 
    
 
     
 
    
 
    

      //获取第四项数据 
    
 
    
 
     
        List  users=new ArrayList();
        users.add(new User("张三", "22"));
        users.add(new User("李四", "24"));
        users.add(new User("老王", "25"));
        users.add(new User("大锤", "22"));
        users.add(new User("大锤", "25"));

        Observable.from(users).elementAt(3).subscribe(new Action1() {
            @Override
            public void call(User user) {
                Log.i("GGGDDD::",user.toString());
            }
        });
 
     
 
      
     
 
    
 
    
 
     
 
    
 
    
 
     
 
    
 
    

      9.distinct(过滤操作符) 
    
 
    
 
     
 
    
 
    

      过滤掉重复的元素 
    
 
    
 
     
        List users = new ArrayList();
        users.add(new User("张三", "22"));
        users.add(new User("李四", "24"));
        users.add(new User("老王", "25"));
        users.add(new User("大锤", "25"));
        users.add(new User("大锤", "25"));

        Observable.from(users).distinct().subscribe(new Action1() {
            @Override
            public void call(User user) {
                Log.i("GGGDDD::", user.toString());
            }
        });
 
     
 
     android 积累一些关于rxjava的知识点_第2张图片 
     
 
    
 
    
 
     
 
    
 
    

      //可还是有两条数据相等，足以可见其判断相同的机制不满足于对象与对象之间的比较 
    
 
    

      //所有还可以更加细节的过滤 
    
 
    
 
     
        List users = new ArrayList();
        users.add(new User("张三", "22"));
        users.add(new User("李四", "24"));
        users.add(new User("老王", "25"));
        users.add(new User("大锤", "25"));
        users.add(new User("大锤", "25"));
        
        Observable.from(users).distinct(new Func1() {
            @Override
            public String call(User user) {
                return user.getFirstName();//过滤掉重名
            }
        }).subscribe(new Action1() {
            @Override
            public void call(User user) {
                Log.i("GGGDDD::",user.toString());
            }
        });
 
     
 
      
     
 
    
 
    
 
     
 
    
 
    

      10.last last == takeLast(1) 
    
 
    
 
     
 
    
 
    

      最后一项 
    
 
    
 
     
 
    
 
    
 
     
        List users = new ArrayList();
        users.add(new User("张三", "22"));
        users.add(new User("李四", "24"));
        users.add(new User("老王", "25"));
        users.add(new User("大锤", "25"));
        users.add(new User("大锤", "25"));

        Observable.from(users).last().subscribe(new Action1() {
            @Override
            public void call(User user) {
                Log.i("GGGDDD::",user.toString());
            }
        });
 
     
11.merge(组合操作符) 
    
 
    
 
     
 
    
 
    

      将多个发射序列合并成一个发射序列，新序列里的数据是无序的 
    
 
    
 
     
 
    
 
    
 
     
        List users = new ArrayList();
        users.add(new User("张三", "22"));
        users.add(new User("李四", "24"));
        users.add(new User("老王", "25"));
        users.add(new User("大锤", "25"));
        users.add(new User("大锤", "25"));

        Observable ob1 = Observable.from(users);

        Observable ob2 = Observable.just(1, 2, 3, 4);


        Observable.merge(ob1, ob2).subscribe(new Subscriber() {
            @Override
            public void onCompleted() {
                
            }

            @Override
            public void onError(Throwable e) {

            }

            @Override
            public void onNext(Object o) {
                
                Log.i("TTGGG:::",o.toString());

            }
        }); 
     
 
     android 积累一些关于rxjava的知识点_第3张图片 
     
 
     
    

      ？？？说好无序的呢？难道测试数据过小？ 
    
 
    

      12.startWith(组合操作符) 
    
 
    

      发射数据之前插入一条相同类型的新数据或者相同类型的新发射序列 
    
 
    
 
     
        List users = new ArrayList();
        users.add(new User("张三", "22"));
        users.add(new User("李四", "24"));
        users.add(new User("老王", "25"));
        users.add(new User("大锤", "25"));
        users.add(new User("大锤", "25"));

        Observable.from(users).startWith(new User("帅哥","18")).subscribe(new Action1() {
            @Override
            public void call(User user) {
                Log.i("TTTDDDD::",user.toString());
            }
        });
 
     
 
     android 积累一些关于rxjava的知识点_第4张图片 
     
 
    
 
    
 
     
 
    
 
    

      13.concat(组合操作符) 
    
 
    

      多个发射序列，逐个序列数据发出，接收的数据一定是顺序的 
    
 
    
 
     
        List users = new ArrayList();
        users.add(new User("张三", "22"));
        users.add(new User("李四", "24"));
        users.add(new User("老王", "25"));
        users.add(new User("大锤", "25"));
        users.add(new User("大锤", "25"));

        Observable ob1 = Observable.from(users);


        Observable ob2 = Observable.just(1, 2, 3, 4, 5);


        Observable.concat(ob1, ob2).subscribe(new Action1() {
            @Override
            public void call(Object o) {
                Log.i("TTGGGD:",o.toString());
            }
        }); 
     
 
     android 积累一些关于rxjava的知识点_第5张图片 
     
 
     
    

      14.zip（组合操作符） 
    
 
    

      1+1组合, 
    
 
    
 
     
 
    
 
    
 
     
        List users = new ArrayList();
        users.add(new User("张三", "22"));
        users.add(new User("李四", "24"));
        users.add(new User("老王", "25"));
        users.add(new User("大锤", "25"));
        users.add(new User("大锤", "25"));

        Observable ob1 = Observable.from(users);


        Observable ob2 = Observable.just(1, 2, 3, 4, 5,6);


       Observable.zip(ob1, ob2, new Func2() {
           @Override
           public String call(User user, Integer integer) {
               return user.getFirstName()+integer;
           }
       }).subscribe(new Action1() {
           @Override
           public void call(String s) {
               Log.i("TGGDD::",s);
           }
       });

 
     android 积累一些关于rxjava的知识点_第6张图片 
     
 
     
 
    
 
    

      15.combineLatest(组合操作符) 
    
 
    
 
     
 
    
 
    

      第一个发射序列的最后一个元素与第二个发射序列的所有元素组合 
    
 
    
 
     
        List users = new ArrayList();
        users.add(new User("张三", "22"));
        users.add(new User("李四", "24"));
        users.add(new User("老王", "25"));
        users.add(new User("大锤", "25"));
        users.add(new User("大锤", "25"));

        Observable ob1 = Observable.from(users);


        Observable ob2 = Observable.just(1, 2, 3, 4, 5,6);


       Observable.combineLatest(ob1, ob2, new Func2() {
           @Override
           public String call(User user, Integer integer) {
               return user.getFirstName()+integer;
           }
       }).subscribe(new Action1() {
           @Override
           public void call(String s) {
               Log.i("TGGDD::",s);
           }
       });
 
     
 
     android 积累一些关于rxjava的知识点_第7张图片 
     
 
    
 
    
 
     
 
    
 
    
 
     
 
    
 
    
 
     
 
    
 
    
 
     
 
    
 
    
 
     
 
    
 
    
 
     
 
    
 
    
 
    
 
    
总结:既然rxjava里可以转换，那么转换处在哪个线程里呢，转换通通处在观察者的线程里
 
    
即你在转换之前observable.observeOn()设定的是什么线程，它就处在什么线程里。
 
    
 
    
高级进阶:
 
    
rxjava+retrofit2
 
    
 
    
关于retrofit2我也在学习中,先做简单的使用:
 
    
导入:
 
    
 
    
    compile 'com.squareup.retrofit2:retrofit:2.1.0'
    compile 'com.squareup.retrofit2:converter-scalars:2.0.0'
    compile 'com.squareup.retrofit2:adapter-rxjava:2.0.0'
 
    
别忘了添加网络权限,切记要添加 
    
 
    
addCallAdapterFactory(RxJavaCallAdapterFactory.create())//让rxjava能使用retrofit2
 
    


 
    
 
    
 
    
 private void initData() {
        Retrofit retrofit = new Retrofit.Builder().baseUrl("http://fdj.abc5.cn")
                .addConverterFactory(ScalarsConverterFactory.create())
                .addCallAdapterFactory(RxJavaCallAdapterFactory.create())
                .build();
        HttpUser httpUser = retrofit.create(HttpUser.class);

        httpUser.getUsers("hcy", "1234")
                .subscribeOn(Schedulers.io())
                .observeOn(AndroidSchedulers.mainThread())
                .subscribe(new Subscriber() {
                    @Override
                    public void onCompleted() {
                        Log.i("网络请求的数据::", "onCompleted");
                    }

                    @Override
                    public void onError(Throwable e) {
                        Log.i("网络请求的数据::", "onError" + e.getMessage());
                    }

                    @Override
                    public void onNext(String s) {

                        Log.i("网络请求的数据::", s);
                        tv.setText(s);

                    }
                });
        
    }


    public interface HttpUser {
        @POST("/api/index/posttest")
        @FormUrlEncoded
        Observable getUsers(@Field("username") String username, @Field("password") String password);
    }
 
    
小结： 
    
 
    
关于Action1,Action0,Func1使用与区别:
 
    
Func1:有形参，有返回
 
    
Func2:多个形参,有返回
 
    
Action1:有形参，无返回
 
    
Action0:无形参，无返回
 
    
 
    
Action1,Action0可以代替观察者里的三个方法,OnNext,OnError,OnCompleted;
 
    
 
    
 
    
Action1 onNextAction = new Action1() {
            // onNext()
            @Override
            public void call(String s) {
                Log.i("onNext:::",s);
            }
        };
        Action1 onErrorAction = new Action1() {
            // onError()
            @Override
            public void call(Throwable throwable) {
                Log.i("onError:::",throwable.getMessage());
            }
        };
        Action0 onCompletedAction = new Action0() {
            // onCompleted()
            @Override
            public void call() {
                Log.i("onCompleted","");
            }
        };
        Observable.just("hasaki","posigei").subscribe(onNextAction,onErrorAction,onCompletedAction);

 
    
 
    
 
    
 
    
 
    
 
    
 
    
 
    
 
    
 
    
 
    
 
    
 
    
 
    
 
    
 
    
 
    
如何多次切换线程:: 
    
(线程切换容易出现的异常::java.lang.IllegalStateException: Fatal Exception thrown on Scheduler.Worker thread.
 
    
找到异常的最后一般又可以看到::Caused by: android.os.NetworkOnMainThreadException)
 
    
example:像我所在的公司要强求服务器的一条连接，要请求两次,第一次请求服务器的时间，然后按
 
    
字母顺序将请求的参数排序在最后加载请求的时间和appkey字段形成sign，再把sign和时间放入
 
    
参数map中请求第二个连接才能得到想要的数据，是不是贼几把麻烦，以前封装的时候因为要考虑到
 
    
其实是两次网络请求（不能放在主线程中，android基础），但请求得到的数据我又想能切换到主线程
 
    
跟新UI，以前的代码一大堆，现在贴出我第一次封装的代码，感受下rxjava切换线程的好处
 
    
 
    
package utils;

import android.util.Log;

import com.alibaba.fastjson.JSON;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

import contact.Contact;
import okhttp3.RequestBody;
import retrofit2.Call;
import retrofit2.Retrofit;
import retrofit2.adapter.rxjava.RxJavaCallAdapterFactory;
import retrofit2.converter.scalars.ScalarsConverterFactory;
import retrofit2.http.GET;
import retrofit2.http.Multipart;
import retrofit2.http.POST;
import retrofit2.http.PartMap;
import retrofit2.http.Url;
import rx.Observable;
import rx.Subscriber;
import rx.android.schedulers.AndroidSchedulers;
import rx.functions.Func1;
import rx.schedulers.Schedulers;

/**
 * Created by hcy on 2016/12/24.
 */

public class WytHttpUtils {

    public interface HttpServerTime {
        @GET("/api/getservicetime.php")
        Observable HttpTime();
    }


    public interface HttpResult {
        @POST
        @Multipart
        Observable httpResult(@Url String url, @PartMap Map params);
    }


    private Map map;


    public WytHttpUtils(Map map) {
        this.map = map;
    }


    public void HttpRequest(String url) {
        ServiceFactory.createServiceFrom(HttpServerTime.class, "http://iexue.quxue100.cn")
                .HttpTime()
                .subscribeOn(Schedulers.io())
                .observeOn(Schedulers.io())
                .flatMap(new Func1>() {
                    @Override
                    public Observable call(HttpTime httpTime) {

                        Log.i("DDDSSS222::", httpTime.toString());
                        if (httpTime.getStatus() == 1) {
                            //时间获取成功
                            String sign = getValueFromMap(map).append(httpTime.getResult()).append(Contact.APPKEY).toString();
                            map.put("time", httpTime.getResult() + "");
                            map.put("sign", md5Encode(sign));
                            getValueFromMap2(map);
                            Observable observable1 =  ServiceFactory.createServiceFrom(HttpResult.class,"http://iexue.quxue100.cn").httpResult(url, getValueFromMap2(map));
                            return observable1;
                        } else {
                            return null;
                        }

                    }
                }).observeOn(AndroidSchedulers.mainThread())//切换到主线程
                .subscribe(new Subscriber() {
            @Override
            public void onCompleted() {
                Log.i("rxjava::onCompleted:", "onCompleted");

            }

            @Override
            public void onError(Throwable e) {

                Log.i("rxjava::onError:", e.getMessage());

            }

            @Override
            public void onNext(String s) {

                Log.i("rxjava::onNext:", s);

            }
        });


        //return  observable;
    }


    private String md5Encode(String content) {
        //选择摘要算法
        MessageDigest md = null;
        try {
            md = MessageDigest.getInstance("md5");
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        //设置要摘要的内容:
        md.update(content.getBytes());
        //生成摘要
        byte[] value = md.digest();
        //转16进制
        String md5Value = toHexString(value);
        return md5Value;
    }


    private String toHexString(byte[] value) {
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < value.length; i++) {
            //消除负数 我们认为每一个byte都是正数
            int values = value[i] & 255;
            if (values < 16) {
                //如果值小于16 那么使用Integer.toHexString算出来的值是0-f
                //必须补0
                sb.append("0");
            }
            sb.append(Integer.toHexString(values));
        }
        return sb.toString();
    }


    private StringBuffer getValueFromMap(Map map) {

        Iterator iter = map.entrySet().iterator();
        StringBuffer buffer = new StringBuffer();

        while (iter.hasNext()) {
            Map.Entry entry = (Map.Entry) iter.next();

            Object val = entry.getValue();

            buffer.append(val + "");


        }
        return buffer;
    }


    private Map getValueFromMap2(Map map) {

        Iterator iter = map.entrySet().iterator();
        Map requestBodyMap = new HashMap();
        Log.i("DSDSDS::", map.size() + "");
        while (iter.hasNext()) {
            Map.Entry entry = (Map.Entry) iter.next();

            String val = (String) entry.getValue();

            String key = (String) entry.getKey();

            Log.i("rxjava::", key + "???" + val);

            requestBodyMap.put(key, RequestBody.create(null, val));
            //photos.put("password",  RequestBody.create(null, "123456"));


        }
        return requestBodyMap;
    }

    private class HttpTime {


        public HttpTime(int status, String msg, int result) {
            this.status = status;
            this.msg = msg;
            this.result = result;
        }

        public HttpTime() {
        }


        @Override
        public String toString() {
            return "HttpTime{" +
                    "status=" + status +
                    ", msg='" + msg + '\'' +
                    ", result=" + result +
                    '}';
        }

        /**
         * status : 1
         * msg : 获取成功
         * result : 1482549878
         */

        private int status;
        private String msg;
        private int result;

        public int getStatus() {
            return status;
        }

        public void setStatus(int status) {
            this.status = status;
        }

        public String getMsg() {
            return msg;
        }

        public void setMsg(String msg) {
            this.msg = msg;
        }

        public int getResult() {
            return result;
        }

        public void setResult(int result) {
            this.result = result;
        }
    }

}


 
    
 
    
附录:
 
    
rxjava 正计时 与 倒计时
 
    
 
    
 
    
 
    
package utils;
import android.content.Context;

import com.orhanobut.logger.Logger;

import java.text.SimpleDateFormat;
import java.util.TimeZone;
import java.util.concurrent.TimeUnit;

import lessonmodule.LessonActivity;
import rx.Observable;
import rx.Subscription;
import rx.android.schedulers.AndroidSchedulers;
import rx.functions.Func1;
import wytnewhttp.WytHttpUtils;


/**
 * Created by hcy on 2017/2/24.
 */

public class RxUtils {
    //倒计时
    public static Observable countDownTime(int time) {
        if (time < 0) {
            time = 0;
        }
        final int countTime = time;
        return Observable.interval(0,1, TimeUnit.SECONDS)
                .observeOn(AndroidSchedulers.mainThread())
                .map(new Func1() {
                    @Override
                    public String call(Long aLong) {
                        //解决八小时的时区问题
                        String format = new SimpleDateFormat("HH:mm:ss").format((countTime - aLong.intValue()) * 1000- TimeZone.getDefault().getRawOffset());

                        Logger.i("倒计时：："+format);
                        return format;
                    }
                })
                .take(countTime + 1);

    }


    //正计时

    public static Observable countUpTime() {
        final int countTime = 0;
        return Observable.interval(0,1, TimeUnit.SECONDS)
                .observeOn(AndroidSchedulers.mainThread())
                .map(new Func1() {
                    @Override
                    public String call(Long aLong) {
                        return new SimpleDateFormat("HH:mm:ss").format((countTime + aLong.intValue())*1000);
                    }
                });
    }


    public static void unsubscribe(Subscription subscription) {
        if (subscription != null && !subscription.isUnsubscribed()) {
            subscription.unsubscribe();
        }
    }


}

 
    
 
    
 
    
 
    


 
    
 
    
 
     
    
      countTimeSubscription = RxUtils.countDownTime(60).subscribe(new Action1() {
                    @Override
                    public void call(String s) {
                        tv_countTime.setText(s);
                    }
                });
 
    
 
    
 
    
 
    
 
    
 
    
 
    
 
    
   
 
   
 
   
  
 
   
 
  
 
  
 
   
 
  
 
  
 
   
 
  
 
  
 
   
 
  
 
  
 
   
 
  
 
  
 
   
 
  
 
  
 
  

 
  
 
  
 
  
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(Android)

        

            

                
    
                    
  • android系统selinux中添加新属性property
                        辉色投像

                        
    1.定位/android/system/sepolicy/private/property_contexts声明属性开头：persist.charge声明属性类型：u:object_r:system_prop:s0图12.定位到android/system/sepolicy/public/domain.te删除neverallow{domain-init}default_prop:property
    
                    
    • 
                    
  • 2.2.6 通知类控件 Toast、Menu
                        常思行

                        
    本文例程下载：WillFlow_Toast、WillFlowMenu一、什么是Toast？Toast也被叫做吐司，是Android系统提供的一种非常好的提醒方式，在程序中可以使用它将一些短小的信息通知给用户，它有如下两个特点：Toast是没有焦点的Toast显示的时间有限过一定的时间就会自动消失所以一般来讲Toast的使用并不会影响我们的正常操作，并且它通常不会占用太大的屏幕空间，有着良好的用户体
    
                    
    • 
                    
  • mac 备份android 手机通讯录导入iphone,iphone如何导出通讯录（轻松教你iPhone备份通讯录的方法）...
                        weixin_39762838
mac备份android手机通讯录导入iphone
                        
    在日新月异的手机更替中，换手机已经成为一个非常稀松平常的事情，但将旧手机上面的通讯录导入到新手机还是让不少小伙伴为难，本篇将给大家详细讲解这方面的知识：“苹果手机通讯录怎么导入到新手机”及“安卓手机通讯录导入到新手机”的方法。一、苹果手机通讯录导入到新手机常用方法(SIM卡导入)在苹果手机主频幕上找到“设置”，单击进入设置菜单，下拉菜单列表，点击“邮件、通讯录、日历”，然后找到“导入SIM卡通讯录
    
                    
    • 
                    
  • android 更改窗口的层次,浮窗开发之窗口层级
                        Ms.Bu
android更改窗口的层次
                        
    最近在项目中遇到了这样的需求：需要在特定的其他应用之上悬浮自己的UI交互(拖动、输入等复杂的UI交互)，和九游的浮窗类似，不过我们的比九游的体验更好，我们越过了很多授权的限制。浮窗效果很多人都知道如何去实现一个简单的浮窗，但是却很少有人去深入的研究背后的流程机制，由于项目中浮窗交互比较复杂，遇到了些坑查看了很多资料，故总结浮窗涉及到的知识点：窗口层级关系(浮窗是如何“浮”的)？浮窗有哪些限制，如何
    
                    
    • 
                    
  • Android应用性能优化
                        轻口味
Android
                        
    Android手机由于其本身的后台机制和硬件特点，性能上一直被诟病，所以软件开发者对软件本身的性能优化就显得尤为重要；本文将对Android开发过程中性能优化的各个方面做一个回顾与总结。Cache优化ListView缓存：ListView中有一个回收器，Item滑出界面的时候View会回收到这里，需要显示新的Item的时候，就尽量重用回收器里面的View；每次在getView函数中inflate新
    
                    
    • 
                    
  • Android实现监听事件的方法
                        Amy木婉清

                        
    1.通过内部类实现2.通过匿名内部类实现3.通过事件源所在类实现4.通过外部类实现5.布局文件中onclick属性(针对点击事件)1.通过内部类实现代码:privateButtonmBtnEvent;//oncreate中mBtnEvent.setOnClickListener(newOnClick());//内部类实现监听classOnClickimplementsView.OnClickLis
    
                    
    • 
                    
  • 高级UI<第二十四篇>：Android中用到的矩阵常识
                        NoBugException

                        
    （1）定义在数学中，矩阵（Matrix）是一个按照长方阵列排列的复数或实数集合。由m×n个数aij排成的m行n列的数表称为m行n列的矩阵，简称m×n矩阵。记作：图片.png这m×n个数称为矩阵A的元素，简称为元，数aij位于矩阵A的第i行第j列，称为矩阵A的(i,j)元，以数aij为(i,j)元的矩阵可记为(aij)或(aij)m×n，m×n矩阵A也记作Amn。元素是实数的矩阵称为实矩阵，元素是复
    
                    
    • 
                    
  • RK3229_Android9.0_Box 4G模块EC200A调试
                        suifen_
网络
                        
    0、kernel修改这部分完全可以参考Linux的移植：RK3588EC200A-CN【4G模块】调试_rkec200a-cn-CSDN博客1、修改device/rockchip/rk322xdiff--gita/device.mkb/device.mkindexec6bfaa..e7c32d1100755---a/device.mk+++b/device.mk@@-105,6+105,8@@en
    
                    
    • 
                    
  • kt文件和java文件_Java与Kotlin之间怎样进行互操作
                        铭空间
kt文件和java文件
                        
    Java与Kotlin之间怎样进行互操作发布时间：2021-02-0210:50:43来源：亿速云阅读：98作者：小新这篇文章主要介绍了Java与Kotlin之间怎样进行互操作，具有一定借鉴价值，感兴趣的朋友可以参考下，希望大家阅读完这篇文章之后大有收获，下面让小编带着大家一起了解一下。前言目前kotlin是谷歌首推的开发Android的语言，但由于历史原因，我们绝大部分项目依旧还是以Java为主
    
                    
    • 
                    
  • Android shell 常用 debug 命令
                        晨春计
Audiodebugandroidlinux
                        
    目录1、查看版本2、am命令3、pm命令4、dumpsys命令5、sed命令6、log定位查看APK进程号7、log定位使用场景1、查看版本1.1、Android串口终端执行getpropro.build.version.release#获取Android版本uname-a#查看linux内核版本信息uname-r#单独查看内核版本1.2、linux服务器执行lsb_release-a#查看Lin
    
                    
    • 
                    
  • 2024年最全Flutter如何和Native通信-Android视角，Electron开发Android界面
                        2401_84544531
程序员android面试学习
                        
    总结【Android详细知识点思维脑图（技能树）】其实Android开发的知识点就那么多，面试问来问去还是那么点东西。所以面试没有其他的诀窍，只看你对这些知识点准备的充分程度。so，出去面试时先看看自己复习到了哪个阶段就好。虽然Android没有前几年火热了，已经过去了会四大组件就能找到高薪职位的时代了。这只能说明Android中级以下的岗位饱和了，现在高级工程师还是比较缺少的，很多高级职位给的薪
    
                    
    • 
                    
  • 分享一个基于python的电子书数据采集与可视化分析 hadoop电子书数据分析与推荐系统 spark大数据毕设项目（源码、调试、LW、开题、PPT)
                        计算机源码社
Python项目大数据大数据pythonhadoop计算机毕业设计选题计算机毕业设计源码数据分析spark毕设
                        
    作者：计算机源码社个人简介：本人八年开发经验，擅长Java、Python、PHP、.NET、Node.js、Android、微信小程序、爬虫、大数据、机器学习等，大家有这一块的问题可以一起交流！学习资料、程序开发、技术解答、文档报告如需要源码，可以扫取文章下方二维码联系咨询Java项目微信小程序项目Android项目Python项目PHP项目ASP.NET项目Node.js项目选题推荐项目实战|p
    
                    
    • 
                    
  • android ndk 开发jni调用对象方法，数组参数
                        wulongkou
开发问题安卓的事ndkandroidstudiojni
                        
    一、JNI和NDK关系JNI是Java语言提供的Java和C/C++相互沟通的机制，Java可以通过JNI调用本地的C/C++代码，本地的C/C++的代码也可以调用java代码。JNI是本地编程接口，Java和C/C++互相通过的接口。Java通过C/C++使用本地的代码的一个关键性原因在于C/C++代码的高效性。NDK是一系列工具的集合。它提供了一系列的工具，帮助开发者快速开发C（或C++）的动
    
                    
    • 
                    
  • Android jni中数组参数的传递方式
                        lokeyme
Andriodandroid开发JNINDKjavac语言
                        
    1、背景今天调试了一下Androidjni关于Java中调用C代码的程序，发现我的数组参数传递方式不对，导致值传递不正确，我的方法是：C代码，入口函数#include#includejintJava_sony_MedicalRecordDemo_MainActivity_decryptionSuccess(JNIEnv*env,jobjectthiz,jintAttr[]){returnAttr[
    
                    
    • 
                    
  • 1-1.Jetpack 之 Navigation 简单编码模板
                        我命由我12345
Android-Jetpack简化编程javajava-eeandroid-studioandroidstudio安卓androidjetpack
                        
    一、Navigation1、Navigation概述Navigation是Jetpack中的一个重要成员，它主要是结合导航图（NavigationGraph）来控制和简化Fragment之间的导航，即往哪里走，该怎么走2、Navigate引入在模块级build.gradle中引入相关依赖implementation'androidx.navigation:navigation-fragment:2
    
                    
    • 
                    
  • Android JetPack架构——结合记事本Demo一篇打通对Sqlite的增删改查结合常用jetpack架构应用
                        erhtre
程序员androidjetpack架构sqlite
                        
    为什么要用Jetpack?========================================================================关于为什么要用Jetpack，我参考了许多的博客和官方文档，开阔了我对Android生态圈的理解和认识，在Jetpack推出前出现的许许多多强大的第三方框架与语言，典型代表无疑是强大的RxJava在Jetpack仍然有许多粉丝在一
    
                    
    • 
                    
  • Android干净架构MVI模板使用指南
                        井美婵Toby

                        
    Android干净架构MVI模板使用指南android-clean-architecture-mvi-boilerplateAforkofourcleanarchitectureboilerplateusingtheModel-View-Intentpattern项目地址:https://gitcode.com/gh_mirrors/an/android-clean-architecture-mv
    
                    
    • 
                    
  • ⭐Unity 安卓环境中正确地读取和处理 XML 文件
                        惊鸿醉
Unityunityandroidxml
                        
    写了一个选择题Demo，电脑包和编辑器内无问题，但是打包安卓手机之后题目无法正常使用，想到的是安卓环境中正确地读取文件的问题改进方案：1.由于XmlDocument.Load方法在Android上的路径问题（由于文件位于APK内部，无法像在文件系统中那样直接访问），需要先使用UnityWebRequest来异步加载文件内容，然后再解析XML。2.异步处理：修改你的代码，以支持异步文件加载和处理，这
    
                    
    • 
                    
  • 《Android进阶之光》读书笔记
                        soleil雪寂
读书笔记#Android进阶之光
                        
    文章目录第1章Android新特性1.1.Android5.0新特性1.2.RecyclerView1.1.4.3种Notification1.1.5.Toolbar与Palette1.1.6.Palette1.2.Android6.0新特性1.2.2.运行时权限机制1.3.Android7.0新特性第2章MaterialDesign2.2.DesignSupportLibrary常用控件详解第3
    
                    
    • 
                    
  • 《Android进阶之光》— Android 书籍
                        王睿丶
Android永无止境《Android进阶之光》Android书籍Androidphoenix移动开发
                        
    文章目录第1章Android新特性1第2章MaterialDesign48第3章View体系与自定义View87第4章多线程编程165第5章网络编程与网络框架204第6章设计模式271第7章事件总线308第8章函数响应式编程333第9章注解与依赖注入框架382第10章应用架构设计422第11章系统架构与MediaPlayer框架460出版年:2017-7简介：《Android进阶之光》是一本And
    
                    
    • 
                    
  • 《android进阶之光》——多线程编程（上）
                        TAING要一直努力
读书笔记
                        
    今天了解了下多线程编程，知识点如下：进程与线程：进程是什么？线程是什么？进程可以看作是程序的实体，是线程的容器，是受操作系统管理的基本运行单元，例如exe文件就是一个进程。线程是进程运行的一些子任务，是操作系统调度的最小单元，各线程拥有自己的计数器，堆栈，局部变量等，也可以访问线程间共享的内存。线程的状态有哪些？新创建，可运行，等待，超时等待，阻塞，终止怎么创建一个线程？-三种方法第一种，MyTr
    
                    
    • 
                    
  • android进阶之光！Android面试必备的集合源码详解，系列篇
                        程序员Sunbu
程序员Android
                        
    前言面试：如果不准备充分的面试，完全是浪费时间，更是对自己的不负责。文末会给大家分享下我整理的Android面试专题及答案其中大部分都是大企业面试常问的面试题，可以对照这查漏补缺，当然了，这里所列的肯定不可能覆盖全部方式，不过对大家找工作肯定是有帮助！本月飞机到达上海，到今天第6天了，四家大公司华为，小米，映客，抖音，还有二家中小型公司。有几家已经面了几轮，下周还要面，挂了几家，不过目前已经选择了
    
                    
    • 
                    
  • Android-悬浮窗功能的实现（附Java、KT实现源码）(1)
                        egrhef
程序员androidjava开发语言
                        
    //获取服务的操作对象valbinder=serviceasFloatWinfowServices.MyBinderbinder.service}overridefunonServiceDisconnected(name:ComponentName){}}overridefunonActivityResult(requestCode:Int,resultCode:Int,data:Intent){
    
                    
    • 
                    
  • Visual Studio中的Android模拟器使用详解
                        wurui8
androidandroidstudioandroidandroid应用
                        
    关注微信号：javalearns随时随地学Java或扫一扫随时随地学JavaMicrosoft本周发布了VisualStudio2015预览版,里面包含Android开发工具.安装的时候,如果选Android开发,VisualStudio会把调试Android应用程序用的VisualStudio模拟器也装上.在介绍这个新模拟器之前,我们先来聊一聊,为什么需要一个新的Android模拟器–当然,你也
    
                    
    • 
                    
  • Unity 热更 之 【HybirdCLR】+【YooAsset】 [安卓 Android端] [代码 + 资源热更] 功能的 简单实现演示
                        仙魁XAN
Unity进阶unityHybirdCLRYooAssetHotUpdate热更新
                        
    Unity热更之【HybirdCLR】+【YooAsset】[安卓Android端][代码+资源热更]功能的简单实现演示目录Unity热更之【HybirdCLR】+【YooAsset】[安卓Android端][代码+资源热更]功能的简单实现演示一、简单介绍二、HybridCLR三、YooAsset四、HybirdCLR引入工程五、YooAsset引入工程六、Python服务器简单构建七、Hybir
    
                    
    • 
                    
  • Android 用线程池实现一个简单的任务队列(Kotlin)
                        深海呐
Android#Android进阶#Kotlinandroidkotlin线程池延时任务队列线程池延时任务
                        
    关于线程池,Kotlin和java的使用方式一样在Android中,很多人喜欢用Handler的postDelayed()去实现延时任务.要使用postDelayed(),去实现延时任务队列,就不可避免要使用递归.但是这样做,代码的简洁性,和书写的简易,就远不如使用线程池.使用线程池的简单程度:privatevalmThreadPool=Executors.newSingleThreadSched
    
                    
    • 
                    
  • （小白入门）Windows环境下搭建React Native Android开发环境
                        码农老黑
前端ReactNative移动开发Androidstudio
                        
    ReactNative(简称RN)是Facebook于2015年4月开源的跨平台移动应用开发框架，是Facebook早先开源的UI框架React在原生移动应用平台的衍生产物，目前支持iOS和Android两大平台。RN的环境搭建在RN的中文社区有所介绍，但是对于小白来说还是有些太过简略了。RN中文社区详见参考，本文不涉及的问题也许在其中能够有所解答。ReactNative思想底层引擎是JavaSc
    
                    
    • 
                    
  • Android Dialog圆角设置无效的问题
                        ly969434341
android
                        
    一，参考AndroidDialog圆角设置无效的问题https://blog.csdn.net/woshi_awei/article/details/99664527Android自定义Dialog实现通用圆角对话框https://cloud.tencent.com/developer/article/1740956二，原因Diallog的默认背景是白色（直角背景），我自定义的Dialog背景也是
    
                    
    • 
                    
  • MultiSnapRecyclerView：让Android RecyclerView的滚动停靠更灵活
                        技术无疆
Androidandroiduiandroidstudioandroid-studiojavaandroidx
                        
    在Android应用开发中，RecyclerView是一个强大且灵活的组件，用于展示大量数据集合。然而，标准的RecyclerView只支持单一的滚动停靠点，这在某些场景下可能不够灵活。为了解决这个问题，TakuSemba开发了一个名为MultiSnapRecyclerView的库，它允许开发者在RecyclerView中实现多个滚动停靠点。文章目录什么是MultiSnapRecyclerView
    
                    
    • 
                    
  • Android界面特效全汇总
                        小飞鹤
Android开发详解android
                        
    （一）Activity页面切换的效果Android2.0之后有了overridePendingTransition（），其中里面两个参数，一个是前一个activity的退出两一个activity的进入，Java代码1.@OverridepublicvoidonCreate(BundlesavedInstanceState){2.super.onCreate(savedInstanceState);
    
                    
    • 
                                
  • [星球大战]阿纳金的背叛
                                    comsci

                                    
     
      本来杰迪圣殿的长老是不同意让阿纳金接受训练的......... 
 
    但是由于政治原因,长老会妥协了...这给邪恶的力量带来了机会 
 
    所以......现代的地球联邦接受了这个教训...绝对不让某些年轻人进入学院 
 
   
    
                                
    • 
                                
  • 看懂它，你就可以任性的玩耍了！
                                    aijuans
JavaScript
                                    
              javascript作为前端开发的标配技能，如果不掌握好它的三大特点：1.原型 2.作用域 3. 闭包 ,又怎么可以说你学好了这门语言呢？如果标配的技能都没有撑握好，怎么可以任性的玩耍呢？怎么验证自己学好了以上三个基本点呢，我找到一段不错的代码，稍加改动，如果能够读懂它，那么你就可以任性了。 
function jClass(b
    
                                
    • 
                                
  • Java常用工具包 Jodd
                                    Kai_Ge
javajodd
                                    
    Jodd 是一个开源的 Java 工具集， 包含一些实用的工具类和小型框架。简单，却很强大！  写道   Jodd = Tools + IoC + MVC + DB + AOP + TX + JSON + HTML < 1.5 Mb  
Jodd 被分成众多模块，按需选择，其中 
 
  工具类模块有：  
  
   jodd-core    &nb
    
                                
    • 
                                
  • SpringMvc下载
                                    120153216
springMVC
                                    
    @RequestMapping(value = WebUrlConstant.DOWNLOAD)
	public void download(HttpServletRequest request,HttpServletResponse response,String fileName) {
		OutputStream os = null;
		InputStream is = null;

    
                                
    • 
                                
  • Python 标准异常总结
                                    2002wmj
python
                                    
    Python标准异常总结  
    AssertionError 断言语句（assert）失败   AttributeError 尝试访问未知的对象属性   EOFError 用户输入文件末尾标志EOF（Ctrl+d）   FloatingPointError 浮点计算错误   GeneratorExit generator.close()方法被调用的时候   ImportError 导入模块失
    
                                
    • 
                                
  • SQL函数返回临时表结构的数据用于查询
                                    357029540
SQL Server
                                    
    这两天在做一个查询的SQL，这个SQL的一个条件是通过游标实现另外两张表查询出一个多条数据，这些数据都是INT类型，然后用IN条件进行查询，并且查询这两张表需要通过外部传入参数才能查询出所需数据，于是想到了用SQL函数返回值，并且也这样做了，由于是返回多条数据，所以把查询出来的INT类型值都拼接为了字符串，这时就遇到问题了，在查询SQL中因为条件是INT值，SQL函数的CAST和CONVERST都
    
                                
    • 
                                
  • java 时间格式化 | 比较大小| 时区 个人笔记
                                    7454103
javaeclipsetomcatcMyEclipse
                                    
    个人总结！ 不当之处多多包含！ 
 
  引用   1.0 如何设置 tomcat 的时区： 
         位置：(catalina.bat---JAVA_OPTS  下面加上) 
         set JAVA_OPT
    
                                
    • 
                                
  • 时间获取Clander的用法
                                    adminjun
Clander时间
                                    
    /** 
   * 得到几天前的时间 
   * @param d 
   * @param day 
   * @return 
   */ 
  public static Date getDateBefore(Date d,int day){ 
   Calend
    
                                
    • 
                                
  • JVM初探与设置
                                    aijuans
java
                                    
    JVM是Java Virtual Machine（Java虚拟机）的缩写，JVM是一种用于计算设备的规范，它是一个虚构出来的计算机，是通过在实际的计算机上仿真模拟各种计算机功能来实现的。Java虚拟机包括一套字节码指令集、一组寄存器、一个栈、一个垃圾回收堆和一个存储方法域。 JVM屏蔽了与具体操作系统平台相关的信息，使Java程序只需生成在Java虚拟机上运行的目标代码（字节码）,就可以在多种平台
    
                                
    • 
                                
  • SQL中ON和WHERE的区别
                                    avords

                                    
    SQL中ON和WHERE的区别       
数据库在通过连接两张或多张表来返回记录时，都会生成一张中间的临时表，然后再将这张临时表返回给用户。   www.2cto.com     在使用left jion时，on和where条件的区别如下：    1、 on条件是在生成临时表时使用的条件，它不管on中的条件是否为真，都会返回左边表中的记录。  
    
                                
    • 
                                
  • 说说自信
                                    houxinyou
工作生活
                                    
    自信的来源分为两种,一种是源于实力,一种源于头脑.实力是一个综合的评定,有自身的能力,能利用的资源等.比如我想去月亮上,要身体素质过硬,还要有飞船等等一系列的东西.这些都属于实力的一部分.而头脑不同,只要你头脑够简单就可以了!同样要上月亮上,你想,我一跳,1米,我多跳几下,跳个几年,应该就到了!什么?你说我会往下掉?你笨呀你!找个东西踩一下不就行了吗? 
  
  
无论工作还
    
                                
    • 
                                
  • WEBLOGIC事务超时设置
                                    bijian1013
weblogicjta事务超时
                                    
            系统中统计数据，由于调用统计过程，执行时间超过了weblogic设置的时间，提示如下错误： 
统计数据出错!
原因：The transaction is no longer active - status: 'Rolling Back. [Reason=weblogic.transaction.internal
    
                                
    • 
                                
  • 两年已过去，再看该如何快速融入新团队
                                    bingyingao
java互联网融入架构新团队
                                    
    偶得的空闲，翻到了两年前的帖子 
该如何快速融入一个新团队，有所感触，就记下来，为下一个两年后的今天做参考。 
 
    时隔两年半之后的今天，再来看当初的这个博客，别有一番滋味。而我已经于今年三月份离开了当初所在的团队，加入另外的一个项目组，2011年的这篇博客之后的时光，我很好的融入了那个团队，而直到现在和同事们关系都特别好。大家在短短一年半的时间离一起经历了一
    
                                
    • 
                                
  • 【Spark七十七】Spark分析Nginx和Apache的access.log
                                    bit1129
apache
                                    
    Spark分析Nginx和Apache的access.log，第一个问题是要对Nginx和Apache的access.log文件进行按行解析，按行解析就的方法是正则表达式： 
  
Nginx的access.log解析正则表达式 
  
val PATTERN = """([^ ]*) ([^ ]*) ([^ ]*) (\\[.*\\]) (\&q
    
                                
    • 
                                
  • Erlang patch
                                    bookjovi
erlang
                                    
    Totally five patchs committed to erlang otp, just small patchs. 
IMO, erlang really is a interesting programming language, I really like its concurrency feature. 
but the functional programming style 
    
                                
    • 
                                
  • log4j日志路径中加入日期
                                    bro_feng
javalog4j
                                    
    要用log4j使用记录日志，日志路径有每日的日期，文件大小5M新增文件。 
实现方式 
log4j: 
<appender name="serviceLog"
		class="org.apache.log4j.RollingFileAppender">
      	<param name="Encoding" v
    
                                
    • 
                                
  • 读《研磨设计模式》-代码笔记-桥接模式
                                    bylijinnan
java设计模式
                                    
    声明： 本文只为方便我个人查阅和理解，详细的分析以及源代码请移步 原作者的博客http://chjavach.iteye.com/ 
 
 



/**
 * 个人觉得关于桥接模式的例子，蜡笔和毛笔这个例子是最贴切的：http://www.cnblogs.com/zhenyulu/articles/67016.html
 * 笔和颜色是可分离的，蜡笔把两者耦合在一起了：一支蜡笔只有一种
    
                                
    • 
                                
  • windows7下SVN和Eclipse插件安装
                                    chenyu19891124
eclipse插件
                                    
    今天花了一天时间弄SVN和Eclipse插件的安装，今天弄好了。svn插件和Eclipse整合有两种方式，一种是直接下载插件包，二种是通过Eclipse在线更新。由于之前Eclipse版本和svn插件版本有差别，始终是没装上。最后在网上找到了适合的版本。所用的环境系统：windows7JDK：1.7svn插件包版本：1.8.16Eclipse：3.7.2工具下载地址：Eclipse下在地址：htt
    
                                
    • 
                                
  • [转帖]工作流引擎设计思路
                                    comsci
设计模式工作应用服务器workflow企业应用
                                    
     作为国内的同行，我非常希望在流程设计方面和大家交流，刚发现篇好文(那么好的文章，现在才发现，可惜)，关于流程设计的一些原理，个人觉得本文站得高，看得远，比俺的文章有深度，转载如下 
 
================================================================================= 
 
自开博以来不断有朋友来探讨工作流引擎该如何
    
                                
    • 
                                
  • Linux 查看内存，CPU及硬盘大小的方法
                                    daizj
linuxcpu内存硬盘大小
                                    
    一、查看CPU信息的命令 
 
[root@R4 ~]# cat /proc/cpuinfo |grep "model name" && cat /proc/cpuinfo |grep "physical id" 
model name : Intel(R) Xeon(R) CPU X5450 @ 3.00GHz 
model name : 
    
                                
    • 
                                
  • linux 踢出在线用户
                                    dongwei_6688
linux
                                    
    两个步骤： 
1.用w命令找到要踢出的用户，比如下面： 
  
[root@localhost ~]# w
 18:16:55 up 39 days,  8:27,  3 users,  load average: 0.03, 0.03, 0.00
USER     TTY      FROM              LOGIN@   IDLE   JCPU   PCPU WHAT
    
                                
    • 
                                
  • 放手吧,就像不曾拥有过一样
                                    dcj3sjt126com

                                    
    内容提要：   
静悠悠编著的《放手吧就像不曾拥有过一样》集结“全球华语世界最舒缓心灵”的精华故事，触碰生命最深层次的感动，献给全世界亿万读者。《放手吧就像不曾拥有过一样》的作者衷心地祝愿每一位读者都给自己一个重新出发的理由，将那些令你痛苦的、扛起的、背负的，一并都放下吧！把憔悴的面容换做一种清淡的微笑，把沉重的步伐调节成春天五线谱上的音符，让自己踏着轻快的节奏，在人生的海面上悠然漂荡，享受宁静与
    
                                
    • 
                                
  • php二进制安全的含义
                                    dcj3sjt126com
PHP
                                    
    PHP里，有string的概念。
string里，每个字符的大小为byte（与PHP相比，Java的每个字符为Character，是UTF8字符，C语言的每个字符可以在编译时选择）。
byte里，有ASCII代码的字符，例如ABC，123，abc，也有一些特殊字符，例如回车，退格之类的。
特殊字符很多是不能显示的。或者说，他们的显示方式没有标准，例如编码65到哪儿都是字母A，编码97到哪儿都是字符
    
                                
    • 
                                
  • Linux下禁用T440s，X240的一体化触摸板(touchpad)
                                    gashero
linuxThinkPad触摸板
                                    
    自打1月买了Thinkpad T440s就一直很火大，其中最让人恼火的莫过于触摸板。 
  
Thinkpad的经典就包括用了小红点(TrackPoint)。但是小红点只能定位，还是需要鼠标的左右键的。但是自打T440s等开始启用了一体化触摸板，不再有实体的按键了。问题是要是好用也行。 
  
实际使用中，触摸板一堆问题，比如定位有抖动，以及按键时会有飘逸。这就导致了单击经常就
    
                                
    • 
                                
  • graph_dfs
                                    hcx2013
Graph
                                    
    package edu.xidian.graph;

class MyStack {
	private final int SIZE = 20;
	private int[] st;
	private int top;

	public MyStack() {
		st = new int[SIZE];
		top = -1;
	}

	public void push(i
    
                                
    • 
                                
  • Spring4.1新特性——Spring核心部分及其他
                                    jinnianshilongnian
spring 4.1
                                    
    目录 
Spring4.1新特性——综述 
Spring4.1新特性——Spring核心部分及其他 
Spring4.1新特性——Spring缓存框架增强 
Spring4.1新特性——异步调用和事件机制的异常处理 
Spring4.1新特性——数据库集成测试脚本初始化 
Spring4.1新特性——Spring MVC增强 
Spring4.1新特性——页面自动化测试框架Spring MVC T
    
                                
    • 
                                
  • 配置HiveServer2的安全策略之自定义用户名密码验证
                                    liyonghui160com

                                    
      
  
具体从网上看 
  
http://doc.mapr.com/display/MapR/Using+HiveServer2#UsingHiveServer2-ConfiguringCustomAuthentication 
  
 
  
   
   LDAP Authentication using OpenLDAP 
   Setting 
    
                                
    • 
                                
  • 一位30多的程序员生涯经验总结
                                    pda158
编程工作生活咨询
                                    
    1.客户在接触到产品之后，才会真正明白自己的需求。 
　　这是我在我的第一份工作上面学来的。只有当我们给客户展示产品的时候，他们才会意识到哪些是必须的。给出一个功能性原型设计远远比一张长长的文字表格要好。 2.只要有充足的时间，所有安全防御系统都将失败。 
　　安全防御现如今是全世界都在关注的大课题、大挑战。我们必须时时刻刻积极完善它，因为黑客只要有一次成功，就可以彻底打败你。   3.
    
                                
    • 
                                
  • 分布式web服务架构的演变
                                    自由的奴隶
linuxWeb应用服务器互联网
                                    
    最开始，由于某些想法，于是在互联网上搭建了一个网站，这个时候甚至有可能主机都是租借的，但由于这篇文章我们只关注架构的演变历程，因此就假设这个时候已经是托管了一台主机，并且有一定的带宽了，这个时候由于网站具备了一定的特色，吸引了部分人访问，逐渐你发现系统的压力越来越高，响应速度越来越慢，而这个时候比较明显的是数据库和应用互相影响，应用出问题了，数据库也很容易出现问题，而数据库出问题的时候，应用也容易
    
                                
    • 
                                
  • 初探Druid连接池之二——慢SQL日志记录
                                    xingsan_zhang
日志连接池druid慢SQL
                                    
    由于工作原因，这里先不说连接数据库部分的配置，后面会补上，直接进入慢SQL日志记录。 
  
1.applicationContext.xml中增加如下配置： 
<bean abstract="true" id="mysql_database" class="com.alibaba.druid.pool.DruidDataSourc
    
                                
    •