Web开发“菊花宝典”OperaMasks系列之二（连载）

 

OperaMasks2.0开发实例入门之二：用户注册

1. 前言

用户注册和登录是比较常用的功能，本文演示了一个比较简单的登录和注册系统原型。

2. 开发环境

Jdk1.5 + ApusicStudio5.0m4 + OperaMasks2.0m1 + Apusi5.1 tp4

3. 实例介绍

我们先看看示例的运行效果，先做个感性的认识。

1)登录页面

 

2)注册页面

 

3)注册完成页面

 

4）登录完成页面

4. 架构设计

本例虽然比较简单，但是仍然采用三层架构的设计：

1）表示层：利用AOM2.0的IoVC技术，优雅的实现了MVC模式，解决了开发上view层和model层互相纠缠和view层包含业务逻辑等问题。同时，因为利用AOM2.0的LiteBean技术，控制页面的数据，导航，注入并调用业务逻辑层的相关业务，然后由AOM2.0的框架，调用相应的表示层视图，进行显示。

2）业务逻辑层：本例的逻辑层包括两个方面的业务逻辑，

a)一个方面：是针对单个用户的业务逻辑处理接口UserPersonalService，这个接口提供了诸如用户登录逻辑，注销逻辑，是否已登录等等。

b)另一方面：是针对用户管理的业务逻辑处理接口UsersManagerService，这个接口提供了诸如增加用户，删除用户，查询用户等等面向管理方面的业务处理逻辑。

3）数据访问层：本例的数据虽然使用ArrayList，不过仍然设计为采用DAO方式进行数据访问，这也是一般情况大多数类似应用的数据层访问方式，例如使用HibernianDAO访问数据库。本例并没有用诸如MySQL等数据库存储数据，但并不影响本文的思路。这里，我们使用ArrayList来存储数据，通过UserDAO接口来访问。

5. 数据访问层 （org.operamasks.example.registration.model.dao）

5.1. UserDAO

首先，我们定义一个UserDAO接口，该接口定义了一些访问用户数据的一些方法。

其相应的代码如下：

     
     
     
     

      
      
      
      

       
       
       
       package org.operamasks.example.registration.dao; 
       
       
       
       

       
       
       
       import java.util.List; 
       
       
       
       

       
       
       
       import org.operamasks.example.registration.businessobject.User; 
       
       
       
       

       
       
       
       public 
       
       
       
       interface UserDAO {  
       
       
       
       

       
       
       
       public 
       
       
       
       void addUser(User user);
       
       
       
       //增加 
       
       
       
       

       
       
       
       public 
       
       
       
       void modifyUser(User user);
       
       
       
       //修改 
       
       
       
       

       
       
       
       public 
       
       
       
       void removeUser(String id);
       
       
       
       //删除 
       
       
       
       

       
       
       
       public User getUser(String id);
       
       
       
       //查找 
       
       
       
       

       
       
       
       public List getAllUsers();
       
       
       
       //查找 
       
       
       
       

       
       
       
       public 
       
       
       
       boolean validate(User user);
       
       
       
       //校验 
       
       
       
       
} 
       
       
       
       

      
      
      
      
     
     
     
     

5.2. UserDAOListImpl

接着，我们设计一个实现该接口的类：UserDAOListImpl，这个UerDAO具体访问一个ArrayList，该list存放的是所有已注册用户的信息，那么在实际开发中，这里应使用其他工业方式来进行，例如：public class YourUserDAOImple extends HibernateDaoSupport implements UserDAO等等。

那么，限于篇幅，我这里就不具体贴出这个供演示用的UserDAO的全部代码了，下面是个示意，在本文的的附件中，有这个示意类的全部代码。

     
     
     
     

      
      
      
      

       
       
       
       package org.operamasks.example.registration.dao; 
       
       
       
       

       
       
       
       import ...... 
       
       
       
       
@ManagedBean(name=
       
       
       
       "dao", scope = ManagedBeanScope.SESSION) 
       
       
       
       

       
       
       
       public 
       
       
       
       class UserDAOListImpl 
       
       
       
       implements UserDAO { 
       
       
       
       
...... 
       
       
       
       
} 
       
       
       
       

      
      
      
      
     
     
     
     

