pepe_士奇
pepe_士奇

RxJava----操作符：组合操作符

Combining Observables（组合操作符）

本节介绍如何把多个数据源的数据组合为一个数据源的操作函数。

repeat

repeat 顾名思义，可以重复的发射自己。 repeat 不会缓存之前的数据，当再次发射数据的时候，会从新就算数据。

对一个Observable重复发射

repeat和repeatWhen操作符默认情况下是运行在一个新线程上的，当然你可以通过传入参数来修改其运行的线程。

RxJava----操作符：组合操作符_第1张图片

public final Observable repeat()
public final Observable repeat(long count)

         Observable.just(1,2)
//              .repeat()//无限循环
                .repeat(2)
                .subscribe(new Action1<Integer>() {
                    @Override
                    public void call(Integer integer) {
                        log(integer+"");
                    }
                });

结果：

1
2
1
2

repeatWhen

repeatWhen 可以指定一个条件，当该条件满足的时候才重复发射数据流。条件为一个 Observable，当源Observable结束的时候，会等待 条件 Observable 来发射数据通知源 Observable 重复发射数据流。如果条件 Observable结束了，则不会触发源 Observable 重复发射数据。

有时候需要知道一个重复发射的数据量是何时结束的。repeatWhen 提供了一种特别的 Observable 在数据流结束的时候发射一个Void。可以使用这个 Observable来当做一种信号。

public final Observable<T> repeatWhen(
    Func1 super Observable extends java.lang.Void>,? extends Observable>> notificationHandler)

RxJava----操作符：组合操作符_第2张图片

repeatWhen 的参数是一个函数，该函数的参数为 Observable 返回另外一个 Observable。这两个Observable 发射的数据类型是无关紧要的。输入的 Observable 用了表示重复结束的信号，返回的 Observable 用来表示重新开始的信号。
下一个示例使用 repeatWhen 来自己实现一个 repeat(n) ：

        Observable values = Observable.interval(100, TimeUnit.MILLISECONDS);
        values
                .take(2)
                .repeatWhen(new Func1, Observable>() {
                    @Override
                    public Observable call(Observable observable) {
                        return observable.take(2);
                    }
                })
                .subscribe(new Action1() {
                    @Override
                    public void call(Object o) {
                        log(o.toString());
                    }
                }); 
  
结果：
 
  
0
1
0
1
 
  
上面的示例中，当重复发射完成后，ob 就立刻发射信号告诉源 Observable 重新发射。 
 下面的示例中，创建一个每隔两秒就重复一次的无限循环数据流：
 
  
        Observable values2 = Observable.interval(100, TimeUnit.MILLISECONDS);
        values2
                .take(3)
                .repeatWhen(new Func1, Observable>() {
                    @Override
                    public Observable call(Observable observable) {
                        return Observable.interval(2, TimeUnit.SECONDS);
                    }
                })
                .subscribe(new Action1() {
                    @Override
                    public void call(Object o) {
                        log(o.toString());
                    }
                }); 
  
结果：
 
  
0
1
2
(隔两秒)
0
1
2
...
 
  
注意上面的返回的条件 Observable 每隔两秒就发射一次信号。在后面会介绍更多关于时间控制的技巧。 
 另外一个需要注意的就是 ob.subscribe() 语句，看起来是多余的其实是必不可少的。这样会强制创建 ob 对象，当前 repeatWhen 的实现需要 ob 被订阅，否则是不会触发重复发射数据的。
 
  
startWith
 
  
 
   
startWith 的参数为一个数据流，然后先发射该数据再发射 源 Observable 中的数据。
 
  
 
  
public final Observable startWith(java.lang.Iterable values)
public final Observable startWith(Observable values)
public final Observable startWith(T t1)
public final Observable startWith(T t1, T t2)
public final Observable startWith(T t1, T t2, T t3)
// up to 10 values
 
  
RxJava----操作符：组合操作符_第3张图片
 
  
        Observable values = Observable.range(0, 3);
        values.startWith(-1,-2)
                .subscribe(new Action1() {
                    @Override
                    public void call(Object o) {
                        log(o.toString());
                    }
                }); 
  
结果：
 
  
-1
-2
0
1
2
 
  
startWith 是使用 参数为 just 的 concat 函数的简写。
 
  
Observable.concat(
    Observable.just(-1,-2,-3),
    values)
// 和下面的是一样的效果
values.startWith(-1,-2,-3)
 
  
merge
 
  
 
   
merge 把多个 Observable 合并为一个，合并后的 Observable 在每个源Observable发射数据的时候就发射同样的数据。所以多个源 Observable 的数据最终是混合是一起的：
 
  
 
  
public static final <T> Observable<T> merge(
    java.lang.IterableT>> sequences)
public static final <T> Observable<T> merge(
    java.lang.IterableT>> sequences,
    int maxConcurrent)
public static final <T> Observable<T> merge(
    ObservableT>> source)
public static final <T> Observable<T> merge(
    ObservableT>> source,
    int maxConcurrent)
public static final <T> Observable<T> merge(
    ObservableT> t1,
    ObservableT> t2)
public static final <T> Observable<T> merge(
    ObservableT> t1,
    ObservableT> t2,
    ObservableT> t3)
...
 
  
RxJava----操作符：组合操作符_第4张图片
 
  
示例：
 
  
        Observable.merge(
                Observable.interval(250, TimeUnit.MILLISECONDS) .map(new Func1() {
                    @Override
                    public Object call(Long aLong) {
                        return "First";
                    }
                }),
                Observable.interval(150, TimeUnit.MILLISECONDS).map(new Func1() {
                    @Override
                    public Object call(Long aLong) {
                        return "Second";
                    }
                }))
                .take(10)
                .subscribe(new Action1() {
                    @Override
                    public void call(Object o) {
                        log(o.toString());
                    }
                }); 
  
结果：
 
  
Second
First
Second
Second
First
Second
Second
First
Second
First
 
  
concat 和 merge 的区别是:
 
  
     
   
  • merge 不会等到前面一个 Observable 结束才会发射下一个 Observable 的数据
    •  
   
  • merge 订阅到所有的 Observable 上，如果有任何一个 Observable 发射了数据，则 就把该数据发射出来。
    •  
  
 
  
mergeWith
 
  
 
   
同样 还有一个 mergeWith 函数用了串联调用。
 
  
 
  
        Observable.interval(250, TimeUnit.MILLISECONDS).map(new Func1() {
            @Override
            public Object call(Long aLong) {
                return "First";
            }
        })
                .mergeWith(Observable.interval(150, TimeUnit.MILLISECONDS).map(new Func1() {
                    @Override
                    public Object call(Long aLong) {
                        return "Second";
                    }
                }))
                .take(10)
                .subscribe(new Action1() {
                    @Override
                    public void call(Object o) {
                        log(o.toString());
                    }
                }); 
  
和上面merge 输出的结果一样。
 
  
mergeDelayError
 
  
 
   
合并几个不同的Observable，merge 中如果任意一个源 Observable 出现错误了，则 merge 后的 Observable 也就出错并结束发射。使用mergeDelayError 可以推迟发生的错误，继续发射其他 Observable 发射的数据。
 
  
 
  
public static final <T> Observable<T> mergeDelayError(
    ObservableT>> source)
