2011년 11월 28일 월요일

Java 7 Feature Overview


public class ProjectCoinBanker {


 private static final Integer ONE_MILLION = 1_000_000;
 private static final String RICH_MSG = "You need more than $%,d to be considered rich.";


 public static void main(String[] args) throws Exception {
  System.out.println(String.format(RICH_MSG, ONE_MILLION));


  String requestType = args[0];
  String accountId = args[1];
  switch (requestType) {
   case "displayBalance":
    printBalance(accountId);
    break;
   case "lastActivityDate" :
    printLastActivityDate(accountId);
    break;
   case "amIRich" :
    amIRich(accountId);
    break;
   case "lastTransactions" :
    printLastTransactions(accountId, Integer.parseInt(args[2]));
    break;
   case "averageDailyBalance" :
    printAverageDailyBalance(accountId);
    break;
   default: break;
  }
 }


 private static void printAverageDailyBalance(String accountId) {
  String sql = String.format(AVERAGE_DAILY_BALANCE_QUERY, accountId);
  try (
    PreparedStatement s = _conn.prepareStatement(sql);
    ResultSet rs = s.executeQuery();
   ) {
   while (rs.next()) {
    //print the average daily balance results
   }
   } catch (SQLException e) {
    // handle exception, but no need for finally to close resources
    for (Throwable t : e.getSuppressed()) {
     System.out.println("Suppressed exception message is " + t.getMessage());
    }
  }
 }


 private static void printLastTransactions(String accountId, int numberOfTransactions) {
  List transactions = new ArrayList<>();
  //... handle fetching/printing transactions
 }


 private static void printBalance(String accountId) {
  try {
   BigDecimal balance = getBalance(accountId);
   //print balance
  } catch (AccountFrozenException | ComplianceViolationException | AccountClosedException e) {
   System.err.println("Please see your local branch for help with your account.");
  }
 }


 private static void amIRich(String accountId) {
  try {
   BigDecimal balance = getBalance(accountId);
   //find out if the account holder is rich
  } catch (AccountFrozenException | ComplianceViolationException | AccountClosedException e) {
   System.out.println("Please see your local branch for help with your account.");
  }
 }


 private static BigDecimal getBalance(String acccountId)
 throws AccountFrozenException, AccountClosedException, ComplianceViolationException {
  //... getBalance functionality
 }


}

Briefly, our ProjectCoinBanker class demonstrates basic usage of the following Project Coin features.

  • Underscores in numeric literals
  • Strings in switch
  • Multi-catch
  • Type inference for typed object creation
  • try with resources and suppressed exceptions 


First of all, underscores in numeric literals are pretty self-explanatory. Our example,


private static final Integer ONE_MILLION = 1_000_000;


shows that the benefit is visual. Developers can quickly look at the code to verify that values are as expected. Underscores can be used in places other than natural groupings locations, being ignored wherever they are placed. Underscores in numeric literals cannot begin or terminate a numeric literal, otherwise, you’re free to place them where you’d like. While not demonstrated here, binary literal support has also been added. In the same way that hex literals are prefixed by 0x or 0X, binary literals would be prefixed by 0b or 0B.

Strings in switch are also self-explanatory. The switch statement now also accepts String. In our example, we switch on String argument passed to the main method to determine what request was made. On a side note, this is purely a compiler implementation with an indication that JVM support for switching on String may be added at a later date.

Type inference is another easy-to-understand improvement. Now instead of our old code




List<Transaction> transactions = new ArrayList<Transaction>(); 

we can simply do

List<Transaction> transactions = new ArrayList<>(); 

since the type can be inferred. Probably won’t find anyone who would argue that it shouldn’t have been so since the introduction of generics, but it’s now here.

Multi-catch will turn out to be very nice for the conciseness of exception handling code. Too many times when wanting to actually do something based on the exception type thrown, until now we were forced to have multiple catch blocks all doing essentially the same thing. The new syntax is very clean and logical. Our example,

catch (AccountFrozenException | ComplianceViolationException | AccountClosedException e) 

shows how easily it can be done.

Finally, the last demonstration of a Project Coin feature is the try with resources syntax and support for retrieving suppressed exceptions. A new interface has been introduced, AutoCloseable that has been applied to all the expected suspects including Input/OutputStreams, Readers/Writers, Channels, Sockets, Selectors and java.sql resources Statement, ResultSet and Connection. In my opinion, the syntax is not as natural as the multi-catch change was, not that I have an alternative in mind.

try(  
PreparedStatement s = _conn.prepareStatement(sql);  
ResultSet rs = s.executeQuery();
){  
while (rs.next()) {  
//print the average daily balance results  
}  
} catch (SQLException e) {  
//handle exception, but no need for finally to close resources  
for (Throwable t : e.getSuppressed()) {  
System.out.println("Suppressed exception message is " + t.getMessage());  
}

First we see that we can include multiple resources in try with resources ? very nice. We can even reference previously declared resources in the same block as we did with our PreparedStatement. We still handle our exception, but we don’t need to have a finally block just to close the resources. Notice too that there is a new method getSuppressed() on Throwable. This allows us to access any Exceptions that were thrown in trying to “autoclose” the declared resources. There can be at most one suppressed exception per resource declared. Note: if the resource initialization throws an exception, it would be handled in your declared catch block.

That’s it. Nothing earth-shattering but some simple enhancements that we can all begin using without too much trouble. Project Coin also includes a feature regarding varargs and compiler warnings. Essentially, it boils down to a new annotation (@SafeVarargs) that can be applied at the method declaration to allow developers to remove @SuppressWarnings("varargs") from their consuming code. This has been applied on all the key suspects within the JDK, but the same annotation is available to you in any of your genericized varags methods.

The Project Coin feature set as it is described online is inconsistent at best. Hopefully this will give you a solid summary of what you can use from the proposal in JDK 7. 

댓글 없음:

댓글 쓰기

ETL 솔루션 환경

ETL 솔루션 환경 하둡은 대용량 데이터를 값싸고 빠르게 분석할 수 있는 길을 만들어줬다. 통계분석 엔진인 “R”역시 하둡 못지 않게 관심을 받고 있다. 빅데이터 역시 데이터라는 점을 볼때 분산처리와 분석 그 이전에 데이터 품질 등 데이...