Embracing the-power-of-refactor

Embracing the Power of
Refactor
REN Xiaojun

Code smells are heuristics for
refactoring

Our design communicates to
us through resistance.

This resistance is valuable
feedback

Code smells are hints from our software
about how to reduce this resistance.

This is one way our design
emerges.

Commands
PING
responds with PONG
SEND
send messages to GCM

Queue<String> queue = new LinkedBlockingQueue<>();
HttpClient httpclient = HttpClients.createDefault();
DatagramSocket socket = new DatagramSocket(6889);

Runnable pusher = new Runnable() {
@Override
public void run() {
while (true) {
String json = queue.poll();
if (json == null || json.length() <= 0) {
try {
sleep(1000);
continue;
} catch (InterruptedException e) {
e.printStackTrace();
}
}
HttpPost post = new HttpPost("https://android.googleapis.com/gcm/send");
post.setHeader("Authorization", "key=AIzaSyCABSTd47XeIH");
post.setHeader("Content-Type", "application/json");
System.out.println("posting " + json);
try {
HttpEntity entity = new StringEntity(json);
post.setEntity(entity);
httpclient.execute(post);
} catch (Exception e) {
}
}
}
};
Thread t = new Thread(pusher);
t.start();
request creation &
delivery

while (true) {
try {
byte[] buf = new byte[4096];
DatagramPacket received = new DatagramPacket(buf, buf.length);
socket.receive(received);
String data = new String(received.getData());
String command = data.split("s")[0];
if ("PING".equals(command)) {
byte[] sendData = "PONG".getBytes();
DatagramPacket sendPacket = new DatagramPacket(…);
socket.send(sendPacket);
} else if ("SEND".equals(command)) {
String message = data.replace(command, "").trim();
Pattern p = Pattern.compile("([a-zA-Z0-9_-]*) "([^"]*)"");
Matcher matcher = p.matcher(message);
if (matcher.matches()) {
String json = …
queue.add(json);
}
}
} catch (IOException e) {
}
}
}
command dispatch
parameter extraction

recipe:Replace Method With
Method Object

public class PushDaemon {
private final Queue<String> queue;
private final HttpClient httpclient;
private final DatagramSocket socket;
public PushDaemon() throws SocketException {
queue = new LinkedBlockingQueue<>();
httpClient = HttpClients.createDefault();
socket = new DatagramSocket(6889);
}
}

public void start() {
Runnable client = new Runnable() {
@Override
public void run() {
while (true) {
try {
sleep(1000);
continue;
}
}
try {
}
}
}
};
Thread t = new Thread(client);
t.start();
while (true) {
try {
DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, received.getAddress(), received.getPort());
String json = "{"registration_ids" : "" + matcher.group(1) + "", "data" : { "alert" : "" + matcher.group(2) + ""}}";
System.out.println(json);
queue.add(json);
}
}
}
}
}
}

@Override
public void run() {
while (true) {
try {
sleep(1000);
continue;
}
}
try {
}
}
}
};
t.start();
while (true) {
try {
DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length, received.getAddress(), received.getPort());
String json = "{"registration_ids" : "" + matcher.group(1) + "", "data" : { "alert" : "" + matcher.group(2) + ""}}";
queue.add(json);
}
}
}
}
}
}
spawn workers
process requests

spawnWorkers();
while(true){
processRequests();
}
}

private void spawnWorkers() {
@Override
public void run()
while (true) {
try {
sleep(1000);
continue;
}
}
try {
}
}
}
};
t.start();
}
}

private void processRequests() {
try {
DatagramPacket sendPacket = new DatagramPacket(sendData, sendData.length,
received.getAddress(), received.getPort());
String json = "{"registration_ids" : "" + matcher.group(1) + "", "data
{ "alert" : "" + matcher.group(2) + ""}}";
queue.add(json);
}
}
}
}

httpclient = HttpClients.createDefault();
}
spawnWorkers();
while(true){processRequests();}
}
//…
}
private void spawnWorkers() {
//…
}
}

Update authorization key
Increase thread pool size
Swap HTTP client
Use a different transport protocol
Modify wire protocol format
Add commands
Add a different push notiﬁcation service
Move UDP port
Use x-www-urlencoded instead of JSON
Lower maximum payload size
Bind a speciﬁc interface address
Update push service URL

