Chưa phân loại

Eclipse tutorial: Hướng dẫn cài đặt và sử dụng CheckStyle plugin

Eclipse tutorial: Hướng dẫn cài đặt và sử dụng CheckStyle plugin

Bài viết này sẽ hướng dẫn các bạn cài đặt và sử dụng CheckStyle plugin trong Eclipse. CheckStyle là một trong những plugin phổ biến nhất trong Eclipse, giúp chúng ta kiểm tra coding convention (quy ước viết mã) dựa trên những quy tắc đã được định nghĩa trước đó. Các bạn có thể tham khảo thêm bộ quy tắc đồ sộ của CheckStyle tại đây: http://checkstyle.sourceforge.net/availablechecks.html

Cài đặt

Chọn Menu Help –> Install New Software… và nhập vào địa chỉ sau:
http://eclipse-cs.sf.net/update/

1. Download

Sau đó tiến hành cài đặt với vài cú click, sau đó khởi động lại Eclipse

Để kiểm tra việc cài đặt có thành công hay không, các bạn vào Menu Window –> Preferences sẽ thấy mục CheckStyle

2. InstallSuccess

Định nghĩa những quy ước

Mặc định CheckStyle dùng bộ quy ước đã được định nghĩa sẵn từ Sun, tuy nhiên bạn cũng có thể tạo ra những quy ước riêng cho mình, tùy theo đặc thù của dự án.
Đầu tiên chúng ta sẽ tạo 1 configuration file có tên là CheckStyleTemplate.xml với nội dung như sau:

<?xml version="1.0" encoding="UTF-8"?>
<!--
Checkstyle configuration (v5.x)
-->
<!DOCTYPE module PUBLIC "-//Puppy Crawl//DTD Check Configuration 1.2//EN" "http://www.puppycrawl.com/dtds/configuration_1_2.dtd">
<module name="Checker">
    <property name="severity" value="warning"/>
</module>

Root tag của file là module, bên trong hiện chỉ có 1 child tag là

<property name="severity" value="warning"/>

với ý nghĩa sẽ hiện những thông báo dưới dạng warning trong Eclipse khi phát hiện những đoạn code vi phạm quy tắc.

Tiếp theo là thêm những quy tắc vào trong file config này, các bạn có thể tham khảo danh sách các quy tắc mà CheckStyle hỗ trợ tại: http://checkstyle.sourceforge.net/availablechecks.html

Trong ví dụ này, mình sẽ sử dụng 3 quy tắc: StrictDuplicateCode (không cho phép có những đoạn code trùng lặp), EqualsHashCode (khi override phương thức equals thì bắt buộc phải override phương thức hashCode) và MethodLength (giới hạn số dòng tối đa trong 1 method)

<?xml version="1.0" encoding="UTF-8"?>
<!--
Checkstyle configuration (v5.x)
-->
<!DOCTYPE module PUBLIC "-//Puppy Crawl//DTD Check Configuration 1.2//EN" "http://www.puppycrawl.com/dtds/configuration_1_2.dtd">
<module name="Checker">
    <property name="severity" value="warning"/>
	<module name="StrictDuplicateCode">
		<property name="min" value="15"/>
	</module>
	<module name="TreeWalker">
		<module name="EqualsHashCode"/>
		<module name="MethodLength">
		<property name="tokens" value="METHOD_DEF, CTOR_DEF"/>
		<property name="max" value="30"/>
		<property name="countEmpty" value="false"/>
	</module>
	</module>
</module>

Áp dụng những quy tắc vào dự án

Import những quy tắc trên vào Eclipse bằng cách chọn New trong cửa sổ CheckStyle, sau đó chọn External Configuration Filebrowse đến file config CheckStyleTemplate.xml

3. CreateNew

Sau đó chọn Set as Default để áp dụng bộ quy tắc này cho các project trong Eclipse workspace hiện tại

4. SetDefault

Kiểm tra source code với CheckStyle

Với file config như trên, ta sẽ áp dụng kiểm tra cho đoạn code dưới đây

public class TestCheckStyle {

	public static void main(String[] args) {
		foo();
	}

