Nghỉ giải lao #109. Các kỹ năng được yêu cầu nhiều nhất trong phát triển Java hiện nay. 7 mẹo tùy chọn Java để loại bỏ sự lộn xộn trong mã

Các kỹ năng được yêu cầu nhiều nhất trong phát triển Java hiện nay

Nguồn: Medium Java vẫn là một trong những ngôn ngữ lập trình phổ biến và có nhu cầu cao nhất, mặc dù thực tế là nó đã có tuổi đời gần một phần tư thế kỷ. Do đó, thật hợp lý khi cho rằng mức độ phổ biến của Java sẽ tiếp tục tăng và các nhà phát triển Java sẽ nhận thấy nhu cầu thậm chí còn lớn hơn từ các nhà tuyển dụng trong tương lai. Để tạo ra các sản phẩm chất lượng, các nhà phát triển cần cập nhật các công cụ Java mới nhất và nâng cao kỹ năng cũng như kiến ​​thức kỹ thuật của mình. Dưới đây chúng tôi trình bày sáu kỹ năng cần thiết cần thiết cho các nhà phát triển Java.

1. Kiến thức tốt về Java 8

Mặc dù các phiên bản Java mới hơn đã được sử dụng rộng rãi nhưng tất cả các nhà phát triển Java đầy tham vọng đều cần có kiến ​​thức và kinh nghiệm chuyên sâu về Java 8. Một số tính năng hữu ích nhất của Java 8 bao gồm:

• Các phương thức tiêu chuẩn và tĩnh để tạo giao diện với việc triển khai phương thức.
• Giao diện chức năng chỉ có một phương thức trừu tượng và giúp nhà phát triển tránh thêm các phương thức trừu tượng khác.
• Biểu thức Lambda giúp tạo giao diện chức năng.
• API Java Stream để cho phép thực thi song song và tuần tự.
• Các phương thức mới trong API Bộ sưu tập.

Tất cả những tính năng này làm cho Java 8 không thể thiếu trong lập trình chức năng. Lập trình chức năng cung cấp tính đồng thời và tính ngắn gọn của mã, đồng thời giúp tạo các ứng dụng tải cao với mã được tối ưu hóa. Java 8 cũng trở thành nền tảng cho việc tối ưu hóa mã gốc, cho phép tối ưu hóa quá trình phát triển bằng các ngôn ngữ khác như Scala, Kotlin và Grails.

2. Kinh nghiệm kiểm thử

Kiểm thử đơn vị trong Java là một chủ đề khá gây tranh cãi. Một số nhà phát triển cho rằng viết bài kiểm thử đơn vị là lãng phí thời gian, nhưng chúng tôi tin chắc rằng kỹ năng kiểm thử đơn vị là điều bắt buộc đối với bất kỳ nhà phát triển Java chuyên nghiệp nào. Kiểm thử đơn vị cho phép bạn kiểm tra từng khối mã riêng lẻ và đảm bảo rằng sản phẩm cuối cùng hoạt động không có lỗi. Vì vậy, nếu một nhà phát triển muốn nâng cao kỹ năng và kiến ​​thức của mình, anh ta cần học cách sử dụng các công cụ kiểm tra phổ biến và hiệu quả nhất. Khung thử nghiệm chính mà bạn cần làm quen là thư viện JUnit 5. Các công cụ khác bao gồm:

• Khung robot
• Mockito
• PowerMock

Ngoài thử nghiệm đơn vị, nhà phát triển Java không nên quên các phương pháp thử nghiệm khác (thử nghiệm hệ thống, thử nghiệm chấp nhận và thử nghiệm tích hợp). Điều này cho phép bạn thực hiện kiểm tra toàn diện phần mềm và đảm bảo không có lỗi, lỗi hoặc lỗi nghiêm trọng. Điều chính cần nhớ về thử nghiệm là những thay đổi nhỏ sẽ dẫn đến kết quả lớn. Nếu bạn không ngần ngại dành thời gian và công sức cho việc thử nghiệm đơn vị, bạn sẽ ngạc nhiên trước sự cải thiện về chất lượng công việc của mình.

3. DevOps

Mặc dù không bắt buộc nhưng việc tìm hiểu về DevOps và các nguyên tắc của nó có thể mang lại lợi ích cho bạn với tư cách là nhà phát triển và cho công ty mà bạn làm việc. Tính linh hoạt và tổ chức của các quy trình DevOps cho phép các công ty tối ưu hóa chất lượng sản phẩm và hợp lý hóa hoạt động. và cũng làm tăng tính minh bạch của các quy trình. DevOps trong Java về cơ bản là ứng dụng DevOps vào phát triển Java. Điêu nay bao gôm:

