Implementation patterns

実装パターン
リファクタリングでよく使う7つの基本的な実装パターン

牧竜也
Androidアプリ開発エンジニア

public SearchRequest(String query, String lang,
String order, String sort) {
this(query, lang, order, sort, LIMIT, PAGE);
}
String order, String sort,
int limit, int page) {
mUrl = buildUrl(query, lang, order, sort, limit, page);
}
パラメータの多い

コンストラクタ

同じ型が連続すると
型チェックに弱い
}
}

任意のパラメータも
与える必要がある
}
}

public class Builder {
private final String mQuery;
private String mOrder;
private String mSort;
private String mLang;
public Builder(String query) {
mQuery = query;
}
public Builder setOrder(String order) {
mOrder = order;
return this;
}
public Builder setSort(String sort) {
mSort = sort;
return this;
}
...
public SearchRequest build() {
return new SearchRequest(this);
}
}
強制するのは
必須パラメータのみ

任意パラメータは
メソッドから与える
public class Builder {
private final String mQuery;
private String mOrder;
private String mSort;
private String mLang;
public Builder(String query) {
mQuery = query;
}
public Builder setOrder(String order) {
mOrder = order;
return this;
}
public Builder setSort(String sort) {
mSort = sort;
return this;
}
...
public SearchRequest build() {
return new SearchRequest(this);
}
}

Request request = new SearchRequest.Builder("Java")
.setLang("ja")
.setOrder("date")
.setSort("desc")
.setLimit(100)
.setPage(2)
.build();
インスタンス生成時の
可読性が向上

インスタンス生成時の可読性が向上

public void setPadding(int left, int top,
int right, int bottom) {
...
}
パラメータの多い

メソッド

public void setPadding(int left, int top,
int right, int bottom) {
...
}
同じ型が連続すると
型チェックに弱い

public class Padding {
public int left;
public int top;
public int right;
public int bottom;
}
関連するパラメータを
１つのクラスとして定義

Padding padding = new Padding();
padding.left = 10;
padding.top = 20;
padding.right = 10;
padding.bottom = 20;
object.setPadding(padding);
切り出したクラスを

パラメータとして与える

メソッド呼び出し時の可読性が向上

public int getItemCount() {
if (mCursor == null) {
return 0;
}
return mCursor.getCount();
}
public long getItemId(int position) {
return NO_ID;
}
mCursor.moveToPosition(position);
return mCursor.getLong(mRowIdColumn);
}
public Cursor changeCursor(Cursor cursor) {
Cursor oldCursor = mCursor;
mCursor = cursor;
return oldCursor;
}
Nullableな
フィールドを持つクラス

Nullになりうる
引数をそのまま受け取る
return 0;
}
}
return NO_ID;
}
}
mCursor = cursor;
return oldCursor;
}

return 0;
}
}
return NO_ID;
}
}
mCursor = cursor;
return oldCursor;
}
Nullチェックが点在し
実装が複雑化

public class NullCursor implements Cursor {
@Override
public int getCount() {
return 0;
}
@Override
public int getPosition() {
return 0;
}
@Override
public boolean move(int offset) {
return true;
}
@Override
public boolean moveToPosition(int position) {
return true;
}
...
}
適切な振舞をする
Null Objectを定義

@Override
}
@Override
}
mCursor = new NullCursor();
} else {
mCursor = cursor;
}
return oldCursor;
}
Nullが与えられたら
Null Objectを代わりに利用

@Override
}
@Override
}
mCursor = new NullCursor();
} else {
mCursor = cursor;
}
return oldCursor;
}
他の処理では
Nullチェックが不要

Nullチェックが減りコードがシンプルに

public class UpdateTask extends Task {
@Override
public void execute() throws TaskException {
SQLiteDatabase db = mHelper.getWritableDatabase();
try {
db.beginTransaction();
db.update(TABLE, mValues, mWhere, mArgs);
db.setTransactionSuccessful();
} catch (SQLiteException e) {
throw new TaskException(e);
} finally {
db.endTransaction();
}
}
}
DB操作など
定型的な処理が多いクラス