	private static void foo() {
		System.out.println("Bla bla bla...");
		int a = 10;
		int b = 20;
		int c = 30;
		int d = 40;
		int e = a + b + c + d;
		System.out.println(a);
		System.out.println(b);
		System.out.println(c);
		System.out.println(d);
		System.out.println(e);
		System.out.println("Bla bla bla... again");
		System.out.println(a);
		System.out.println(b);
		System.out.println(c);
		System.out.println(d);
		System.out.println(e);
		System.out.println("Bla bla bla... again");
		System.out.println(a);
		System.out.println(b);
		System.out.println(c);
		System.out.println(d);
		System.out.println(e);
		System.out.println("Bla bla bla... again");
		System.out.println(a);
		System.out.println(b);
		System.out.println(c);
		System.out.println(d);
		System.out.println(e);
		System.out.println("Bla bla bla... again");
		System.out.println(a);
		System.out.println(b);
		System.out.println(c);
		System.out.println(d);
		System.out.println(e);
		System.out.println("Bla bla bla... again");
		System.out.println(a);
		System.out.println(b);
		System.out.println(c);
		System.out.println(d);
		System.out.println(e);
		System.out.println("Bla bla bla... again");
	}

	@Override
	public boolean equals(Object o) {
		if(o instanceof TestCheckStyle) {
			return true;
		}
		return false;
	}
}

Click chuột phải vào file Java, package hoặc Project cần kiểm tra và chọn CheckStyle –> Check code with CheckStyle

5. Check

Nếu đoạn code nào vi phạm các quy tắc trên sẽ được hightlight như hình bên dưới:

6. FoundError

CheckStyle chỉ hỗ trợ phát hiện ra những đoạn code vi phạm quy tắc chứ không hỗ trợ gợi ý sửa chúng ra sao. Vì vậy việc còn lại của các bạn là sửa những vi phạm đó để tránh những lỗi về coding convention.

Kết thúc bài giới thiệu về CheckStyle plugin ở đây. Hi vọng có thể giúp ích cho các bạn trong việc kiểm tra và tránh những lỗi về coding convention trong dự án

Nguồn: https://edwardthienhoang.wordpress.com
Email: edwardthienhoang@gmail.com

Chưa phân loại

Hướng dẫn sử dụng plugin Vanaraha để kiểm tra code trùng lặp

Hướng dẫn sử dụng plugin Vanaraha để kiểm tra code trùng lặp

Trong bài viết này mình sẽ giới thiệu về plugin Vanaraha, một công cụ để kiểm tra những đoạn code trùng lặp có trong chương trình, từ đó chúng ta có thể đặt những đoạn code giống nhau đó trong 1 phương thức và tái sử dụng lại.

Download

Việc sử dụng Vanaraha rất đơn giản, các bạn vào trang chủ tại: https://code.google.com/p/vanaraha/ sau đó download gói jar ở mục Download về và bỏ vào trong thư mục eclipse\plugins. Quá trình cài đặt đã hoàn tất, khởi động lại Eclipse nếu các bạn đã mở trước đó.

Tạo 1 class để test

public class TestDuplicateCode {

	public static void main(String[] args) {

	}

	private static void foo1() {
		int a = 10;
		int b = 20;
		int c = 30;
		int d = 40;
		int e = a + b + c + d;
		System.out.println(a);
		System.out.println(b);
		System.out.println(c);
		System.out.println(d);
		System.out.println(e);
	}

	private static void foo2() {
		System.out.println("Bla bla bla...");
		int a = 10;
		int b = 20;
		int c = 30;
		int d = 40;
		int e = a + b + c + d;
		System.out.println(a);
		System.out.println(b);
		System.out.println(c);
		System.out.println(d);
		System.out.println(e);
		System.out.println("Bla bla bla... again");
	}
}

Click chuột phải vào class TestDuplicateCode hoặc 1 package hoặc nguyên cả Project, sau đó chọn Vanahara (Find Duplicates) –> Find duplicated in this file(s) để tìm ra những đoạn code trùng lặp.

1. HuongDan

Ngoài ra Vanaraha cũng có 1 số setting tùy chỉnh như:
File Extension: để filter ra những loại file cần kiểm tra

2. File Extension
Minimum number of duplicate line(threshold): chỉ tính những đoạn code trùng lặp từ n dòng trở lên.
Và một số tùy chỉnh khác

3. Threshold

Kết thúc phần giới thiệu về plugin Vanahara tại đây, hi vọng bài viết sẽ giúp ích cho các bạn trong quá trình refactor để loại bỏ những đoạn code trùng lặp không cần thiết.

Nguồn: https://edwardthienhoang.wordpress.com

Email: edwardthienhoang@gmail.com

Chưa phân loại

Hướng dẫn sử dụng VisualVM để đo hiệu năng chương trình Java

Hướng dẫn sử dụng VisualVM để đo hiệu năng chương trình Java

