都元ダイスケ IT-PRESS このページをアンテナに追加 RSSフィード

最近は会社ブログしか書いてません。

2011-12-25

[]細かすぎて伝わらないJava7の変更点

本日のエントリーはJava Advent Calendarの25日目です。昨日は @mike_neck さんのmike、mikeなるままに…: hamcrestを拡張してmoreThanとか作ってみたでした。本日はクリスマスですが、Advent Calendarはまだまだ続きます。明日はt.ogisawaさんのno titleです。

さて、今年はJava7がリリースされましたね。try-with-resources、diamond operator、invoke dynamic、Folk/Join framework…魅力的な新機能の数々が、多くの人によって紹介されています。が、Java7の変更はそれだけじゃないはず。小粒だが、キラリと光る変更がきっとあるはず。ということで、Java6とJava7のsrc.zipを比較してみました。小ネタなのでサラっと読んで頂ければと思います。

まず、比較に用いたのは以下の通り。


で、まず普通にdiffを掛けてみたのだが、意外とdocコメント上で頑張っていることが判明。docコメント内のcodeタグやttタグ、preタグの多くを{@code}や{@link}で書き直してある部分が目立つ。まぁ、未だにcodeタグのままの部分も多いのだが、頑張ったよね。個人的にはHTMLタグよりも読みやすいと思っているので、嬉しいです。

あと、Java6までのソースは、インデントがTABだったりSPACEだったりまちまちだった。そしてどうやらTAB幅8としているようで、TAB幅4の環境で見るとそれはそれは残念な感じになってしまう。もうこの辺りのコーディングスタイルに関しては、標準APIであるにも関わらずもう壊滅的でしたよね。自分のコーディング規約やJavadocの書き方ルール策定の参考にしようと思って愕然とした記憶がある。しかし、Java7では、インデントがSPACEに直っているのが目立つ。未確認だが、全部統一されているのかもしれない。喜ばしい。

といった所の差異までdiffで見えてしまうと、もはやノイズでしかないので、ここは思い切って両者のソースをいじってしまいます。

find . -type f | xargs sed -e 's/\<code\>\([^<]*\)\<\/code\>/{@code \1}/g' -i ""
find . -type f | xargs sed -e 's/\<tt\>\([^<]*\)\<\/tt\>/{@code \1}/g' -i ""

両者のソースに対して、上記の置換を掛けた後、俺俺コードフォーマッタを掛けてからdiffに挑みました。で、com.sunパッケージなんかの差を見始めてもアレなので、ひとまず java.* パッケージに絞って、そして都元が個人的に気になったポイントを中心に、以下にご紹介しまーす。

スペルミスや細かいバグフィックス

まずは軽く。Java6と7の比較、という視点ではありませんが、結構色々直していますね。

 * @throw new NullPointerException

なんていうdocコメントがあったり。勢いでnewって書いちゃったんだろうなーw

public Foo {
  // …
  private void Foo() {}
}

なんてやっちゃってるクラスもありました。


古いコーディングスタイルの刷新

Java6のソースにはstatic publicという語順(?)や、char foo[]; のような配列宣言、rawtype型など、古い書き方が内部に随分残ってます。こういった所がちょいちょい直してありました。あと、ダイアモンドオペレータもきっちり使われてましたよ。


各Exception実装クラスにserialVersionUIDが追加

ExceptionはSerializableのサブタイプです。従って、例外の実装クラスには全てserialVersionUIDを記述するのが望ましいんですね。まぁ、実装の詳細の話ではありますが、各ExceptionにserialVersionUIDが追加されてます。


Byte/Integer/Long/BigIntegerの文字列paese

int i1 = Integer.parseInt("3");
int i2 = Integer.parseInt("-6");
int i3 = Integer.parseInt("+2");

皆さん、このコード実行するとどうなると思います? 実は、Java6だと "+2" は NumberFormatException になってしまうのです。文字列の整数parseにおいて、プラス記号は今まで使えませんでした。これが、Java7からは普通に通るようになります。

ちなみに、DoubleやFloatのparseでは、Java6でもプラス記号が使えます。


primitive wrapper class

Integer.compare(10, 15);

というような、比較ロジックがstaticメソッドとして提供されるようになりました。プリミティブラッパー型にそれぞれ定義されています。比較ロジックを引き算で実装してバグを出してしまう位なら、このユーティリティメソッドに委譲してしまうのがよいですね。

比較ロジックの引き算実装については下記参考書籍の「パズル65」を参照。


ComparableとComparator

