BlogJava-paulwong-随笔分类-J2SE

openJDK无法进行jmap

paulwong — Thu, 19 May 2022 05:53:00 GMT

https://blog.csdn.net/qq_32447301/article/details/85109014

paulwong 2022-05-19 13:53 发表评论

API接口中的敏感数据的加密与解密

paulwong — Wed, 11 May 2022 06:37:00 GMT

摘要: 签名为防止request中的json在传输过程中被更改，需要在传送双方保存一个字符串sinature-key 用SHA256 hash请求中的json字符串，结果为hash1 {"payload":hash1}以此为字符和sinature-key用JWS HS256算法进行签名，得到sinature1 在请求的json中加入字段："sina... 阅读全文

paulwong 2022-05-11 14:37 发表评论

免注册JDK下载

paulwong — Wed, 25 Aug 2021 08:17:00 GMT

https://repo.huaweicloud.com/java/jdk/

paulwong 2021-08-25 16:17 发表评论

JSR-303 Bean Validation - @Size和@Max@Min的区别

paulwong — Thu, 29 Apr 2021 01:55:00 GMT

@Min and @Max are used for validating numeric fields which could be String(representing number), int, short, byte etc and their respective primitive wrappers.

@Size is used to check the length constraints on the fields.

As per documentation @Size supports String, Collection, Map and arrays while @Min and @Max supports primitives and their wrappers. See the documentation.

paulwong 2021-04-29 09:55 发表评论

java泛型方法返回值带有泛型

paulwong — Fri, 19 Mar 2021 07:10:00 GMT

  /**
         *
         * @param 声明此方法持有一个类型T，也可以理解为声明此方法为泛型方法
         * @param clazz 作用是指明泛型T的具体类型
         * @return 指明该方法的返回值为类型T
         * @throws InstantiationException
         * @throws IllegalAccessException
         */
        public  T getObject(Class clazz) throws InstantiationException, IllegalAccessException {
            T t = clazz.newInstance();//创建对象
            return t;
        }

方法返回值前的的左右是告诉编译器，当前的方法的值传入类型可以和类初始化的泛型类不同，也就是该方法的泛型类可以自定义，不需要跟类初始化的泛型类相同

paulwong 2021-03-19 15:10 发表评论

JSR-303 Bean Validation - Date String Validation

paulwong — Thu, 25 Feb 2021 01:44:00 GMT

@Past @Future只针对Date类型的验证，如果是String类型的验证，则不适用。
其实可以新加一个方法返回Date类型，再配合@Future@Past 进行验证。

@Future(message = "Invalid CN_ID_INFO.EXPIRE_DATE.")
private LocalDate getValidExpireDate() {
    try {
        return LocalDate.parse(this.dateString, DateTimeFormatter.ofPattern("yyyy-MM-dd"));
    } catch (Exception e) {
        return null;
    }
}

此方法对dateString进行解释，返回LocalDate，如果dateString为空或格式错误，则返回空，再配合@Future 进行是否未来日期的验证。

paulwong 2021-02-25 09:44 发表评论

JSR-303 Bean Validation - Conditional Validation

paulwong — Thu, 25 Feb 2021 01:24:00 GMT

bean validation的注释是针对单个变量的，如果要针对多个变量的联动，则不行，需要用到这个注释。
这种方法避免了自定义校验器而增加类。
https://www.chkui.com/article/java/java_bean_validation

@AssertTrue(message = "Missing BANK_CARD_IMG_INFO.IMG")
private Boolean getValidImg() {
    if(YNEnum.Y.code.equals(super.getNeedChecked())) {
            return StringUtils.hasText(this.img);
        }
        return null;//igore checking.
}

这个是当needChecked为Y的时候才执行检查img变量是否为空。
有几点注意：

方法名称要以get开头
返回类型用Boolean，而不用boolean
返回值有三种：true,false,null如果是null则当成通过，与true的结果一样

paulwong 2021-02-25 09:24 发表评论

Java8中文件转Base64和Base64转文件

paulwong — Thu, 07 Jan 2021 01:44:00 GMT

有几个项目中，都需要将图片或者数字证书的文件转为Base64，昨天写代码的时候，发现在jdk8中本就含有关于Base64的API。

从此后不再需要其他的jar包来转换Base64了!!!

据说是JDK8加入的。

先是将文件转为Base64：

public String encryptToBase64(String filePath) {
        if (filePath == null) {
            return null;
        }
        try {
            byte[] b = Files.readAllBytes(Paths.get(filePath));
            return Base64.getEncoder().encodeToString(b);
        } catch (IOException e) {
            e.printStackTrace();
        }

        return null;
    }

Files、Paths类是JDK7里加入的，读取文件不再需要调用IO包里的FileInputStream，简单便捷。
字符串参数filePath是文件的路径。

首先是将文件读成二进制码，然后通过Base64.getEncoder().encodeToString()方法将二进制码转换为Base64值。

然后是将Base64转为文件：

public String decryptByBase64(String base64, String filePath) {
        if (base64 == null && filePath == null) {
            return "生成文件失败，请给出相应的数据。";
        }
        try {
            Files.write(Paths.get(filePath), Base64.getDecoder().decode(base64),StandardOpenOption.CREATE);
        } catch (IOException e) {
            e.printStackTrace();
        }
        return "指定路径下生成文件成功！";
    }

字符串参数base64指的是文件的Base64值，filePath是指的文件将要保存的位置。
通过Files.write()方法轻松将文件写入指定位置，不再调用FileOutStream方法。

第三个参数StandardOpenOption.CREATE是处理文件的方式，我设置的是不管路径下有或没有，都创建这个文件，有则覆盖。

在StandardOpenOption类中有很多参数可调用，不再累赘。

paulwong 2021-01-07 09:44 发表评论

开始日期与结束日期的用法

paulwong — Tue, 29 Dec 2020 02:37:00 GMT

通常要用到取某个时间段内的数据，那么时间段要如何定义？
取2020-12-01这天的数据，"2020-12-01 00:00:00" <= time < "2020-12-02 00:00:00"。
apache common3中提供了相应的方法：

startDate = DateUtils.parseDate(startDateStr, DATE_PATTERN);

String endDateStr = args.getOptionValues(END_DATE).get(0);
endDate = DateUtils.parseDate(endDateStr, DATE_PATTERN);

//清零开始日期，返回类似2020-12-01 00:00:00
startDate = DateUtils.truncate(startDate, Calendar.DATE);
//取结束日期的上限，返回隔天的时间，2020-12-02 00:00:00
endDate = DateUtils.ceiling(endDate, Calendar.DATE);"。
apache common3中提供了相应的方法：

paulwong 2020-12-29 10:37 发表评论

Java的BIO和NIO很难懂？用代码实践给你看，再不懂我转行！

paulwong — Wed, 02 Dec 2020 00:52:00 GMT

http://www.52im.net/thread-2846-1-1.html

paulwong 2020-12-02 08:52 发表评论

Pretty print JSON using org.json library in Java

paulwong — Wed, 28 Oct 2020 09:17:00 GMT

Syntax

public java.lang.String toString(int indentFactor) throws JSONException

Example

import org.json.*;
public class JSONPrettyPrintTest {
   public static void main(String args[]) throws JSONException {
      String json = "{" +
                    "Name : Jai," +
                    "Age : 25, " +
                    "Salary: 25000.00 " +
                    "}";
      JSONObject jsonObj = new JSONObject(json);
      System.out.println("Pretty Print of JSON:");
      System.out.println(jsonObj.toString(4)); // pretty print json
   }
}

Output

Pretty Print of JSON:
{
   "Salary": 25000,
   "Age": 25,
   "Name": "Jai"
}

paulwong 2020-10-28 17:17 发表评论

Scheduling a task in Java within a CompletableFuture

paulwong — Mon, 24 Aug 2020 01:06:00 GMT

When we want to do something later in our Java code, we often turn to the ScheduledExecutorService. This class has a method called schedule(), and we can pass it some code to be run later like this:

ScheduledExecutorService executor =
    Executors.newScheduledThreadPool(4);
executor.schedule(
    () -> {System.out.println("..later");},
    1,
    TimeUnit.SECONDS
);
System.out.println("do");
// (Don't forget to shut down the executor later)

The above code prints “do…” and then one second later it prints “…later”.

We can even write code that does some work and returns a result in a similar way:

// (Make the executor as above.)
ScheduledFuture future = executor.schedule(
() -> 10 + 25, 1, TimeUnit.SECONDS);
System.out.println("answer=" + future.get())

The above code prints “answer=35”. When we call get() it blocks waiting for the scheduler to run the task and mark the ScheduledFuture as complete, and then returns the answer to the sum (10 + 25) when it is ready.

This is all very well, but you may note that the Future returned from schedule() is a ScheduledFuture, and a ScheduledFuture is not a CompletableFuture.

Why do you care? Well, you might care if you want to do something after the scheduled task is completed. Of course, you can call get(), and block, and then do something, but if you want to react asynchronously without blocking, this won’t work.

The normal way to run some code after a Future has completed is to call one of the “then*” or “when*” methods on the Future, but these methods are only available on CompletableFuture, not ScheduledFuture.

Never fear, we have figured this out for you. We present a small wrapper for schedule that transforms your ScheduledFuture into a CompletableFuture. Here’s how to use it:

CompletableFuture future =
    ScheduledCompletable.schedule(
        executor,
        () -> 10 + 25,
        1,
        TimeUnit.SECONDS
     );
future.thenAccept(
    answer -> {System.out.println(answer);}
);
System.out.println("Answer coming")

The above code prints “Answer coming…” and then “35”, so we can see that we don’t block the main thread waiting for the answer to come back.

So far, we have scheduled a synchronous task to run in the background after a delay, and wrapped its result in a CompletableFuture to allow us to chain more tasks after it.

In fact, what we often want to do is schedule a delayed task that is itself asynchronous, and already returns a CompletableFuture. In this case it feels particularly natural to get the result back as a CompletableFuture, but with the current ScheduledExecutorService interface we can’t easily do it.

It’s OK, we’ve figured that out too:

Supplier> asyncTask = () ->
    CompletableFuture.completedFuture(10 + 25);
CompletableFuture future =
    ScheduledCompletable.scheduleAsync(
        executor, asyncTask, 1, TimeUnit.SECONDS);
future.thenAccept(
    answer -> {System.out.println(answer);}
);
System.out.println("Answer coming")

The above code prints “Answer coming…” and then “35”, so we can see that our existing asynchronous task was scheduled in the background, and we didn’t have to block the main thread waiting for it. Also, under the hood, we are not blocking the ScheduledExecutorService‘s thread (from its pool) while the async task is running – that task just runs in whatever thread it was assigned when it was created. (Note: in our example we don’t really run an async task at all, but just immediately return a completed Future, but this does work for real async tasks.)

I know you’re wondering how we achieved all this. First, here’s how we run a simple blocking task in the background and wrap it in a CompletableFuture:

public static  CompletableFuture schedule(
    ScheduledExecutorService executor,
    Supplier command,
    long delay,
    TimeUnit unit
) {
    CompletableFuture completableFuture = new CompletableFuture<>();
    executor.schedule(
        (() -> {
            try {
                return completableFuture.complete(command.get());
            } catch (Throwable t) {
                return completableFuture.completeExceptionally(t);
            }
        }),
        delay,
        unit
    );
    return completableFuture;
}

And here’s how we delay execution of an async task but still return its result in a CompletableFuture:

public static  CompletableFuture scheduleAsync(
    ScheduledExecutorService executor,
    Supplier> command,
    long delay,
    TimeUnit unit
) {
    CompletableFuture completableFuture = new CompletableFuture<>();
    executor.schedule(
        (() -> {
            command.get().thenAccept(
                t -> {completableFuture.complete(t);}
            )
            .exceptionally(
                t -> {completableFuture.completeExceptionally(t);return null;}
            );
        }),
        delay,
        unit
    );
    return completableFuture;
}

Note that this should all work to run methods like exceptionally(), thenAccept(), whenComplete() etc.

Feedback and improvements welcome!

https://www.artificialworlds.net/blog/2019/04/05/scheduling-a-task-in-java-within-a-completablefuture/

paulwong 2020-08-24 09:06 发表评论

CompletableFuture

paulwong — Fri, 14 Aug 2020 03:46:00 GMT

很久以前多线程是这样创建：

Thread t1 = new Thread();
Thread t2 = new Thread();
t1.start(); // 启动新线程
t2.start(); // 启动新线程

由于创建和销毁线程是非常耗资源，因此改成线程建好后不销毁，可以重用，用户只需提供run方法的具体实现：

public static void main(String[] args) throws Exception {
        ExecutorService executor = Executors.newSingleThreadExecutor();
        Future stringFuture = executor.submit(new Callable() {
            @Override
            public String call() throws Exception {
                Thread.sleep(2000);
                return "async thread";
            }
        });
        Thread.sleep(1000);
        System.out.println("main thread");
        System.out.println(stringFuture.get());

    }

但如果很多线程被创建，并且线程间有依赖，即按流程和条件执行线程，实现起来就有点复杂，于是CompletableFuture横空出世。一共有50各方法可供使用。

CompletableFuture.supplyAsync()，相当于创建了ExecutorService，同时也创建了Callable，然后提交到线程池中执行。

CompletableFuture futureA = CompletableFuture.supplyAsync(() -> "任务A");
CompletableFuture futureB = CompletableFuture.supplyAsync(() -> "任务B");
CompletableFuture futureC = futureB.thenApply(b -> {
      System.out.println("执行任务C.");
      System.out.println("参数:" + b);//参数:任务B
      return "a";
});

!!How to use CompletableFuture and Callable in Java
https://ducmanhphan.github.io/2020-02-10-How-to-use-CompletableFuture-Callable-in-Java/

使用CompletableFuture优化你的代码执行效率
https://www.cnblogs.com/fingerboy/p/9948736.html

CompletableFuture 使用详解
https://www.jianshu.com/p/6bac52527ca4

使用CompletableFuture
https://www.liaoxuefeng.com/wiki/1252599548343744/1306581182447650

https://github.com/eugenp/tutorials/blob/master/core-java-modules/core-java-concurrency-basic/src/test/java/com/baeldung/completablefuture/CompletableFutureLongRunningUnitTest.java

paulwong 2020-08-14 11:46 发表评论

Springboot+proguard+maven 混淆

paulwong — Thu, 13 Aug 2020 02:53:00 GMT

https://blog.csdn.net/qq_35981283/article/details/78529929

paulwong 2020-08-13 10:53 发表评论

Different ways to create objects in Java

paulwong — Fri, 07 Aug 2020 02:04:00 GMT

https://www.geeksforgeeks.org/different-ways-create-objects-java/

paulwong 2020-08-07 10:04 发表评论

为啥文件的CHECKSUM中SHA512比MD5高级？

paulwong — Tue, 16 Jun 2020 02:21:00 GMT

https://stackoverflow.com/questions/2117732/reasons-why-sha512-is-superior-to-md5

paulwong 2020-06-16 10:21 发表评论

各种获取JVM DUMP的方法

paulwong — Mon, 24 Feb 2020 14:03:00 GMT

JVM 的线程堆栈 dump 也称 core dump，内容为文本，主要包含当时 JVM 的线程堆栈，堆 dump 也称 heap dump，内容为二进制格式，主要包含当时 JVM 堆内存中的内容。由于各个操作系统、各个 JVM 实现不同，即使同一 JVM 实现，各个版本也有差异，本文描述的方法都基于 64 位 Linux 操作系统环境，Java 8 Oracle HotSpot JVM 实现。

堆栈和堆的内容在定位问题的时候，都是非常重要的信息。线程堆栈 dump 可以了解当时 JVM 中所有线程的运行情况，比如线程的状态和当前正在运行的代码行。堆 dump 可以了解当时堆的使用情况，各个类实例的数量及各个实例所占用的空间大小。