（1）值得注意的地方是是，这里，我把这个类利用@ManagedBean声明为一个LiteBean，为什么要用这个标注呢，我这里的目的，将会利用AOM2强大的依赖注入功能，注入接口的具体实现类，而不出现诸如new XXXImpl这样的代码，实现业务层代码只与接口相关，而实现类则由AOM2负责自动帮你初始化和管理具体实现类，这里我们思维跨越一下，提前偷窥一下，看看业务层调用这个DAO的方式:

     
     
     
     

      
      
      
      package org.operamasks.example.registration.business; 
      
      
      
      

      
      
      
      import ...... 
      
      
      
      
@ManagedBean(name = 
      
      
      
      "usersManagerService", scope = ManagedBeanScope.SESSION) 
      
      
      
      

      
      
      
      public 
      
      
      
      class UsersManagerServiceImpl 
      
      
      
      implements UsersManagerService { 
      
      
      
      
  @ManagedProperty(
      
      
      
      "#{dao}") 
      
      
      
      

      
      
      
      private UserDAO dao; 
      
      
      
      

      
      
      
      public 
      
      
      
      void createUser(User user) { 
      
      
      
      
  dao.addUser(user); 
      
      
      
      
  } 
      
      
      
      
     
      
      
      
      public ...... 
      
      
      
      //其他业务方法 
      
      
      
      
} 
      
      
      
      

     
     
     
     

(1)观察这个实现类的代码，我们不会看到dao = new UserDAOImpl()这样的语句，那么后面调用dao的方法为什么不会有问题呢？原来这就是@ManagedProperty的功劳，通过该Annotation的作用，从AOM框架中取得一个命名为dao的UserDAO类型的实例，而这个名字“dao”，就对应的是UserDAOImpl类里的@ManagedBean中那个name=“dao”。

那么，当你下次觉得这个访问List的UserDAOImpl不爽，要换成自己的DAO类来访问真实数据库，那么，直接把你写好的实现类，替换掉这个类，就OK了，业务逻辑层不需要修改任何代码，也不需要修改任何配置文件，那么初始化业务逻辑层的时候，AOMLiteBean管理容器会自动寻找并实例化UserDAO的具体实现。

 

5.3. User

User类是一个普通的POJO类，没啥可以阐述的：

     
     
     
     

      
      
      
      

       
       
       
       package org.operamasks.example.registration.model.businessobject; 
       
       
       
       
@SuppressWarnings(
       
       
       
       "serial") 
       
       
       
       

       
       
       
       public 
       
       
       
       class User 
       
       
       
       implements java.io.Serializable { 
       
       
       
       

       
       
       
       private String id; 
       
       
       
       //用户帐号 
       
       
       
       

       
       
       
       private String name; 
       
       
       
       //真实姓名 
       
       
       
       

       
       
       
       private String password; 
       
       
       
       //密码 
       
       
       
       

       
       
       
       private String email; 
       
       
       
       //电子邮件 
       
       
       
       

       
       
       
       public User(){ 
       
       
       
       
} 
       
       
       
       
..... 
       
       
       
       
} 
       
       
       
       

      
      
      
      
     
     
     
     

6. 业务逻辑层（org.operamasks.example.registration.business.*）

业务逻辑层，我们定义了两个接口以及他们各自的实现类：

1）UserPersonalService及其实现类UserPersonalServiceImpl。

2） UsersManagerService及其实现类UsersManagerServiceImpl。

6.1. UserPersonalService

这个接口规定了用于针对单个用户的一些业务逻辑处理，例如：登陆，注销，是否登陆，获得当前User对象等方法。 其相应的代码如下：

     
     
     
     

      
      
      
      

       
       
       
       package org.operamasks.example.registration.business; 
       
       
       
       

       
       
       
       import org.operamasks.example.registration.businessobject.User; 
       
       
       
       

       
       
       
       //针对个人的业务处理逻辑  
       
       
       
       

       
       
       
       public 
       
       
       
       interface UserPersonalService { 
       
       
       
       

       
       
       
       public 
       
       
       
       boolean login(String userid, String password);
       
       
       
       // 登录 
       
       
       
       

       
       
       
       public 
       
       
       
       void logout();  
       
       
       
       // 注销 
       
       
       
       

       
       
       
       public 
       
       
       
       boolean isLogined(); 
       
       
       
       // 是否已登录 
       
       
       
       

       
       
       
       public User getUser();  
       
       
       
       // 获得当前用户所代表的商业对象User 
       
       
       
       
} 
       
       
       
       

      
      
      
      
     
     
     
     