従来、Comparable#compareToやComparator#compareの引数にnullを渡した時の仕様は「未定義」でした。また、私は基底型のjavadocに明示してある例外しか投げないようにしているため、「nullとは比較できないComparable」を実装したい時、とても気持ち悪い思いをしていました。

そんな中、Java7ではこれらの比較メソッドjavadocに、NPEの記述が追加されました。

@throws NullPointerException if the specified object is null

引数がnullな時はNPEを投げてよくなったのですね。


Collections

以前から、Collectionsクラスには emptyList() 等のメソッドがありましたが、似たような感じで以下のメソッドが追加になりました。大したことではありませんが、使う機会があれば使った方が良いですね。

  • emptyEnumeration()
  • emptyIterator()
  • emptyListIterator()

Objets

新しいユーティリティクラスです。requireNonNullやnull-safeなequals/hashCode/toStringなど、小粒ながら使い勝手は良さそうです。


ReflectiveOperationException

従来、リフレクションAPIを利用しようとすると数多くのチェック例外を処理する必要がありました。NoSuchMethodException, InvocationTargetException, ClassNotFoundException, IllegalAccessException… 実際は発生しないと踏んでいる例外をこんなに大量にキャッチさせられるのはストレスでしたね。しかし、Java7からはReflectiveOperationExceptionという基底クラスが定義されました。これによって、リフレクション操作時の例外をまとめてキャッチできます。


AutoCloseable

try-catch-resources用に出て来た新しいインターフェイスです。Closeableはもちろん、Connection/ResultSet/Statementもこいつのサブタイプに。

従来はJDBC API用の closeQuietly 的なユーティリティを、I/O とは別に書かなければなりませんでしたが、今度からまとめられますね。


ThreadLocalRandom

っていうクラスが追加になっています。まぁ、内容は名前から想像できる通りです。


Scanner

ScannerがCloseableのサブタイプになりました。今までCloseableじゃなかったのは、単に忘れてただけなのでしょうかw


Integer, Short, LongのvalueOf

Sun(Oracle)のJavaにおいて、Integer型のインスタンスは-128〜127の値がキャッシュされる、というのは有名な(?)話でした。しかし、このキャッシュは「Sun(Oracle)の実装がたまたまそうなっている」だけであり、Javaの仕様ではないものでした。つまり、別のJava実装(例えばIBM Javaとか?)ではキャッシュをしていないかもしれません。キャッシュの範囲が違うかもしれません。

という状況だったのですが。Java7のjavadocには以下のような記述が追加されています。

【Integer#valueOf及びShort#valueOfより】
     * This method will always cache values in the range -128 to 127,
     * inclusive, and may cache other values outside of this range.
【Long#valueOfより】
     * Note that unlike the {@linkplain Integer#valueOf(int)
     * corresponding method} in the {@code Integer} class, this method
     * is <em>not</em> required to cache values within a particular
     * range.

これって…。Javadocに明示されたということは、キャッシュの挙動も含めて仕様化したということで良いんでしょうかね。


System

System#lineSeparator() っていうメソッドが追加。プラットフォーム依存の改行文字(列)をさくっと手に入れられて便利ですね。

また、Systemクラス内の in, out staticフィールドの初期化方法が変わったようです。Java6までは、staticフィールドが参照元クラスにインライン展開されないように、ちょっとしたハックがされていましたが、Java7では直接null初期化しています。これはインライン展開されなくなったんですかね。そこまでは追いきれませんでした。


暦システム関連

f:id:daisuke-m:20111225165712p:image:right

week yearのサポートが手厚くなってます。GregorianCalendarに以下の3メソッドが追加になりました。

  • getWeeksInWeekYear()
  • getWeekYear()
  • isWeekDateSupported()

って何の事だかわからんですね。えーと。「1週間は月曜〜日曜である」として、「2011年の第1週」って何日から何日だと思いますか? まぁこのネタはこちらが詳しいので参照してください。 → 今が年の何週目か - 気付いたとき、気が向いたとき。by ykhr

で、結論としては、ISO8601的には1/3〜1/9が「2011年の第1週」ということになります。ということは、2010/12/27〜2011/01/02は「2010年の第52週」なんですね。デフォルトのGregorianCalendarの挙動は「1週間は日曜始まりで、1/1を含むのが第1週」ということにになっていますが、それをISO的に「1週間は月曜始まりで、1/4を含むのが第1週」という設定をするのが先ほどの id:ykhr-kokko 氏のエントリです。

で、ここで注目したいのは「2011/01/02は、2011年の日付であるにも関わらず、週レベルで見ると2010年に属する」ということです。めんどくさいですねw 今日は何年の第何週なのかが知りたいとします。第何週かは cal.get(Calendar.WEEK_OF_YEAR) で良いでしょう。では「ある日付を与えた時、それは週レベルでは何年に属するのか?」をどうやって取るのか。これが getWeekYear() です。