线程堆栈

使用 jstack

jstack 是 JDK 自带的工具，用于 dump 指定进程 ID(PID)的 JVM 的线程堆栈信息。

# 打印堆栈信息到标准输出 jstack PID  
# 打印堆栈信息到标准输出，会打印关于锁的信息 jstack -l PID  
强制打印堆栈信息到标准输出，如果使用 jstack PID 没有响应的情况下(此时 JVM 进程可能挂起)，
加 -F 参数 jstack -F PID

使用 jcmd

jcmd 是 JDK 自带的工具，用于向 JVM 进程发送命令，根据命令的不同，可以代替或部分代替 jstack、jmap 等。可以发送命令 Thread.print 来打印出 JVM 的线程堆栈信息。

# 下面的命令同等于 jstack PID 
jcmd PID Thread.print  

# 同等于 jstack -l PID 
jcmd PID Thread.print -l

使用 kill -3

kill 可以向特定的进程发送信号(SIGNAL)，缺省情况是发送终止(TERM) 的信号，即 kill PID 与 kill -15 PID 或 kill -TERM PID 是等价的。JVM 进程会监听 QUIT 信号(其值为 3)，当收到这个信号时，会打印出当时的线程堆栈和堆内存使用概要，相比 jstack，此时多了堆内存的使用概要情况。但 jstack 可以指定 -l 参数，打印锁的信息。

kill -3 PID 
# 或 kill -QUIT PID

堆

-XX:+HeapDumpOnOutOfMemoryError

添加 JVM 参数 -XX:+HeapDumpOnOutOfMemoryError 后，当发生 OOM(OutOfMemory)时，自动堆 dump。缺省情况下，JVM 会创建一个名称为 java_pidPID.hprof 的堆 dump 文件在 JVM 的工作目录下。但可以使用参数 -XX:HeapDumpPath=PATH 来指定 dump 文件的保存位置。

# JVM 发生 OOM 时，会自动在 /var/log/abc 目录下产生堆 dump 文件 java_pidPID.hprof 
java -XX:+HeapDumpOnOutOfMemoryError -XX:HeapDumpPath=/var/log/abc/

jmap

jmap 也是 JDK 自带的工具，主要用于获取堆相关的信息。

堆 dump

# 将 JVM 的堆 dump 到指定文件，如果堆中对象较多，需要的时间会较长，子参数 format 只支持 b，
即二进制格式
jmap -dump:format=b,file=FILE_WITH_PATH

# 如果 JVM 进程未响应命令，可以加上参数 -F 尝试
jmap -F -dump:format=b,file=FILE_WITH_PATH

# 可以只 dump 堆中的存活对象，加上 live 子参数，但使用 -F 时不支持 live
jmap -dump:live,format=b,file=FILE_WITH_PATH

获取堆概要信息

# -heap 参数用于查看指定 JVM 进程的堆的信息，包括堆的各个参数的值，堆中新生代、年老代的内存大小、使用率等 
jmap -heap PID  

# 同样，如果 JVM 进程未响应命令，可以加上参数 -F 尝试 
jmap -F -heap PID

一个实例输出如下：

Attaching to process ID 68322, please wait
Debugger attached successfully.
Server compiler detected.
JVM version is 25.112-b16

using thread-local object allocation.
Parallel GC with 4 thread(s)

Heap Configuration:
   MinHeapFreeRatio         = 0
   MaxHeapFreeRatio         = 100
   MaxHeapSize              = 268435456 (256.0MB)
   NewSize                  = 8388608 (8.0MB)
   MaxNewSize               = 89128960 (85.0MB)
   OldSize                  = 16777216 (16.0MB)
   NewRatio                 = 2
   SurvivorRatio            = 8
   MetaspaceSize            = 21807104 (20.796875MB)
   CompressedClassSpaceSize = 1073741824 (1024.0MB)
   MaxMetaspaceSize         = 17592186044415 MB
   G1HeapRegionSize         = 0 (0.0MB)

Heap Usage:
PS Young Generation
Eden Space:
   capacity = 41943040 (40.0MB)
   used     = 1701504 (1.6226806640625MB)
   free     = 40241536 (38.3773193359375MB)
   4.05670166015625% used
From Space:
   capacity = 4194304 (4.0MB)
   used     = 0 (0.0MB)
   free     = 4194304 (4.0MB)
   0.0% used
To Space:
   capacity = 5242880 (5.0MB)
   used     = 0 (0.0MB)
   free     = 5242880 (5.0MB)
   0.0% used
PS Old Generation
   capacity = 30408704 (29.0MB)
   used     = 12129856 (11.56793212890625MB)
   free     = 18278848 (17.43206787109375MB)
   39.889421134159484% used

16658 interned Strings occupying 1428472 bytes.

获取堆中的类实例统计

# 打印 JVM 堆中的类实例统计信息，以占用内存的大小排序，同样，如果 JVM 未响应命令，也可以使用 -F 参数 
jmap -histo PID  

# 也可以只统计堆中的存活对象，加上 live 子参数，但使用 -F 时不支持 live 
jmap -histo:live PID

使用 jcmd

# 等同 jmap -dump:live,format=b,file=FILE_WITH_PATH
jcmd PID GC.heap_dump FILE_WITH_PATH

# 等同 jmap -dump:format=b,file=FILE_WITH_PATH
jcmd PID GC.heap_dump -all FILE_WITH_PATH

# 等同 jmap -histo:live PID
jcmd PID GC.class_histogram

# 等同 jmap -histo PID
jcmd PID GC.class_histogram -all

paulwong 2020-02-24 22:03 发表评论

CountDownLatch、CyclicBarrier和Semaphore

paulwong — Tue, 24 Sep 2019 02:18:00 GMT

CountDownLatch、CyclicBarrier和Semaphore这三个并发辅助类，可以在线程中呼叫，使得线程暂停等，但各有不同。

CountDownLatch

1、初始化，并传入计数器
2、向不同的线程传入CountDownLatch实例
3、如果在某一线程中呼叫await()，则此线程被挂起，直到计数器为0，才往下执行
4、如果在某一线程中呼叫countDown()，计数器减1
5、最终如果计数器值为0时，则CountDownLatch实例不再起作用了，即为一次性的

CyclicBarrier

1、初始化，并传入计数器值，也可传入一个Runnable类，会在计数器为0时，被执行
2、向不同的线程传入CyclicBarrier实例
3、如果在某一线程中呼叫await()，则此线程被挂起，直到计数器为0，才往下执行
4、其他线程呼叫await()，则此线程被挂起，直到计数器为0，才往下执行
5、最终如果计数器值为0时，则CyclicBarrier实例会将计数器值恢复，又可重用

Semaphore

1、初始化，并传入计数器值
2、向不同的线程传入Semaphore实例
3、如果在某一线程中呼叫acquire()，则Semaphore实例会将计数器值减1，如果计数器值为-1，则将计数器值置为0，此线程被挂起，直到计数器值大于1时，才往下执行
4、此线程需呼叫release()，使得计数器值+1，以便其他线程在计数器值为0时不受阻

CountDownLatch 例子：