6.2. UserPersonalServiceImpl

接着，我们设计一个实现该接口的类：UserPersonalServiceImpl，这个实习进行业务逻辑的处理，通过DAO把数据放入数据库。 代码：

 

package org.operamasks.example.registration.business;
import ......
@ManagedBean(name = "userPersonalService", scope = ManagedBeanScope.SESSION)
public class UserPersonalServiceImpl implements UserPersonalService {
     //数据访问层UserDAO(接口),利用@ManagedPrperty从AOM注入UserDAO的具体实例。
    @ManagedProperty( "#{dao}")
     private UserDAO dao;  
    @Accessible
     private User user; //当前用户的商业对象User的实例,登录后实例化，登出后置空。
    @Accessible
     private boolean logined; //当前用户的User的实例,登录后实例化，登出后置空。
  
     public boolean login(String userid, String password) { //登录
   boolean flag = false;
  User user = dao.getUser(userid);
   if (user != null) {
       if (user.getPassword().equals(password)) {
     this.logined = true;
     this.user = user;
    flag = true;
      }
  }
   return flag;
    }
     public void logout() { //注销
   this.logined = false;
   this.user = null;
    }
     public User getUser() {
   return this.user;
    }
     public boolean isLogined() { //是否登陆
   return this.logined;
    }
}

 