public static final <T> Observable<T> mergeDelayError(
    ObservableT> t1,
        ObservableT> t2)
public static final <T> Observable<T> mergeDelayError(
    ObservableT> t1,
    ObservableT> t2,
    ObservableT> t3)
...
 
  
RxJava----操作符：组合操作符_第5张图片
 
  
        Observable failAt200 = Observable.concat(
                        Observable.interval(100, TimeUnit.MILLISECONDS).take(2),
                        Observable.error(new Exception("Failed")));
        Observable completeAt400 =
                Observable.interval(100, TimeUnit.MILLISECONDS)
                        .take(4);
        Observable.mergeDelayError(failAt200, completeAt400)
                .subscribe(new Action1() {
                    @Override
                    public void call(Object o) {
                        log(o.toString());
                    }
                }, new Action1() {
                    @Override
                    public void call(Throwable throwable) {
                        log(throwable.getMessage().toString());
                    }
                }); 
  
结果：
 
  
0
0
1
1
2
3
Failed
 
  
 
   
上面的示例中，开始两个 Observable 都发射一样的数据，当发射第二个数据 1 后，第一个 Observable抛出一个异常退出，而合并后的数据流继续发射直到所有的 Observable 完成或者也出现异常。
 
   
如果合并多个 Observable，则合并后的 Observable 只有当所有源 Observable 结束后才结束，如果有多个源 Observable 出现了异常，则合并后的 Observable 会用一个 CompositeException 来结束。
 
  
 
  
        Observable failAt200 = Observable.concat(
                        Observable.interval(100, TimeUnit.MILLISECONDS).take(2),
                        Observable.error(new Exception("Failed")));
        Observable failAt300 = Observable.concat(
                        Observable.interval(100, TimeUnit.MILLISECONDS).take(3),
                        Observable.error(new Exception("Failed")));
        Observable completeAt400 = Observable.interval(100, TimeUnit.MILLISECONDS)
                        .take(4);
        Observable.mergeDelayError(failAt200, failAt300, completeAt400)
                .subscribe(new Action1() {
                    @Override
                    public void call(Object o) {
                        log(o.toString());
                    }
                }, new Action1() {
                    @Override
                    public void call(Throwable throwable) {
                        log(throwable.getMessage().toString());
                    }
                }); 
  
结果：
 
  
0
0
0
1
1
1
2
2
3
2 exceptions occurred. 
 
  
switchOnNext
 
  
     
   
  • switchOnNext 的参数为一个返回 Observable 对象的 Observable。
    •  
   
  • 也就是说，这个参数为一个Observable， 但是这个 Observable 所发射的数据类型是 Observable 。
    •  
  
 
  
switchOnNext 返回的Observable 发射数据的规则如下：
 
  
     
   
  • 在参数 Observable 返回的 Observable 中，把最先发射数据的 Observable 中的数据拿来转发，如果之后又有新的Observable 开始发射数据了，则就切换到新的 Observable 丢弃前一个。 
     RxJava----操作符：组合操作符_第6张图片
    •  
  
 
  
        Observable.switchOnNext(
                Observable.interval(100, TimeUnit.MILLISECONDS).map(new Func1>() {
                    @Override
                    public Observable call(final Long aLong1) {
                        return Observable.interval(30, TimeUnit.MILLISECONDS).map(new Func1() {
                            @Override
                            public Object call(Long aLong2) {
                                return aLong1;
                            }
                        });
                    }
                }))
                .take(9)
                .subscribe(new Action1() {
                    @Override
                    public void call(Object o) {
                        log(o.toString());
                    }
                }); 
  
结果：
 
  
0
0
0
1
1
1
2
2
2
 
  
 
   
注意上面示例中 switchOnNext 的参数 每隔 100毫秒返回一个 Observable 。这个返回的 Observable 会每隔 30 毫秒发射一个数字，这个数字被映射为 100毫秒发射一个数据的 Observable返回的数据。所以在第一个100毫秒的时候，switchOnNext 的参数返回的第一个 Observable 可以发射3个数据 0，然后到第100毫秒的时候，switchOnNext 的参数返回的第二个 Observable 开发发射数据1， 所以前一个发射数据 0 的 Observable 就被丢弃了， switchOnNext 切换到新的发射数据的 Observable。
 
  
 
  
switchMap
 
  
 
   
就像 flatMap 内部使用 merge 来组合发射的数据；以及 concatMap 使用 concat 来组合数据，而switchMap 内部使用 switchOnNext 来打散组合数据。
 
  
 
  
public final  Observable switchMap(Func1super T,? extends Observableextends R>> func)
 
  
RxJava----操作符：组合操作符_第7张图片
 
  
 
   
源 Observable 所发射的每一个数据都被 func 函数给转换为一个新的 Observable 了。每次只要 源Observable发射一个数据，func 函数都把该数据转换为一个 Observable 然后 switchMap 返回的 Observable就使用这个新的 Observable 来发射数据。
 
  
 
  
前面的示例也可以用 switchMap 实现：
 
  
        Observable.interval(100, TimeUnit.MILLISECONDS)
                .switchMap(new Func1>() {
                    @Override
                    public Observable call(final Long aLong1) {
                        return Observable.interval(30, TimeUnit.MILLISECONDS)
                                .map(new Func1() {
                                    @Override
                                    public Object call(Long aLong2) {
                                        return aLong1;
                                    }
                                });
                    }
                })
                .take(9)
                .subscribe(new Action1() {
                    @Override
                    public void call(Object o) {
                        log(o.toString());
                    }
                }); 
  
结果：
 
  
0
0
0
1
1
1
2
2
2
 
  
Pairing sequences
 
  
 
   
下面几个操作符用来把多个源 Observable 发射的数据组合成一个数据。
 
  
 
  
zip
 
  
 
   
zip 是函数式编程中的一个基本概念，参数为多个源 Observable， 返回的结果是把这些源 Observable发射的数据按照顺序给组合起来。 
 RxJava----操作符：组合操作符_第8张图片
 
  
 
  
下面的示例中，有两个源 Observable 发射数据的速度是不一样的。
 
  
        Observable.zip(
                Observable.interval(100, TimeUnit.MILLISECONDS).doOnNext(new Action1() {
                    @Override
                    public void call(Long aLong) {
                        log("Left emits " + aLong);
                    }
                }),
                Observable.interval(150, TimeUnit.MILLISECONDS).doOnNext(new Action1() {
                    @Override
                    public void call(Long aLong) {
                        log("Right emits " + aLong);
                    }
                }),
                new Func2() {
                    @Override
                    public Object call(Long aLong, Long aLong2) {
                        return aLong + " - " + aLong2;
                    }
                })
                .take(6)
                .subscribe(new Action1() {
                    @Override
                    public void call(Object o) {
                        log(o.toString());
                    }
                }); 
  
结果：
 
  
Left emits 0
Right emits 0
0 - 0
Left emits 1
Right emits 1
Left emits 2
1 - 1
Left emits 3
Right emits 2
2 - 2
Left emits 4
Left emits 5
Right emits 3
3 - 3
Left emits 6
Right emits 4
4 - 4
Left emits 7
Right emits 5
Left emits 8
5 - 5
 
  
从上面示例中可以看到，zip 是按照顺序来组合数据的。

 
  