とは言え、大抵 Calendar.YEAR と一致してますから、年末年始だけ気をつけておけば簡単に計算できるんじゃね? …と思いきや、正確にやり出すと結構大変みたいです。1582年以前は、今のグレゴリオ暦ではなくユリウス暦が…詳しくは getWeekYear() の実装をご覧下さい。

んでまぁ、上記に関連してSimpleDateFormatに新しいパターンが追加になりました。Y, u, X の3つですが、このYってのがweek yearです。uとXは大した事ないので気になったら各自ググってくださいw

ちなみに「1週間は月曜始まりで、1/4を含むのが第1週」というルールを知っているのはCalendarですから、下記の通りSimpleDateFormatにcalを与えてやらないと、ISOのルール通りには動きませんので注意しましょう。

Calendar cal = new GregorianCalendar();
cal.setMinimalDaysInFirstWeek(4);
cal.setFirstDayOfWeek(Calendar.MONDAY);
SimpleDateFormat f = new SimpleDateFormat("yyyy/MM/ddはYYYY年の第ww週です。");
f.setCalendar(cal);
System.out.println(f.format(new Date()));

…と、まぁdiffをしてみて気づいたあれやこれやを並べてみました。明日以降も引き続き、Java Advent Calendarでお楽しみください :)

2011-11-26