public class Worker {
public Worker() {
}
public void add(String json) {
this.queue.add(json);
}
}

}
}

worker = new Worker();
}
}

try {
worker.add(json);
}
}
}
}

spawnWorkers();
}
}

worker.spawn();
}
}

while (true) {
try {
worker.add(json);
}
}
}
}
}

public class UDPServer {
public UDPServer() throws SocketException {
}
}

while (true) {
try {
worker.add(json);
}
}
}
}
}
receive
send

public UDPServer() throws SocketException {
}
public DatagramPacket receive() throws IOException {
return received;
}
public void send(String message, InetAddress address, int port) throws
IOException {
byte[] sendData = message.getBytes();
address, port);
}
}

private final Worker worker;
private final UDPServer server;
server = new UDPServer();
}
worker.spawn();
}
//…
}
}

try {
DatagramPacket received = server.receive();
server.send("PONG", received.getAddress(), received.getPort());
String json = "{"registration_ids" : "" + matcher.group(1) +
"", "data" : { "alert" : "" + matcher.group(2) + ""}}";
worker.add(json);
}
}
}
}

server = new UDPServer();
}
worker.spawn();
processRequests();
}
//…
}
}

server = new UDPServer(this);
}
worker.spawn();
processRequests();
}
//…
}
}

}
worker.spawn();
}
//…
}
}

}
worker.spawn();
server.listen(6889);
}
//…
}
}

private void processRequests(DatagramPacket received) {
try {
worker.add(json);
}
}
}
}

private void call(DatagramPacket received) {
try {
worker.add(json);
}
}
}
}

public UDPServer(PushDaemon app) {
this.app = app;
}
public void listen(int port) throws IOException {
socket = new DatagramSocket(port);
while (true) { app.call(receive()); }
}
public DatagramPacket receive() throws IOException {
return received;
}
public void send(String message, InetAddress address, int port) throws
IOException {
byte[] sendData = message.getBytes();
address, port);
}
}

}
public void start() throws IOException {
worker.spawn();
}
public void call(DatagramPacket received) {
try {
String json = "{"registration_ids" : "" + matcher.group(1) + "",
"data" : { "alert" : "" + matcher.group(2) + ""}}";
worker.add(json);
}
}
}
}
}

recipe: Replace Conditional
with Polymorphism

try {
worker.add(json);
}
}
}
}
}

public class Ping {
private UDPServer server;
private DatagramPacket received;
public Ping(UDPServer server, DatagramPacket received) {
this.server = server;
this.received = received;
}
public void run() throws IOException {
}
}

try {
new Jobs(server, received).run();
worker.add(json);
}
}
}
}
}

public class Send {
public Send(DatagramPacket received) {
}
public String run() {
String message = data.replace("SEND", "").trim();
return "{"registration_ids" : "" + matcher.group(1) + "", "data" :
}
return null;
}
}

try {
new Ping(server, received).run();
String json = new Send(received).run();
worker.add(json);
}
}
}
}

public Worker() {
}
public void add(String json) {
this.queue.add(json);
}
void spawn() {
@Override
public void run() {
while (true) {
try {
sleep(1000);
continue;
}
}
try {
}
}
}
};
t.start();
}
}

public class Send {
public Send(DatagramPacket received) {
this.httpclient = HttpClients.createDefault();
}
String json = "{"registration_ids" : "" + matcher.group(1) + "",
"data" : { "alert" : "" + matcher.group(2) + ""}}";
HttpPost post = new HttpPost("https://android.googleapis.com/gcm/
send");
}
}
}

public Worker() {
}
public void accept(Job job) {
this.queue.add(job);
}
void spawn() {
@Override
public void run() {
while (true) {
Job job = queue.poll();
if (job != null) {
try {
job.run();
}
}
}
}
};
t.start();
}
}

public interface Job {
void run() throws IOException;
}
public class Ping implements Job {
//…
}
public class Send implements Job {
//…
}

}
worker.spawn();
}
Job job = null;
job = new Ping(server, received);
job = new Send(received);
}
if(job != null) {
worker.accept(job);
}
}
}

Recipe:Move Creation
Knowledge to Factory

public static Job create(DatagramPacket received, UDPServer server) {
Job job = null;
job = new Ping(server, received);
job = new Send(received);
}
return job;
}
}

}
worker.spawn();
}
Job job = Job.create(received, server);
if (job != null) {
worker.accept(job);
}
}
}

}
}
send");
}
}
}

