读ruby on rails有感

看了ror后，突发其想，如何在java里实现象ror的设计思想，于是就开始研究，其初步设计思想如下：

框架代码如下：

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里对要某个类进行事物控制的话，这个类一定得是基于接口的，否则会有一定的麻烦，具体什么原因，下次有时间再进行讲解！

}