[][]Spring 3.1 の Cache Abstraction(キャッシュ抽象化

しばらくコード付きのエントリ書いてないなぁ、と思ったので。Springの新機能についてひとつ。

Spring3.1は、まだリリース版は出ていないのだけど、RC1が出ている。(参考 Spring 3.1 RC1リリース

その新機能にCache Abstraction(キャッシュ抽象化)ってのがあって、色々調べてみた。例えばWebAPIなんかを叩いて情報を取ってくるようなメソッドは、情報があまり変化しないものであればキャッシュしちゃえばいいよね。例えば Amazon API で、ASINから商品名やら何やかんやを取ってくるメソッドとか。

下準備

package jp.xet.sample;

public interface EntityRepository {
    
  String get(int id);
    
  void put(int id, String value);
    
}

例えばこんな(↑)インターフェイスがあって、このgetのコストが高いとしましょう。で、今回使うサンプルの実装がコレ(↓)。コストの高さをThread.sleepで表現してみました。実際は単なるMapストレージなんだけども。

package jp.xet.sample;

import java.util.HashMap;
import java.util.Map;
import org.springframework.stereotype.Repository;

@Repository
public class EntityRepositoryImpl implements EntityRepository {
    
  private Map<Integer, String> storage = new HashMap<Integer, String>();
    
    
  @Override
  public String get(int id) {
      
    // simulate slow operation
    try {
      Thread.sleep(1000L);
    } catch (InterruptedException e) {
      throw new AssertionError(e);
    }
      
    return storage.get(id);
  }
    
  @Override
  public void put(int id, String value) {
    storage.put(id, value);
  }
}

で、こいつ(↑)には@Repositoryアノテーションがついている。まぁ@Componentと全く一緒*1らしい。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
  xmlns:context="http://www.springframework.org/schema/context"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.1.xsd">

 <context:component-scan base-package="jp.xet.sample"/>

</beans>

で、jp.xet.sampleパッケージ以下のアノテーション付きのコンポーネントをcontext.xmlで読んでもらう、と。まぁ、EntityRepositoryImplしかないんですが。そんなわけで、Mainクラスいきましょう。

package jp.xet.sample;

import org.apache.commons.lang.time.StopWatch;
import org.springframework.context.ApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;

public class Main {
    
    
  public static void main(String[] args) {
    ApplicationContext ctx =
      new ClassPathXmlApplicationContext("/context.xml");
    EntityRepository repos = ctx.getBean(EntityRepository.class);

こうして出来たコンテナからは、EntityRepositoryが取り出せる。あとは、適当にデータを置いて、時間をはかってみる。

    repos.put(1, "one");
    repos.put(2, "two");
    repos.put(3, "three");
    
    StopWatch sw = new StopWatch();
    sw.start();
    
    System.out.format("time=%2$s, value=%1$s%n",
        repos.get(1), sw.toString());
    System.out.format("time=%2$s, value=%1$s%n",
        repos.get(2), sw.toString());
    System.out.format("time=%2$s, value=%1$s%n",
        repos.get(1), sw.toString());
    System.out.format("time=%2$s, value=%1$s%n",
        repos.get(2), sw.toString());
    System.out.format("time=%2$s, value=%1$s%n",
        repos.get(3), sw.toString());
    
    repos.put(1, "壱");
    repos.put(3, "参");
    
    System.out.format("time=%2$s, value=%1$s%n",
        repos.get(1), sw.toString());
    System.out.format("time=%2$s, value=%1$s%n",
        repos.get(2), sw.toString());
    System.out.format("time=%2$s, value=%1$s%n",
        repos.get(1), sw.toString());
    System.out.format("time=%2$s, value=%1$s%n",
        repos.get(2), sw.toString());
    System.out.format("time=%2$s, value=%1$s%n",
        repos.get(3), sw.toString());
  }
}
time=0:00:01.002, value=one
time=0:00:02.012, value=two
time=0:00:03.014, value=one
time=0:00:04.014, value=two
time=0:00:05.015, value=three
time=0:00:06.016, value=壱
time=0:00:07.018, value=two
time=0:00:08.018, value=壱
time=0:00:09.019, value=two
time=0:00:10.020, value=参

だいたい、1getにつき1秒掛かってますね。

このget処理をキャッシングして、高速化しよう

まずcontext.xmlに手をいれましょう。キャッシュの設定。

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
  xmlns:context="http://www.springframework.org/schema/context"
  xmlns:cache="http://www.springframework.org/schema/cache"
  xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  xsi:schemaLocation="
http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans-3.1.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context-3.1.xsd
http://www.springframework.org/schema/cache
http://www.springframework.org/schema/cache/spring-cache.xsd">

 <cache:annotation-driven />
 <bean id="cacheManager" class="org.springframework.cache.support.SimpleCacheManager">
  <property name="caches">
   <set>
    <bean class="org.springframework.cache.concurrent.ConcurrentMapCacheFactoryBean">
     <property name="name" value="default"/>
    </bean>
   </set>
  </property>
 </bean>

 <context:component-scan base-package="jp.xet.sample"/>

</beans>

この設定は、裏ではシンプルに普通のConcurrentHashMapに値をキャッシュする設定です。この他に、springではehcacheにも対応したりしてるらしい。で、ここでは「default」という名前のキャッシュを1つ作りました、ということになります。次にEntityRepositoryImplに @Cacheable アノテーションをつける。

  @Cacheable(value = "default")
  public String get(int id) {
    // ...
  }

こんな感じ。このメソッドの結果はキャッシュして、キャッシュヒットした場合は中身は実際には呼ばずに済ますよ、という意味です。この状態でもっかいMainを実行してみよう。

time=0:00:01.004, value=one
time=0:00:02.016, value=two
time=0:00:02.017, value=one
time=0:00:02.017, value=two
time=0:00:03.018, value=three
time=0:00:03.018, value=one
time=0:00:03.019, value=two
time=0:00:03.019, value=one
time=0:00:03.019, value=two
time=0:00:03.019, value=three

最初のone,twoには1秒ずつ掛かっているけど、その次のone,twoは一瞬で終わっている。threeは初アクセスなので再び1秒掛かってる。で、残りはもう全部キャッシュに載っているのでずばーーーっと。計約3秒。すばらしい。

漢数字はどうした

    repos.put(1, "壱");
    repos.put(3, "参");

途中でoneとthreeの値を書き換えたのだが、無視してキャッシュを返しちゃってますね。これを何とかしたい。ならば@CacheEvictアノテーションだ。

  @CacheEvict(value = "default", key = "#id")
  public void put(int id, String value) {
    // …
  }

このアノテーションがついたメソッドが呼ばれた時は、特定のキャッシュエントリを無効にします、っていうアノテーションだ。で、どのキャッシュエントリを無効にするの? ってのが key パラメータ。ここでは「idって名前の引数を利用します」ってことです。この表記法はSpEL(Spring Expression Langage)参照。

ちなみに、@CacheEvict(value = "default", allEntries = true) とすると、全キャッシュエントリをクリアしてくれる。

という対策を施し、再びMainを回す。

time=0:00:01.001, value=one
time=0:00:02.011, value=two
time=0:00:02.012, value=one
time=0:00:02.012, value=two
time=0:00:03.013, value=three
time=0:00:04.014, value=壱
time=0:00:04.014, value=two
time=0:00:04.015, value=壱
time=0:00:04.015, value=two
time=0:00:05.015, value=参

キャッシュのevictが上手く動いていることが分かります。

*1:ざっくりとしたコンポーネントには@Componentを付ければいいんだけど「こいつはコンポーネントだけど、特にリポジトリなんだよ」っていう気分で@Repositoryってのが用意されている。あとは@Serviceなんてのもある。気分で使い分ければよろし。

2011-11-20

[]nullを受け付けないメソッドにnullを渡した時の挙動

っていう話を書こうと思ってたら、以前書いてた(cf. 前提条件を破った場合、どのような挙動をするのか? - 都元ダイスケ IT-PRESS

上のエントリにも書いたのだが、自分はこういう時IllegalArgumentExceptionを使うようにしている。そして、commons-lang v2.6 をよく使っていたので、その中の Validate#notNull を利用してnullチェックをするのが自分のスタイルだ。

しかし、いい加減commons-lang v3系に移行しようかな、と考えて色々触っていたのだが、v3から Validate#notNull の仕様が変わり、NullPointerExceptionを投げるようになったのだ。

といった辺りの俺周辺タイムラインJavaでnullを受け付けないメソッドにnullを渡したらどうなるべきか - Togetter

で、いくつかのライブラリ引数チェックユーティリティの仕様を調べてみたのだが、以下の通り、統一感がない。。。

Apache commons-lang v2.6 Validate#notNull IllegalArgumentException
Apache commons-lang v3.1 Validate#notNull NullPointerException
Spring spring-core v3.0.5 Assert#notNull IllegalArgumentException
Google guava v10.0.1 Preconditions#checkNotNull NullPointerException

最後に、Facebook Questionsを利用してアンケートを取ってみたところ…。IAEの圧勝。

http://www.facebook.com/questions/309546165723428


色々考えて出した結論

自分が引数チェックを執拗に行うのは、アプリケーションコードというよりも、汎用ライブラリコード側だ。そういったライブラリについては、事実上Validateを使うためだけにcommonsに依存している状態だ。別に自分はcommonsにこだわりがある訳じゃない。

むしろ、汎用ライブラリはなるべく依存ライブラリが無い方が良いだろう。

というわけで、…ライブラリ毎にオレオレ引数チェックユーティリティクラスをIAE版として作って、コピーして使うのがいいのかな、と思った。

2011-06-10

[]オブジェクト指向のソースを読むのが難しい理由

ダラダラ書かない予定だよ。ざっくり行くよ。あと、分かってる人には当たり前な事だと思うよ。


あるクラスについて知りたかったら、まずその基底クラスを知れ

例えば、Integerクラスについて知りたいと思ったら、Integer.java だけを読んでいてはダメだ。確かに「Integerに特化した責務・構造・操作」は読み取れるかもしれないが、数値としての基本的な責務・構造・操作はNumberに書かれている。それを読まずして、Integerが保つ数値という一面を知ることはできない。Integer.javaには「Integer - Number」*1の情報しか書いてないのだよ。差分プログラミング。

さらに、忘れちゃいけない。Object.javaを読め。全ての道は暗黙的にObjectにつながっている。Objectを知らずしてJavaのクラスを知る事は絶対にできない。Objectなんて、みんな「知った気」になってるんじゃなかろうか*2。あと、クラスのextends関係だけではなく、当然インターフェイスのimplementsも必須。

ソースを読むのが難しいのは、出来るだけソースを読みたくないから「そのファイルだけに読む範囲を絞ろう」という甘えがあるからだ。知りたいクラスが使用*3しているクラスをも知るに越した事はないが、時間的制約もあるだろうから、せめて基底は押さえておく、という方針が良いのではないかとおもっちょる。


あるクラスについて知りたかったら、まずそのドキュメントを読め

トークンの並びを理解する前に、そのトークン列が何を達成しようとしてるのかを知らないと。というわけで、最初に読まなきゃいけないのは、実は「コード」じゃなくて「ドキュメンテーションコメント(Javadoc)」だ。

当然、メソッドやフィールドについているコメントも重要だが、もうほんとに最初に読むのは「型(classとかinterface等)に対するドキュメント」ね。結構分かった風になっちゃってるから飛ばすんだよね、みんな。

例えばStringBuilder。みんな、これを「文字列(string)組み立て(build)屋(er)」だと思ってるでしょ。まぁ、間違っちゃいないし、初心者連載では俺もそう説明しているんだけど。しかし、このクラスの第一義は「可変(mutable)な、文字(character)の、列(sequence)」だ。「屋(er)」を表すんじゃなくて、「列(sequence)」を表すクラスだったりする。Javadoc見りゃ1行目に書いてあることさ。

(あとはStringをネタにして深淵に潜り込むのもよし。これは本当に「文字列」か? 文字(character)の列(sequence)ならば、CharSequenceではないのか? そういう型もあるぞ? とか言って。あとはもうどうにでもしてクダサイ。俺はめんどくさいので燃料だけ投下して離脱しますw)

で、まぁこの例だと「だから何だ」になりかねないが。みんな名前だけで仕様と責務を想像して、その上で実装読んでたりしない? じゃなくて、ドキュメントで仕様と責務を把握した上で実装読むんだよ。

ソースを読むのが難しいのは、「英語を読みたくない」という甘えがあるからだ。英語ドキュメント読むよりトークン列を読むほうが楽だと、みんな思っているんだよね。僕にはわけがわからないよ。

*1:引き算ね。

*2:toString, equals, hashCode辺りが有名すぎてナメられがち。本当に知ってる?

*3:compositionとかuseとか。

2011-05-27

[]SerializableとserialVersionUID

以前、Javaのシリアライズ仕様がよくわからなくてエントリを書いた。

難解なSerializableという仕様について俺が知っていること、というか俺の理解 - 都元ダイスケ IT-PRESS

まぁ、わからないまま書いたので論点もあっちゃこっちゃ飛びながらのエントリだったわけだけど、一年経ってコメントを頂いた。

serialVersionUIDに関しては、定義をしない場合にはクラスの構造を解釈して勝手にコンパイラが生成してくれます。

つまり、クラスのフィールドを変更したら勝手に変更してくれます。

問題点としては、コンパイラが勝手に計算してくれるので、複数のコンパイラをまたぐ場合に同じ定義のはずだけれども失敗することがある(らしい)ということです。

つまり、記事に書いてあることとは逆ですね。

JavaDocに記載されているのでご参照ください。

http://java.sun.com/j2se/1.5.0/ja/docs/ja/api/java/io/Serializable.html#そもそもSun実装以外のコンパイラを使うことがあるのかという疑問はありますが。

#そして、自分は複数のコンパイラ(+VM)で失敗することを見たことがないというか、Sun実装以外のコンパイラを使用したことがない。

難解なSerializableという仕様について俺が知っていること、というか俺の理解 - 都元ダイスケ IT-PRESS

なるほどっ。ありがとうございます。デフォルトコンストラクタを定義しないとコンパイラが勝手に作ってくれるアレだね! 非staticなメンバークラスを定義した時にコンパイラが勝手にフィールドを追加したりするアレだね! と思ったので実験してみた。

import java.io.Serializable;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;

public class Main implements Serializable {
 
  public static void main(String[] args) throws Exception {
    // (1)
    Constructor<Main> mainConst = Main.class.getDeclaredConstructor();
    System.out.println(mainConst);
   
    // (2-1)
    Main main = new Main();
    Child child = main.new Child(128);
    Constructor<Child> childConst = null;
    try {
      childConst = Child.class.getDeclaredConstructor(int.class);
      System.out.println("NG");
    } catch (NoSuchMethodException e) {
      System.out.println("OK");
    }
    childConst = Child.class.getDeclaredConstructor(Main.class, int.class);
    System.out.println(childConst);

    // (2-2)
    Field f = Child.class.getDeclaredField("this$0");
    Object object = f.get(child);
    System.out.println(object == main);
   
    // (3)
    Field field = Main.class.getDeclaredField("serialVersionUID");
    Object id = field.get(null);
    System.out.println(id);
  }
 

  class Child {
   
    private final int hoge;

    Child(int hoge) {
      this.hoge = hoge;
    }
  }
}

コンストラクタを1つも宣言しないと…

(1)は、Mainクラスには引数なしのコンストラクタを明示的に宣言していないけど、リフレクションでは取れる、という例。実行結果として「public Main()」みたいな文字列が表示されるので、コンストラクタは確かに存在することが分かる。もし指定した(引数なしの)コンストラクタが存在しないのならばgetDeclaredConstructorの時点でNoSuchMethodException飛ぶのがJavaの仕様である。

非staticの内部クラスを宣言すると…

(2)に先立って、まず用語整理。Mainを外包クラス(enclosing class)、Childを内部クラス(inner class)とします。それぞれのインスタンスを enclosing instance / inner instance と呼ぶ事にします。

で、(2-1)は、非static内部クラスのコンストラクタの第一引数に外包クラスが追加されている例だ。知らない人は、なぜコンパイラはこんな手を加えるのか、っての考えると面白いよ。本題からズレるのでその話は割愛。ポイントは、ChildのコンストラクタはChild(int hoge)と宣言したので Child.class.getDeclaredConstructor(int.class); でいいはずなのに、なぜか取れない。コンパイルしたバイトコードは実際は以下のような形をしているのだ。

public class Main implements Serializable {
  // 略
  class Child {
    final Main this$0;    
    Child(Main x, int hoge) {
      this$0 = x;
      this.hoge = hoge;
    }
  }
}

従って、Child.class.getDeclaredConstructor(Main.class, int.class); が正解。引き続き実行すると「Main$Child(Main,int)」と表示される。Childのコンストラクタ引数の数は、実は2個なんですね。

(2-2)は、上記コードの謎の this$0 フィールドの存在と同一性を確認しています。表示は「true」。

Serializableを実装して、serialVersionUIDを宣言しないと…!?

さて、本題は(3)です。1〜2でノリノリになってしまった。MainはSerializableを実装しているので、同じノリで自動生成してくれるんだろうなぁ、ということで Main.class.getDeclaredField("serialVersionUID"); してみた。が、

java.lang.NoSuchFieldException: serialVersionUID

くっ…。無いらしい。もっと単純にしてjadってみる。

import java.io.Serializable;
import java.lang.reflect.Field;

public class Main implements Serializable {
 
  public static void main(String[] args) throws Exception {
    Field field = Main.class.getDeclaredField("serialVersionUID");
    Object id = field.get(null);
    System.out.println(id);
  }
}

// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.kpdus.com/jad.html
// Decompiler options: packimports(3)
// Source File Name:   Main.java

import java.io.PrintStream;
import java.io.Serializable;
import java.lang.reflect.Field;

public class Main
    implements Serializable
{

    public Main()
    {
    }

    public static void main(String args[])
        throws Exception
    {
        Field field = Main.getDeclaredField("serialVersionUID");
        Object obj = field.get(null);
        System.out.println(obj);
    }
}

やっぱりねぇよー。あらためて仕様を読み直す。

直列化可能クラスが明示的に serialVersionUID を宣言しない場合、直列化ランタイムは、『Java(TM) Object Serialization Specification』に記述されているように、さまざまな局面に基づいて、そのクラスのデフォルトの serialVersionUID 値を計算します。

直列化ランタイムは

直列化ランタイムは

直列化ランタイムは


うおぉ。読み漏らした。自動生成するのはコンパイラじゃなくてランタイムだっ。というわけで、コンパイラ(javacコマンド)がバイトコードに埋め込むんじゃなくて、ランタイム(javaコマンド)が頑張るんだね。

というわけで、コンパイラをSun-JDKに固定したとしても、ランタイムが異なるとアレな結果になるかもしれないっぽい。

最後に。ランタイムが未定義のserialVersionUIDにどんな値を割り当ててるのか、見る方法は分からなかった。誰か知ってますか?

2011-03-25

[]新連載、はじめました「Javaで始めるオブジェクト指向」

最近blogではApache Mahoutを中心にお送りしていますが、日経ソフトウエアでは新連載を担当させて頂くことになりました。先月までは「Javaで始めるプログラミング」でしたが、今月からは「Javaで始めるオブジェクト指向」です。前の連載の続きのようで続きじゃない、という微妙なポジションですがw

日経ソフトウエア 2011年 05月号 [雑誌]

日経ソフトウエア 2011年 05月号 [雑誌]

本文中にも書きましたが、オブジェクト指向というのは掴み所のない概念です。本来がぼんやりした存在なので、掴みづらくて当然、そして伝えづらいものです。そんなオブジェクト指向の私なりの解釈をなるべく分かりやすく皆さんにお届けできればと思っています。

どうぞよろしくお願いします。

2011-03-02

[]Javaのcloneは悪者か?

Effective Java 第2版 (The Java Series)

Effective Java 第2版 (The Java Series)

Java: The Good Partsが(賛否両論の)話題を呼んでいるが、それ以前にEffective Javaは皆さん、読んだだろうか? この本の項目11に、「cloneを注意してオーバーライドする」というセクションがある。そのほかにも、Javaのcloneメソッドは各所で嫌われているようだ。

そのような論調において、clone代替案としては、コピーコンストラクタと、staticなファクトリメソッドがしばしば挙げられる*1

うん、確かにJavaのcloneメソッドはイケてない。俺もそう思う。まぁ、イケてない理由はみんなと同じだから上記の各文献を当たってください。まぁ要するに「きちんと実装するのが難しく、それをコンパイラに強制させられない」のです。

では、cloneメソッドは要らないのか? と言われれば、俺はNOだ。要る。要件として「コピー元と同じ実装クラスのインスタンスを生成しなければならない」というケースでcloneを使わざるを得ない場合がある。

  • コピーコンストラクタは、コピー元の実装クラスを知らなければ使えない。
  • staticなファクトリメソッドも、オーバーライドが出来ないため、やはりコピー元の実装クラスを知る必要がある。

まぁ、言いたいことはだいたい伝わったとは思うのだが、具体例で説明してみたい。…で、これを説明するにあたって、良く知られたクラスを例に出したかった。が、そんな例が見つからなかった…。不当に嫌われすぎていて、そんな実装例が見つからないのだ*2

というわけで、現実の話を少し曲げて説明に使ってみる。

JavaにはListというインターフェイスがあって、その実装としてArrayListやLinkedListがある。まず前提として確認したいのは、Listは Cloneable インターフェイスを実装しておらず、ArrayListとLinkedListはこれを実装しているということ。これは何故だろう、と考えると、ArrayListやLinkedListは、順序付き集合をオンメモリで扱う実装だからだ。メモリ上の集合ならばcloneしても構わない。しかし、Listはというと、実装がオンメモリであるとは限らない。add/removeなどを実行する度に、律儀にファイルやDB、もしくはリモートのサーバに内容を書き出すような実装クラスを作っても、Listインターフェイス契約的には何ら問題にならない。List型にcloneを認めてしまうと、このような実装を妨げてしまうからであろう。

ここで、現実の話を少し曲げる。Listとその実装型の間に、仮に OnMemoryList というインターフェイスを挟んであるものだと仮定する。さらにもう一つ、ArrayList#clone()も戻り値型はObject型ではなくArrayList型、そしてLinkedList#clone()の戻り値型は同様にLinkedList型である、とします。共変戻り値ですね。

f:id:daisuke-m:20110302140802p:image:w600

ではここで問題。

/**
 * {@code in}に与えたリストが持つ要素のうち、{@code p}を満たす要素のみで
 * 構成される新しいリストを返す。
 * 
 * <p>戻り値のリストの実装型は{@code in}の実装型と同じである。
 * また、{@code in}は破壊してはならない。
 * 戻り値のリストの要素順は、{@code in}の要素間の相互の位置関係を維持する。
 * </p>
 * 
 * @param<E> 要素の型
 * @param in 入力のリスト
 * @param p 条件を表す述語
 * @return 新しい {@link OnMemoryList}
 * @throws IllegalArgumentException 引数に{@code null}を与えた場合
 */
public <E>OnMemoryList<E> filter(OnMemoryList<E> in, Predicate<? super E> p) {
  // ...
}
ArrayList<String> idList = new ArrayList<String>();
// LinkedList<String> idList = new LinkedList<String>();
// どちらでもテストは成功すること。

idList.add("dai.0304");
idList.add("daisuke_m");
idList.add("dai19780304");
idList.add("daisuke-m");
idList.add("dai0304");
idList.add("daisuke");

OnMemoryList<String> filtered = filter(idList, new Predicate<String>() {
  public boolean apply(String input) {
    return input.matches(".*[0-9].*"); // contains digits
  }
});

// idListの非破壊を確認
assertThat(idList.toString(), is("[dai.0304, daisuke_m, dai19780304, daisuke-m, dai0304, daisuke]"));

// 正常にフィルタリングされていることを確認
assertThat(filtered.toString(), is("[dai.0304, dai19780304, dai0304]"));

// 実装クラスが同じであることを確認
assertThat(filtered.getClass().equals(idList.getClass()), is(true));

このメソッド、どうやって実装しますか? よくある関数型っぽいことをするためのメソッドですね。ミソは「戻り値のリストの実装型は{@code in}の実装型と同じである」ってところで、これが恐らく、cloneを使わないと実装できないところだと思います。

Validate.notNull(in);
Validate.notNull(p);
OnMemoryList<E> result = in.clone();
Iterator<E> itr = result.iterator();
while (itr.hasNext()) {
  if (p.apply(itr.next()) == false) {
    itr.remove();
  }
}
return result;

このように、cloneにも重要な役割があるのであって、cloneはイケてないから一律使わない、と思考停止するのはあんまりよくないんじゃないかなー、と思っています。Effective Javaは、本当にcloneが必要なケースかを問いかけ、必要ならばうまくやれ、と言っているんだ。決して「cloneはイケてないから使うな」とは言っておらず「イケてないから、注意深く実装しようね」と指摘しているに過ぎないのだ。

cloneをうまく使っているコードってあまり見ないなぁ、不当に迫害され過ぎてんじゃないかなぁ、と思ったので、こんなん書いてみました。

まぁ、4ヶ月ほど前まで、自分が思考停止してたんですけどネ。

*1:もしくは、シリアライズ+デシリアライズの組み合わせ、なんてのを提案する場合もある。

*2:分かってる、コレは俺の願望だw