public class Client {
private final InetSocketAddress socketAddress;
public Client(InetSocketAddress socketAddress) {
this.socketAddress = socketAddress;
}
public int port() {
return socketAddress.getPort();
}
public InetAddress address() {
return socketAddress.getAddress();
}
}

public UDPServer(PushDaemon app) {
this.app = app;
}
while (true) { app.call(receive()); }
}
}

while (true) {
DatagramPacket received = receive();
String message = messageOf(received);
Client client = clientOf(received);
app.call(message, client);
}
}
private String messageOf(DatagramPacket received) {
return new String(received.getData());
}
private Client clientOf(DatagramPacket received) {
return new Client((InetSocketAddress) received.getSocketAddress());
}
}

public static Job create(Client client, String message, UDPServer server) {
//…
}
}

private final Client client;
private final String message;
private UDPServer server;
public Ping(Client client, String message, UDPServer server) {
this.client = client;
this.message = message;
}
server.send("PONG", client.address(), client.port());
}
}

Extracted objects tend to
attract behaviour.

public class Client {
private final InetSocketAddress socketAddress;
public Client(InetSocketAddress socketAddress, UDPServer server) {
this.socketAddress = socketAddress;
}
public int port() {
return socketAddress.getPort();
}
public InetAddress address() {
return socketAddress.getAddress();
}
public void send(String message) throws IOException {
server.send(message, address(), port());
}
}

client.send("PONG");
}
}

public Send(Client client, String message) {
this.client = client;
this.httpclient = HttpClients.createDefault();
}
@Override
String message = this.message.replace("SEND", "").trim();
send");
}
}
}

public class PushNotification {
public PushNotification(String registrationId, String alert) {
this.registrationId = registrationId;
this.alert = alert;
}
public void deliver() throws IOException {
HttpEntity entity = new StringEntity(toJson());
}
private String toJson() {
return "{"registration_ids" : "" + registrationId + "", "data" :
{ "alert" : "" + alert + ""}}";
}
}

private final String message;
public Send(String message) {
}
@Override
String message = this.message.replace("SEND", "").trim();
new PushNotification(matcher.group(1), matcher.group(2)).deliver();
}
}
}

we’re using simple data types
to represent complex ideas

parameter “second parameter”

public class Request {
private static Pattern PATTERN = Pattern.compile("([SEND|PING]) ([a-zA-
Z0-9_-]*) "([^"]*)"");
private final boolean acceptable;
private final Matcher matcher;
public Request(String message) {
matcher = PATTERN.matcher(message);
acceptable = matcher.matches();
}
public String command() {
return matcher.group(1);
}
public List<String> parameters() {
List<String> parameters = new ArrayList<>();
for (int i = 2; i <= matcher.groupCount(); i++) {
parameters.add(matcher.group(i));
}
return parameters;
}
public boolean isAcceptable() {
return acceptable;
}
}

private final Request request;
public Send(Request request) {
this.request = request;
}
@Override
if(request.isAcceptable())
new PushNotification(registrationId(), alert()).deliver();
}
private String registrationId() {
return request.parameters().get(0);
}
private String alert() {
return request.parameters().get(1);
}
}

public void call(String message, Client client) {
Request request = new Request(message);
Job job = Job.create(client, request);
if (job != null) {
worker.accept(job);
}
}
}

null communicates that an unknown
command has been requested

public class NullJob implements Job {
@Override
}
}

worker.accept(job);
}
}

job.enqueueTo(worker);
}
}

void run() throws IOException;
public static Job create(Client client, Request request) {
Job job = null;
if (request.isAcceptable()) {
job = new NullJob();
}
if ("PING".equals(request.command())) {
job = new Ping(client);
} else if ("SEND".equals(request.command())) {
job = new Send(request);
}
return job;
}
default void enqueueTo(Worker worker) {
worker.accept(this);
}
}

public class NullJob implements Job {
@Override
//noop
}
@Override
public void enqueueTo(Worker worker) {
//noop
}
}

Reference
http://tx.pignata.com/2013/04/mwrc-code-
smells-talk.html
https://github.com/nicholasren/refactor_push

Embracing the-power-of-refactor

More Related Content

What's hot

Viewers also liked

Similar to Embracing the-power-of-refactor

Recently uploaded

Embracing the-power-of-refactor