注册页面的搭建

先用javaScript对form表单做处理

function dosubmit() {
        var th = document.form1;
        if (th.username.value == "") {
            alert("用户名不能为空！！");
            th.username.focus();
            return;
        }
        if (th.realname.value == "") {
            alert("姓名不能为空！！");
            th.realname.focus();
            return;
        }
        if (th.pswd.value == "") {
            alert("密码不能为空！！");
            th.pswd.focus();
            return;
        }
        th.action="<%=path%>/servlet/RegisterAction";
        th.submit();
    }
</script>

还需要对jdbc连接mySql做简单的封装

package com.jdbc.util;

import java.lang.reflect.Field;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.ResultSetMetaData;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;


public class MySqlConnect {
    private Connection conn;

    private PreparedStatement preState;

    private ResultSet resultSet;

    public MySqlConnect() {
        try {
            Class.forName("com.mysql.jdbc.Driver").newInstance();
            System.out.println("驱动注册成功！");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
    }

    public Connection getConnect() {

        try {
            conn = DriverManager.getConnection("jdbc:mysql://localhost/mydata?"
                    + "user=root&password=root");
            System.out.println("数据库连接成功！");
        } catch (SQLException e) {
            e.printStackTrace();
        }
        return conn;
    }

    /**
     * 封装的删除 增加 修改操作
     * 
     * @param sql
     *            执行的sql语句
     * @param params
     *            sql语句的占位符
     * @return 操作是否成功
     * @throws SQLException
     */
    public boolean updataByPrepareStatement(String sql, List<Object> params)
            throws SQLException {
        boolean flag = false;
        // 执行数据操作所影响的行数
        int result = -1;
        preState = conn.prepareStatement(sql);
        int index = 1;
        if (params != null && !params.isEmpty()) {
            for (int i = 0; i < params.size(); i++) {
                preState.setObject(index++, params.get(i));
            }
        }
        result = preState.executeUpdate();
        flag = result > 0 ? true : false;
        return flag;

    }

    /**
     * 封装单条语句查询
     * 
     * @param sql
     *            执行的sql语句
     * @param params
     *            执行sql语句的占位符
     * @return 返回单条语句查询结果
     * @throws SQLException
     */
    public Map<String, Object> queryBySimpleResult(String sql,
            List<Object> params) throws SQLException {
        Map<String, Object> map = new HashMap<String, Object>();
        preState = conn.prepareStatement(sql);
        int index = 1;
        if (params != null && !params.isEmpty()) {
            for (int i = 0; i < params.size(); i++) {
                preState.setObject(index++, params.get(i));
            }
        }
        resultSet = preState.executeQuery();
        ResultSetMetaData resultSetMetaData = resultSet.getMetaData();
        int column_long = resultSetMetaData.getColumnCount();
        while (resultSet.next()) {
            for (int i = 0; i < column_long; i++) {
                String column_name = resultSetMetaData.getColumnName(i + 1);
                Object column_value = resultSet.getObject(column_name);
                if (column_value == null) {
                    column_value = "";
                }
                map.put(column_name, column_value);
            }
        }
        return map;
    }

    /**
     * 封装多条语句查询
     * 
     * @param sql
     * @param params
     * @return
     * @throws SQLException
     */
    public List<Map<String, Object>> queryByMoreResults(String sql,
            List<Object> params) throws SQLException {
        List<Map<String, Object>> list = new ArrayList<Map<String, Object>>();
        int index = 1;
        preState = conn.prepareStatement(sql);
        if (params != null && !params.isEmpty()) {
            for (int i = 0; i < params.size(); i++) {
                preState.setObject(index++, params.get(i));
            }
        }
        resultSet = preState.executeQuery();
        ResultSetMetaData metaData = resultSet.getMetaData();
        int column_long = metaData.getColumnCount();
        while (resultSet.next()) {
            Map<String, Object> map = new HashMap<String, Object>();
            for (int i = 0; i < column_long; i++) {
                String cloumn_name = metaData.getColumnName(i + 1);
                Object cloumn_Value = resultSet.getObject(cloumn_name);
                if (cloumn_Value == null) {
                    cloumn_Value = "";
                }
                map.put(cloumn_name, cloumn_Value);
            }
            list.add(map);
        }
        return list;
    }

    /**
     * 使用反射来查询单条数据
     * 
     * @param sql
     *            sql语句
     * @param params
     * @param cls
     *            封装数据的类
     * @return
     * @throws Exception
     */
    public <T> T refQueryBySimpleResult(String sql, List<Object> params,
            Class<T> cls) throws Exception {
        T resultObject = null;
        int index = 1;
        preState = conn.prepareStatement(sql);
        if (params != null && !params.isEmpty()) {
            for (int i = 0; i < params.size(); i++) {
                preState.setObject(index++, params.get(i));
            }
        }
        resultSet = preState.executeQuery();
        ResultSetMetaData metaData = resultSet.getMetaData();
        int column_long = metaData.getColumnCount();
        while (resultSet.next()) {
            // 通过反射机制完成实例
            resultObject = cls.newInstance();
            for (int i = 0; i < column_long; i++) {
                String column_name = metaData.getColumnName(i + 1);
                Object column_value = resultSet.getObject(column_name);
                if (column_value == null) {
                    column_value = "";
                }
                // 获取类的成员变量
                Field field = cls.getDeclaredField(column_name);
                // 打开成员变量的private访问权限
                field.setAccessible(true);
                field.set(resultObject, column_value);
            }
        }
        return resultObject;

    }

    /**
     * 使用反射来查询多条数据
     * 
     * @param sql
     *            sql语句
     * @param params
     * @param cls
     *            封装数据的类
     * @return
     * @throws Exception
     */
    public <T> List<T> refQueryByMoreResult(String sql, List<Object> params,
            Class<T> cls) throws Exception {
        List<T> list = new ArrayList<T>();
        int index = 1;
        preState = conn.prepareStatement(sql);
        if (params != null && !params.isEmpty()) {
            for (int i = 0; i < params.size(); i++) {
                preState.setObject(index++, params.get(i));
            }
        }
        resultSet = preState.executeQuery();
        ResultSetMetaData metaData = resultSet.getMetaData();
        int column_long = metaData.getColumnCount();
        while (resultSet.next()) {
            // 通过反射机制完成实例
            T resultObject = cls.newInstance();
            for (int i = 0; i < column_long; i++) {
                String column_name = metaData.getColumnName(i + 1);
                Object column_value = resultSet.getObject(column_name);
                if (column_value == null) {
                    column_value = "";
                }
                // 获取类的成员变量
                Field field = cls.getDeclaredField(column_name);
                // 打开成员变量的private访问权限
                field.setAccessible(true);
                field.set(resultObject, column_value);
            }
            list.add(resultObject);
        }
        return list;

    }

    // 释放连接
    public void releaseConnect() {
        if (resultSet != null) {
            try {
                resultSet.close();
                resultSet = null;
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (preState != null) {
            try {
                preState.close();
                preState = null;
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if (conn != null) {
            try {
                conn.close();
                conn = null;
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }

    

}

连接数据库需要jar包，以及一些简单的数据库操作，这里就不进行说明了

 

定义一个接口  用来完成用户注册 利用实现接口来解决单继承的窘境

package com.servlet.register.service;

import java.util.List;

public interface RegisterService {
    public boolean registerUser(List<Object> params);
}

 建立一个类来完成数据的访问

package com.servlet.register.dao;

import java.util.List;

import com.jdbc.util.MySqlConnect;
import com.servlet.register.service.RegisterService;

public class RegisterDao implements RegisterService {
    private MySqlConnect util = null;

    public RegisterDao() {
        util = new MySqlConnect();
    }

    
    /* (non-Javadoc)
     * 完成注册
     * @see com.servlet.register.service.RegisterService#registerUser(java.util.List)
     */
    public boolean registerUser(List<Object> params) {
        boolean flage = false;
        // 连接数据库
        util.getConnect();
        String sql = "insert into userinfo(username,password,realname) values(?,?,?)  ";
        try {
            // 执行sql语句
            util.updataByPrepareStatement(sql, params);
            flage=true;
        } catch (Exception e) {
            System.out.println("执行出错！");
        } finally {
            // 关闭数据库
            util.releaseConnect();
        }

        return flage;
    }

}

再建立一个类 来完成业务逻辑的处理

package com.servlet.register.action;

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.servlet.register.dao.RegisterDao;
import com.servlet.register.service.RegisterService;

public class RegisterAction extends HttpServlet {

    private static final long serialVersionUID = 1L;
    private RegisterService service;

    public RegisterAction() {
        super();
    }

    public void destroy() {
        super.destroy();
    }

    public void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        this.doPost(request, response);
    }

    public void doPost(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        // 获得上下文路径
        String path = request.getContextPath();
        System.out.println("path  " + path);

        response.setContentType("text/html;charset=utf-8");

        String username = request.getParameter("username");
        String password = request.getParameter("pswd");
        String realname = request.getParameter("realname");

        List<Object> params = new ArrayList<Object>();
        params.add(username);
        params.add(password);
        params.add(realname);

        boolean flag = service.registerUser(params);
        if (flag) {
　　//跳转到登陆页面
            response.sendRedirect(path + "/index.jsp");
        }

    }

    public void init() throws ServletException {
        // Put your code here
        service = new RegisterDao();
    }

}

 总结一下，这种像三层架构或者MVC框架来编写的方式，结构清晰、耦合度低，可维护性高，可扩展性高，利于开发任务同步进行；容易适应需求变化等。