（1）同样的，通过@ManagedBean(name="userPersonalService"…将该实现类交个AOM容器管理，这样当表示层的model调用逻辑时，不用写new XXX()这样的代码，而是直接申明一个UserPersonalService即可，然后直接调用。那么具体的实例化交给AOM好了。我们看看表示层调用的方式：

 

package org.operamasks.example.registration.litebean;
import ......
@ManagedBean(scope = ManagedBeanScope.REQUEST)
public class LoginBean {
     //利用@Inject，注入UserPersonalService的具体实例。
  @Inject(value = "userPersonalService")
     private UserPersonalService service;

    @Bind     private String userid;
    @Bind     private String password;
    @Bind     private String message;

     //登录，调用业务逻辑完成。
    @Action(id = "btnLogin")
     public String login() {
  String nextView;
   boolean success = this.service.login(userid, password);
   if (!success) {
       this.message = "用户帐号或密码错误!";
      nextView = null;
  } else {
      nextView = "view:userDetail";
  }
   return nextView;
    }
}

 

(1)可以看到：我们利用@Inject(value = "userPersonalService")，注入了UserPersonalServiceImpl，而申明时，只涉及接口：private UserPersonalService service; 下面的代码并没有出现UserPersonalServiceImpl的实例化过程，这些也是交给AOM自动完成的。 都是注入完成功能，那@Inject 和@ManagedProperty 有什么区别呢，一般@Inject 是在需要调用这个类的时候才进行初始化，而@ManagedProperty是一旦调用者被初始化了，则被调用者跟着被实例化，两者的时机稍有不同，读者可以自行试验，那么一般的经验是，在表示层的Model上使用@Inject来注入资源，在非表示层Model的类上使用@ManagedProperty注入资源，就像本例一样。

那么，当下次你决定换掉实现类，而不想改代码的时候，Model层的调用逻辑是不用发生任何改变的，并且，你有权决定业务层使用Spring来组织和管理，那么尽情的用Spring。AOM和Spring可以紧密的集成，表示层Model的逻辑在这种情况下，同样不需要任何改变，AOM的LiteBean容器能够从Spring中找到业务逻辑的具体实现并初始化。

6.3. UsersManagerService

这个接口规定了用于管理用户的一些业务逻辑处理，例如：创建用户，删除用户，查询用户等等。 其相应的代码如下：

     
     
     
     

      
      
      
      

       
       
       
       package org.operamasks.example.registration.business; 
       
       
       
       

       
       
       
       import ...... 
       
       
       
       

       
       
       
       //针对用户管理的业务处理逻辑 
       
       
       
       

       
       
       
       public 
       
       
       
       interface UsersManagerService { 
       
       
       
       
    
       
       
       
       public User findUser(String id);  
       
       
       
       //查询用户 
       
       
       
       
    
       
       
       
       public 
       
       
       
       void createUser(User user);  
       
       
       
       //创建用户 
       
       
       
       
    
       
       
       
       public 
       
       
       
       void removeUser(String userid);    
       
       
       
       //删除用户 
       
       
       
       
    
       
       
       
       public 
       
       
       
       void modifyUser(User user);  
       
       
       
       //修改用户 
       
       
       
       
    
       
       
       
       public 
       
       
       
       boolean validate(User user);    
       
       
       
       //操作之前，调用此方法进行信息校验 
       
       
       
       
    
       
       
       
       public List findAllUsers();  
       
       
       
       //查询所有用户 
       
       
       
       
} 
       
       
       
       

      
      
      
      
     
     
     
     

6.4. UsersManagerServiceImple

代码如下：

 

package org.operamasks.example.registration.business;
import ......
@ManagedBean(name = "usersManagerService", scope = ManagedBeanScope.SESSION)
public class UsersManagerServiceImpl implements UsersManagerService {
    @ManagedProperty( "#{dao}")
     private UserDAO dao;
     public void createUser(User user) {
  dao.addUser(user);
    }
     public void modifyUser(User user) {
  dao.modifyUser(user);
    }
     public void removeUser(String userid) {
  dao.removeUser(userid);
    }
     public User findUser(String id) {
   return dao.getUser(id);
    }
     public List findAllUsers() {
   return dao.getAllUsers();
    }
     public boolean validate(User user) {
   return dao.validate(user);
    }
}

 

注意的地方在前面基本上都介绍了，AOM会注入DAO的具体实现，然后可以直接使用了，对于这个业务逻辑类来说，DAO的具体实现是透明的，使用者无需关心，即使当DAO的实现类发生了×××的变化，不管你具体实现类是哪个，其调用者，是完全不知道的，AOM在后面默默的帮你搞定。

7. 表现层

那么，表示层主要分为两块介绍，视图和模型，而控制层就是AOM的FacesServlet，本文我们可以不用关心她。

1） 视图方面，我们设计了这样几个页面：login.xhtml，register.xhtml，userDatail.xhtml，success.xhtml。

2）模型方面，我们设计了对应的model类：LoginBean，RegisterBean，UserDetailBean。Success因为只有一个链接，所以我们不打算生成其后台对应的LiteBean。

7.1. 视图

利用Apusic Stuido来开发AOM应用最方便不过了，拖拖拉拉，这里点点，那里击击就帮你代码生成了，并且后台的LiteBean也帮你把代码框架生成好了。因此，这几个视图的代码我就不一一贴出了。仅仅讲下客户端校验。 一些页面需要一些校验，比如输入不能为空。那么我们在form的属性中设置一个属性，则也会进行客户端校验：从而减少和服务器段的交互，代码如下：

     
     
     
     

      
      
      
      

       
       
       
       "true">
      
      
      
      
     
     
     
     

那么我通过监控工具FireBug，看看实际效果：

 

可以看到，校验发生时，没有和服务器进行交互，如果是通过服务器的校验的话，则会是下面这样样子（我们用输错密码的方式检验一下，密码是否正确是肯定要通过后台才能知道的）。

7.2. 模型：LiteBean

现在，我们来看看我们的模型层的设计，除了success.xhtml，其他的页面都对应一个后台的LiteBean。

1）LoginBean

首先看登陆页面的后台LiteBean ：LoginBean

 

package org.operamasks.example.registration.litebean;
import  ......
@ManagedBean(scope = ManagedBeanScope.REQUEST)
public class LoginBean {
     //利用@Inject，注入UserPersonalService的具体实例。
    @Inject(value = "userPersonalService")
     private UserPersonalService service;
    @Bind     private String userid;

    @Bind     private String password;

    @Bind     private String message;

     //登录，调用业务逻辑完成。
    @Action(id = "btnLogin")
     public String login() {
  String nextView;
   boolean success = this.service.login(userid, password);
   if (!success) {
       this.message = "用户帐号或密码错误!";
      nextView = null;
  } else {
      nextView = "view:userDetail";
  }
   return nextView;
    }
}

 

代码相当简单，主要是一个按钮事件，该事件调用UserPersonalService的login业务逻辑，进行登陆。成功则用户会看到userDetail视图，失败，则用界面上的一个outputlabel控件会显示“用户帐号活密码错误”。

2）UserDetailBean

这个页面是登陆成功后，进入用户详情的页面，本例设计的比较简单，就是显示这个用户的帐号，邮件，和真实姓名。这里通过资源注入的方式，取得当前的用户个人服务类UserPersonalService的实例，取得相关参数。然后用来个@Bind，页面就能显示被绑定的数据。

 

package org.operamasks.example.registration.litebean;
import ......
@ManagedBean(scope = ManagedBeanScope.REQUEST)  
public class UserDetailBean {
    @Bind
    @ManagedProperty( "#{userPersonalService.user.id}")
     private String userid;

    @Bind
    @ManagedProperty( "#{userPersonalService.user.email}")
     private String email;

    @Bind
    @ManagedProperty( "#{userPersonalService.user.name}")
     private String name;

}

 

#{userPersonalService.user.id} 这句话是个表达式，如果用代码方式来翻译就是：userPersonalService.getUer().getId()。

 

3）RegisterBean

首先，这个注册页面的第一个输入框是要求用户输入想要注册的帐户名，那么经常上论坛的我们知道，大部分的注册，会提供一个在线用户检测功能，以免用户好不容易填到最后并提交，然后等待服务器响应，结果服务器响应后来个“用户己注册”这样的信息，那将是十分不友好的。 本例，也提供了这样的功能，效果如下，先看下帐号存在时注册效果：

 

一个可以注册的帐号，会有个小勾表示通过，可以注册此帐号。

 

这个实现思路是：

a) 文本框输入字符后，焦点移开时，会触发一个onblur事件.

