Codice legacy, usciamo dal pantano! @iad11

Codice Legacy,
usciamo dal pantano!
Simone Casciaroli (@simonecasc)
Stefano Leli (@sleli)

Bird Watching Game
http://github.com/sleli/BirdWatching

Il Gioco
• Simulatore di Bird Watching
• Una sorta di “battaglia navale”...
ma qui gli assi sono 3 (gli uccelli
volano)

Classe GameField
Responsabilità Collaborazioni

Gestisce la collezione di Birds
Dispone il campo da gioco
Valida il campo da gioco Classe Bird
Inizializza il campo (start)
Gestisce le logiche degli shot

Refactoring Hints

Rimozione della duplicazione
Rimozione degli if
Oggetti invece che primitive type
Tell don’t ask

Duplicazione (semplice)

@Before
public void Setup() {
field = new GameField(10,5,3, new FieldSize(10,5,3));
}

public GameField(int width, int height, int depth,
FieldSize fieldSize) {
this.width = width;
this.height = height;
this.depth = depth;
this.fieldSize = fieldSize;
birds = new ArrayList<Bird>();
}


//Place the birds on the fields
private void placeBirds(PlacingMode type) throws Exception {
...
Location location = new Location(new Random().nextInt(this.width),
new Random().nextInt(this.height));
bird.setLocation(location);
if (!(bird instanceof Chicken))
bird.setHeight(new Random().nextInt(this.depth));
...
}

Eliminiamola!
@Before
field = new GameField(new FieldSize(10,5,3));
}

Eliminiamola!
@Before
}

public GameField(FieldSize fieldSize) {
}

Eliminiamola!
@Before
}

public GameField(FieldSize fieldSize) {
}

//Place the birds on the fields
...
Location location = new Location(new Random().nextInt(fieldSize.width()),
new Random().nextInt(fieldSize.height()));
bird.setHeight(new Random().nextInt(fieldSize.depth()));
...
}

Diamo a Cesare
ciò che è di Cesare

public class Location {
int x = 0;
int y = 0;

public Location (int x, int y) {
this.x = x;
this.y = y;
}

}


Bird duck = new Duck();
duck.setLocation(new Location(10,5));
duck.setHeight(3);


Bird duck = new Duck();
duck.setLocation(new Location(10,5));
duck.setHeight(3);

int h = bird.getHeight();
Location location = bird.getLocation();
int x = location.x;
int y = location.y;
isValid = fieldSize.isWithinField(h, x, y);

new Random().nextInt(fieldSize.height()),
new Random().nextInt(fieldSize.depth()));

private boolean isGameFieldValid()
{
boolean isValid = true;
for(Bird bird : birds) {
int h = bird.getHeight();
int x = location.x;
int y = location.y;
if (!isValid)
break;
}
return isValid;
}

{
int h = location.h;
int x = location.x;
int y = location.y;
if (!isValid)
break;
}
return isValid;
}

public boolean shot(int x, int y, int h) {
boolean hit = false;
if (gameStarted)
{
int height = bird.getHeight();
hit = location.x == x && location.y == y && height == h;
if (hit)
{
bird.sing();
break;
}
}
}
return hit;
}

if (gameStarted)
{
hit = location.x == x && location.y == y && location.h == h;
if (hit)
{
bird.sing();
break;
}
}
}
return hit;
}

public abstract class Bird {
Location location;
int height;

public void setHeight(int height) throws Exception{
this.height = height;
}

public int getHeight() {
return height;
}

public void setLocation(Location location) {
this.location = location;

}

public Location getLocation() {
return location;
}

public abstract void sing();
}

Serve ancora?

//Random Distribution
if (type == PlacingMode.Random) {
new Random().nextInt(fieldSize.eighth()),
}
}
//Custom Distribution
else if (type == PlacingMode.Custom) {

}
}

Tell, don’t Ask
if (gameStarted)
{
hit = location.x == x && location.y == y && location.h == h;
if (hit)
{
bird.sing();
break;
}
}
}
return hit;
}

Applied
public boolean shot(Location shotLocation) {
if (gameStarted)
{
hit = shotLocation.equals(bird.getLocation());
if (hit)
{
bird.sing();
break;
}
}
}
return hit;
}