zip 有很多重载函数可以接受多个 Observable ：
 
  
public static final  Observable zip(
    java.lang.Iterableextends Observable> ws,
    FuncNextends R> zipFunction)
public static final  Observable zip(
    Observableextends Observable> ws,
    FuncNextends R> zipFunction)
public static final  Observable zip(
    Observableextends T1> o1,
    Observableextends T2> o2,
    Func2super T1,? super T2,? extends R> zipFunction)
public static final  Observable zip(
    Observableextends T1> o1,
    Observableextends T2> o2,
    Observableextends T3> o3,
    Func3super T1,? super T2,? super T3,? extends R> zipFunction)
...
 
  
如果有多个 源 Observable，则 zip 会等待最慢的一个 Observable 发射完数据才开始组合这次发射的所有数据。
 
  
        Observable.zip(
                Observable.interval(100, TimeUnit.MILLISECONDS),
                Observable.interval(150, TimeUnit.MILLISECONDS),
                Observable.interval(050, TimeUnit.MILLISECONDS),
                new Func3() {
                    @Override
                    public Object call(Long aLong, Long aLong2, Long aLong3) {
                        return aLong + " - " + aLong2 + " - " + aLong3;
                    }
                })
                .take(6)
                .subscribe(new Action1() {
                    @Override
                    public void call(Object o) {
                        log(o.toString());
                    }
                }); 
  
结果：
 
  
0 - 0 - 0
1 - 1 - 1
2 - 2 - 2
3 - 3 - 3
4 - 4 - 4
5 - 5 - 5
 
  
     
   
  • zip 的任意一个源 Observable 结束标示着 zip 的结束。
    •  
   
  • 其他源 Observable 后续发射的数据被忽略了。 
    •  
  
 
  
下面的例子组合三个 Observable，然后统计下 zip 返回的 Observable 发射了多少个数据：
 
  
        Observable.zip(
                Observable.range(0, 5),
                Observable.range(0, 3),
                Observable.range(0, 8),
                new Func3<Integer, Integer, Integer, Object>() {
                    @Override
                    public Object call(Integer integer, Integer integer2, Integer integer3) {
                        return integer + " - " + integer2 + " - " + integer3;
                    }
                })
                .count()
                .subscribe(new Action1<Object>() {
                    @Override
                    public void call(Object o) {
                        log(o.toString());
                    }
                });
 
  
结果：
 
  
3
 
  
所以：
 
  
     
   
  • zip 返回的Observable发射的速度和最慢的那个 Observable 一样
    •  
   
  • 发射的数据和发射最少数据的 那个 Observable 一样。
    •  
  
 
  
zipWidth 还可以使用一个 iterable 为参数：
 
  
        Observable.range(0, 5)
                .zipWith(Arrays.asList(0, 2, 4, 6, 8), new Func2<Integer, Integer, Object>() {
                    @Override
                    public Object call(Integer integer, Integer integer2) {
                        return integer + " - " + integer2;
                    }
                })
                .subscribe(new Action1<Object>() {
                    @Override
                    public void call(Object o) {
                        log(o.toString());
                    }
                });
 
  
结果：
 
  
0 - 0
1 - 2
2 - 4
3 - 6
4 - 8
 
  
zipWith
 
  
zip 还有一个 zipWith 操作函数：
 
  
        Observable.interval(100, TimeUnit.MILLISECONDS).zipWith(
                Observable.interval(150, TimeUnit.MILLISECONDS),
                new Func2() {
                    @Override
                    public Object call(Long aLong, Long aLong2) {
                        return aLong + " - " + aLong2;
                    }
                })
                .take(6)
                .subscribe(new Action1() {
                    @Override
                    public void call(Object o) {
                        log(o.toString());
                    }
                }); 
  
结果：
 
  
0 - 0
1 - 1
2 - 2
3 - 3
4 - 4
5 - 5
 
  
combineLatest
 
  
 
   
前面的 zip 使用源 Observable 发射的顺序为组合的标记，而 combineLatest 使用的是时间。只要 combineLatest 的任何一个源 Observable 发射数据，则就使用该数据和其他Observable最后一次发射的数据去组合。
 
  
 
  
RxJava----操作符：组合操作符_第9张图片
 
  
        Observable.combineLatest(
                Observable.interval(100, TimeUnit.MILLISECONDS).doOnNext(new Action1() {
                    @Override
                    public void call(Long aLong) {
                        log("Left emits " + aLong);
                    }
                }),
                Observable.interval(150, TimeUnit.MILLISECONDS).doOnNext(new Action1() {
                    @Override
                    public void call(Long aLong) {
                        log("Right emits " + aLong);
                    }
                })
                , new Func2() {
                    @Override
                    public Object call(Long aLong, Long aLong2) {
                        return aLong + " - " + aLong2;
                    }
                }
        )
                .take(6)
                .subscribe(new Action1() {
                    @Override
                    public void call(Object o) {
                        log(o.toString());
                    }
                }); 
  