責務ごとに
複数のクラスが存在
public class DeleteTask extends Task {
@Override
try {
db.delete(TABLE, mWhere, mArgs);
} finally {
}
}
}

複数のサブクラスで

似たような処理を実装
public class XxxTask extends Task {
@Override
try {
db.doXxx();
} finally {
}
}
}

public abstract class SQLiteTask extends Task {
public final void execute() throws TaskException {
try {
runInTx(db);
} finally {
}
}
protected abstract void runInTx(SQLiteDatabase db)
throws SQLiteException;
}
定型処理を

抽象クラスで定義

public abstract class SQLiteTask extends Task { {
public final void execute() throws TaskException {
try {
runInTx(db);
} finally {
}
}
protected abstract void runInTx(SQLiteDatabase db)
throws SQLiteException;
}
サブクラスの担当は
抽象メソッドとして定義

public class UpdateTask extends SQLiteTask {
@Override
protected void runInTx(SQLiteDatabase db)
throws SQLiteException {
db.update(TABLE, mValues, mWhere, mArgs);
}
}
定型処理以外は
各サブクラスで実装

public class DeleteTask extends SQLiteTask {
@Override
protected void runInTx(SQLiteDatabase db)
throws SQLiteException {
db.delete(TABLE, mWhere, mArgs);
}
}
定型処理以外は
各サブクラスで実装

重複コードがなくなりシンプルに

public class ViewAnimator {
private final Animation mAnimation;
private final Animator mAnimator;
public ViewAnimator(int from, int to) {
if (Build.VERSION.SDK_INT <
Build.VERSION_CODES.HONEYCOMB) {
mAnimation = ValueAnimation.ofInt(from, to);
mAnimator = null;
} else {
mAnimation = null;
mAnimator = ValueAnimator.ofInt(from, to);
}
}
...
public void start() {
mView.start(mAnimation);
} else {
mAnimator.start();
}
}
}
APIバージョンに応じて
異なるAPIやクラスを切替

バージョン判定が点在し
クラスやメソッドを切替
public class ViewAnimator {
private final Animation mAnimation;
private final Animator mAnimator;
mAnimation = ValueAnimation.ofInt(from, to);
mAnimator = null;
} else {
mAnimation = null;
mAnimator = ValueAnimator.ofInt(from, to);
}
}
...
mView.start(mAnimation);
} else {
mAnimator.start();
}
}
}

互換性担保のための

共通インターフェースを定義
public abstract class ViewAnimator {
...
}
public abstract void setDuration(long duration);
public abstract void setInterpolator(Interpolator i);
public abstract void start();
}

各サブクラスは
複数ではなく単一責務を負う
public class OldViewAnimator extends ViewAnimator {
private Animation mAnimation;
private View mView;
...
@Override
public void setDuration(long duration) {
mAnimation.setDuration(duration);
}
@Override
public void setInterpolator(Interpolator i) {
mAnimation.setInterpolator(i);
}
@Override
mView.startAnimation(mAnimation);
}
}

public class NewViewAnimator extends ViewAnimator {
private Animator mAnimator;
private View mView;
...
@Override
public void setDuration(long duration) {
mAnimator.setDuration(duration);
}
@Override
public void setInterpolator(Interpolator i) {
mAnimator.setInterpolator(i);
}
@Override
mAnimator.start();
}
}
各サブクラスは
複数ではなく単一責務を負う

public static ViewAnimator create(int version,
int from, int to) {
if (version < Build.VERSION_CODES.HONEYCOMB) {
return new OldViewAnimator(from, to);
} else {
return new NewViewAnimator(from, to);
}
}
インスタンスの生成は
Factory methodで隠蔽

統一されたインターフェースでシンプルに

