Re: passing a Factory to a method to create a generic instance
This message is in MIME format. The first part should be readable text,
while the remaining parts are likely unreadable without MIME-aware tools.
---910079544-97588463-1210339822=:9855
Content-Type: TEXT/PLAIN; charset=iso-8859-1; format=flowed
Content-Transfer-Encoding: 8BIT
On Fri, 9 May 2008, thufir wrote:
The two nearly identical methods, loadGuests and loadRooms, I would like
to consolidate by passing in a Factory. However, I haven't found much
documentation on what that looks like.
Do you have a copy of 'Design Patterns', by Gamma, Helm, Johnson and
Vlissides? If not, get one. Your university library will probably have it.
If you want to use patterns, it's really worth having!
I've had a look through your code, and it all seems a bit complicated. I
notice that you're planning to use reflection to move data from JDBC
result sets to your objects. That's kind of gross. But if you are going to
do that, you don't need a factory: just pass in the Class object for the
objects you want to create (Guest.class or Room.class), then use the
newInstance method on the class object to create objects to feed to your
reflective loader. You can do this for loading from a file too. No
factories, just reflection. Although really, the Class object is acting as
a factory.
However, if you want to use a factory properly, it looks like:
public class Room {
public Room(String[] data) {
...
}
}
public class Guest {
public Guest(String[] data) {
...
}
}
public interface Factory {
public Object make(String[] data) ;
}
public class RoomFactory implements Factory {
public Object make(String[] data) {
return new Room(data) ;
}
}
public class GuestFactory implements Factory {
public Object make(String[] data) {
return new Guest(data) ;
}
}
public List load(Factory fac) {
List l = new ArrayList() ;
for (String[] row : somehowReadDataFromSomewhere()) {
Object obj = fac.make(row) ;
l.add(obj) ;
}
return l ;
}
Obviously you'll need to add all your generics and actual implemention and
whatnot.
A smell in this code is the use of arrays of strings as constructor
arguments. This is not typesafe or self-documenting. I think i'd refactor
so that the Room and Guest objects took proper parameters (so Room takes
int floor, int number, int numBeds, boolean enSuite, etc), then move the
parsing code to the factories.
tom
PS Does the code you posted even compile? Looks a total mess to me.
Guest and Room implement Factory, but that's just part of the picture.
public Guest new() {return new Guest());} //in Guest.java
public Room new() {return new Room());} //in Room.java
Is the idea to make a single method, outside of Room and Guest, which
returns an instance of, well, type <T>?
But, how? I understand that one approach is to pass a Factory to
FileUtils.load(), which is fine, but how is that Factory instance first
created? Where's it created, in the driver which invokes FileUtils.load
()?
Here's what I have, it's just the top method which I'm working on right
now:
thufir@arrakis:~/bcit-comp2611-project1$
thufir@arrakis:~/bcit-comp2611-project1$
thufir@arrakis:~/bcit-comp2611-project1$ cat src/a00720398/interfaces/
Factory.java
package a00720398.interfaces;
public interface Factory <T>{
T make();
}
thufir@arrakis:~/bcit-comp2611-project1$
thufir@arrakis:~/bcit-comp2611-project1$ cat src/a00720398/util/
FileUtil.java
/**
* FileUtil.java
*/
package a00720398.util;
import java.util.*;
import java.io.*;
import a00720398.data.*;
import a00720398.interfaces.*;
public abstract class FileUtil {
public static <E> List<E> load(File file) {
List<E> foos = new ArrayList<E>();
List<String> lines = getLines(file);
for(String line : lines){
// <E> foo = new <E>(); //how do I pass in a
// //factory to return an "E"?
}
return new ArrayList<E>();
}
/*
a00720398/util/FileUtil.java:31: cannot find symbol
symbol : class T
location: class a00720398.util.FileUtil
public static void factoryTest(Factory<T> factory) {}
^
1 error */
public static void factoryTest(Factory<T> factory) {} //
/**
interface Factory<T> { T make();}
public <T> Collection<T> select(Factory<T> factory, String statement) {
Collection<T> result = new ArrayList<T>();
/* run sql query using jdbc
for (/* iterate over jdbc results ) {
T item = factory.make();
/* use reflection and set all of itemOOs fields from sql results
result.add(item);
}
return result;
}
You can call this either as
select(new Factory<EmpInfo>(){ public EmpInfo make() {
return new EmpInfo();
}}
, OOselection stringOO);
public static <T> factory<T>(T type) {
return new List<T>(type);
}
@see http://www.ibm.com/developerworks/java/library/j-
djc02113.html
Utilities.make(Integer(0)) //called from driver
<T extends Object> public static <T> factory (T first) {
return ew List<T>(first);
}
class Utilities {
<T extends Object> public static List<T> make(T first) {
return new List<T>(first);
}
}
*/
//this method is a repaid of loadGuests
public static List<Room> loadRooms(File file) {
List<Room> rooms = new ArrayList<Room>();
List<String> lines = getLines(file);
for (String line : lines) {
List<String> tokens = getTokens(line);
Room room = new Room();
System.out.println(rooms);
}
return rooms;
}
public static List<Guest> loadGuests(File file) {
List<Guest> guests = new ArrayList<Guest>();
List<String> lines = getLines(file);
for (String line : lines) {
List<String> tokens = getTokens(line);
Guest guest = new Guest(tokens);
System.out.println(guest);
}
return guests;
}
private static List<String> getTokens (String string){
List<String> tokens = new ArrayList<String>();
Scanner lineScanner = new Scanner(string);
while (lineScanner.hasNext()){
String token = lineScanner.next();
tokens.add(token);
}
return tokens;
}
private static Guest newGuest(String string) {
List<String> guestData = getTokens(string);
Guest guest = new Guest(guestData);
return guest;
}
private static List<String> getLines(File file) {
List<String> lines = new ArrayList<String>();
try {
Scanner scanner = new Scanner(file);
while (scanner.hasNextLine()) {
String line = scanner.nextLine();
Scanner lineScanner = new Scanner(line);
lineScanner.useDelimiter("\n");
while (lineScanner.hasNextLine()) {
String oneLine = lineScanner.next
();
lines.add(oneLine);
}
}
} catch (FileNotFoundException e) {
e.printStackTrace();
}
return lines;
}
}
--
I could tell you a great many more particulars but suppose that you are
tired of it by this time. -- John Backhouse, Trainspotter Zero
---910079544-97588463-1210339822=:9855--