I’ve been playing with Apache wicket and ran into this problem. Here’s the scenario:

PageBorder – a border component that wraps around a BasePage and does stuff like setting title, meta etc.

class PageBorder extends Border {
public PageBorder (id, BasePage page){
this.page = page;
add (”title”, new Label(”title”, page.getTitle());
}
}

At the same time, since the BasePage contains the PageBorder, the BasePage needs to know about the border (create the border passing this as a ctor param)
public abstract class BasePage extends Page {
PageBorder border;
public add (Component c) {
if (border == null) {
border = getBorder();
// subclass must create a border passing themselves in
add (”border”, border);
}
border.add(c);
}
}

In this case, in the BasePage class, I’ve put a protected method – getBorder() – so that the implementing page can decide which border to create.

While this set up works, somehow this seems smelly.

OTOH, if I look at wicket itself, seems like this mutual knowledge is rampant (Page class has a getComponent) and Component classes have a getPage() – however, the coupling is lower.

Any suggestions?

Well, i was trying to solve that problem since a week

I’m waiting for new post/presentation about Oriented Object Concept !

Good luck, and thank you !

class Character {

private final Client client;
private final CharStatus status;

// other fields…

public Character(Client _client, CharStatus _status);

}

public CharStatus {

private final Client client;
private int lifePoints;

public CharStatus(Client _client, int _lifePoint);

public void fireStatusUpdated(String _property, int _old, int _new); // Using Observer/Observable pattern

}

And finally, class “C” :
class Client {

public void onStatusUpdate(Client _client, String _property, int _old, int _new);

}

The issue was I wanted my collaborator class to send an update to my “super class” Character. Then, my Character send an update to the Client, then Client send data throw network…

In fact, collaborator classes have to send an update directely to the client…
Circular dependency avoided

Sorry for posting !
Thomas.

Ps : I love your job, I think DI is the key for keeping a clean code.
Ps2 : Sorry for ma poor English =) I’m French, and French reputation is to be bad at English ^^

I have a question about circular dependency…

I have a class Character who is responsible for many and many things : appearance (face, hair…), status (lifepoints…), stats (attack power, defense power…) and i’m stuck !
Look at an example :

class Character {
private CharAppearance ca;
private CharStatus status;
private CharStats stats;

public Character(CharAppearance _ca, CharStatus _status, CharStats _stats) {
//
}

}

Example of CharStatus :
class CharStatus {

private int lifePoints;
private Character owner;

public CharStatus(Character _owner, int _lifePoint) // Here.. circular dependency !

}

How to solve that issue ? Should I remove the owner of CharStatus ?
Thanks a lot
Thomas.

here is how I would attack you problem.

class Database() implements DB;
class Logger(Database db);
class LoggingDatabase(Logger log, Database db) implements DB;

DB rawDatabase = new Database();
Logger log = new Logger(rowDatabase);
DB dbForTheRestoOfApplication = new LoggingDatabase(log, rowDatabase);

There you go. LoggingDatabase logs the commands as they go by and than delegate it on a class of the same interface. This is know as chain of responsibility and it is my favorite design pattern.

Can you please help me understand it a little better.

Lets say i have two classes, a database service for writing to databases and a log service for writing to logs.
I want to pass a logger into the database service via a constructor so that it may the commands.
I also wish to pass a data service into the log service so that it may write the logs to a database.

Can you offer some method of refactoring this such that this is possible?
Secondly i think ive just realised that even if i could instantiate this mess then i will probably end up getting a stack fault when it executes a command, logs it, writes the message to the database, logs about that, logs it, writes a message etc etc…..Perhaps the refactoring will address this too?

public class LogService : ILogService
{
private IDataService _data;

public LogService(IDataService data)
{
_data = data;
}

#region ILogService Members

public void Write(string message)
{
_data.Execute(string.Format(”prcLogMessage {0}.”, message));
}

#endregion

public override string ToString()
{
return string.Format(”Complex Log Service with data provided by {0}.”, _data.ToString());
}
}

public class DataService : IDataService
{
private ILogService _log;

public DataService(ILogService log)
{
_log = log;
}

public void Execute(string command)
{
_log.Write(string.Format(”Starting execution: {0}.”, command));
// Execute command
_log.Write(string.Format(”Finished executing: {0}”, command));
}

public override string ToString()
{
return string.Format(”Complex Data Service with logging provided by {0}.”,_log.ToString());
}
}

That sounds right. I always have an uneasy feeling whenever I create circular dependency. Sounds like in your case there are some common things you need to pull out to C. I guess the question to ask is why do these two objects need to have circular dependency, on how can we rearrange the responsibility to break it. Without knowing details it is hard to make a suggestion.

class A {
final B b;
A(){
}
setB(B b)
this.b = b;
}
}

class B {
final A a;
B(A a){
this.a = a;
}
}

B createB() {
A a = new A();
B b = new B(a); // Sets the backreference internally
a.setB(b); // Sets the backreference explicitly.
return b;
}

I am sorry, but I don’t understand your question. Can you explain it in more detail.

In general if I have legacy code and I creating an object is expensive, I first make sure that I can DI the object so that I can control the instantiation and hence where the cost is incurred. I would than try to pull out an interface so that I can write a mock.