@Override
public boolean onOptionsItemSelected(MenuItem item) {
int itemId = item.getItemId();
if (itemId == R.id.action_refresh) {
refresh();
return true;
} else if (itemId == R.id.action_edit) {
edit();
return true;
} else if (itemId == R.id.action_delete) {
delete();
return true;
} else if (itemId == R.id.action_clear) {
clear();
return true;
}
return super.onOptionsItemSelected(item);
}
条件によって
処理をディスパッチ

条件が増えると
条件分岐が肥大化
@Override
if (itemId == R.id.action_refresh) {
refresh();
return true;
} else if (itemId == R.id.action_edit) {
edit();
return true;
} else if (itemId == R.id.action_delete) {
delete();
return true;
} else if (itemId == R.id.action_clear) {
clear();
return true;
} else if (itemId == R.id.action_setting) {
showSetting();
return true;
} else if (itemId == R.id.action_help) {
showHelp();
return true;
}
return super.onOptionsItemSelected(item);
}

private void refresh() {
...
}
private void edit() {
...
}
private void delete() {
...
}
private void clear() {
...
}
private void showSetting() {
...
}
private void showHelp() {
...
}
メソッドも増えて
クラスも肥大化

public interface Command {
boolean execute();
}
各処理に共通する
インターフェースを定義

public class RefreshCommand implements Command {
@Override
public boolean execute() {
...
return true;
}
}
処理ごとに
サブクラスを作成

mCommands = new SparseArray<>();
mCommands.append(
R.id.action_edit, new EditCommand());
mCommands.append(
R.id.action_delete, new DeleteCommand());
mCommands.append(
R.id.action_clear, new ClearCommand());
mCommands.append(
R.id.action_refresh, new RefreshCommand());
コマンドの識別子がキーの
コマンドマップを定義

@Override
Command command = mCommands.get(
itemId, new NullCommand());
return command.execute(getApplicationContext());
}
コマンドマップから
コマンドを引き当てて実行

巨大な条件分岐がなくなりシンプルに

public void changeState(int state) {
if (state == STATE_LOADING) {
mLoadingView.setVisibility(View.VISIBLE);
mSuccessView.setVisibility(View.GONE);
mFailureView.setVisibility(View.GONE);
} else if (state == STATE_SUCCESS) {
mLoadingView.setVisibility(View.GONE);
mSuccessView.setVisibility(View.VISIBLE);
} else if (state == STATE_FAILURE) {
mFailureView.setVisibility(View.VISIBLE);
}
}
Viewの表示切替などで
複雑な条件分岐

public void changeState(int state) {
if (state == STATE_LOADING) {
mLoadingView.setVisibility(View.VISIBLE);
} else if (state == STATE_SUCCESS) {
mSuccessView.setVisibility(View.VISIBLE);
} else if (state == STATE_FAILURE) {
mFailureView.setVisibility(View.VISIBLE);
} else if (state == STATE_SETTING) {
...
} else if (state == STATE_INITIAL) {
...
}
}
状態が増えると
条件分岐が更に肥大化

public enum State {
LOADING {
@Override
void change(StatefulFrameLayout layout) {
layout.getLoadingView()
.setVisibility(View.VISIBLE);
layout.getSuccessView()
.setVisibility(View.GONE);
layout.getFailureView()
}
},
SUCCESS {
@Override
}
},
...
};
abstract void change(StatefulFrameLayout layout);
}
抽象メソッド化して
サブクラスに実装を強制

public enum State {
LOADING {
@Override
}
},
SUCCESS {
@Override
}
},
...
};
}
実際の処理は
サブクラスや列挙型で実装

public enum State {
LOADING {
@Override
}
},
SUCCESS {
@Override
}
},
...
};
}
状態ごとに
サブクラスや列挙型を定義

public void changeState(State state) {
state.change(this);
}
自身をパラメータとして
メソッドを呼び出す

肥大化しがちな条件分岐がシンプルに

実装パターンを適切に使って
効果的にリファクタリング

Implementation patterns

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (16)

Ähnlich wie Implementation patterns

Ähnlich wie Implementation patterns (20)

Kürzlich hochgeladen

Kürzlich hochgeladen (12)

Implementation patterns