Hiệu năng chương trình bao gồm tốc độ xử lý, lượng RAM tiêu tốn và cả dung lượng ổ cứng tiêu tốn. Trong thời buổi mà ổ cứng lên tới cả Terabyte thì thì việc tiêu tốn vài GB để lưu trữ data cũng không được bận tâm nhiều lắm. Còn tốc độ xử lý và độ ngốn RAM thì luôn là bài toán với tất cả lập trình viên từ xưa đến nay.

Về thời gian thực thi, có một sốc cách để tính được thời gian thực thi của mỗi hàm, hay một vài đoạn code bằng cách gọi System.currentTimeMillis() ở đầu đoạn code và cuối đoạn code, qua đó tính được thời gian thực thi, hoặc cũng có thể dùng logging tool. Tuy nhiên những cách làm trên rất thủ công và tốn thời gian.

Còn về memory tiêu tốn, có thể mở Task Manager của Window lên để xem process của mình chạy hết bao nhiêu RAM hoặc dùng 1 số lớp có sẵn trong Java để trace ra heap dump tại từng thời điểm. Cũng giống như ở trên, việc làm này gây tốn thời gian và không chính xác nếu ta muốn xem trong chương trình hiện tại có bao nhiêu đối tượng A, B, C đang được khởi tạo, và tổng bộ nhớ dùng cho chúng là bao nhiêu thì không làm được.

Thay vì dùng những cách thủ công để đo hiệu năng của chương trình, chúng ta có thể nghĩ đến các công cụ giúp chúng ta làm chuyện đó. Chỉ cần lên mạng search vài từ khóa như: Java performance reasurement tool, Java performance analysis tool… sẽ cho các bạn rất nhiều lựa chọn.

Trong bài viết này, mình giới thiệu về VisualVM. Một công cụ hỗ trợ rất nhiều tính năng giúp cho việc đo lường hiệu năng của chương trình một cách dễ dàng và đặc biệt là nó cũng cung cấp cho các bạn một cái nhìn trực quan ví dụ như về các thread đang chạy hay thời gian thực thi của những hàm hiện tại… OK let’s start!

Đầu tiên các bạn tải VisualVM bản mới nhất tại đây:
http://visualvm.java.net/download.html

Lưu ý là VisualVM chỉ chạy được trên JDK 6u7 trở lên, nếu máy các bạn chưa cài JDK 6 thì có thể download bản mới nhất tại đây:
http://www.oracle.com/technetwork/java/javase/downloads/index.html?ssSourceSiteId=otnjp

Overview

Sau đó bung nén ra và mở file visualvm_137\bin\visualvm.exe lên sẽ có giao diện như thế này

1. StartScreen

Không chần chừ nữa, hãy tạo 1 project Java sau đó Run và xem ta có thể làm gì với VisualVM

public class OverviewTest {