结果：
 
  
Left emits
Right emits
0 - 0
Left emits
1 - 0
Left emits
2 - 0
Right emits
2 - 1
Left emits
3 - 1
Right emits
3 - 2
 
  
 
   
combineLatest 一开始等待所有的源 Observable 发射第一个数据，然后只要有任意一个 Observable发射数据，就用这个数据和其他 Observable 最后一次发射的数据组合。
 
   
combineLatest 同样有多个重载函数可以组合多个源 Observable。 combineLatest使用场景是只要有一个条件变化了就需要重新计算当前的数据或者状态。比如在用markdown写博客的时候，编辑器里面有个控制按钮为把单词的每个字母转换为大写字母的开关，输入框旁边有个预览界面。每当你在编辑框中输入内容或者改变大小写状态的时候，combineLatest 就用输入框和大小写状态的最新的值来重新渲染预览界面。
 
  
 
  
join
 
  
join操作符把类似于combineLatest操作符，也是两个Observable产生的结果进行合并，合并的结果组成一个新的Observable，但是join操作符可以控制每个Observable产生结果的生命周期，在每个结果的生命周期内，可以与另一个Observable产生的结果按照一定的规则进行合并，流程图如下： 
 RxJava----操作符：组合操作符_第10张图片 
 join方法的用法如下： 
 observableA.join(observableB, 
 observableA产生结果生命周期控制函数， 
 observableB产生结果生命周期控制函数， 
 observableA产生的结果与observableB产生的结果的合并规则） 
 上代码：
 
  
        //产生0,2,4,6,8数列
        Observable observable1 = Observable.timer(0, 1000, TimeUnit.MILLISECONDS)
                .map(new Func1() {
                    @Override
                    public Long call(Long aLong) {
                        return aLong * 2;
                    }
                }).take(5);

        //产生0,3,6,9,12数列
        Observable observable2 = Observable.timer(500, 1000, TimeUnit.MILLISECONDS)
                .map(new Func1() {
                    @Override
                    public Long call(Long aLong) {
                        return aLong * 3;
                    }
                }).take(5);

        observable1.join(observable2, new Func1>() {
            @Override
            public Observable call(Long aLong) {
                //使Observable持续600毫秒有效
                return Observable.just(aLong).delay(600, TimeUnit.MILLISECONDS);
            }
        }, new Func1>() {
            @Override
            public Observable call(Long aLong) {
                //使Observable持续600毫秒有效
                return Observable.just(aLong).delay(600, TimeUnit.MILLISECONDS);
            }
        }, new Func2() {
            @Override
            public Long call(Long aLong, Long aLong2) {
                return aLong + aLong2;
            }
        })
                .subscribe(new Action1() {
                    @Override
                    public void call(Long aLong) {
                        log(aLong + "");
                    }
                });
 
  
结果：
 
  
0
2
5
7
10
12
15
17
20
 
  
groupJoin
 
  
groupJoin操作符非常类似于join操作符，区别在于join操作符中第四个参数的传入函数不一致，其流程图如下： 
 RxJava----操作符：组合操作符_第11张图片
 
  
        //产生100,110,120,130,140数列
        Observable observable1 = Observable.timer(0, 1000, TimeUnit.MILLISECONDS)
                .map(new Func1() {
                    @Override
                    public Long call(Long aLong) {
                        log(System.currentTimeMillis()+"--1--");
                        return aLong*10+100;
                    }
                }).take(5);

        //产生1,3,5,7,9数列
        Observable observable2 = Observable.timer(500, 1000, TimeUnit.MILLISECONDS)
                .map(new Func1() {
                    @Override
                    public Long call(Long aLong) {
                        log(System.currentTimeMillis()+"--2--");
                        return aLong*2+1;
                    }
                }).take(5);

        observable1.groupJoin(observable2, new Func1>() {
            @Override
            public Observable call(Long aLong) {
                //使Observable持续1600毫秒有效
                return Observable.just(aLong).delay(1600, TimeUnit.MILLISECONDS);
            }
        }, new Func1>() {
            @Override
            public Observable call(Long aLong) {
                //使Observable持续600毫秒有效
                return Observable.just(aLong).delay(600, TimeUnit.MILLISECONDS);
            }
        }, new Func2, Observable>() {
            @Override
            public Observable call(final Long aLong, Observable observable) {
                return observable.map(new Func1() {
                    @Override
                    public Long call(Long aLong2) {
                        return aLong + aLong2;
                    }
                });
            }
        })
                .subscribe(new Action1>() {
                    @Override
                    public void call(Observable longObservable) {
                        longObservable.subscribe(new Action1() {
                            @Override
                            public void call(Long aLong) {
                                log(aLong +"");
                            }
                        });
                    }
                });
 
  
结果：
 
  
1462255209637--1--
1462255210138--2--
101
1462255210639--1--
111
1462255211137--2--
103
113
1462255211638--1--
123
1462255212137--2--
115
125
1462255212639--1--
135
1462255213138--2--
127
137
1462255213639--1--
147
1462255214140--2--
149
139
 
  
项目源码 GitHub求赞，谢谢！
 
  
引用： 
 RxJava 教程第三部分：驯服数据流之 组合数据流 - 云在千峰 
 Android RxJava使用介绍（四） RxJava的操作符 - 呼啸而过的专栏 - 博客频道 - CSDN.NET
 
  

                            
                        
                    
                    
                    

                    
                    
                    

                
                

                    
                

            
        
    
    

        
你可能感兴趣的:(开源框架)

        

            

                
    
                    
  • Spring1-概述
                        Onlooker129
Springspring
                        
    目录Spring是什么Spring的狭义和广义SpringFramework特点Spring模块组成Spring是什么Spring是一款主流的JavaEE轻量级开源框架，Spring由“Spring之父”RodJohnson提出并创立，其目的是用于简化Java企业级应用的开发难度和开发周期。Spring的用途不仅限于服务器端的开发。从简单性、可测试性和松耦合的角度而言，任何Java应用都可以从Sp
    
                    
    • 
                    
  • Java Spring Boot 全面教程
                        极客代码
玩转Javajavaspringboot开发语言后端
                        
    一、SpringBoot简介与环境搭建1.1SpringBoot简介SpringBoot是一种基于Java的开源框架，由PivotalSoftware开发，旨在简化新Spring应用程序的初始化、配置和部署过程。它遵循约定优于配置的原则，通过内嵌的Tomcat、Jetty或Undertow等容器，使得开发者能够快速构建独立运行的、生产级别的基于Spring框架的应用程序。SpringBoot包含了
    
                    
    • 
                    
  • Rust 编程语言构建出跨平台应用开源框架 Dioxus
                        百态老人
rust开源开发语言
                        
    是的，Rust编程语言确实构建了一个跨平台应用开源框架Dioxus。Dioxus是一个可移植、高性能的框架，用于在Rust中构建跨平台的用户界面。它支持多种平台的应用开发，包括网页前端、桌面应用、静态网站、移动端应用和TUI程序等。Dioxus的核心特点之一是其声明式编程风格，类似于React框架，但提供了更高效的性能和更好的开发者体验。此外，Dioxus还具有原生桌面支持、强大的状态管理、快速异
    
                    
    • 
                    
  • Ionic 头部和底部
                        lly202406
开发语言
                        
    Ionic头部和底部Ionic是一个强大的开源框架，用于构建高性能、高质量的移动和桌面应用程序。它以其优雅的UI组件和强大的功能而闻名，其中包括头部（Header）和底部（Footer）组件。本文将详细介绍Ionic框架中的头部和底部组件，包括它们的用途、配置选项以及如何在Ionic应用程序中实现它们。Ionic头部组件Ionic头部组件通常用于显示应用程序的标题、副标题和导航按钮。它是应用程序界
    
                    
    • 
                    
  • 洞悉LangChain：LangChain工程化设计，从API到智能Agent的全面探索
                        汀、人工智能
AIAgentLLM技术汇总langchain人工智能自然语言处理大模型AgentLangGraphAIAgent
                        
    洞悉LangChain：LangChain工程化设计，从API到智能Agent的全面探索1.LangChain简介LangChain是2022年10月底，由哈佛大学的HarrisonChase发起的基于开源大语言模型的AI工程开发框架。当然也可以问一下AI：通义千问2.5：LangChain是一个开源框架，专注于简化开发者利用大型语言模型（LLM）创建应用程序的过程。这些大型语言模型，如GPT-3
    
                    
    • 
                    
  • 2024最新Android大厂面试真题大全（附答案）
                        imtokenmax合约众筹
2024年程序员面试android面试职场和发展
                        
    五、架构设计和设计模式1.谈谈你对Android设计模式的理解2.MVCMVPMVVM原理和区别3.你所知道的设计模式有哪些？4.项目中常用的设计模式5.手写生产者/消费者模式6.写出观察者模式的代码7.适配器模式，装饰者模式，外观模式的异同？8.用到的一些开源框架，介绍一个看过源码的，内部实现过程。9.谈谈对RxJava的理解10.Rxjava发送事件步骤11.RxJava的作用，与平时使用的异
    
                    
    • 
                    
  • Java架构师学习路线
                        网络全息测量
心得体会
                        
    (1)第一步：研究spring,hibernate。通过研究jeecms开源框架。也同时学习css,html,javascript,jquery.以前都学习过，不过没有系统学习过，现在必须系统学习。同时看cms相关的论文。然后，改造jeecms能够改为自己的一个开源框架，以后开发cms系统都用我自己开发的框架，作为第一阶段的成果。(2)第二步：学习开源工作流引擎Activiti5，jbpm4.4以
    
                    
    • 
                    
  • 基于webrtc的多人连麦直播开源框架 Janus-gateway-iOS
                        天宇365
ios日常笔记iosobjective-c
                        
    低延时、地卡顿、高音画质是直播技术方向追求的方向，webrtc属于业内良心开源项目，绝大多数连麦直播技术基于此项目，连麦技术架构有Mesh、MCU、SFU三种技术架构。三种技术架构优缺点各异，大家可以自行查阅。但是基于目前的直播状况，现在最合适的，也是使用比较多的是SFU架构。但是SFU架构除了客户端的webrtc需要完成，更重要的服务器也需要搭建。如果你需要多人连麦直播  Janus-gatew
    
                    
    • 
                    
  • 【脚手架 第一篇章】介绍一下若依微服务版框架
                        蜗牛 | ICU
脚手架专栏微服务架构云原生
                        
    若依框架（RuoYi）是一个广泛使用的开源框架，它提供了多种版本以满足不同开发需求。以下是关于若依框架微服务版（RuoYi-Cloud）的详细介绍：一、概述RuoYi-Cloud是基于SpringCloud和SpringBoot的分布式微服务架构平台，专为构建大型分布式系统提供完整的解决方案。它集成了众多微服务特性，如服务发现、配置管理、负载均衡等，适合需要高可扩展性和高可用性的企业级应用。二、技
    
                    
    • 
                    
  • OmniParse：解锁生成式AI潜能的全能数据解析框架
                        花生糖@
AIGC学习资源人工智能AI代码AI实战
                        
    在当今信息爆炸的时代，非结构化数据如潮水般涌来，而如何有效驾驭这些数据，使之成为驱动智能应用的燃料，成为了业界亟待解决的挑战。在此背景下，OmniParse应运而生，作为一个开源框架，它致力于将复杂的非结构化数据转化为生成式AI应用所需的清晰、可操作的结构化数据。本文将深入剖析OmniParse的核心优势与特性，探讨其如何赋能AI+PDF工具、知识库产品的开发，以及其在各行业的潜在应用价值。一、核
    
                    
    • 
                    
  • 2020 年 Github 上最牛的 Java 进阶教程及 Java 实战项目都在这里了！
                        C陈三岁
javajavagithub开发语言面试架构
                        
    写在前面大家都知道Github是一个程序员福地，这里有各种厉害的开源框架、软件或者教程。这些东西对于我们学习和进步有着莫大的进步，所以我有了这个将Github上非常棒的Java开源项目整理下来的想法。觉得不错的话，欢迎小伙伴们去star一波。很多小伙伴都不知道学习什么开源项目，这篇文章定能为你解决疑惑。不论你想要看Java教程方向的开源项目、Java实战项目、SpringBoot教程还是说想要看微
    
                    
    • 
                    
  • Spring基础
                        zzzzzzzziu
springjava后端
                        
    前言Spring是一个开源的Java平台，用于构建企业级应用程序。它提供了一系列的模块和工具，以简化Java应用程序的开发。Spring框架的核心特点是轻量级、灵活性和可扩展性。以下是Spring基础知识的详细概述：Spring概述开源框架：Spring是一个开源的Java平台，广泛用于企业级应用开发。核心特性：Spring通过依赖注入（DI）和面向切面编程（AOP）等技术，降低了组件之间的耦合度
    
                    
    • 
                    
  • 如何彻底搞懂迭代器（Iterator）设计模式？
                        职略
设计模式
                        
    说起迭代器（Iterator），相信你并不会陌生，因为我们几乎每天都在使用JDK中自带的各种迭代器。那么，这些迭代器是如何构建出来的呢？就需要用到了今天内容要介绍的迭代器设计模式。在日常开发过程中，我们可能很少会自己去实现一个迭代器，但掌握迭代器设计模式对于我们学习一些开源框架的源码还是很有帮助的，因为在像Mybatis等主流开发框架中都用到了迭代器模式。迭代器设计模式的概念和简单示例在对迭代器模
    
                    
    • 
                    
  • android开源框架
                        探求之路
android开源okhttp
                        
    facebook/frescoFresco是一个在Android应用程序中显示图像的强大系统。壁画负责图像的加载和显示，所以你不必这么做。它将从网络、本地存储或本地资源加载图像，并在图像到达之前显示一个占位符。它有两个级别的缓存：一个在内存中，另一个在内部存储器中。在android4.x及更低版本中，fresco将图像放在android内存的一个特殊区域。这使您的应用程序运行得更快，并且更少地遭受
    
                    
    • 
                    
  • Python爬虫实战
                        weixin_34007879
爬虫jsonjava
                        
    引言网络爬虫是抓取互联网信息的利器，成熟的开源爬虫框架主要集中于两种语言Java和Python。主流的开源爬虫框架包括：1.分布式爬虫框架：Nutch2.Java单机爬虫框架：Crawler4j,WebMagic,WebCollector、Heritrix3.python单机爬虫框架：scrapy、pyspiderNutch是专为搜索引擎设计的的分布式开源框架，上手难度高，开发复杂，基本无法满足快
    
                    
    • 
                    
  • 热修复从零开始一热修复原理
                        丶小民工

                        
    什么是热修复呢热修复就是我们的app在线上运行的时候出现了bug可以在不发新版本安装包只用发布补丁包用户无感知的前提下修复bug的技术那么热修复要怎么实现呢需要分为开发端服务端以及用户端三个部分开发端的任务自然是修复bug生成补丁包服务端的任务主要是管理补丁包而用户端自然就是下载执行补丁包介绍一下几个主要的开源框架各大开源热更库的对比AndFix与Robust的原理即在编译打包阶段自动插入一段代码
    
                    
    • 
                    
  • Python大数据：深入探索Hadoop库的使用
                        t0_54coder
Python基础入门教程大数据pythonhadoop
                        
    在大数据的世界中，Python和Hadoop结合使用，为处理庞大数据集提供了强大的工具。本文将详细探讨如何在Python中使用Hadoop，特别是通过实例来展示这一过程。1.简介Hadoop是一个用于分布式处理大量数据的开源框架。尽管Hadoop主要用Java编写，但通过HadoopStreaming，Python程序员也可以利用其强大的数据处理能力。Python在数据科学中的流行，加上Hadoo
    
                    
    • 
                    
  • 利用LangChain构建MySQL数据库问答代理
                        Free_Gemini
langchain数据库mysqlpython
                        
    引言随着自然语言处理技术的飞速发展，尤其是大型语言模型（LLM）的应用日益广泛，人们对于如何更高效地与这些模型交互产生了浓厚的兴趣。LangChain是一个旨在简化与语言模型集成的开源框架，它使得开发者能够轻松地构建出强大的应用程序。本文将介绍如何使用LangChain结合MySQL数据库创建一个简单的问答代理。LangChain简介LangChain是一个开源项目，它的目标是让开发者更容易地创建
    
                    
    • 
                    
  • 手写Spring框架，加深对Spring工作机制的理解！
                        Java提升营

                        
    在我们的日常工作中，经常会用到Spring、SpringBoot、SpringCloud、Struts、Mybatis、Hibernate等开源框架，有了这些框架的诞生，平时的开发工作量也是变得越来越轻松，我们用SpringBoot分分钟可以新建一个Web项目。记得自己刚开始工作的时候还是在用Servlet写Web项目，自己写数据库连接池，用原生JDBC操作数据库，好了不发散了。回到这篇文章的主题
    
                    
    • 
                    
  • Spring系列之设计模式
                        johnny233
设计模式Springspring设计模式
                        
    Spring作为Java世界当之无愧的No.1开源框架，其架构设计非常优秀，使用很多设计模式。注：本文参考Spring-6.1.5版本源码；本文目录设置参考设计模式三大类来划分，Spring家族包括Spring、SpringMVC、SpringBoot、SpringCloud、SpringData等，总之Spring源码博大精深；某一种设计模式会在若干个Spring接口、类、或模块里有所体现，不可
    
                    
    • 
                    
  • 六、SpringCloud Alibaba + Spring Boot + mybatis +数据中台+多租户saas+前后端分离之Spring Cloud Alibaba基于Nacos分布式配置中心
                        不会写代码的女程序猿
分布式springbootspringcloud
                        
    1.前言在上一篇文章，我们实现了基于nacos做分布式配置中心，实施的存储、更新我们的配置文件数据，在使用以往的一些配置中心时，服务重启或者注册中心重启后，配置文件数据将会丢失，这种情况是因为将数据储存在JVM的内存当中，当JVM不再提供运行时，数据也会相应的丢失，一些开源框架默认将数据存储在JVM内存中的还挺多的，那么nacos又是存储在哪里呢？架构技术选型核心框架SpringBootSOASp
    
                    
    • 
                    
  • 一、Spring Ioc&DI配置使用
                        禹王穆

                        
    什么是SpringSpring是一个轻量级的，可以创建对象设置属性值并管理对象的开源框架为什么要学Spring提高项目可维护度，提高开发效率Ioc思想和DI思想Ioc思想：将创建对象的控制权交给Spring，让Spring帮我们创建并管理对象DI思想：在Spring创建对象之后，Spring调用对象的setXxx方法，将Value的值设置到对象的属性中使用Spring的基本流程添加Spring的依
    
                    
    • 
                    
  • React-Native优质开源项目
                        换个网名有点难
reactnative
                        
    ReactNative是一个由Facebook开发的开源框架，允许开发者使用JavaScript和React来构建原生移动应用。它允许开发者编写一次代码，然后可以在iOS和Android平台上运行，而无需为每个平台单独编写代码。以下是ReactNative的一些关键特点和优势：跨平台开发：使用ReactNative，开发者可以为iOS和Android创建应用，而不需要分别学习Swift或Java/
    
                    
    • 
                    
  • 计算机毕业设计python企业员工信息管理系统 03j8q
                        QQ58850198
课程设计python开发语言
                        
    本员工工资管理系统使用了开源框架vue开发实现了员工工资管理系统，并且使用了开发工具vscode和数据库MySQL。在开发实现员工工资管理系统之前，需要对系统进行需求分析和调研，从而分析出员工工资管理系统需要具备什么样的功能，设计出对应的总体架构，开发实现完员工工资管理系统之后还需要对系统进行测试。本次开发的员工工资管理系统功能包括：员工：个人中心、员工工资管理、工资变动管理。管理员：个人中心、员
    
                    
    • 
                    
  • （十五）Flink 内存管理机制
                        springk
Flink全景解析flink大数据实时数据flink内存管理内存管理机制
                        
    在大数据领域，很多开源框架（Hadoop、Spark、Storm）都是基于JVM运行，但是JVM的内存管理机制往往存在着诸多类似OutOfMemoryError的问题，主要是因为创建大量的实例，超过JVM的最大堆内存限制，没有被有效的回收。这在很大程度上影响了系统的稳定性，因此很多框架都实现了自己的内存管理，从而更好的使用JVM来处理大规模数据集。本章我们通过对Flink内存模型、JobManag
    
                    
    • 
                    
  • Android 关于ormlite数据库框架解析（二）
                        哎呦不错哦啊呀嘿
android开源框架数据库框架ormlite
                        
    今天又找了了一篇博客，解决了我的燃眉之急，，分享如下：OrmLite是一个数据库操作辅助的开源框架，主要面向Java语言。在Android面向数据库开发中，是一个比较流行的开源框架，方便操作而且功能强大，今天来学习一下，最近的项目中也有所涉及，写个博客来记一下吧，感谢大神团队贡献如此实用的开源框架，准备工作–创建数据库及数据表ORMlite通过Java注解的方式来建立起与数据库的映射关系，在这里我
    
                    
    • 
                    
  • DB-GPT开源项目文档入门
                        AlphaFree_
微信公众号文章gpt
                        
    DB-GPT开源项目文档入门(qq.com)场景：服务中小金融机构、服务业小微商家DB-GPT项目集成了多模型管理、多数据源管理、Text2SQL、增强检索RAG、生成式BI、多智能体，一个大而全的开源框架项目基本信息简介：一个原生数据应用开发框架技术能力：服务化多模型管理框架（SMMF，Service-orientedMulti-modelManagementFramework）Text2SQL
    
                    
    • 
                    
  • 【大模型从入门到精通39】LLM部署运维（LLM Ops）使用Kubeflow Pipelines掌握LLM工作流1
                        水木流年追梦
大模型运维开源langchain机器人语言模型
                        
    使用KubeflowPipelines掌握LLM工作流在本节中，我们将深入探讨如何使用KubeflowPipelines来编排和自动化机器学习工作流。KubeflowPipelines是一个开源框架，旨在简化机器学习管道的构建和管理。这款强大的工具使数据科学家、机器学习工程师和开发者能够高效地定义、部署和管理复杂的流水线。设置KubeflowPipelines首先，我们需要从KubeflowPip
    
                    
    • 
                    
  • string框架应用
                        java复习篇
springmaven
                        
    Spring框架是LoC和DI以及AOP思想实现的开源框架，简化开发操作，保留传统开发的优势是一个黏合器springMVC+Spring+MybatisLoC思想：javaweb组件之间的依赖和对象的创建都交给LoC思想的容器创建DI思想：依赖注入如何使用Spring框架（maven）在pom.Xml文件中导入SPring框架依赖在resources文件配置Spring框架，文件名固定（appli
    
                    
    • 
                    
  • Spring笔记（一）
                        m0_75227909
spring笔记java
                        
    一、了解Spring1.Spring概述Spring是分层的JavaSE/EE应用full-stack轻量级开源框架，以IOC（InverseOfControl：反转控制）和AOP（AspectOrientedProgramming：面向切面编程）为内核，提供了展现层SpringMVC和持久层SpringJDBC以及业务层事务管理等众多的企业级应用技术，还能整合开源世界众多著名的第三方框架和类库，
    
                    
    • 
                                
  • SAX解析xml文件
                                    小猪猪08
xml
                                    
    1.创建SAXParserFactory实例 
2.通过SAXParserFactory对象获取SAXParser实例 
3.创建一个类SAXParserHander继续DefaultHandler，并且实例化这个类 
4.SAXParser实例的parse来获取文件 
    public static void main(String[] args) { 
 //
    
                                
    • 
                                
  • 为什么mysql里的ibdata1文件不断的增长？
                                    brotherlamp
linuxlinux运维linux资料linux视频linux运维自学
                                    
    我们在 Percona 支持栏目经常收到关于 MySQL 的 ibdata1 文件的这个问题。 
当监控服务器发送一个关于 MySQL 服务器存储的报警时，恐慌就开始了 —— 就是说磁盘快要满了。 
一番调查后你意识到大多数地盘空间被 InnoDB 的共享表空间 ibdata1 使用。而你已经启用了 innodbfileper_table，所以问题是： 
ibdata1存了什么？ 
当你启用了 i
    
                                
    • 
                                
  • Quartz-quartz.properties配置
                                    eksliang
quartz
                                    
    其实Quartz JAR文件的org.quartz包下就包含了一个quartz.properties属性配置文件并提供了默认设置。如果需要调整默认配置，可以在类路径下建立一个新的quartz.properties，它将自动被Quartz加载并覆盖默认的设置。 
  
下面是这些默认值的解释 
#-----集群的配置
org.quartz.scheduler.instanceName =
    
                                
    • 
                                
  • informatica session的使用
                                    18289753290
workflowsessionlogInformatica
                                    
    如果希望workflow存储最近20次的log，在session里的Config  Object设置，log  options做配置，save  session log :sessions  run  ;savesessio log for  these runs:20 
session下面的source 里面有个tracing 
    
                                
    • 
                                
  • Scrapy抓取网页时出现CRC check failed 0x471e6e9a != 0x7c07b839L的错误
                                    酷的飞上天空
scrapy
                                    
    Scrapy版本0.14.4 
出现问题现象： 
  
ERROR: Error downloading <GET http://xxxxx  CRC check failed 
  
解决方法 
  
1.设置网络请求时的header中的属性'Accept-Encoding': '*;q=0' 
  
明确表示不支持任何形式的压缩格式，避免程序的解压
    
                                
    • 
                                
  • java Swing小集锦
                                    永夜-极光
java swing
                                    
    1.关闭窗体弹出确认对话框 
  1.1   this.setDefaultCloseOperation (JFrame.DO_NOTHING_ON_CLOSE); 
  1.2   
	this.addWindowListener (
				new WindowAdapter () {
					public void windo
    
                                
    • 
                                
  • 强制删除.svn文件夹
                                    随便小屋
java
                                    
      
        在windows上，从别处复制的项目中可能带有.svn文件夹，手动删除太麻烦，并且每个文件夹下都有。所以写了个程序进行删除。因为.svn文件夹在windows上是只读的，所以用File中的delete()和deleteOnExist()方法都不能将其删除，所以只能采用windows命令方式进行删除
    
                                
    • 
                                
  • GET和POST有什么区别？及为什么网上的多数答案都是错的。
                                    aijuans
get post
                                    
      
    如果有人问你，GET和POST，有什么区别？你会如何回答？ 我的经历 
     前几天有人问我这个问题。我说GET是用于获取数据的，POST，一般用于将数据发给服务器之用。 
    这个答案好像并不是他想要的。于是他继续追问有没有别的区别？我说这就是个名字而已，如果服务器支持，他完全可以把G
    
                                
    • 
                                
  • 谈谈新浪微博背后的那些算法
                                    aoyouzi
谈谈新浪微博背后的那些算法
                                    
    本文对微博中常见的问题的对应算法进行了简单的介绍，在实际应用中的算法比介绍的要复杂的多。当然，本文覆盖的主题并不全，比如好友推荐、热点跟踪等就没有涉及到。但古人云“窥一斑而见全豹”，希望本文的介绍能帮助大家更好的理解微博这样的社交网络应用。 
微博是一个很多人都在用的社交应用。天天刷微博的人每天都会进行着这样几个操作：原创、转发、回复、阅读、关注、@等。其中，前四个是针对短博文，最后的关注和@则针
    
                                
    • 
                                
  • Connection reset 连接被重置的解决方法
                                    百合不是茶
java字符流连接被重置
                                    
    流是java的核心部分,,昨天在做android服务器连接服务器的时候出了问题,就将代码放到java中执行,结果还是一样连接被重置 
  
被重置的代码如下; 
  
客户端代码; 
package 通信软件服务器;

import java.io.BufferedWriter;
import java.io.OutputStream;
import java.io.O
    
                                
    • 
                                
  • web.xml配置详解之filter
                                    bijian1013
javaweb.xmlfilter
                                    
    一.定义 
<filter>
	<filter-name>encodingfilter</filter-name>
	<filter-class>com.my.app.EncodingFilter</filter-class>
	<init-param>
		<param-name>encoding<
    
                                
    • 
                                
  • Heritrix
                                    Bill_chen
多线程xml算法制造配置管理
                                    
    作为纯Java语言开发的、功能强大的网络爬虫Heritrix，其功能极其强大，且扩展性良好，深受热爱搜索技术的盆友们的喜爱，但它配置较为复杂，且源码不好理解，最近又使劲看了下，结合自己的学习和理解，跟大家分享Heritrix的点点滴滴。 
Heritrix的下载（http://sourceforge.net/projects/archive-crawler/）安装、配置，就不罗嗦了，可以自己找找资
    
                                
    • 
                                
  • 【Zookeeper】FAQ
                                    bit1129
zookeeper
                                    
    1.脱离IDE，运行简单的Java客户端程序 
#ZkClient是简单的Zookeeper~$ java -cp "./:zookeeper-3.4.6.jar:./lib/*" ZKClient   
  
1. Zookeeper是的Watcher回调是同步操作，需要添加异步处理的代码 
2. 如果Zookeeper集群跨越多个机房，那么Leader/
    
                                
    • 
                                
  • The user specified as a definer ('aaa'@'localhost') does not exist
                                    白糖_
localhost
                                    
    今天遇到一个客户BUG，当前的jdbc连接用户是root，然后部分删除操作都会报下面这个错误：The user specified as a definer ('aaa'@'localhost') does not exist 
最后找原因发现删除操作做了触发器，而触发器里面有这样一句 
  
 /*!50017 DEFINER = ''aaa@'localhost' */ 
 原来最初
    
                                
    • 
                                
  • javascript中showModelDialog刷新父页面
                                    bozch
JavaScript刷新父页面showModalDialog
                                    
    在页面中使用showModalDialog打开模式子页面窗口的时候，如果想在子页面中操作父页面中的某个节点，可以通过如下的进行： 
      window.showModalDialog('url',self,‘status...’); // 首先中间参数使用self 
      在子页面使用w
    
                                
    • 
                                
  • 编程之美-买书折扣
                                    bylijinnan
编程之美
                                    
    


import java.util.Arrays;

public class BookDiscount {

	/**编程之美 买书折扣

书上的贪心算法的分析很有意思，我看了半天看不懂，结果作者说，贪心算法在这个问题上是不适用的。。
下面用动态规划实现。
哈利波特这本书一共有五卷，每卷都是8欧元，如果读者一次购买不同的两卷可扣除5%的折扣，三卷10%，四卷20%，五卷
    
                                
    • 
                                
  • 关于struts2.3.4项目跨站执行脚本以及远程执行漏洞修复概要
                                    chenbowen00
strutsWEB安全
                                    
    因为近期负责的几个银行系统软件，需要交付客户，因此客户专门请了安全公司对系统进行了安全评测，结果发现了诸如跨站执行脚本，远程执行漏洞以及弱口令等问题。 
下面记录下本次解决的过程以便后续 
1、首先从最简单的开始处理，服务器的弱口令问题，首先根据安全工具提供的测试描述中发现应用服务器中存在一个匿名用户，默认是不需要密码的，经过分析发现服务器使用了FTP协议， 
而使用ftp协议默认会产生一个匿名用
    
                                
    • 
                                
  • [电力与暖气]煤炭燃烧与电力加温
                                    comsci

                                    
     
      在宇宙中,用贝塔射线观测地球某个部分,看上去,好像一个个马蜂窝,又像珊瑚礁一样,原来是某个国家的采煤区..... 
 
      不过,这个采煤区的煤炭看来是要用完了.....那么依赖将起燃烧并取暖的城市,在极度严寒的季节中...该怎么办呢? 
 
  &nbs
    
                                
    • 
                                
  • oracle O7_DICTIONARY_ACCESSIBILITY参数
                                    daizj
oracle
                                    
    O7_DICTIONARY_ACCESSIBILITY参数控制对数据字典的访问.设置为true,如果用户被授予了如select any table等any table权限,用户即使不是dba或sysdba用户也可以访问数据字典.在9i及以上版本默认为false,8i及以前版本默认为true.如果设置为true就可能会带来安全上的一些问题.这也就为什么O7_DICTIONARY_ACCESSIBIL
    
                                
    • 
                                
  • 比较全面的MySQL优化参考
                                    dengkane
mysql
                                    
    本文整理了一些MySQL的通用优化方法，做个简单的总结分享，旨在帮助那些没有专职MySQL DBA的企业做好基本的优化工作，至于具体的SQL优化，大部分通过加适当的索引即可达到效果，更复杂的就需要具体分析了，可以参考本站的一些优化案例或者联系我，下方有我的联系方式。这是上篇。 
  
1、硬件层相关优化 
  
1.1、CPU相关 
  
在服务器的BIOS设置中，可
    
                                
    • 
                                
  • C语言homework2，有一个逆序打印数字的小算法
                                    dcj3sjt126com
c
                                    
    #h1# 
  
0、完成课堂例子 
1、将一个四位数逆序打印 
1234 ==> 4321 
实现方法一： 
# include <stdio.h>

int main(void)
{
	int i = 1234;
	int one = i%10;
	int two =  i / 10 % 10;
	int three = i / 100 % 10;

    
                                
    • 
                                
  • apacheBench对网站进行压力测试
                                    dcj3sjt126com
apachebench
                                    
       ab 的全称是 ApacheBench ， 是 Apache 附带的一个小工具 ， 专门用于 HTTP Server 的 benchmark testing ， 可以同时模拟多个并发请求。前段时间看到公司的开发人员也在用它作一些测试，看起来也不错，很简单，也很容易使用，所以今天花一点时间看了一下。 
通过下面的一个简单的例子和注释，相信大家可以更容易理解这个工具的使用。 
    
                                
    • 
                                
  • 2种办法让HashMap线程安全
                                    flyfoxs
javajdkjni
                                    
    多线程之--2种办法让HashMap线程安全 
多线程之--synchronized 和reentrantlock的优缺点 
多线程之--2种JAVA乐观锁的比较( NonfairSync VS. FairSync) 
  
  
HashMap不是线程安全的,往往在写程序时需要通过一些方法来回避.其实JDK原生的提供了2种方法让HashMap支持线程安全. 
  

    
                                
    • 
                                
  • Spring Security（04）——认证简介
                                    234390216
Spring Security认证过程
                                    
    认证简介 
目录 
1.1     认证过程 
1.2     Web应用的认证过程 
1.2.1    ExceptionTranslationFilter 
1.2.2    在request之间共享SecurityContext 
   

1
    
                                
    • 
                                
  • Java 位运算
                                    Javahuhui
java位运算
                                    
    // 左移( << ) 低位补0 
// 0000 0000 0000 0000 0000 0000 0000 0110 然后左移2位后，低位补0： 
// 0000 0000 0000 0000 0000 0000 0001 1000 
System.out.println(6 << 2);// 运行结果是24 
 
// 右移( >> ) 高位补"
    
                                
    • 
                                
  • mysql免安装版配置
                                    ldzyz007
mysql
                                    
    1、my-small.ini是为了小型数据库而设计的。不应该把这个模型用于含有一些常用项目的数据库。 
2、my-medium.ini是为中等规模的数据库而设计的。如果你正在企业中使用RHEL,可能会比这个操作系统的最小RAM需求(256MB)明显多得多的物理内存。由此可见，如果有那么多RAM内存可以使用，自然可以在同一台机器上运行其它服务。 
3、my-large.ini是为专用于一个SQL数据
    
                                
    • 
                                
  • MFC和ado数据库使用时遇到的问题
                                    你不认识的休道人
sqlC++mfc
                                    
    =================================================================== 
第一个 
=================================================================== 
 
try{
		CString sql;
	sql.Format("select * from p
    
                                
    • 
                                
  • 表单重复提交Double Submits
                                    rensanning
double
                                    
    可能发生的场景： 
 
 
 *多次点击提交按钮  
 *刷新页面  
 *点击浏览器回退按钮  
 *直接访问收藏夹中的地址  
 *重复发送HTTP请求（Ajax） 
 
（1）点击按钮后disable该按钮一会儿，这样能避免急躁的用户频繁点击按钮。 
这种方法确实有些粗暴，友好一点的可以把按钮的文字变一下做个提示，比如Bootstrap的做法： 
http://getbootstrap.co
    
                                
    • 
                                
  • Java String 十大常见问题
                                    tomcat_oracle
java正则表达式
                                    
    　1.字符串比较，使用“==”还是equals()?   　　"=="判断两个引用的是不是同一个内存地址(同一个物理对象)。   　　equals()判断两个字符串的值是否相等。   　　除非你想判断两个string引用是否同一个对象，否则应该总是使用equals()方法。   　　如果你了解字符串的驻留(String Interning)则会更好地理解这个问题。   　 
　
    
                                
    • 
                                
  • SpringMVC 登陆拦截器实现登陆控制
                                    xp9802
springMVC
                                    
    思路，先登陆后，将登陆信息存储在session中，然后通过拦截器，对系统中的页面和资源进行访问拦截，同时对于登陆本身相关的页面和资源不拦截。 
  
实现方法： 
        1   2   3   4   5   6   7   8   9   10   11   12   13   14   15   16   17   18   19   20   21   22   23  
    
                                
    •