b) 后台liteBean响应这个事件，并且使用immediate=true避开其他控件的校验。

c) 在这个事件中，通过代码调用文本框的校验方法。

d) 给文本框，加个校验器，该校验器的作用是调用UserPsersonalService的业务逻辑，判断用户是否存在。

响应onblur事件的代码片段，其核心是fieldUserId.processValidators(ctx)。

     
     
     
     

      
      
      
      

       
       
       
       // 帐号输入框失去焦点事件事件，该事件触发帐号是否已注册的校验。 
       
       
       
       
    @ActionListener(id = 
       
       
       
       "userid", event = 
       
       
       
       "onblur", immediate = 
       
       
       
       true) 
       
       
       
       
    
       
       
       
       public 
       
       
       
       void userid_onBlur(ActionEvent event) { 
       
       
       
       
  UITextField fieldUserId = (UITextField) event.getComponent(); 
       
       
       
       
...... 
       
       
       
       
  FacesContext ctx = FacesContext.getCurrentInstance(); 
       
       
       
       
  fieldUserId.processValidators(ctx); 
       
       
       
       
  
       
       
       
       if (fieldUserId.isValid()) { 
       
       
       
       
      img.setUrl(IMG_CHECK_RIGHT); 
       
       
       
       
      
       
       
       
       this.imgCheckUser.setUrl(img.getUrl()); 
       
       
       
       
  } 
       
       
       
       
    } 
       
       
       
       

      
      
      
      
     
     
     
     

这是帐号输入框上的校验器代码片段:

 

// 轻松注入UsersManagerService的实现类。
    @Inject(value = "usersManagerService")
     private UsersManagerService manager;

......

// 帐号是否存在校验的校验器
    @Validate(id = "userid", message = "帐号已存在。")
     public boolean validateUserId(Object value) {
  String uid = value.toString();
  User user = manager.findUser(uid);
   return user == null ? true : false;
    }

 

使用UsersManagerService的业务逻辑来判断用户帐号是否已存在。

8. 权限认证

那么到这里，本例基本上介绍完了，可以运行这个例子了，可能有的朋友会问了，你的页面没有访问控制，我直接地址栏敲回车，不是一样的可以访问吗，还要登录干啥啊。这个问题问的不错，那么如果我们对这个例子想加入该功能该如何做呢，其实现方式有很多种，比如filter，比如用其他的安全框架，本例是用的JSF生命周期的监听器(PhaseListener)方式，其基本实现思路是：