public class Test {
     public static void main(String[] args) {
         final CountDownLatch latch = new CountDownLatch(2);

         new Thread(){
             public void run() {
                 try {
                     System.out.println("子线程"+Thread.currentThread().getName()+"正在执行");
                    Thread.sleep(3000);
                    System.out.println("子线程"+Thread.currentThread().getName()+"执行完毕");
                    latch.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
             };
         }.start();

         new Thread(){
             public void run() {
                 try {
                     System.out.println("子线程"+Thread.currentThread().getName()+"正在执行");
                     Thread.sleep(3000);
                     System.out.println("子线程"+Thread.currentThread().getName()+"执行完毕");
                     latch.countDown();
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
             };
         }.start();

         try {
             System.out.println("等待2个子线程执行完毕");
            latch.await();
            System.out.println("2个子线程已经执行完毕");
            System.out.println("继续执行主线程");
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
     }
}

结果：

线程Thread-0正在执行
线程Thread-1正在执行
等待2个子线程执行完毕
线程Thread-0执行完毕
线程Thread-1执行完毕
2个子线程已经执行完毕
继续执行主线程

CyclicBarrier例子：

public class Test {
    public static void main(String[] args) {
        int N = 4;
        CyclicBarrier barrier  = new CyclicBarrier(N,new Runnable() {
            @Override
            public void run() {
                System.out.println("当前线程"+Thread.currentThread().getName());
            }
        });

        for(int i=0;i             new Writer(barrier).start();
    }
    static class Writer extends Thread{
        private CyclicBarrier cyclicBarrier;
        public Writer(CyclicBarrier cyclicBarrier) {
            this.cyclicBarrier = cyclicBarrier;
        }

        @Override
        public void run() {
            System.out.println("线程"+Thread.currentThread().getName()+"正在写入数据");
            try {
                Thread.sleep(5000);      //以睡眠来模拟写入数据操作
                System.out.println("线程"+Thread.currentThread().getName()+"写入数据完毕，等待其他线程写入完毕");
                cyclicBarrier.await();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }catch(BrokenBarrierException e){
                e.printStackTrace();
            }
            System.out.println("所有线程写入完毕，继续处理其他任务");
        }
    }
}

执行结果：

线程Thread-0正在写入数据
线程Thread-1正在写入数据
线程Thread-2正在写入数据
线程Thread-3正在写入数据
线程Thread-0写入数据完毕，等待其他线程写入完毕
线程Thread-1写入数据完毕，等待其他线程写入完毕
线程Thread-2写入数据完毕，等待其他线程写入完毕
线程Thread-3写入数据完毕，等待其他线程写入完毕
当前线程Thread-3
所有线程写入完毕，继续处理其他任务
所有线程写入完毕，继续处理其他任务
所有线程写入完毕，继续处理其他任务
所有线程写入完毕，继续处理其他任务

Semaphore例子：

public class Test {
    public static void main(String[] args) {
        int N = 8;            //工人数
        Semaphore semaphore = new Semaphore(5); //机器数目
        for(int i=0;i             new Worker(i,semaphore).start();
    }

    static class Worker extends Thread{
        private int num;
        private Semaphore semaphore;
        public Worker(int num,Semaphore semaphore){
            this.num = num;
            this.semaphore = semaphore;
        }

        @Override
        public void run() {
            try {
                semaphore.acquire();
                System.out.println("工人"+this.num+"占用一个机器在生产");
                Thread.sleep(2000);
                System.out.println("工人"+this.num+"释放出机器");
                semaphore.release();
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }
    }
}

执行结果：

工人0占用一个机器在生产
工人1占用一个机器在生产
工人2占用一个机器在生产
工人4占用一个机器在生产
工人5占用一个机器在生产
工人0释放出机器
工人2释放出机器
工人3占用一个机器在生产
工人7占用一个机器在生产
工人4释放出机器
工人5释放出机器
工人1释放出机器
工人6占用一个机器在生产
工人3释放出机器
工人7释放出机器
工人6释放出机器

https://www.cnblogs.com/dolphin0520/p/3920397.html

https://juejin.im/post/5aeec3ebf265da0ba76fa327

paulwong 2019-09-24 10:18 发表评论

使用 Awaitility 测试异步代码

paulwong — Thu, 01 Aug 2019 02:06:00 GMT

自动化工具异步校验工具 awaitility 快速入门

https://testerhome.com/topics/7408

https://yanbin.blog/test-asyn-call-with-awaitility/

Introduction to Awaitlity

https://www.baeldung.com/awaitlity-testing

paulwong 2019-08-01 10:06 发表评论

zip4j

paulwong — Mon, 10 Jun 2019 08:47:00 GMT

缩解压ZIP之Zip4j
https://rensanning.iteye.com/blog/1836727

paulwong 2019-06-10 16:47 发表评论

JAVA 8 TIME

paulwong — Thu, 09 May 2019 02:15:00 GMT

Java 8新特性（四）：新的时间和日期API

https://lw900925.github.io/java/java8-newtime-api.html

paulwong 2019-05-09 10:15 发表评论

SHARDING-JDBC

paulwong — Tue, 29 Mar 2016 13:26:00 GMT

https://github.com/dangdangdotcom/sharding-jdbc/

paulwong 2016-03-29 21:26 发表评论

Java 中正确使用 hashCode 和 equals 方法

paulwong — Tue, 01 Dec 2015 02:52:00 GMT

摘要: 在这篇文章中，我将告诉大家我对hashCode和equals方法的理解。我将讨论他们的默认实现，以及如何正确的重写他们。我也将使用Apache Commons提供的工具包做一个实现。目录：hashCode()和equals()的用法重写默认实现使用Apache Commons Lang包重写hashCode()和equals()需要注意记住的事情当使用ORM的时候特别要注意的hashC... 阅读全文

paulwong 2015-12-01 10:52 发表评论

javax.crypto.IllegalBlockSizeException: Data must not be longer than 256 bytes 解决办法

paulwong — Wed, 18 Nov 2015 07:27:00 GMT

如果用RSA加密数据的话，会有数据长度的要求，否则会抛异常：

javax.crypto.IllegalBlockSizeException: Data must not be longer than 256 bytes

推荐的做法：

随机生成一个密钥，用作对称密钥UUID
用此对称密钥，用对称加密法AES加密数据
用RSA的公钥加密此对称密钥
发送加密后的对称密钥和加密数据
用RSA私钥解密加密后的对称密钥
用解密密后的对称密钥，解密数据
完成

AESSecurityUtil.java

import java.security.Key;
import java.util.UUID;

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;

import sun.misc.BASE64Decoder;
import sun.misc.BASE64Encoder;

public class AESSecurityUtil {

    // 加密算法
    /** 指定加密算法为RSA */
    private static final String ALGORITHM = "AES";

    // 加密密钥
    // private static final byte[] keyValue = new byte[] { 'T', 'h', 'e',
    // 'B','e', 's', 't', 'S', 'e', 'c', 'r', 'e', 't', 'K', 'e', 'y' };
    // 16位的加密密钥
//    private byte[] keyValue;

    /**
     * 用来进行加密的操作
     *
     * @param Data
     * @return
     * @throws Exception
     */
    public static String encrypt(String keyString, String data)
            throws Exception {
        Key key = generateKey(keyString);
        Cipher c = Cipher.getInstance(ALGORITHM);
        c.init(Cipher.ENCRYPT_MODE, key);
        byte[] encVal = c.doFinal(data.getBytes());
        String encryptedValue = new BASE64Encoder().encode(encVal);
        return encryptedValue;
    }

    /**
     * 用来进行解密的操作
     *
     * @param encryptedData
     * @return
     * @throws Exception
     */
    public static String decrypt(String keyString, String encryptedData) throws Exception {
        Key key = generateKey(keyString);
        Cipher c = Cipher.getInstance(ALGORITHM);
        c.init(Cipher.DECRYPT_MODE, key);
        byte[] decordedValue = new BASE64Decoder().decodeBuffer(encryptedData);
        byte[] decValue = c.doFinal(decordedValue);
        String decryptedValue = new String(decValue);
        return decryptedValue;
    }

    public static String generateKeyString()
    {
        //必须长度为16
        return UUID.randomUUID().toString().replaceAll("-", "").substring(0, 16);
    }

    /**
     * 根据密钥和算法生成Key
     *
     * @return
     * @throws Exception
     */
    private static Key generateKey(String keyString) throws Exception {
        Key key = new SecretKeySpec(keyString.getBytes(), ALGORITHM);
        return key;
    }

    public static void main(String [] args) throws Exception
    {
        String keyString = generateKeyString();
//        String keyString = "1234567890123456";
        System.out.println("密钥：" + keyString);

        String source = "恭喜发财!";// 要加密的字符串
        System.out.println("准备用密钥加密的字符串为：" + source);

        String cryptograph = encrypt(keyString, source);// 生成的密文
        System.out.print("用密钥加密后的结果为:" + cryptograph);
        System.out.println();

        String target = decrypt(keyString, cryptograph);// 解密密文
        System.out.println("用密钥解密后的字符串为：" + target);
        System.out.println();
    }

}

CryptoUtil.java

import com.tcl.project7.boss.common.crypto.CryptoData;
import com.tcl.project7.boss.common.util.JsonManager;
import com.tcl.project7.boss.common.util.file.FileUtil;
import com.tcl.project7.boss.gameapplication.yearendactivities.bigwheelgame.player.valueobject.BigWheelGameRequest;

public class CryptoUtil {

    public static CryptoData encrypt(String data) throws Exception
    {
        //1、产生AES密钥
        String keyString = AESSecurityUtil.generateKeyString();

        //2、用AES法加密数据
        String cryptograph = AESSecurityUtil.encrypt(keyString, data);

        //3、用RSA加密AES密钥
        String finalKey = RSASecurityUtil.encrypt(keyString);
//        System.out.print("用RSA加密AES密钥为:" + finalKey);
//        System.out.print("加密数据:" + cryptograph);

        CryptoData cryptoData = new CryptoData();
        cryptoData.setKey(finalKey);
        cryptoData.setContent(cryptograph);

        //4、返回数据
        return cryptoData;
    }

    public static String decrypt(String keyString, String data) throws Exception
    {
        //1、解密密钥
        String decryptKeyString = RSASecurityUtil.decrypt(keyString);

        //2、解密内容
        String decryptData = AESSecurityUtil.decrypt(decryptKeyString, data);

        //3、返回
        return decryptData;

    }

    public static void main(String [] args) throws Exception
    {
        String aFilePath = "DATA/TESTING-FILE/TOCRYPTO/tocrypto.txt";
        String source = FileUtil.getContents(aFilePath);

        CryptoData cryptoData = encrypt(source);
        System.out.print(cryptoData);

        String target = decrypt(cryptoData.getKey(), cryptoData.getContent());
        System.out.print(target);

        BigWheelGameRequest bigWheelGameRequest = JsonManager.getBean(target, BigWheelGameRequest.class);
        System.out.print(bigWheelGameRequest);
    }

}

CryptoData.java

import java.io.Serializable;

public class CryptoData implements Serializable{

    private static final long serialVersionUID = -4774469372648172844L;

    private String key;

    private String content;

    public String getKey() {
        return key;
    }

    public void setKey(String key) {
        this.key = key;
    }

    public String getContent() {
        return content;
    }

    public void setContent(String content) {
        this.content = content;
    }

    public String toString() {
        return "CryptoData [key=" + key + ", content=" + content + "]";
    }

}

paulwong 2015-11-18 15:27 发表评论

JSON转JAVA BEAN

paulwong — Wed, 18 Nov 2015 05:30:00 GMT

import java.io.IOException;

import org.codehaus.jackson.JsonParseException;
import org.codehaus.jackson.map.DeserializationConfig;
import org.codehaus.jackson.map.JsonMappingException;
import org.codehaus.jackson.map.ObjectMapper;
import org.codehaus.jackson.type.TypeReference;
import org.junit.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class ColumnControllerTest {

    private Logger logger = LoggerFactory.getLogger(ColumnControllerTest.class);


    @Test
    public void testTest()
    {
        ObjectMapper mapper = new ObjectMapper();
        /*AnnotationIntrospector introspector = new JaxbAnnotationIntrospector();
        // make deserializer use JAXB annotations (only)
        mapper.getDeserializationConfig().setAnnotationIntrospector(introspector);
        // make serializer use JAXB annotations (only)
        mapper.getSerializationConfig().setAnnotationIntrospector(introspector);*/
        mapper.configure(DeserializationConfig.Feature.FAIL_ON_UNKNOWN_PROPERTIES, false);

        String userStr = "{\"username\":\"paul\",\"email\":\"paul@paul.com\"}";
        try {
            TypeReference temp = new TypeReference(){};
            TestUser testUser = mapper.readValue(userStr, temp);
            System.out.println(testUser.toString());

            String result = mapper.writeValueAsString(testUser);
            System.out.println(result);

        } catch (JsonParseException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (JsonMappingException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }

}

paulwong 2015-11-18 13:30 发表评论

Java NIO核心概念及基本读写

paulwong — Sun, 10 May 2015 12:55:00 GMT

摘要: 面向流的I/O系统一次一个字节地处理数据。一个输入流产生一个字节的数据，一个输出流消费一个字节的数据。为流式数据创建过滤器非常容易。链接几个过滤器，以便每个过滤器只负责单个复杂处理机制的一部分，这样也是相对简单的。不利的一面是，面向流的I/O通常相当慢。 NIO与原来的I/O有同样的作用和目的，但是它使用块I/O的处理方式。每一个操作都在一步中产生或者消费一个数... 阅读全文

paulwong 2015-05-10 20:55 发表评论

开源中国 2014 最受关注开源软件排行榜 TOP 50

paulwong — Tue, 06 Jan 2015 16:08:00 GMT

开源中国 2014 年最受关注软件排行榜 TOP 50 正式出炉！2014 年结束了，我们来了解一下过去一年里开源中国最受欢迎的 50 款软件。此榜单是根据过去一年的用户访问、交流分享和项目本身的更新频度等诸多角度对收录于开源中国 33000+ 款开源软件进行统计，从而得出前 50 名最受欢迎的开源软件，仅供参考。

本排行榜主要是针对开源中国社区在 2014 年度最受欢迎的 50 款热门开源项目根据用户访问量、讨论和关注等角度进行筛选，从而得出前 50 名开源软件列表：

1. JFinal

JFinal 是基于 Java 语言的极速 WEB + ORM 框架，其核心设计目标是开发迅速、代码量少、学习简单、功能强大、轻量级、易扩展、Restful。在拥有Java语言所有优势的同时再拥有ruby、python、php等动态语言的开发效率！

授权协议：Apache
源码下载：http://git.oschina.net/jfinal/jfinal

2. AngularJS

Angular JS (Angular.JS) 是一组用来开发Web页面的框架、模板以及数据绑定和丰富UI组件。它支持整个开发进程，提供web应用的架构，无需进行手工DOM操作。 AngularJS很小，只有60K，兼容主流浏览器，与 jQuery 配合良好。

授权协议：MIT
源码下载：https://github.com/angular/angular.js

3. Bootstrap

Bootstrap是快速开发Web应用程序的前端工具包。它是一个CSS和HTML的集合，它使用了最新的浏览器技术，给你的Web开发提供了时尚的版式，表单，buttons，表格，网格系统等等。

授权协议：MIT
源码下载：https://github.com/twbs/bootstrap

4. Dubbo

Dubbo 是阿里巴巴公司开源的一个高性能优秀的服务框架，使得应用可通过高性能的 RPC 实现服务的输出和输入功能，可以和 Spring 框架无缝集成。

授权协议：Apache
源码下载：https://github.com/alibaba/dubbo

5. Hadoop

Hadoop 是一个分布式系统基础架构，由Apache基金会开发。用户可以在不了解分布式底层细节的情况下，开发分布式程序。充分利用集群的威力高速运算和存储。

授权协议：Apache
源码下载：http://mirror.bit.edu.cn/apache/

6. jQuery Mobile

jQuery Mobile（jQueryMobile）是 jQuery 在手机上和平板设备上的版本。jQuery Mobile 不仅会给主流移动平台带来jQuery核心库，而且会发布一个完整统一的jQuery移动UI框架。支持全球主流的移动平台。

授权协议：MIT/GPL
源码下载：https://github.com/jquery/jquery-mobile

7. Nginx

Nginx（发音同 engine x）是一款轻量级的Web 服务器／反向代理服务器及电子邮件（IMAP/POP3）代理服务器。其特点是占有内存少，并发能力强，事实上nginx的并发能力确实在同类型的网页伺服器中表现较好。

授权协议：BSD
源码下载：http://nginx.org/en/download.html

8. Qt

Qt 是一个跨平台的C++图形用户界面应用程序框架。它提供给应用程序开发者建立艺术级的图形用户界面所需的所用功能。Qt是完全面向对象的，很容易扩展，并且允许真正地组件编程。

授权协议：GPL/LGPL/QPL
源码下载：http://www.qt.io/download-open-source/

9. 禅道

禅道是第一款国产的开源项目管理软件，她的核心管理思想基于敏捷方法scrum，内置了产品管理和项目管理，同时又根据国内研发现状补充了测试管理、计划管理、发布管理、文档管理、事务管理等功能，在一个软件中就可以将软件研发中的需求、任务、bug、用例、计划、发布等要素有序的跟踪管理起来，完整地覆盖了项目管理的核心流程。

授权协议：LGPL
源码下载：http://git.oschina.net/wwccss/zentaopms

10. Redmine

Redmine 是一个开源的、基于Web的项目管理和缺陷跟踪工具。它用日历和甘特图辅助项目及进度可视化显示。同时它又支持多项目管理。Redmine是一个自由开放源码软件解决方案，它提供集成的项目管理功能，问题跟踪，并为多个版本控制选项的支持。

授权协议：GPL
源码下载：https://github.com/redmine/redmine

11. CKEditor

CKEditor 是新一代的 FCKeditor，是一个重新开发的版本。CKEditor是全球最优秀的网页在线文字编辑器之一，因其惊人的性能与可扩展性而广泛的被运用于各大网站。

授权协议：GPL/LGPL/MPL
源码下载：http://ckeditor.com/download

12. TeamTalk

TeamTalk 是由蘑菇街开发的开源即时通讯解决方案，适用于中小型企业，提供可靠的消息传递机制；支持文字、图片、语音等富文本信息；文件收发等。

授权协议：Apache
源码下载：https://github.com/mogutt

13. Afinal

Afinal 是一个 Android 的 Sqlite ORM 和 IOC 框架。同时封装了Android 中的 HTTP 框架，使其更加简单易用。Afinal 的宗旨是简洁，快速。约定大于配置的方式。尽量一行代码完成所有事情。

授权协议：Apache
源码下载：http://git.oschina.net/fuhai/afinal

14. ECharts

ECharts 开源来自百度商业前端数据可视化团队，基于html5 Canvas，是一个纯Javascript图表库，提供直观，生动，可交互，可个性化定制的数据可视化图表。创新的拖拽重计算、数据视图、值域漫游等特性大大增强了用户体验，赋予了用户对数据进行挖掘、整合的能力。

授权协议：BSD
源码下载：https://github.com/ecomfe/echarts

15. Semantic UI

Semantic UI — 完全语义化的前端界面开发框架，跟 Bootstrap 和 Foundation 比起来，还是有些不同的，在功能特性上、布局设计上、用户体验上均存在很多差异。

授权协议：MIT
源码下载：https://github.com/Semantic-Org/Semantic-UI

16. SWFUpload

SWFUpload 是一个客户端文件上传工具，最初由Vinterwebb.se开发，它通过整合Flash与JavaScript技术为WEB开发者提供了一个具有丰富功能继而超越传统标签的文件上传模式。

授权协议：MIT
源码下载：https://github.com/WordPress/secure-swfupload

17. GoAgent

GoAgent 是一个使用Python和Google Appengine SDK编写的代理软件，goagent的初衷是弥补gappproxy的不足。

授权协议：GPL
源码下载：http://git.oschina.net/goagent/goagent

18. Android Studio

Android Studio 是一个全新的 Android 开发环境，基于 IntelliJ IDEA. 类似 Eclipse ADT，Android Studio 提供了集成的 Android 开发工具用于开发和调试。

授权协议：Apache
源码下载：http://developer.android.com/sdk/index.html

19. Druid

Druid 是一个JDBC组件，它包括三部分：DruidDriver 代理Driver，能够提供基于Filter－Chain模式的插件体系；DruidDataSource 高效可管理的数据库连接池；SQLParser。

授权协议：Apache
源码下载：http://git.oschina.net/wenshao/druid

20. Nagios

Nagios是一个监视系统运行状态和网络信息的监视系统。Nagios能监视所指定的本地或远程主机以及服务，同时提供异常通知功能等。

授权协议：GPL
源码下载：http://www.nagios.org/download/

21. Amaze UI

Amaze UI 是中国首个开源 HTML5 跨屏前端框架。Amaze UI 是一个轻量级、Mobile first的前端框架，基于开源社区流行前端框架编写。

授权协议：MIT
源码下载：http://git.oschina.net/amazeui/amazeui

22. Docker

Docker 是一个开源的应用容器引擎，让开发者可以打包他们的应用以及依赖包到一个可移植的容器中，然后发布到任何流行的 Linux 机器上，也可以实现虚拟化。

授权协议：Apache
源码下载：https://github.com/docker/docker

23. fastjson

fastjson 是一个性能很好的 Java 语言实现的 JSON 解析器和生成器，来自阿里巴巴的工程师开发。

授权协议：Apache
源码下载：http://git.oschina.net/wenshao/fastjson

24. CrossApp

CrossApp是一款完全开源、免费、跨平台的移动应用开发引擎。CrossApp 采用 C++ 开发（即将支持 JS 和 Lua 编写），可直接导出 iOS 和 Android 原生应用，拥有高性能，多控件，开发速度快的优势。

授权协议：MIT
源码下载：http://git.oschina.net/9miao/CrossApp

25. Sonar

Sonar (SonarQube)是一个开源平台，用于管理源代码的质量。Sonar 不只是一个质量数据报告工具，更是代码质量管理平台。支持的语言包括：Java、PHP、C#、C、Cobol、PL/SQL、Flex 等。

授权协议：LGPL
源码下载：https://github.com/SonarSource/sonarqube

26. xUtils

xUtils 最初源于 Afinal 框架，进行了大量重构，使得 xUtils 支持大文件上传，更全面的 http 请求协议支持(10 种谓词)，拥有更加灵活的 ORM，更多的事件注解支持且不受混淆影响...

授权协议：Apache
源码下载：https://github.com/wyouflf/xUtils

27. TeamLab

TeamLab 是一个免费开源的商业协作和项目管理的平台。TeamLab 主要功能包括：项目管理、里程碑管理、任务、报表、事件、博客、论坛、书签、Wiki、即时消息等等。

授权协议：AGPL
源码下载：http://sourceforge.net/projects/teamlab/files/

28. memcached

memcached 是一套分布式的快取系统，当初是Danga Interactive为了LiveJournal所发展的，但目前被许多软件（如MediaWiki）所使用。memcached具有多种语言的客户端开发包，包括：Perl/PHP/JAVA/C/Python/Ruby/C#/MySQL/。

授权协议：BSD
源码下载：https://code.google.com/p/memcached/downloads/list

29. Magnolia

Magnolia CMS 是一家瑞士公司自 2003 年起发布的一个基于 Java 的开源内容管理系统。它适合且已被使用在以下领域：电子商务、银行、媒体娱乐、政府、旅游、航空航天、工业制造、教育和保险。

授权协议：GPL
源码下载：http://git.magnolia-cms.com/gitweb/

30. Django

Django 项目是一个定制 Python WEB 框架，它源自一个在线新闻 Web 站点，于 2005 年以开源的形式被释放出来。

授权协议：BSD
源码下载：https://www.djangoproject.com/download/

31. zabbix

zabbix是一个基于WEB界面的提供分布式系统监视以及网络监视功能的企业级的开源解决方案。zabbix能监视各种网络参数，保证服务器系统的安全运营；并提供柔软的通知机制以让系统管理员快速定位/解决存在的各种问题。

授权协议：GPL
源码下载：http://www.zabbix.com/download.php

32. Kettle

Kettle是一款国外开源的etl工具，纯java编写，绿色无需安装，数据抽取高效稳定(数据迁移工具)。Kettle中有两种脚本文件，transformation和job，transformation完成针对数据的基础转换，job则完成整个工作流的控制。

授权协议：LGPL
源码下载：http://sourceforge.net/projects/pentaho/files/Data%20Integration/

33. Node.js

Node.js 是一套用来编写高性能网络服务器的 JavaScript 工具包，一系列的变化由此开始。比较独特的是，Node.js 会假设你是在 POSIX 环境下运行它 Linux 或 Mac OS X。

授权协议：MIT
源码下载：http://nodejs.org/download/

34. MyBatis

MyBatis 的前身就是 iBatis 。是一个数据持久层(ORM)框架。在线Javadoc：http://tool.oschina.net/apidocs/apidoc?api=mybatis-3.1.1

授权协议：Apache
源码下载：https://github.com/mybatis/mybatis-3

35. TortoiseGit

TortoiseGit (海龟Git)是TortoiseSVN的Git版本，tortoisegit用于迁移TortoiseSVN到TortoiseGit，一直以来Git在Windows平台没有好用GUI客户端，现在tortoisegit的出现给Windows开发者带来福音。

授权协议：GPL
源码下载：https://code.google.com/p/tortoisegit/

36. Openfire

Openfire 是实时的基于WEB的即时消息传输平台，是原来的Jive Messenger。

授权协议：Apache
源码下载：http://www.igniterealtime.org/downloads/index.jsp

37. ZUI

zui 是禅道项目管理软件团队在完善自己产品过程中形成的一个开源前端实践方案，帮助你快速构现代跨屏应用。简单美观，易于使用，快速构建简洁大方的现代web应用。

授权协议：MIT
源码下载：http://git.oschina.net/wwccss/zui

38. Cocos2d-x

Cocos2D-X 是全球知名的开源跨平台游戏引擎，易学易用，目前已经支持iOS、Android、Windows桌面、Mac OSX、Linux、BlackBerry、Windows Phone等平台。Cocos2d-JS统一了使用JS进行开发的开发体验，将HTML5引擎与JSB的API高度统一起来。

授权协议：MIT
源码下载：http://www.cocos2d-x.org/download?project_id=cocos2d-x

39. D3.js

D3 是最流行的可视化库之一，它被很多其他的表格插件所使用。它允许绑定任意数据到DOM，然后将数据驱动转换应用到Document中。你可以使用它用一个数组创建基本的HTML表格，或是利用它的流体过度和交互，用相似的数据创建惊人的SVG条形图。

授权协议：MIT
源码下载：https://github.com/mbostock/d3

40. Twitter Storm

Twitter Storm 是一个分布式的、容错的实时计算系统。Storm 为分布式实时计算提供了一组通用原语，可被用于“流处理”之中，实时处理消息并更新数据库。这是管理队列及工作者集群的另一种方式。

授权协议：EPL
源码下载：https://github.com/nathanmarz/storm

41. Redis

Redis 是一个高性能的key-value数据库。 redis的出现，很大程度补偿了memcached这类keyvalue存储的不足，在部分场合可以对关系数据库起到很好的补充作用。它提供了Python，Ruby，Erlang，PHP客户端，使用很方便。

授权协议：BSD
源码下载：https://github.com/antirez/redis

42. Nutch

Nutch 是一个开源Java 实现的搜索引擎。它提供了我们运行自己的搜索引擎所需的全部工具。包括全文搜索和Web爬虫。

授权协议：Apache
源码下载：http://www.apache.org/dyn/closer.cgi/nutch/

43. PhoneGap

PhoneGap 是一款 HTML5 平台，通过它，开发商可以使用 HTML、CSS 及 JavaScript 来开发本地移动应用程序。因此，目前开发商可以只编写一次应用程序，然后在 7 个主要的移动平台和应用程序商店 (App Store) 里进行发布。

授权协议：Apache
源码下载：https://github.com/phonegap/phonegap

44. Mono

Mono 是一个由 Novell 公司主持的项目。该项目的目标是创建一系列符合ECMA 标准（Ecma-334 和Ecma-335）的.NET 工具，包括C# 编译器和共通语言执行平台。与微软的.NET Framework 不同，Mono 项目不仅可以运行于Windows 系统上，还可以运行于Linux，FreeBSD，Unix，Mac OS X 和Solaris。

授权协议：GPL/LGPL/MIT
源码下载：http://www.mono-project.com/

45. Seafile

Seafile 是新一代的开源云存储软件。它提供更丰富的文件同步和管理功能，以及更好的数据隐私保护和群组协作功能。Seafile 支持 Mac、Linux、Windows 三个桌面平台，支持 Android 和 iOS 两个移动平台。

授权协议：GPL
源码下载：http://git.oschina.net/lins05/seafile

46. ElasticSearch

Elastic Search 是一个基于Lucene构建的开源，分布式，RESTful搜索引擎。设计用于云计算中，能够达到实时搜索，稳定，可靠，快速，安装使用方便。支持通过HTTP使用JSON进行数据索引。

授权协议：Apache
源码下载：https://github.com/elasticsearch/elasticsearch

47. Tor

Tor 是一个帮助你抵御流量分析的软件项目，流量分析是一种对网络的监视行为。Tor 将你的通信通过一个由遍及全球的志愿者运行的中继（relay）所组成的分布式网络转发，以此来保护你的安全：它令监视你的 Internet 连接的那些人无法知道你所访问的站点，它还令你所访问的站点无法知道你的物理位置。

授权协议：BSD
源码下载：https://www.torproject.org/

48. Cacti

Cacti 是一套基于PHP,MySQL,SNMP及RRDTool开发的网络流量监测图形分析工具。它通过snmpget来获取数据，使用 RRDtool绘画图形，而且你完全可以不需要了解RRDtool复杂的参数。

授权协议：GPL
源码下载：http://www.cacti.net/

49. GitLab

GitLab是一个利用 Ruby on Rails 开发的开源应用程序，实现一个自托管的Git项目仓库，可通过Web界面进行访问公开的或者私人项目。它拥有与Github类似的功能，能够浏览源代码，管理缺陷和注释。

授权协议：MIT
源码下载：https://github.com/gitlabhq/gitlabhq

50. Notepad++

Notepad++ 是一款非常有特色的编辑器，是开源软件，可以免费使用。支持的语言: C, C++ , Java , C#, XML, HTML, PHP, Javascript！

授权协议：GPL
源码下载：http://notepad-plus-plus.org/

paulwong 2015-01-07 00:08 发表评论

解压ZIP文件

paulwong — Wed, 29 Oct 2014 09:34:00 GMT

在pom.xml中加入JAR包

<dependency>
<groupId>commons-iogroupId>
<artifactId>commons-ioartifactId>
dependency>

ZipUtil.java

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.nio.charset.Charset;
import java.util.UUID;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;

import org.apache.commons.io.IOUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class ZipUtil {

    private static Logger logger = LoggerFactory.getLogger(ZipUtil.class);

    public static void extractFolder(InputStream inputStream, String outputFolder) throws IOException
    {
        ZipInputStream zis = null;
        try {

            Charset GBK = Charset.forName("GBK");
            zis = new ZipInputStream(inputStream, GBK);
            ZipEntry entry;

            while ((entry = zis.getNextEntry()) != null) {

                // Create a file on HDD in the destinationPath directory
                // destinationPath is a "root" folder, where you want to extract your ZIP file
                String encoding = System.getProperty("file.encoding");
                logger.info("encoding:"+encoding);

                String fileName = new String(entry.getName().getBytes("GBK"), encoding);
                File entryFile = new File(outputFolder, fileName);
//                File entryFile = new File(outputFolder, entry.getName());
                if (entry.isDirectory()) {

                    if (entryFile.exists()) {
                        logger.warn("Directory {0} already exists!", entryFile);
                    } else {
                        entryFile.mkdirs();
                    }

                } else {

                    // Make sure all folders exists (they should, but the safer, the better ;-))
                    if (entryFile.getParentFile() != null && !entryFile.getParentFile().exists()) {
                        entryFile.getParentFile().mkdirs();
                    }

                    // Create file on disk
                    if (!entryFile.exists()) {
                        entryFile.createNewFile();
                    }

                    // and rewrite data from stream
                    OutputStream os = null;
                    try {
                        os = new FileOutputStream(entryFile);
                        IOUtils.copy(zis, os);
                    } finally {
//                        os.close();
                        IOUtils.closeQuietly(os);
                        zis.closeEntry();
                    }
                }
            }
        } finally {
            IOUtils.closeQuietly(zis);
        }
    }

    public static void main(String [] args) throws IOException
    {
        final String INPUT_ZIP_FILE = "D:TESTING-FILE/ZIP/INPUT/应用.zip";
        String OUTPUT_FOLDER = "D:/TESTING-FILE/ZIP/OUTPUT";

        OUTPUT_FOLDER += File.separator + UUID.randomUUID().toString();

        InputStream inputStream = new FileInputStream(new File(INPUT_ZIP_FILE));

        extractFolder(inputStream, OUTPUT_FOLDER);

        /*File file = new File(OUTPUT_FOLDER);
        FileUtil.deleteFolder(file);*/
    }

}

paulwong 2014-10-29 17:34 发表评论

EXCEL转JAVA BEAN

paulwong — Wed, 29 Oct 2014 09:25:00 GMT

pom.xml回入以下包：

  <dependency>
            <groupId>net.sf.jxlsgroupId>
            <artifactId>jxls-coreartifactId>
        dependency>
        <dependency>
            <groupId>net.sf.jxlsgroupId>
            <artifactId>jxls-readerartifactId>
        dependency>
        <dependency>
            <groupId>net.sf.jxlsgroupId>
            <artifactId>jxls-examplesartifactId>
        dependency>

转换的配置文件：

<workbook>
  <worksheet name="Sheet1">
    <section startRow="0" endRow="0" />
    <loop startRow="1" endRow="1" items="result" var="app" varType="n.app.valueobject.App">
      <section startRow="1" endRow="1">
        <mapping row="1" col="0">app.titlemapping>
        <mapping row="1" col="1">app.categoryIdmapping>
        <mapping row="1" col="2">app.updateContentmapping>
        <mapping row="1" col="3">app.rankmapping>
        <mapping row="1" col="4">app.installedQtymapping>
        <mapping row="1" col="5">app.installedTypemapping>
        <mapping row="1" col="6">app.discussmapping>
        <mapping row="1" col="7">app.summarymapping>
        <mapping row="1" col="8">app.deviceTypesmapping>
        <mapping row="1" col="9">app.descriptionmapping>
        <mapping row="1" col="10">app.newFeaturesmapping>
        <mapping row="1" col="11">app.shortRecommendmapping>
        <mapping row="1" col="12">app.appUrlmapping>
      section>
      <loopbreakcondition>
        <rowcheck offset="0">
          <cellcheck offset="0" />
        rowcheck>
      loopbreakcondition>
    loop>
  worksheet>
workbook>

JAVA代码：

import java.io.BufferedInputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import net.sf.jxls.reader.ReaderBuilder;
import net.sf.jxls.reader.XLSReader;

import org.apache.poi.openxml4j.exceptions.InvalidFormatException;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.xml.sax.SAXException;

import application.app.valueobject.App;

public class ExcelUtil {

    private static Logger logger = LoggerFactory.getLogger(ExcelUtil.class);

    public List parseExcelFileToBeans(InputStream xlsFileInputStream, InputStream jxlsConfigInputStream) throws IOException, SAXException, InvalidFormatException  {


        List result = new ArrayList();
        Map beans = new HashMap();
        beans.put("result", result);
        InputStream inputStream = null;
        try {
            XLSReader xlsReader = ReaderBuilder.buildFromXML(jxlsConfigInputStream);
            inputStream = new BufferedInputStream(xlsFileInputStream);
            xlsReader.read(inputStream, beans);
        } catch (IOException e) {
            logger.error(e.getMessage(), e);
            throw e;
        } catch (SAXException e) {
            logger.error(e.getMessage(), e);
            throw e;
        } catch (InvalidFormatException e) {
            logger.error(e.getMessage(), e);
            throw e;
        } finally {
            if (inputStream != null) {
                try {
                    inputStream.close();
                } catch (Exception e) {
                }
            }
        }
        return result;
    }

    public static void main(String[] args) throws Exception {

        String path = "D:/DATA/TESTING-FILE/EXCEL";

        path = System.getProperty("user.home");

        ExcelUtil util = new ExcelUtil();
        String excelFilePath = path + File.separator + "appData.xls";

        InputStream configInputStream =
                ExcelUtil.class.getResourceAsStream("/excel/template/config/app_config.xml");
        InputStream xlsFileInputStream = new FileInputStream(excelFilePath);

        List appList = util.parseExcelFileToBeans(xlsFileInputStream, configInputStream);

        for (App app : appList) {
            System.out.println(app.toString());
        }

        /*String [] args2 = {""};
        GroupingSample.main(args2);*/

    }

}

http://www.yihaomen.com/article/java/530.htm

paulwong 2014-10-29 17:25 发表评论

JAVA线程池例子

paulwong — Mon, 08 Sep 2014 23:31:00 GMT

摘要: 用途及用法网络请求通常有两种形式：第一种，请求不是很频繁，而且每次连接后会保持相当一段时间来读数据或者写数据，最后断开，如文件下载，网络流媒体等。另一种形式是请求频繁，但是连接上以后读/写很少量的数据就断开连接。考虑到服务的并发问题，如果每个请求来到以后服务都为它启动一个线程，那么这对服务的资源可能会造成很大的浪费，特别是第二种情况。因为通常情... 阅读全文

paulwong 2014-09-09 07:31 发表评论

BlogJava-paulwong-随笔分类-J2SE

openJDK无法进行jmap

API接口中的敏感数据的加密与解密

免注册JDK下载

JSR-303 Bean Validation - @Size和@Max@Min的区别

java泛型 方法返回值带有泛型

JSR-303 Bean Validation - Date String Validation

JSR-303 Bean Validation - Conditional Validation

Java8中文件转Base64和Base64转文件

开始日期与结束日期的用法

Java的BIO和NIO很难懂？用代码实践给你看，再不懂我转行！

Pretty print JSON using org.json library in Java

Syntax

Example

Output

Scheduling a task in Java within a CompletableFuture

CompletableFuture

Springboot+proguard+maven 混淆

Different ways to create objects in Java

为啥文件的CHECKSUM中SHA512比MD5高级？

各种获取JVM DUMP的方法

线程堆栈

使用 jstack

使用 jcmd

使用 kill -3

堆

-XX:+HeapDumpOnOutOfMemoryError

jmap

堆 dump

获取堆概要信息

使用 jcmd

CountDownLatch、CyclicBarrier和Semaphore

使用 Awaitility 测试异步代码

zip4j

JAVA 8 TIME

SHARDING-JDBC

Java 中正确使用 hashCode 和 equals 方法

javax.crypto.IllegalBlockSizeException: Data must not be longer than 256 bytes 解决办法

JSON转JAVA BEAN

Java NIO核心概念及基本读写

开源中国 2014 最受关注开源软件排行榜 TOP 50

1. JFinal

2. AngularJS

3. Bootstrap

4. Dubbo

5. Hadoop

6. jQuery Mobile

7. Nginx

8. Qt

9. 禅道

10. Redmine

11. CKEditor

12. TeamTalk

13. Afinal

14. ECharts

15. Semantic UI

16. SWFUpload

17. GoAgent

18. Android Studio

19. Druid

20. Nagios

21. Amaze UI

22. Docker

23. fastjson

24. CrossApp

25. Sonar

26. xUtils

27. TeamLab

28. memcached

29. Magnolia

30. Django

31. zabbix

32. Kettle

33. Node.js

34. MyBatis

35. TortoiseGit

36. Openfire

37. ZUI

38. Cocos2d-x

39. D3.js

java泛型方法返回值带有泛型