Let’s apply it another time
if (gameStarted)
{
hit = bird.wasHit(shotLocation)
if (hit)
{
bird.sing();
break;
}
}
}
return hit;
}

Another time too
if (gameStarted)
{
if (hit)
{
break;
}
}
}
return hit;
}

Programmiamo ad oggetti o
a tipi primitivi...?
{
int h = location.h;
int x = location.x;
int y = location.y;
if (!isValid)
break;
}
return isValid;
}

...ad Oggetti
{
isValid = fieldSize.isWithinField(bird.getLocation());
if (!isValid) Text
break;
}
return isValid;
}

Gli IF proprio non ci
piacciono!

Come procediamo?

//Random Distribution
if (type == PlacingMode.Random) {
new Random().nextInt(fieldSize.eighth()),
}
}
//Custom Distribution
else if (type == PlacingMode.Custom) {

}
}

I Passi di refactoring
• Estratta responsabilità di “Random placing strategy” in
una classe

• estratta interfaccia IPlacingStrategy

• creata class NullPlacingStrategy

• creata Factory per Placing strategy

• inline metodo placeBirds

• trasformata la factory in un ﬁeld ed estratto come
parametro del costruttore

Il risultato
public class PlacingStrategyFactory { public interface IPlacingStrategy {

public IPlacingStrategy create(PlacingMode type, void place(List<Bird> birds);
FieldSize fieldSize) {
if (type == PlacingMode.Random) { }
return new RandomPlacingStrategy(fieldSize);
}
public class NullPlacingStrategy implements IPlacingStrategy {
return new NullPlacingStrategy();
} @Override
public void place(List<Bird> birds) {
} // Do nothing
}

}

public class RandomPlacingStrategy implements IPlacingStrategy {
private FieldSize fieldSize;

public RandomPlacingStrategy(FieldSize fieldSize) {
}

@Override
public void place(List<Bird> birds) {
new Random().nextInt(fieldSize.height()),
}
}

}

Il risultato
public class GameField {
...
public boolean startGame(PlacingMode pm) {
placingStrategyFactory.create(pm, fieldSize).place(birds);
gameStarted = isGameStarted();
return gameStarted;
}
...
}

Altri IF che non ci
piacciono
{
isValid = fieldSize.isWithinField(bird.getLocation());
if (!isValid)
break;
}
return isValid;
}

{
isValid = isValid && fieldSize.isWithinField(bird.getLocation());
}
return isValid;
}

what does it mean?

Groovy

Java + Guava

Stesso discorso
if (gameStarted)
{
if (hit)
{
break;
}
}
}
return hit;
}

if (gameStarted)
{
hit = hit || bird.wasHit(shotLocation)
}
}
return hit;
}

or

Groovy

Java + Guava

Di nuovo sulle
responsabilità

Notate qualcosa?
{
isValid = isValid && fieldSize.isWithinField(bird.getLocation());
}
return isValid;
}

if (gameStarted)
{
hit = hit || bird.wasHit(shotLocation)
}
}
return hit;
}

ed ecco i chiamanti

private boolean isGameStarted() {
return birds.areAllBirdsPlacedWithinField(fieldSize);
}

return birds.anyBirdWasHit(shotLocation) && gameStarted;
}

Conclusioni
Test funzionali attorno al codice da refattorizzare

Refactoring ad ogni step e’ l’ideale

Se si parte con codice legacy usate le techniche viste

Conclusioni

Rimozione della duplicazione
Rimozione degli if
Oggetti invece che primitive type
Tell don’t ask

Repository

http://github.com/sleli/BirdWatching

GRAZIE

http://joind.in/4513

@simonecasc
@sleli

Codice legacy, usciamo dal pantano! @iad11

Empfohlen

Empfohlen

Weitere ähnliche Inhalte

Was ist angesagt?

Was ist angesagt? (20)

Ähnlich wie Codice legacy, usciamo dal pantano! @iad11

Ähnlich wie Codice legacy, usciamo dal pantano! @iad11 (20)

Mehr von Stefano Leli

Mehr von Stefano Leli (17)

Kürzlich hochgeladen

Kürzlich hochgeladen (20)

Codice legacy, usciamo dal pantano! @iad11