用户登陆的实现
这不快毕业了吗？我选的题目就和struts有关，做一个关于学校的毕业设计选题系统，就是b/s结构，访问数据库的一些俗套的东西，为了巩固我这段时间学习struts，我把这个系统竟往难里做，这样对我这个动手能力差的人，实际工作经验少的人来说，会有点帮助吧？
当初就是这样想的，所以就开始了我的struts之旅。
那我就从我的第一页讲起吧，当然第一页一般都是登陆，至于怎么配置struts，您还是参考一些别人的文章吧，我觉得写这些就够土的了，写怎么配置，怎么实现就更土！
<%@ page contenttype="text/html; charset=gb2312"%>
<%@ taglib uri="/web-inf/struts-bean.tld" prefix="bean" %>
<%@ taglib uri="/web-inf/struts-html.tld" prefix="html" %>
用户名：
密码：
把控制格式的html删除掉，应该剩下这些就是主干了，对于这个毕业设计选题系统，有三种角色，管理员(admin)，教师(teacher)，学生(student)而我把他们的登陆都做到了一起，在后台这三种角色也是都放在了一个表中，对于他们这三种对象，都是继承于person的类，所以在登陆时可以忽视他们的具体角色，用多态来实现登陆。
action="/ajax.do?method=login" ：将一些关于登陆啊，注册的一些乱七八糟的操作我都放到了一个dispatchaction，之后可以用method的不同来分别调用不同的功能。
onsubmit="return validateloginform(this)"：这个是用来实现struts自带的validate验证
在这里需要的struts相关配置会有如下的几个方面：
首先是要对配置文件进行配置我们登陆时需要的formbean和action
(1)struts-config.xml：
(2)validation.xml:
这里是常量配置，因为我们还会需要到用户名的验证，所以把他设置为了常量
下面是对这个bean的具体严整手段了，按字段field分别来写他们所依赖depaends的检验手段，常用的有必须填required，正则表达式验证mask，最大maxlength和最小minlength
对于我们需要的formbean是这样写的：
package com.boya.subject.view;
import javax.servlet.http.httpservletrequest;
import org.apache.struts.action.*;
public class loginform extends actionform
{
private static final long serialversionuid = 1l;
private string user = null;
private string password = null;
public string getpassword()
{
return password;
}
public void setpassword( string password )
{
this.password = password;
}
public string getuser()
{
return user;
}
public void setuser( string user )
{
this.user = user;
}
public void reset(actionmapping mapping,httpservletrequest request)
{
this.password = null;这里很重要，当用户输入有错时，需要返回登陆界面给用户，为了用户填写方便我们可以设置返回给用户的哪部分信息设置为空
}
}
我用来实现登陆的dispatchaction代码如下：
public actionforward login( actionmapping mapping, actionform form,
httpservletrequest req, httpservletresponse res ) throws exception
{
service service = getservice();调用业务逻辑
loginform loginform = (loginform) form;获取formbean
string user = loginform.getuser();提取用户名
person person = service.getuser( user );从业务逻辑中查找用户
actionmessages messages = new actionmessages();
actionmessage am;
if ( person == null )如果用户不存在，我们就返回
{
am = new actionmessage( "index.jsp.fail.user", user );参数的意义：第一个是主串，而后面的作为arg数组
messages.add( "user", am );把错误信息放到errors 属性为user那里去显示
saveerrors( req, messages );
form.reset( mapping, req );如果出现错误，调用formbean的重置功能
return mapping.findforward( id.fail );
}
if ( !person.getpassword().equals( loginform.getpassword() ) )如果密码不一致
{
am = new actionmessage( "index.jsp.fail.password", user );
messages.add( "password", am );
saveerrors( req, messages );
form.reset( mapping, req );
return mapping.findforward( id.fail );
}
setsessionobject( req, person.gettype(), person );把用户放到session里
return new actionforward( person.gettype() + ".do", true );我在每个类型用户的类中加入了一个gettype来在这里调用，之后动态的去对应的admin.do,student.do,teacher.do的主页面，并且这里实现的不是请求转发，而是请求从定向
}
为了让大家更方便的了解我这个设计，我先把我的一些整体的规划都说出来吧，由于我是初学，难免会参照本书籍来看，我买的是那本孙某女的书《精通：*****》，看了看她前面的介绍，我一看了不得，能出书，写的还都不错，这女的可不得了，渐渐疑惑的地方非常多，比如例子里面注释都拽上了英语，搞不懂，而当我从网上下到电子盗版jakarta struts（我已安下栽说明要求的那样在24小时后删除了）这本书的时候我才恍然大悟，原来是抄袭啊？至于是谁抄的谁，口说无凭，不能乱诽谤，不过大家心里都该有杆称！
下面就是代码了：
package com.boya.subject.model;
public interface person
{
public long getid();
public void setid( long id );
public string getname();
public void setname( string name );
public string getpassword();
public void setpassword( string password );
public string gettelphone();
public void settelphone( string telphone );
public string getuser();
public void setuser( string user );
public string gettype();
}
package com.boya.subject.model;
public abstract class user implements person
{
private long id;数据库id
private string user;用户名
private string password;密码
private string name;姓名
private string telphone;电话
public long getid()
{
return id;
}
public void setid( long id )
{
this.id = id;
}
public string getname()
{
return name;
}
public void setname( string name )
{
this.name = name;
}
public string getpassword()
{
return password;
}
public void setpassword( string password )
{
this.password = password;
}
public string gettelphone()
{
return telphone;
}
public void settelphone( string telphone )
{
this.telphone = telphone;
}
public string getuser()
{
return user;
}
public void setuser( string user )
{
this.user = user;
}
}
package com.boya.subject.model;
public class admin extends user
{
private string grade = null; 管理员权限
public string getgrade()
{
return grade;
}
public void setgrade( string grade )
{
this.grade = grade;
}
public string gettype()
{
return "admin";
}
}
package com.boya.subject.model;
public class teacher extends user
{
private string level; 教师职称
public string getlevel()
{
return level;
}
public void setlevel( string level )
{
this.level = level;
}
public string gettype()
{
return "teacher";
}
}
package com.boya.subject.model;
public class student extends user
{
private string sn;学生学号
private schoolclass schoolclass; 班级
public schoolclass getschoolclass()
{
return schoolclass;
}
public void setschoolclass( schoolclass schoolclass )
{
this.schoolclass = schoolclass;
}
public string getsn()
{
return sn;
}
public void setsn( string sn )
{
this.sn = sn;
}
public string gettype()
{
return "student";
}
}
而对于action我分别做了一个抽象类，之后别的从这里继承
先是action的
package com.boya.subject.controller;
import java.io.ioexception;
import javax.servlet.http.httpservletrequest;
import javax.servlet.http.httpservletresponse;
import javax.servlet.http.httpsession;
import org.apache.struts.action.action;
import org.apache.struts.action.actionform;
import org.apache.struts.action.actionforward;
import org.apache.struts.action.actionmapping;
import com.boya.subject.frame.id;
import com.boya.subject.frame.servicefactory;
import com.boya.subject.model.person;
import com.boya.subject.service.service;
import com.boya.subject.util.htmlutil;
public abstract class baseaction extends action
{
/**
* 由服务工厂方法创建服务
* @return 数据库操作的服务
* 2006-5-16 18:10:04
*/
public service getservice()
{
servicefactory factory = (servicefactory) getappobject( id.sf );
service service = null;
try
{
service = factory.createservice();
}
catch ( exception e )
{
}
return service;
}
/**
* 判断用户是否合法登陆
* @param req
* @return 用户是否登陆
* 2006-5-16 18:11:26
*/
public boolean islogin( httpservletrequest req )
{
if ( getperson( req ) != null ) return true;
else
return false;
}
/**
* 抽象方法,子类实现
* @param mapping
* @param form
* @param req
* @param res
* @return
* @throws exception
* 2006-5-16 18:12:54
*/
protected abstract actionforward executeaction( actionmapping mapping,
actionform form, httpservletrequest req, httpservletresponse res )
throws exception;
/**
* 获取session范围的用户
* @param req
* @return 当前用户
* 2006-5-16 18:13:35
*/
public abstract person getperson( httpservletrequest req );
/**
* 父类的执行action
* @see org.apache.struts.action.action#execute(org.apache.struts.action.actionmapping, org.apache.struts.action.actionform, javax.servlet.http.httpservletrequest, javax.servlet.http.httpservletresponse)
*/
public actionforward execute( actionmapping mapping, actionform form,
httpservletrequest req, httpservletresponse res ) throws exception
{
if ( !islogin( req ) )
{
htmlutil.callparentgo( res.getwriter(), id.m_unlogin, id.p_index );
return null;
}
return executeaction( mapping, form, req, res );
}
/**
* 删除session中属性为attribute的对象
* @param req
* @param attribute 对象属性
* 2006-5-16 18:16:59
*/
public void removesessionobject( httpservletrequest req, string attribute )
{
httpsession session = req.getsession();
session.removeattribute( attribute );
}
/**
* 设置session中属性为attribute的对象
* @param req
* @param attribute 设置属性
* @param o 设置对象
* 2006-5-16 18:17:50
*/
public void setsessionobject( httpservletrequest req, string attribute,
object o )
{
req.getsession().setattribute( attribute, o );
}
/**
* 设置application中属性为attribute的对象
* @param req
* @param attribute 设置属性
* @param o 设置对象
* 2006-5-16 18:17:50
*/
public void setappobject( string attribute, object o )
{
servlet.getservletcontext().setattribute( attribute, o );
}
public object getsessionobject( httpservletrequest req, string attribute )
{
object obj = null;
httpsession session = req.getsession( false );
if ( session != null ) obj = session.getattribute( attribute );
return obj;
}
public object getappobject( string attribute )
{
return servlet.getservletcontext().getattribute( attribute );
}
public void callparentgo( httpservletresponse res, string msg, string url )
throws ioexception
{
htmlutil.callparentgo( res.getwriter(), msg, url );
}
public void callmego( httpservletresponse res, string msg, string url )
throws ioexception
{
htmlutil.callmego( res.getwriter(), msg, url );
}
public void callback( httpservletresponse res, string msg )
throws ioexception
{
htmlutil.callback( res.getwriter(), msg );
}
public void callmeconfirm( httpservletresponse res, string msg, string ok,
string no ) throws ioexception
{
htmlutil.callmeconfirm( res.getwriter(), msg, ok, no );
}
}
再是dispatchaction的
package com.boya.subject.controller;
import java.io.ioexception;
import javax.servlet.http.httpservletrequest;
import javax.servlet.http.httpservletresponse;
import javax.servlet.http.httpsession;
import org.apache.struts.action.actionform;
import org.apache.struts.action.actionforward;
import org.apache.struts.action.actionmapping;
import org.apache.struts.actions.dispatchaction;
import com.boya.subject.frame.id;
import com.boya.subject.frame.servicefactory;
import com.boya.subject.model.person;
import com.boya.subject.service.service;
import com.boya.subject.util.htmlutil;
public abstract class basedispatchaction extends dispatchaction
{
/**
* 由服务工厂方法创建服务
* @return 数据库操作的服务
* 2006-5-16 18:10:04
*/
public service getservice()
{
servicefactory factory = (servicefactory) getappobject( id.sf );
service service = null;
try
{
service = factory.createservice();
}
catch ( exception e )
{
}
return service;
}
/**
* 判断用户是否合法登陆
* @param req
* @return 用户是否登陆
* 2006-5-16 18:11:26
*/
public boolean islogin( httpservletrequest req )
{
if ( getperson( req ) != null ) return true;
else
return false;
}
/**
* 获取session范围的用户
* @param req
* @return 当前用户
* 2006-5-16 18:13:35
*/
public abstract person getperson( httpservletrequest req );
/**
* 父类的执行dispatchaction
* @see org.apache.struts.action.action#execute(org.apache.struts.action.actionmapping, org.apache.struts.action.actionform, javax.servlet.http.httpservletrequest, javax.servlet.http.httpservletresponse)
*/
public actionforward execute( actionmapping mapping, actionform form,
httpservletrequest req, httpservletresponse res ) throws exception
{
try
{
if ( !islogin( req ) )
{
callparentgo( res, id.m_unlogin, id.p_index );
return null;
}
return super.execute( mapping, form, req, res );
}
catch ( nosuchmethodexception e )
{
callback( res, id.m_nomethod );
return null;
}
}
/**
* 删除session中属性为attribute的对象
* @param req
* @param attribute 对象属性
* 2006-5-16 18:16:59
*/
public void removesessionobject( httpservletrequest req, string attribute )
{
httpsession session = req.getsession();
session.removeattribute( attribute );
}
/**
* 设置session中属性为attribute的对象
* @param req
* @param attribute 设置属性
* @param o 设置对象
* 2006-5-16 18:17:50
*/
public void setsessionobject( httpservletrequest req, string attribute,
object o )
{
req.getsession().setattribute( attribute, o );
}
/**
* 设置application中属性为attribute的对象
* @param req
* @param attribute 设置属性
* @param o 设置对象
* 2006-5-16 18:17:50
*/
public void setappobject( string attribute, object o )
{
servlet.getservletcontext().setattribute( attribute, o );
}
public object getsessionobject( httpservletrequest req, string attribute )
{
object obj = null;
httpsession session = req.getsession( false );
if ( session != null ) obj = session.getattribute( attribute );
return obj;
}
public object getappobject( string attribute )
{
return servlet.getservletcontext().getattribute( attribute );
}
public void callparentgo( httpservletresponse res, string msg, string url )
throws ioexception
{
htmlutil.callparentgo( res.getwriter(), msg, url );
}
public void callmego( httpservletresponse res, string msg, string url )
throws ioexception
{
htmlutil.callmego( res.getwriter(), msg, url );
}
public void callback( httpservletresponse res, string msg )
throws ioexception
{
htmlutil.callback( res.getwriter(), msg );
}
public void callmeconfirm( httpservletresponse res, string msg, string ok,
string no ) throws ioexception
{
htmlutil.callmeconfirm( res.getwriter(), msg, ok, no );
}
}
对于程序中的一些提示信息，我比较喜欢用js来写，所以我把这些都放到了一个类中
import java.io.ioexception;
import java.io.writer;
public class htmlutil
{
public static void callparentgo( writer out, string msg, string url )
throws ioexception
{
out.write( " " );
}
public static void callmego( writer out, string msg, string url )
throws ioexception
{
out.write( " " );
}
public static void callmeconfirm( writer out, string msg ,string ok, string no )
throws ioexception
{
out.write( " " );
}
public static void callback( writer out, string msg ) throws ioexception
{
out.write( " " );
}
}
比如当用户在注册的时候，用户点一个按纽不用刷新界面就可以获得一句提示，是有这人还是没有这人啊？这次我尝试了用ajax技术来做一个三级关键的下拉列表，而这是我要讲的关键。
其实现在一般的ajax都是向servlet发出请求，之后服务器响应，再偷摸的把结果传给它，之后显示出来，而换到struts，有人会发甍，也一样，action是servlet，dispatchaction也是，只要把代码往这里写，让它往.do那里请求就行了。
在接下来我就向大家介绍我是怎样实现上述功能的
因为大学里面的结构是这里的
学院-专业-班级-学生
在学生注册的时候他是依赖于上述对象的，所以用户注册就需要一个三级的下拉选择
而ajax就能象变魔术一样，从服务器那里偷摸弄来您需要的列表
下面我先给大家展示一下第一个功能是怎么实现的吧？
当用户在注册的时候，点一个按纽，之后会弹出一个alert来告诉你这个用户是否有人用了，下面就让我们来看看这个功能是怎么实现的吧？
这里定义了按纽，用来测试老师是否已经存在了
大体的ajax的js代码都上面这四部分，
先是创建xmlhttprequest，
var xmlhttp;
function createxmlhttprequest()
{
if (window.xmlhttprequest)
{
xmlhttp = new xmlhttprequest();
}
else if (window.activexobject)
{
xmlhttp = new activexobject("microsoft.xmlhttp");
}
}
之后是客户响应部分的代码
function teachercheck()
{
var f = document.teacherregisterform 从表单里读字段
var user = f.user.value
if(user=="")
{
window.alert("用户名不能为空！")
f.user.focus()
return false
}
else
{
createxmlhttprequest() 这里都是精华了
var url = "ajax.do?method=checkuserisexist&user="+user 定义响应地址
xmlhttp.open("get",url, true) 发出响应
xmlhttp.onreadystatechange = checkuser 把从服务器得到的响应再传给另个函数
xmlhttp.send(null)
}
}
function checkuser()
{
if (xmlhttp.readystate == 4)
{
if (xmlhttp.status == 200)
{
alert(xmlhttp.responsetext) 这里是对响应结果的操作，在这里我们是滩出对话框，并把服务器发来的信息显示出来
}
}
}
我把所有乱七八糟的操作都放到了一个dispatchaction里，所以它也不例外的在这个da中了
public actionforward checkuserisexist( actionmapping mapping,
actionform form, httpservletrequest req, httpservletresponse res )
throws exception
{
service service = getservice();
res.getwriter().write(service.checkuserisexistforajax( req.getparameter( "user" ) ) );
return null;
}
它仅仅是把业务逻辑部分的结果发送回去，而真正的判断是在业务逻辑那里实现的，
public string checkuserisexistforajax( string user )把结果弄成string的形式传回去
{
connection connection = null;
preparedstatement pstmt1 = null;
resultset rs = null;
try
{
connection = getconnection();
pstmt1 = connection
.preparestatement( "select * from user where user=?" );
pstmt1.setstring( 1, user );
rs = pstmt1.executequery();
rs.last();
if ( rs.getrow() > 0 )
{
return id.m_exist; 用户存在
}
}
catch ( exception e )
{
e.printstacktrace();
}
finally
{
close( rs );
close( pstmt1 );
close( connection );
}
return id.m_noexist;用户不存在
}
接着上次的话题，下面的就是学生注册时需要的学院，专业，班级，三层列表，
学院：
专业：
班级：
学院是上来就应该有的，我们把他放到了labelvaluebean里
public vector
{
connection connection = null;
preparedstatement pstmt = null;
resultset rs = null;
try
{
connection = getconnection();
pstmt = connection.preparestatement( "select * from institute" );
rs = pstmt.executequery();
vector
institutes.add( new labelvaluebean( "请选择所在学院", "" ) );
while ( rs.next() )
{
institutes.add( new labelvaluebean(
rs.getstring( "institute" ), rs.getstring( "id" ) ) );
}
return institutes;
}
catch ( exception e )
{
e.printstacktrace();
}
finally
{
close( rs );
close( pstmt );
close( connection );
}
return null;
}
var xmlhttp;
function createxmlhttprequest()
{
if (window.xmlhttprequest)
{
xmlhttp = new xmlhttprequest();
}
else if (window.activexobject)
{
xmlhttp = new activexobject("microsoft.xmlhttp");
}
}
发出请求
function getdepartments(institute)
{
createxmlhttprequest()
var url = "ajax.do?institute="+institute+"&method=getdepartments"
xmlhttp.open("get",url, true)
xmlhttp.onreadystatechange = departments
xmlhttp.send(null)
}
处理响应
function departments()
{
if (xmlhttp.readystate == 4)
{
if (xmlhttp.status == 200)
{
restext = xmlhttp.responsetext
each = restext.split("|")
buildselect( each, document.getelementbyid("departmentid"), "请选择所在专业");
}
}
}
function buildselect(str,sel,label)
{
sel.options.length=0;
sel.options[sel.options.length]=new option(label,"")
for(var i=0;i
each=str[i].split(",")
sel.options[sel.options.length]=new option(each[0],each[1])
}
}
我把从数据库中得到的各个专业进行了编码，之后再这里再回归回去，下面的是编码过程
public stringbuffer getdepartmentsbyinstituteidforajax( long instituteid )
{
connection connection = null;
preparedstatement pstmt = null;
resultset rs = null;
try
{
connection = getconnection();
pstmt = connection
.preparestatement( "select * from department where instituteid=?" );
pstmt.setlong( 1, instituteid );
rs = pstmt.executequery();
stringbuffer sb = new stringbuffer();
while ( rs.next() )
{
sb.append( rs.getstring( "department" ) + ","
+ rs.getlong( "id" ) );
if ( !rs.islast() ) sb.append( "|" );
}
return sb;
}
catch ( exception e )
{
e.printstacktrace();
}
finally
{
close( rs );
close( pstmt );
close( connection );
}
return null;
}
当然这些都是由
public actionforward getdepartments( actionmapping mapping,
actionform form, httpservletrequest req, httpservletresponse res )
throws exception
{
service service = getservice();
res.getwriter().write(
service.getdepartmentsbyinstituteidforajax(
long.parselong( req.getparameter( "institute" ) ) )
.tostring() );
return null;
}
来控制
===========班级的再这里
public actionforward getclasses( actionmapping mapping, actionform form,
httpservletrequest req, httpservletresponse res ) throws exception
{
service service = getservice();
res.getwriter().write(
service.getclassesbydepartmentidforajax(
long.parselong( req.getparameter( "department" ) ) )
.tostring() );
return null;
}
public stringbuffer getclassesbydepartmentidforajax( long departmentid )
{
connection connection = null;
preparedstatement pstmt = null;
resultset rs = null;
try
{
connection = getconnection();
pstmt = connection
.preparestatement( "select * from class where departmentid=?" );
pstmt.setlong( 1, departmentid );
rs = pstmt.executequery();
stringbuffer sb = new stringbuffer();
while ( rs.next() )
{
sb.append( rs.getstring( "class" ) + "," + rs.getlong( "id" ) );
if ( !rs.islast() ) sb.append( "|" );
}
return sb;
}
catch ( exception e )
{
e.printstacktrace();
}
finally
{
close( rs );
close( pstmt );
close( connection );
}
return null;
}
function getclasses(department)
{
createxmlhttprequest()
var url = "ajax.do?department="+department+"&method=getclasses"
xmlhttp.open("get",url, true)
xmlhttp.onreadystatechange = classes
xmlhttp.send(null)
}
function classes()
{
if (xmlhttp.readystate == 4)
{
if (xmlhttp.status == 200)
{
restext = xmlhttp.responsetext
each = restext.split("|")
buildselect( each, document.getelementbyid("classid"), "请选择所在班级");
}
}
}
从分页体会mvc
大家都知道struts是一种基于mvc的结构，而这个mvc又怎么样理解呢？书上阐述的一般都很详细，而我的理解很直白，我们可以把业务逻辑放到每个jsp页面中，当你访问一个jsp页面的时候，就可以看到业务逻辑得到的结果
闽公网安备 35060202000074号