• Phân phối và tích hợp liên tục.
• Làm việc với microservice thay vì nguyên khối.
• Cơ sở hạ tầng như mã.
• Kiểm tra tự động.

DevOps là một lĩnh vực rộng lớn và cần nhiều thời gian và nguồn lực để nghiên cứu nó. Nhưng nếu bạn là nhà phát triển Java, việc học DevOps sẽ có ích vì nó sẽ giúp bạn trở thành kỹ sư DevOps trong tương lai. Nếu bạn không muốn trở thành kỹ sư DevOps hoặc công ty của bạn không quan tâm đến việc đó thì cũng không sao. Chỉ cần lưu ý rằng DevOps ngày càng trở nên phổ biến trong cộng đồng Java.

4. Kiến thức về thư viện Java và API.

Vì Java là một trong những ngôn ngữ lập trình hàng đầu trên thế giới nên không có gì ngạc nhiên khi nó có số lượng lớn các API và thư viện có sẵn để làm việc. Những công cụ này đơn giản hóa đáng kể quá trình phát triển và cho phép các nhà phát triển nhanh chóng tạo ra phần mềm đáng tin cậy. Dưới đây chúng tôi đã liệt kê một bộ công cụ cơ bản mà bất kỳ nhà phát triển Java giỏi nào cũng biết và có thể tự tin sử dụng. Những công cụ này giúp bạn nhanh chóng xây dựng ứng dụng và quản lý dữ liệu cũng như lưu trữ dữ liệu một cách hiệu quả:

• Gradle (một công cụ để xây dựng ứng dụng);
• Maven (hơi lỗi thời nhưng vẫn phổ biến, cũng được sử dụng để xây dựng ứng dụng);
• Gói tiêu chuẩn Java 8;
• Khung mùa xuân;
• JPA ORM (Ngủ đông, TopLink);
• Cơ sở dữ liệu NoSQL (MongoDB, Cassandra).

Về phần API, để làm việc được với Java API cốt lõi, nhà phát triển cần có kiến ​​thức tốt về OpenJDK, Android, Oracle và IS2T. Ưu điểm lớn của những công cụ này là chúng đều có tài liệu chi tiết và đầy đủ thông tin. Hơn nữa, các nhà phát triển luôn có thể nhận được sự hỗ trợ của cộng đồng, đây cũng là một lợi thế lớn.

5. Tự tin kiến ​​thức về Spring và Spring Boot

Spring Framework là framework được sử dụng phổ biến nhất để phát triển các ứng dụng dựa trên Java, vì vậy điều quan trọng là nhà phát triển phải biết cách làm việc với nó. Một trong những lợi ích chính của Spring là tính năng chèn phụ thuộc, cho phép bạn tạo các ứng dụng được liên kết lỏng lẻo và giúp các nhà phát triển linh hoạt hơn. Spring cũng rất nhẹ, hỗ trợ các cấu hình, chú thích và lập trình khai báo XML. Vì vậy nếu muốn thành thạo các kỹ năng phát triển Java, bạn cũng nên thành thạo việc triển khai Spring. Spring Boot là phiên bản lặp lại của Spring, cung cấp một công cụ thuận tiện để triển khai nhanh các ứng dụng. Có thể nói rằng Spring Boot sử dụng Spring làm cơ sở và xây dựng các tính năng riêng của nó dựa trên nó. Trong khi Spring tập trung vào tính linh hoạt thì Spring Boot giúp giảm bớt code và đơn giản hóa quá trình phát triển. Nó cung cấp cho các nhà phát triển các tính năng có sẵn, giúp xây dựng các ứng dụng độc lập và nhìn chung dễ khởi chạy và quản lý hơn. Spring Boot rất phù hợp cho các vi dịch vụ và ứng dụng cần được xây dựng nhanh chóng, vì nó giúp thiết lập và chạy ứng dụng cho nhiều môi trường khác nhau (sản xuất, kiểm tra, chất lượng, CI/CD) nhanh chóng và dễ dàng. Cả Spring và Spring Boot đều đã mở rộng khả năng lập trình React, đây là một xu hướng hot khác trong cộng đồng nhà phát triển. Ví dụ: Spring 5 hiện có WebFlux để triển khai phương pháp tiếp cận phản ứng để lập trình và giải quyết các hệ thống phân tán phức tạp.

6. Trải nghiệm với Dữ liệu lớn

Dữ liệu lớn là xu hướng ngày càng tăng mà các nhà phát triển phải theo dõi và áp dụng để đáp ứng nhu cầu thị trường. Các công cụ chính mà các nhà phát triển Java chuyên nghiệp có thể làm quen là:

• Apache Spark
• Apache Kafka
• Hadoop (để xử lý hàng loạt)