	public static void main(String[] args) {
		
		System.out.println("Hello VisualVM");
		
		// Hey! I'm waiting you to switch to VisualVM
		// and see I'm also in there
		// just in 1 minute
		try {
			Thread.sleep(60000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}

}

Sau khi run đoạn code trên, các bạn chuyển qua VisualVM sẽ thấy được 1 process Java tương ứng với đoạn chương trình trên, double click vào sẽ thấy được thông tin overview về chương trình như: Process ID, main class, argument, phiên bản Java đang dùng…

2. OverviewAnProcess

Bây giờ hãy dùng VisualVM để kiểm tra các vấn đề về performance như:

  • Thời gian thực thi qua đó cải thiện tốc độ chương trình
  • Độ tiêu thụ memory cùng với việc kiểm tra và giải quyết memory leak
  • Theo dõi tất cả các thread đang chạy trong chương trình cùng với việc kiểm tra và giải quyết deadlock

Đo thời gian thực thi

public class PerformanceTest {

	public static void main(String[] args) {

		// Hey! I'm waiting you to switch to VisualVM
		// and see I'm also in there
		// just in 20 seconds
		try {
			Thread.sleep(20000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}

		for (int i = 0; i < 10; i++) {
			PerformanceClass testClass = new PerformanceClass();
			testClass.foo1();
			try {
				Thread.sleep(2000);
			} catch (InterruptedException e) {
				e.printStackTrace();
			}
		}
	}

}
public class PerformanceClass {
	
	private int mField = 10;
	
	public void foo1() {
		mField += 3;
		System.out.println("foo1()");
		try {
			Thread.sleep(1000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		foo2();
		foo3();
	}
	
	public void foo2() {
		mField += 2;
		System.out.println("foo2()");
		try {
			Thread.sleep(2000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		foo3();
	}
	
	public void foo3() {
		mField += 1;
		System.out.println("foo3()");
		try {
			Thread.sleep(500);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

Sau khi run chương trình, các bạn chuyển qua VisualVM, tìm process của chương trình đang chạy và double click vào, chọn thẻ Sampler và chọn button CPU, nó sẽ ra như sau:

3. CPU

Các bạn có thể nhìn thấy sự trực quan trên màn hình. Và có thể thấy thời gian thực thi của các hàm đang được gọi. Sau khi chương trình kết thúc ta có được kết quả cuối cùng

4.

Dựa vào kết quả trên, có thể nhận biết được thời gian thực thi của mỗi hàm qua cột “Self Time“. Từ đó các bạn có thể kết luận rằng hàm nào đang tốn nhiều thời gian xử lý hơn bạn mong muốn, từ đó để đưa ra những điều chỉnh thích hợp để tăng tốc độ thực thi. Nếu muốn biết thời gian chiếm CPU thì có thể xem thêm ở cột “Self Time (CPU)“.

Đo độ tiêu thụ memory

Cùng đoạn code như trên, khi các bạn chạy chương trình Java và chuyển sang VisualVM, chọn thẻ Sampler và chọn button Memory, nó sẽ ra như sau:

5. MemoryOverview

Trong màn hình này, tại thẻ Heap Histogram, các bạn có thể xem trực quan số lượng class đã được load lên, tổng số instance của một lớp đang tồn tại trong bộ nhớ Heap và tổng số byte của chúng.

Chuyển qua thẻ Per thread allocations sẽ cho các bạn thấy các thông số giống ở trên nhưng cho từng thread.

Bên cạnh đó, chức năng Snapshot cho phép các bạn lưu / chụp lại các thông tin ngay tại thời điểm đó.

Bên cạnh chức năng theo dõi memory trực quan này, VisualVM còn hỗ trợ chúng ta xem HeapDump của chương trình đang chạy ngay thời điểm hiện tại. HeapDump sẽ cung cấp cho chúng ta nhiều thông tin hơn về giá trị của các biến thành viên trong instance đó. Để load HeadDump của chương trình hiện tại, các bạn click phải vào process của chương trình, sau đó chọn HeapDump, 1 tab HeapDump mới sẽ mở ra, các bạn chọn qua nút Classes. Tại đây các bạn có thể double click vào 1 class nào đó sẽ hiển ra danh sách các instance của lớp đó, double click vào 1 đối tượng, bạn sẽ thấy thông tin về các field của nó và danh sách các đối tượng khác đang reference đến nó.

7. DetailInstance

Chẩn đoán memory leak

Bây giờ hãy chuyển sang 1 ví dụ để hiểu VisualVM cung cấp thông tin cho chúng ta như thế nào khi 1 chương trình bị leak memory

Các bạn có thể lên mạng để tìm hiểu 1 số nguyên nhân dẫn đến việc leak memory trong Java, ở đây mình lấy 1 ví dụ về hàm subString. Từ Java 6 trở về trước, khi gọi hàm subString trên 1 đối tượng String luôn luôn gây ra memory leak, và lỗi này đã được fix từ Java 7.

import java.util.ArrayList;
import java.util.List;

class Stringer {
	static final int MB = 1024 * 1024;

	static String createLongString(int length) {
		StringBuilder sb = new StringBuilder(length);
		for (int i = 0; i < length; i++)
			sb.append('a');
		sb.append(System.nanoTime());
		return sb.toString();
	}

	public static void main(String[] args) {
		try {
			Thread.sleep(10000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
		
		List<String> substrings = new ArrayList<String>();
		for (int i = 0; i < 100; i++) {
			String longStr = createLongString(MB);
			// Leak here. Just in Java 6-
			String subStr = longStr.substring(1, 10);
			substrings.add(subStr);
		}
		
		try {
			Thread.sleep(20000);
		} catch (InterruptedException e) {
			e.printStackTrace();
		}
	}
}

Để tái hiện memory leak, mình sẽ chạy chương trình trên Java 6, kết quả đoạn code trên sẽ như sau

8. SubStringJava6

Còn khi chạy trên Java 8, thì kết quả như sau.

9. SubStringJava8

Qua 2 ví dụ trên, cho ta thấy nếu memory tiêu tốn trong chương trình tăng một cách bất thường hoặc biến thiên tăng dần theo thời gian, thì có thể chương trình bạn đang gặp vấn đề memory leak.

Theo dõi tất cả các thread đang chạy

VisualVM cũng hỗ trợ việc theo dõi một cách trực quan về vòng đời của tất cả các thread đang chạy trong chương trình. Với mỗi trạng thái của Thread sẽ được biểu diễn bằng một màu khác nhau, bạn sẽ dễ dàng hình dung ra mọi thứ đang hoạt động thế nào. Bắt đầu với 1 đoạn code test

public class ThreadTest {

	public static void main(String[] args) {
		try {
			Thread.sleep(10000);
		} catch (InterruptedException e1) {
			e1.printStackTrace();
		}

		for (int i = 0; i < 100; i++) {
			new Thread(new Runnable() {
				@Override
				public void run() {
					for (int i = 0; i < 100; i++) {
						System.out
								.println(i + Thread.currentThread().getName());
						try {
							URL url = new URL(
									"http://www.google.com/");
							URLConnection conn = url.openConnection();
							conn.connect();
							System.out.println("Dude its Working Fine ! ");
						} catch (Exception e) {
							System.out.println("Not Working");
						}
					}

				}
			}).start();
		}
	}

}

Chuyển sang VisualVM, double click vào ProcessID, sau đó chọn thẻ Thread Dump sẽ thấy được các thread đang chạy trong chương trình

10. ThreadVisual

Ứng với mỗi trạng thái của thread được biểu diễn bằng các màu khác nhau.

  • Màu xanh lá: Thread đang chạy
  • Màu tím: Thread đang sleep khi gọi câu lệnh Thread.sleep(…)
  • Màu vàng: Thread đang wait khi gọi hàm wait()
  • Màu đỏ: Thread đang bị block và đợi đến lượt để vào khối lệnh synchronize

Kiểm tra deadlock trong chương trình

Giả sử như có rất nhiều thread đang bị block để đợi đến lượt vào khối lệnh synchronize mà thread hiện tại đang giữ. Tuy nhiên vì một lý do nào đó mà thread hiện tại không thể thoát ra khối lệnh synchronize để nhường chỗ cho thread khác dẫn đến các thread khác sẽ phải chờ rất lâu thậm chí là mãi mãi dẫn đến việc “tắc đường” làm ngưng trệ toàn bộ chương trình. Vì vậy trong môi trường multithread, khi thấy chương trình mình bị “đơ” thì rất có thể đã xảy ra deadlock. Và để chắc chắn hơn, các bạn có thể dùng VisualVM để kiểm tra có deadlock hay không. Ví dụ như đoạn code dưới đây, cùng kiểm tra xem hình hài của deadlock như thế nào. 😀

public class DeadlockTest {

	public static void main(String[] args) throws InterruptedException {
        Object obj1 = new Object();
        Object obj2 = new Object();
        Object obj3 = new Object();
     
        Thread t1 = new Thread(new SyncThread(obj1, obj2), "t1");
        Thread t2 = new Thread(new SyncThread(obj2, obj3), "t2");
        Thread t3 = new Thread(new SyncThread(obj3, obj1), "t3");
         
        t1.start();
        Thread.sleep(5000);
        t2.start();
        Thread.sleep(5000);
        t3.start();
         
    }

}
class SyncThread implements Runnable{
    private Object obj1;
    private Object obj2;
 
    public SyncThread(Object o1, Object o2){
        this.obj1=o1;
        this.obj2=o2;
    }
    @Override
    public void run() {
        String name = Thread.currentThread().getName();
        System.out.println(name + " acquiring lock on "+obj1);
        synchronized (obj1) {
         System.out.println(name + " acquired lock on "+obj1);
         work();
         System.out.println(name + " acquiring lock on "+obj2);
         synchronized (obj2) {
            System.out.println(name + " acquired lock on "+obj2);
            work();
        }
         System.out.println(name + " released lock on "+obj2);
        }
        System.out.println(name + " released lock on "+obj1);
        System.out.println(name + " finished execution.");
    }
    private void work() {
        try {
            Thread.sleep(30000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
    }
}

Khi chạy VisualVM sẽ thấy như sau

11. Deadlock

3 thread t1, t2, t3 hiện đang ở trạng thái màu đỏ, nghĩa là cả 3 cùng đang chờ lẫn nhau dẫn đến không thread nào có thể chạy tiếp được dẫn đến deadlock.

Kết thúc bài viết hi vọng đã chia sẻ cho các bạn một công cụ hữu ích trong việc theo dõi và đo hiệu năng chương trình Java.

Nguồn: https://edwardthienhoang.wordpress.com

Email: edwardthienhoang@gmail.com