1)我们先创建一个类AuthorityCheckPhaseListener，并实现PhaseListener接口。由于我们需要在执行其他操作之前先执行我们的访问控制操作，我们设置：

UserAuthorityCheckListener.java

    
    
    
    

     
     
     
     

      
      
      
      public PhaseId getPhaseId() 
      
      
      
      
{        
      
      
      
      return PhaseId.RESTORE_VIEW;     
      
      
      
      
}
     
     
     
     
    
    
    
    

就可以了，告诉AOM，我们需要侦听RESTORE_VIEW阶段(AOM收到请求的第一个阶段)。 我们实现一个空的beforePhase方法，什么也不做，因为这个方法是接口规定的，必须要写上，即使是个空方法。

    
    
    
    

     
     
     
     

      
      
      
      public 
      
      
      
      void beforePhase(PhaseEvent phaseEvent) {}
     
     
     
     
    
    
    
    

2)然后在afterPhase方法里做我们的访问控制操作：

    
    
    
    

     
     
     
     

      
      
      
      public 
      
      
      
      final 
      
      
      
      void afterPhase(PhaseEvent phaseEvent) {    
      
      
      
      //这里做访问控制操作}
     
     
     
     
    
    
    
    

那么我们该做些什么呢：

1） 取得用户访问的url

2） 根据配置文件判断该url是否需要认证

3） 需要认证的情况，则判断该用户是否已经登录（还记得我们的UserPersonalService有这个业务方法吗），未登录则迁移到用户登录页面。 看下代码的具体实现片段吧：

 

package org.operamasks.example.registration;
import ......
@SuppressWarnings( "serial")
public class UserAuthorityCheckListener implements PhaseListener {
    ......
     public void afterPhase(PhaseEvent event) {
  FacesContext ctx = FacesContext.getCurrentInstance();
  String url = ctx.getViewRoot().getViewId();
  NavigationHandler nh = ctx.getApplication().getNavigationHandler();
   if (!authorityCheckOk(url)) {
      nh.handleNavigation(ctx, null, "LoginView");
  }
    }

    ......

     public PhaseId getPhaseId() {
   return PhaseId.RESTORE_VIEW;
    }

     private boolean authorityCheckOk(String url) {

   if (notNeedToCheck(url))
       return true;

  ExternalContext etx = FacesContext.getCurrentInstance()
    .getExternalContext();
  Map map = etx.getSessionMap();
   if (map != null) {
      UserPersonalService service = (UserPersonalService) map
        .get( "userPersonalService");
       if (service != null) {
     return service.isLogined();
      }
  }
   return false;
    }

     private boolean notNeedToCheck(String url) {
   boolean flag = false;

   for (String page : NOT_NEED_TO_CHECK_PAGE_LIST) {
       if (url.indexOf(page) != -1) {
    flag = true;
     break;
      }
  }
   return flag;
    }
}

 

因为我们使用的是 AOM2.0的m1版本，没有Annotation来简化阶段监听器的开发，那么我们在使用监听器的时候，需要在faces-config.xml中怎加一段：

 

  
    org.operamasks.example.registration.UserAuthorityCheckListener
  
    

    
  *
  case>
      LoginView
      /login.jsf
  case>
    

 

不过，还好的是，OperaMasks2.0 M2版本已经对此进行了优化，增加了相关的Annotation支持，这样，以后我们就不用在这个配置文件中增加这些内容了（这是这个例子中唯一和配置文件打交道的地方），直接写一个@PhaseListener这样的标注放在类上面，这个类就是一个阶段监听器了，你也不需要继承什么接口，只写自己兴趣的代码就行了。

9. 资料

本例设计我们都已经介绍完毕，如果想结合具体代码一起观看的，这是应用包下载地址(含源代码)：

1) aom-example-registraion(for_tomcat).zip

2) aom-example-registration(for_apusic).zip

注：因为笔者使用的是OperaMasks2.0 M1版本，而不是M2版本，如果是M2版本，则两个zip将会是一样的。