Apache Spark là một nền tảng xử lý Dữ liệu lớn phân tán cung cấp các liên kết gốc cho Java. Khung này đã trở nên cực kỳ phổ biến nhờ các tính năng và hiệu suất của nó và hiện là công cụ dữ liệu lớn được ưa thích nhất trong cộng đồng Java. Apache Spark có thể chạy ở chế độ độc lập cụm và để làm được điều này, bạn chỉ cần môi trường Apache Spark và JVM (cho mỗi máy trong cụm). Spark cũng cực kỳ nhanh và có API Spark rất thân thiện với người dùng. Hadoop là một nền tảng lưu trữ dữ liệu cũng được các nhà phát triển Java biết đến. Mặc dù Hadoop không nhanh bằng Spark nhưng nó vẫn là một trong những công cụ phổ biến nhất để làm việc với dữ liệu lớn. Điều này cũng là do Hadoop (và các giải pháp tương tự) có số lượng lớn plugin cho phép bạn giải quyết hiệu quả các vấn đề xử lý Dữ liệu lớn và nói chung là tối ưu hóa hiệu suất của Hadoop (bao gồm hỗ trợ xử lý luồng thời gian thực).

7 mẹo tùy chọn Java để loại bỏ sự lộn xộn trong mã

Nguồn: Medium “Tôi có những đồng nghiệp không biết về sự tồn tại của Tùy chọn,” một nhà phát triển Java trên Reddit viết. Chúng ta có thể cho rằng Tùy chọn cải thiện “khả năng đọc” của mã không? Có đáng để sử dụng nó mọi lúc không? Việc sử dụng Tùy chọn hoàn toàn không cần thiết ở đâu? Vì nhiều nhà phát triển vẫn chưa biết cách sử dụng Tùy chọn một cách chính xác nên tôi sẽ đưa ra 7 ví dụ về việc lạm dụng Tùy chọn và những việc cần làm đối với chúng.

1. Không sử dụng Tùy chọn để kiểm tra null

Sử dụng Tùy chọn thay vì kiểm tra null chỉ làm tăng thêm sự lộn xộn. Không có lợi ích từ việc này. Việc sử dụng các phương thức Tùy chọn và isPresent và get cũng là một sai lầm . Các nhà phát triển tin rằng get sẽ hoạt động như mong đợi. Sau đó, họ thêm isPresent và quay lại kiểm tra null. Hãy nhớ rằng Tùy chọn không khắc phục được các kiểm tra rỗng của bạn. Lần tới khi bạn nhìn thấy isPresent và nhận (hoặc ElseThrow ) hãy thay đổi đoạn mã này. Sử dụng ánh xạ và orElse để loại bỏ kiểm tra null tiêu chuẩn và sử dụng Tùy chọn có chọn lọc hơn. Đây là một ví dụ điển hình:

var user = userService.getCurrentUser();
if(user == null) {
    return "(unknown)";
}
var username = user.getUsername();
if (username == null) {
    return "(unknown)";
}
return username;
vs

var user = userService.getCurrentUser();
if(user.isEmpty()) {
    return "(unknown)";
}
var username = user.orElseThrow().getUsername();
if (username == null) {
    return "(unknown)";
}
return username;
vs

return userService.getCurrentUser()
                  .map(User::getUsername)
                  .orElse("(unknown)");

Bạn có thể bắt đầu với mục tiêu Tùy chọn. Mục đích của Tùy chọn là thể hiện các giá trị tùy chọn, bị thiếu. Sau đó quay lại vấn đề của bạn và xem nó có hiệu quả với bạn không. Một cách khác để giải quyết vấn đề kiểm tra null là sử dụng chú thích. Nullable hoặc NotNull sẽ hoạt động tốt. Đúng, chúng có thể làm ô nhiễm mã của bạn và chúng chỉ bảo vệ vào thời gian biên dịch. Để kiểm tra thời gian chạy, hãy sử dụng Objects.requireNonNull .

2. Xử lý lỗi thích hợp

Đôi khi null đại diện cho các ngoại lệ. Và đây là cách sai lầm để báo hiệu lỗi và ngoại lệ. “Đã xảy ra lỗi và ở đây nó không có giá trị” là một mô hình phản đối cần tránh. Ngoài ra, bạn không nên sử dụng Tùy chọn để bao gồm các trường hợp ngoại lệ. Đây là một ví dụ.

public Optional<MyObject> getMyObject(final String jql) {
    try {
        return Optional.ofNullable(get(sql));
    } catch (final JqlParseException e) {
        return Optional.empty();
    }
}

