在java里实现象ror的设计思想

看了Ruby on Rails后，突发其想，如何在java里实现象Ruby on Rails的设计思想，于是就开始研究，其初步设计思想如下：
Hibernate框架代码如下：

public interface DAO {
  public void save(Object o);
  public void loadById(Class entityClass, Serializable id);
  public void update(Object o);
  public void delete(Object o);
  public List loadAll(Class entityClass);
  Object queryForObject(String sql);
  List queryForList(String sql);
  void queryForPagination(String sql, Pagination pagination);
  void queryForPagination(Pagination pagination);
  void execute(String hql, boolean lock);
}

 

public class HibernateDAO extends HibernateDaoSupport implements DAO { 
public void save(Object entity) { 
  this.getHibernateTemplate().save(entity); 
} 
public void delete(Object entity) { 
  this.getHibernateTemplate().delete(entity); 
} 
public void update(Object entity) { 
  this.getHibernateTemplate().update(entity); 
} 
public Object loadById(Class entityClass, Serializable id) { 
  try { 
   return this.getHibernateTemplate().load(entityClass, id); 
  } catch (Exception e) { 
   e.printStackTrace(); 
   return null; 
  } 
} 
public List loadAll(Class entityClass) { 
  return this.getHibernateTemplate().loadAll(entityClass); 
} 
public Object queryForObject(final String sql) { 
  return this.getHibernateTemplate().execute(new HibernateCallback() { 
   public Object doInHibernate(Session session) throws HibernateException, 
     SQLException { 
    return session.createQuery(sql).uniqueResult(); 
   } 
  }); 
} 
public List queryForList(final String sql) { 
  List records = this.getHibernateTemplate().find(sql); 
  return records; 
} 
public void queryForPagination(String sql, Pagination pagination) { 
  // TODO Auto-generated method stub 
  
} 
public void queryForPagination(Pagination pagination) { 
  // TODO Auto-generated method stub 
  
} 
public void execute(final String hql, final boolean lock) { 
  this.getHibernateTemplate().execute(new HibernateCallback(){ 
   public Object doInHibernate(Session session) throws HibernateException, SQLException { 
    session.createQuery(hql).executeUpdate(); 
    return null; 
   } 
   
  }, lock); 
} 
}

 

public abstract class Entity<T, ID extends Serializable> implements Serializable { 
protected static DAO dao = (DAO)ServiceLocator.getDao("DAO"); 

//private Class entityClass; 

protected ID id; 

public ID getId() {return id;} 

public void setId(ID id) {this.id = id;} 

// protected Entity() { 
//  this.entityClass = (Class<T>) ((ParameterizedType) getClass() 
//        .getGenericSuperclass()).getActualTypeArguments()[0]; 
// } 

public void save() { 
  dao.save(this); 
} 

public void update() { 
  dao.update(this); 
} 

public void delete() { 
  dao.delete(this); 
} 

@SuppressWarnings("unchecked") 
public T load() {  
  return (T)dao.loadById(this.getClass(), this.getId()); 
} 

@SuppressWarnings("unchecked") 
public T load(ID id) { 
  return (T)dao.loadById(this.getClass(), id); 
} 

@SuppressWarnings("unchecked") 
public List<T> loadAll() { 
  return (List<T>)dao.loadAll(this.getClass()); 
} 

public static Object queryForObject(String hql) { 
  return dao.queryForObject(hql); 
} 

public static List queryForList(String hql) { 
  return dao.queryForList(hql); 
} 

public static void queryForPagination(Pagination pagination) { 
  dao.queryForPagination(pagination); 
} 

public static void queryForPagination(String hql, Pagination pagination) { 
  dao.queryForPagination(hql, pagination); 
} 

/**执行一条SQL语句*/ 
public static void execute(String hql, boolean lock) { 
  dao.execute(hql, lock); 
} 
} 

 

领域模型如下： 

@SuppressWarnings("serial") 
public class User extends Entity<User, String> { 
private int inviter = 0; 

private String email = ""; 
private String nickname = ""; 
private String password = ""; 
public int getInviter() { 
  return inviter; 
} 
public void setInviter(int inviter) { 
  this.inviter = inviter; 
} 
public String getEmail() { 
  return email; 
} 
public void setEmail(String email) { 
  this.email = email; 
} 
public String getNickname() { 
  return nickname; 
} 
public void setNickname(String nickname) { 
  this.nickname = nickname; 
} 
public String getPassword() { 
  return password; 
} 
public void setPassword(String password) { 
  this.password = password; 
} 
}

 

客户端调用如下： 

public class Client { 
  public static void main(String...args) { 
    User user = new User(); 
    user.setId(10); 
    user.setName("arden"); 
    user.save();    
  } 
}

 

其次如果你需要对某些复杂的业务逻辑操作进行事物控制的话，您可以建立一个业务逻辑类，根据以上代码，我们可以根据业务的需求将User类建立一个有事物托管的类出来，很多时候因为在web开发中都是简单的CRUD操作，而这些简单的CRUD操作基本上不需要事物控制，所以通常情况下只要有User这个充血的领域模型就可以实现我们常规的大多应用，如果有复杂业务逻辑时我们再根据需求建立一个：

public interface UserManager { 
  public void register(User user); 
} 

 

public class UserManagerImpl implements UserManager { 
  public void register(User user) { 
    Object o = User.queryForObject("FROM User.name WHERER id = " + user.getName(); 
    if (ObjectUtil.isNull(o)) { 
      // 如果用户不存 
      user.save(); 
     // 发送激活邮件 
     EmailUtil.send(........); 
     //在这个时候发邮件可能出现异常，所以当发邮件出现异常时我们要回滚数据操作，因此这里需要在spring里对register方法进行事物控制！ 
    } 
  } 

 
注意这里一定得为UserManagerImpl建立一个接口，因为在spring里对要某个类进行事物控制的话，这个类一定得是基于接口的，否则会有一定的麻烦，具体什么原因，下次有时间再进行讲解