Tại sao myObject trống? Đây là một lỗi hoặc một giá trị trống. Vì vậy, bạn sẽ lại nhận được một kết quả không rõ ràng và kết quả là xóa bỏ các lợi ích của Tùy chọn. Mã này tồn tại vì mọi người đang cố gắng sử dụng Tùy chọn cho luồng điều khiển. Tùy chọn sẽ loại bỏ một số số không khỏi cơ sở mã của bạn. Nhưng bạn vẫn cần sử dụng cấu trúc try-catch để xử lý các trường hợp ngoại lệ. Sử dụng tính năng thử bắt để xử lý các trường hợp ngoại lệ một cách chính xác. Đừng loại bỏ Tùy chọn khi xử lý lỗi, chỉ cần chờ đợi và nó sẽ hoạt động hoàn hảo. Nhưng có một ngoại lệ ở đây - trống Catch . Khi bạn không biết phải trả lại cái gì trong một lần bắt trống, Tùy chọn trống sẽ hoạt động tốt.

private int readExpirationAsInt(Milk milk)
{
  String expiration = milk.getExpiration();
  try {
    return Integer.parseInt(expiration);
  }
  catch(NumberFormatException ignored) {}

  return 0;
}


private OptionalInt readExpirationAsInt(Milk milk)
{
  String expiration = milk.getExpiration();

  try {
    return Optional.of(Integer.parseInt(expiration));
  }
  catch(NumberFormatException e) {
    return OptionalInt.empty();
  }
}

3. Không trả về null từ các phương thức Tùy chọn

public static Optional<POSType> getPOSType(String posName) {
    if (StringUtils.isNotBlank(posName)) {
        return Arrays.stream(POSType.values())
                .filter(type -> type.toString().equalsIgnoreCase(posName))
                .findFirst();
    }
    return null;
}

Điều này đánh bại mục đích của Tùy chọn. Đây là một ví dụ khác về thử nghiệm kém. Vì đầu vào trống nên điều này có nghĩa là chúng ta cần tệp IllegalArgumentException . Ngoài ra, đây là một sai lầm. Không ai cần kiểm tra các phương thức gọi tùy chọn. Trả về một phần tử Tùy chọn trống và không bao giờ kiểm tra phần tử Tùy chọn xem có rỗng hay không.

4. Không sử dụng Tùy chọn với các bộ sưu tập.

Không cần phải bọc các bộ sưu tập trong Tùy chọn. Hơn nữa, đừng đưa Tùy chọn vào bộ sưu tập. Điều này chỉ làm phức tạp thêm mọi thứ bằng cách thêm vào những quyền anh vô nghĩa và việc mở thêm gói. Không thêm Tùy chọn vào bộ sưu tập. Không có lợi ích rõ ràng từ việc này. Giữ nó đơn giản và sử dụng Tùy chọn cho các giá trị bị thiếu.

5. Đừng xâu chuỗi chỉ vì mục đích xâu chuỗi

Optional.ofNullable(foo).ifPresent(value -> {
  //do something
})

Tùy chọn có các phương pháp chi tiết có thể trợ giúp việc này. Thay vì chuỗi, một kiểm tra null đơn giản sẽ đủ. Tôi biết Tùy chọn có phương pháp tốt và hỗ trợ IDE tốt. Bạn có thể sử dụng chúng.

6. Sử dụng trình bao bọc giá trị nguyên thủy

Đây không phải là vấn đề lớn nhưng bạn có thể sử dụng Tùy chọnInt hoặc Tùy chọnLong . Đơn giản bằng cách loại bỏ các generic không cần thiết, bạn sẽ cải thiện hiệu suất và viết mã ngắn gọn hơn.

7. Bạn nên biết về ofNullable

if (a==null){
  return Optional.empty();
} else {
  return Optional.of(a);
}

Loại mã này thường được viết bởi các nhà phát triển không biết về Tùy chọn#ofNullable . Hầu hết các nhà phát triển thậm chí không hiểu sự khác biệt giữa ofNullable và of . Họ không hiểu làm thế nào Tùy chọn#of có thể phản tác dụng. Hầu hết sẽ dùng đến ofNullable vì sợ ném NullPointerException vào Tùy chọn#of . Một lần nữa, điều này làm mất đi mục đích của hai phương pháp này. Nếu chúng ta chỉ sử dụng ofNullable , tại sao chúng ta lại cần Tùy chọn#of ? Tùy chọn#of ném NPE khi bạn chuyển sang giá trị rỗng. Điều này xảy ra vì một lý do. Phương pháp này nên được sử dụng khi bạn mong đợi giá trị hiện diện. Nếu không có nó, nó sẽ nhanh chóng thất bại. Tùy chọn#ofNullable chuyển đổi null thành Tùy chọn trống. Phương thức này lấy null làm đối số, khớp với một Tùy chọn trống.