【javaweb】自己动手实现简易的Tomcat2

一个服务器server中可以存放jd，oa这样的多个web应用；

Web应用是通过sun公司制定的servlet接口与Tomcat，JBoss等多个服务器解耦合的

所以，同一个web应用，就可以运行在多种不同的服务器上；（Tomcat，JBoss等服务器就是通过sun制定的Servlet接口来找到要执行的servlet类，从而启动web应用）

Java程序和数据库也是 JDBC接口来进行了解耦合；

Http协议的作用：

注意：

返回状态码500，就说明代码出现了问题；

 

 

项目目录

主启动类

package cn.huangyan.httpserver.core;

import java.io.BufferedReader;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;

import cn.huangyan.httpserver.util.Logger;

/*
 * httpserver程序主入口
 * @author：huangyan
 * @version：1.0
 * */ 
public class BootStrap {

	public static void main(String[] args) {
		start();
	}

	// 主程序入口
	public static void start() {
		ServerSocket serverSocket = null;
		BufferedReader br = null;
		Socket clientSocket = null;
		try {
			Logger.log("httpserver start");
			
			// 获取当前时间
			long startTime = System.currentTimeMillis();
			
			// 解析服务器中包含的所有web.xml配置文件
			String[] webAppNames = {"oa"};
			WebParser.parser(webAppNames);
			
			
			// 获取系统端口号
			int port = ServerParser.getPort();
			Logger.log("httpserver-port："+port);
			
			serverSocket = new ServerSocket(port);
			
			// 获取结束时间
			long endTime = System.currentTimeMillis();
			Logger.log("httpserver started：" + (endTime - startTime) + " ms");
			
			// 通过while循环，让服务器一直处理监听状态
			while(true) {
				
				// 开始监听
				clientSocket = serverSocket.accept();
				
				// 每一次请求，都开启一个新的线程进行请求处理
				new Thread(new HandlerRequest(clientSocket)).start();
			}
			
		} catch (Exception e) {
			e.printStackTrace();
		}finally {
			if(serverSocket != null) {
				try {
					serverSocket.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}
		
	}

}

a）主线程负责接收每个客户端socket，并为每个客户端socket创建一个子线程负责处理

b）解析服务器中包含的所有web.xml配置文件

c）扫描配置文件server.xml，获取系统端口号

conf/server.xml

<?xml version="1.0" encoding="UTF-8"?>
<server>
	<service>
		<connector port="8080"></connector>
	</service>
</server>

 

package cn.huangyan.httpserver.core;

import java.io.File;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

/*
 * 解析服务器中的web.xml配置文件
 * */
public class WebParser {
	
	public static  Map<String, Map<String,String>> servletMaps = new HashMap<String,  Map<String,String>>();
	
	/*
	 * 解析服务器中所有web应用的web.xml
	 * */
	public static void parser(String[] webAppNames) throws DocumentException{
		for(String webAppName : webAppNames) {
			Map<String,String> servletMap = parser(webAppName);
			
			servletMaps.put(webAppName, servletMap);
		}
	}

	
	/*
	 * 解析单个应用的web.xml配置文件
	 * */
	private static Map<String,String> parser(String webAppName) throws DocumentException{
		// 获取web.xml的路径
		String webPath = webAppName + "/WEB-INF/web.xml"; // sun公司规定的路径，没有为什么；    实现web服务器和app解耦

		// 创建xml解析器
		SAXReader saxReader = new SAXReader();

		Document document = saxReader.read(new File(webPath));

		// 获取servlet节点元素
		List<Element> servletNodes = document.selectNodes("/web-app/servlet");
		
		// 创建一个servletInfoMap集合：将servlet-name和servlet-class当做key和value存入此Map中
		Map<String,String> servletInfoMap = new HashMap<String, String>();

		// 开始遍历servletNodes
		for(Element servletNode : servletNodes) {
			// 获取servlet-name节点元素
			Element servletNameEle = (Element) servletNode.selectSingleNode("servlet-name");
			// 获取servlet-name节点元素对象的值
			String servletName = servletNameEle.getStringValue();

			// 获取servlet-class节点元素
			Element servletClassEle = (Element) servletNode.selectSingleNode("servlet-class");
			// 获取servlet-class节点元素对象的值
			String servletClassName = servletClassEle.getStringValue();

			// 将servletName和servletClassName作为key/value，放入servletInfoMap集合中
			servletInfoMap.put(servletName, servletClassName);
		}

		// 获取servlet节点元素
		List<Element> servletMappingNodes = document.selectNodes("/web-app/servlet-mapping");
		// 创建一个servletInfoMap集合：将servlet-name和url，当做key和value存入此Map中
		Map<String,String> servletMappingInfoMap = new HashMap<String, String>();

		// 开始遍历servletMappingNodes
		for(Element servletMappingNode : servletMappingNodes) {
			Element servletNameEle = (Element) servletMappingNode.selectSingleNode("servlet-name");
			String servletName = servletNameEle.getStringValue();

			Element urlPatternEle = (Element) servletMappingNode.selectSingleNode("url-pattern");
			String urlPattern = urlPatternEle.getStringValue();
			
			// 这里要替换为servletMappingInfoMap，不要再写成servletInfoMap
			servletMappingInfoMap.put(servletName, urlPattern);
		}
		
		
		// 获取servletInfoMap的keySet()
		Set<String> servletNames = servletInfoMap.keySet();
		
		// 创建一个servletMap:
		// 将servletMappingInfoMap的value与servletInfoMap的value，分别作为key与value存入此servletMap
		Map<String,String> servletMap = new HashMap<String, String>();
		for(String servletName : servletNames) {
			String urlPattern = servletMappingInfoMap.get(servletName);
			String servletClassName = servletInfoMap.get(servletName);
			
			servletMap.put(urlPattern, servletClassName);
		}
		
		return servletMap;
	}
}

 

考虑使用web.xml配置文件的原因：（解耦合）

Sun公司制定了规范；

Sun公司规定了webapp开发人员必须把web.xml放在规定的位置，必须使用规定的标签来描述url和类名之间的映射关系

Sun公司也规定了web服务器开发人员，就去这里读取web.xml，并读取web.xml中的规定的标签；

从而，实现了webapp开发人员和web服务器开发人员的解耦合

a）使用SAXReader，并使用三个Map，读取web.xml，最终将一个web.xml中的所有urlPattern <--> servletClassName保存进入ServletMap中

解析server.xml配置文件的类

package cn.huangyan.httpserver.core;

import java.io.File;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.io.SAXReader;

/*
 * 解析server.xml配置文件
 * */
public class ServerParser {

	/*
	 * 获取服务器的端口号
	 * @return int port
	 * */
	public static  int getPort() {
		
		// 设置服务器默认启动端口
		int port = 8080;
		
		try {
			// 创建解析器
			SAXReader saxReader = new SAXReader();
			
			// 通过解析器的read方法，将配置文件读取到内存中，生成一个Document[org.dom4j]对象树
			//Document document = saxReader.read("D:\\ecli_space\\workspace\\myday06\\src\\main\\resources\\conf\\server.xml");
			//Document document = saxReader.read("src/main/resources/conf/server.xml");
			/*
			 * File用在web项目中，路径最前面不以/开头时，则是以当前web项目为根目录
			 * */
			Document document = saxReader.read(new File("src/main/resources/conf/server.xml"));
			
			// 获取connector节点的路径：server -> service -> connector
			// 获取connector节点的xpath路径：/server/service/connector
			// 获取connector节点的xpath路径：server//connector
			// 获取connector节点的xpath路径：//connector
			Element connectorEle = (Element) document.selectSingleNode("//connector");
			
			// 获取port属性的值
			port = Integer.parseInt(connectorEle.attributeValue("port"));
			
		} catch (DocumentException e) {
			e.printStackTrace();
		}
		
		return port;
	}
}

a）涉及到File类在javaweb项目中，读取文件时路径书写的用法

 

客户端请求处理类

package cn.huangyan.httpserver.core;

import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.net.Socket;
import java.util.Map;

import javax.servlet.Servlet;
import javax.servlet.ServletRequest;

import org.huangyan.oa.servlet.LoginServlet;

import cn.huangyan.httpserver.util.Logger;

/*
 * 处理客户端请求
 * @version 1.0
 * @since 1.0
 * */
public class HandlerRequest implements Runnable {
	public Socket clientSocket;
	public HandlerRequest(Socket clientSocket) {
		this.clientSocket = clientSocket;
	}

	@Override
	public void run() {
		// 处理客户端请求

		BufferedReader br = null;
		Logger.log("httpserver thread: "+ Thread.currentThread().getName());;

		PrintWriter out = null;

		// 接收客户端消息
		try {
			br = new BufferedReader(new	InputStreamReader(clientSocket.getInputStream()));

			// 获取响应流对象
			out = new PrintWriter(clientSocket.getOutputStream());

			/*
			// 打印出全部，请求协议
			 * String temp = null; while((temp = br.readLine()) != null) {
			 * System.out.println(temp); }
			 */

			String requestLine = br.readLine(); // GET /oa/index.html HTTP/1.1
			String requestURI = requestLine.split(" ")[1];
			System.out.println("reqeustURI="+requestURI);

			// 判断用户请求是否为静态页面：以.html或者.htm后缀名的文件叫做HTML静态页面
			if(requestURI.endsWith(".html") || requestURI.endsWith(".htm")) {
				//处理静态页面的方法
				responseStaticPage(requestURI,out);
			}else {
				// 动态资源：java程序，业务处理类

				// requestURI：/oa/login?username=jack&password=123
				String servletPath = requestURI;
				if(servletPath.contains("?")) {
					servletPath = servletPath.split("\\?")[0]; // servletPath.split("[?]")[0]
				}
				System.out.println("servletPath="+servletPath);
				
				/*
				 * // 这里请求路径和LoginServlet在服务器程序中耦合了
				 *  if("/oa/login".equals(servletPath)) {
				 * 		LoginServlet loginServlet = new LoginServlet(); 
				 * 		loginServlet.service();
				 *  }
				 */

				// 获取应用的名称webAppName
				// webAppName: oa，在URI中：/oa/login
				String webAppName = servletPath.split("[/]")[1];
				System.out.println("webAppName="+webAppName); // oa
				
				// 获取servletMaps集合中的value值
				Map<String,String> servletMap = WebParser.servletMaps.get(webAppName);

				// 从uri：/oa/login 中获取到：/login
				String urlPattern = servletPath.substring(1+webAppName.length());

				String servletClassName = servletMap.get(urlPattern);

				try {
					if(servletClassName != null) {
						// 如果找到了动态资源
						
						// 封装请求对象
						ServletRequest request = new RequestObject(requestURI);
						
						// 封装响应对象
						ResponseObject response = new ResponseObject();
						response.setWriter(out);
						
						// 拼接响应信息
						out.print("HTTP/1.1 200 OK\n");
						out.print("Content-Type:text/html;charset=utf-8\n\n");
						
						
						/*
						 * 创建Servlet对象之前，先从Servlet缓存池中查找
						 * 1. 有，直接拿来用
						 * 2. 没有，创建Servlet对象，并放入缓存池中
						 * */
						Servlet servlet = ServletCache.get(urlPattern);
						if(servlet == null) {
							Class clazz = Class.forName(servletClassName);
							Object obj = clazz.newInstance();
							
							servlet = (Servlet)obj;
							
							// 将创建好的Servlet放入缓存池中
							ServletCache.put(urlPattern, servlet);
						}
						
						
						/*
						 * 服务器将out输出流对象，传递给webapp开发人员使用的service方法
						 * 从而webapp开发人员便可以拿着此out输出流对象，往页面写一些数据
						 * 
						 * 由于当前线程持有的是此out输出流对象
						 * 我们为了保证同处于当前线程的service()业务方法，也持有同样的out输出流对象，
						 * 则必须把此out输出流对象传递给service方法，而不能自己去service()业务方法中去new一个新的out对象
						 * 
						 * servlet.service(out);
						 * */
						
						Logger.log("Servlet对象是："+servlet);
						// 这个时候，服务器开发人员不知道如何调用servlet业务处理类里的业务方法
						// 这个时候，sun公司的servlet规范又出来了
						servlet.service(request,response);
						
					}else {
						// 404找不到动态资源
						StringBuilder html = new StringBuilder();
						html.append("HTTP/1.1 404 NotFound\n");
						html.append("Content-Type:text/html;charset=utf-8\n\n");
						html.append("<html>\r\n" + 	"<head>\r\n" + 	"<meta charset=\"UTF-8\">\r\n" + 
								"<title>404-错误</title>\r\n" + "</head>\r\n" + 
								"<body>\r\n" + 	"<center><font size=\"35xp\" color=\"red\">404-Not-Found</font></center>\r\n" + 
								"</body>\r\n" + "</html>");

						out.print(html);
					}
					
				} catch (ClassNotFoundException | InstantiationException | IllegalAccessException e) {
					e.printStackTrace();
				}

			}

			// 强制刷新（否则，浏览器无法显示）
			out.flush();

		} catch (IOException e) {
			e.printStackTrace();
		} finally {
			if(br != null) {
				try {
					br.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
			if(clientSocket != null) {
				try {
					clientSocket.close();
				} catch (IOException e) {
					e.printStackTrace();
				}
			}
		}

	}

	/* 处理静态页面
	 * requestURI 
	 * */
	public void responseStaticPage(String requestURI, PrintWriter out) {
		// requestURI: /oa/index.html
		// 静态页面路径：oa/index.html
		String htmlPath = requestURI.substring(1);

		BufferedReader br = null;

		try {
			// 读取页面
			br = new BufferedReader(new FileReader(htmlPath));
			String temp = null;
			StringBuilder html = new StringBuilder();

			// 拼接响应信息
			html.append("HTTP/1.1 200 OK\n");
			html.append("Content-Type:text/html;charset=utf-8\n\n");
			while((temp = br.readLine()) != null) {
				html.append(temp);
			}

			// 输出HTML
			out.print(html);

		} catch (FileNotFoundException e) {
			// 404找不到静态资源
			StringBuilder html = new StringBuilder();
			html.append("HTTP/1.1 404 NotFound\n");
			html.append("Content-Type:text/html;charset=utf-8\n\n");
			html.append("<html>\r\n" + 	"<head>\r\n" + 	"<meta charset=\"UTF-8\">\r\n" + 
					"<title>404-错误</title>\r\n" + "</head>\r\n" + 
					"<body>\r\n" + 	"<center><font size=\"35xp\" color=\"red\">404-Not-Found</font></center>\r\n" + 
					"</body>\r\n" + "</html>");

			out.print(html);
		}catch(IOException e) {
			e.printStackTrace();
		}


	}

}

a）客户端请求处理类又细分为两个部分：处理静态资源，处理请求的动态资源

b）如果处理的请求是请求动态资源，则涉及到在服务器代码中封装请求对象，封装响应对象，servlet缓存池

c）引出sun公司定义javax.servlet.Servlet接口的目的

Servlet缓存池

package cn.huangyan.httpserver.core;

import java.util.HashMap;
import java.util.Map;

import javax.servlet.Servlet;

/*
 * Servlet缓存池
 * */
public class ServletCache {

	private static Map<String,Servlet> servletMap = new HashMap<String,Servlet>();
	
	public static void put(String urlPattern , Servlet servlet) {
		servletMap.put(urlPattern, servlet);
	}
	
	public static Servlet get(String urlPattern) {
		return servletMap.get(urlPattern);
	}
}

javax.servlet.Servlet接口

package javax.servlet;

/*
 * 由sun公司指定的servlet接口规范，
 * 该接口由web服务器开发人员调用，由webapp开发人员来实现；
 * */
public interface Servlet {

	// 业务处理方法
	void service(ServletRequest request,ServletResponse response);
	
}

/*
 * import cn.huangyan.httpserver.core.ResponseObject;  
 * // 这个又出现一个问题，此ResponseObject是web服务器开发人员开发程序是自定义的
 * 
 * 
 * 由sun公司指定的servlet接口规范， 
  
  public interface Servlet {
      void service(ResponseObject response); 
  }
  
  	----------  这就出现了耦合的问题：
  	在sun公司开发的接口中出现了比如Tomcat公司自定义的ResponseObject类
  	----------  这时，就需要把sun公司和Tomcat公司再通过接口进行解耦合
  	定义ServletResponse接口
  	
 */

a）在sun公司的Servlet接口中出现了Tomcat公司自定义的Response类，这就又出现了耦合的问题

b）sun公司为了消除这种耦合，就又定义了ServletRequest接口和ServletResponse接口

请求对象接口

package javax.servlet;

/*
 * 负责封装请求参数的对象
 * */
public interface ServletRequest {
	
	// 获取单选框标参数的值
	public String getParametervalue(String key);

	// 获取多选框标参数的值
	public String[] getParametervalues(String key);
}

响应对象接口

package javax.servlet;

import java.io.PrintWriter;

/*
 * sun公司定义的：
 *   封装响应参数的接口规范
 * */
public interface ServletResponse {

	void setWriter(PrintWriter out);
	
	PrintWriter getWriter();
}

 

工具类

日期工具类

package cn.huangyan.httpserver.util;

import java.text.SimpleDateFormat;
import java.util.Date;

/* 日期工具类
 * @author huangyan
 * @version 1.0
 * #since 1.0
 * */
public class DateUtil {
	private static SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS");
	private DateUtil() {}
	
	/*
	 * 获取系统当前时间
	 * @return String [yyyy-MM-dd HH:mm:ss SSS]
	 * */
	public static String getCurrentTime() {
		return dateFormat.format(new Date());
	}
}

日志工具类

package cn.huangyan.httpserver.util;

import java.text.SimpleDateFormat;
import java.util.Date;

/*
 * 日志记录器
 * @author：huangyan
 * @version：1.0
 * */
public class Logger {
	
	// 工具类的方法往往是静态的，直接通过类名来调用，不需要创建对象；
	
	// 工具类的构造方法往往是私有的，但不是必须的；
	private Logger() {
		
	}
	
	public static void log(String msg) {
		/*
		 * SimpleDateFormat dataFormat = new
		 * SimpleDateFormat("yyyy-MM-dd HH:mm:ss SSS"); Date nowTime = new Date();
		 * String nowTimeStr = dataFormat.format(nowTime);
		 */
		System.out.println("[INFO] "+DateUtil.getCurrentTime()+" "+msg);
	}
}

 

业务处理类

登录的业务处理类

package org.huangyan.oa.servlet;

import java.io.PrintWriter;

import javax.servlet.Servlet;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

import cn.huangyan.httpserver.core.ResponseObject;

/*
 * 处理登录业务的java程序
 * 该java程序由webapp开发人员编写；由web服务器来调用
 * */
public class LoginServlet implements Servlet{

	@Override
	public void service(ServletRequest request,ServletResponse response) {
		System.out.println("login-service：正在执行身份验证...");	

		// 获取当前线程的输出流对象（也就是当前客户端socket对象对应的输出流对象）
		PrintWriter out = response.getWriter();

		out.append("<html>\r\n" + 	"<head>\r\n" + 	"<meta charset=\"UTF-8\">\r\n" + 
				"<title>404-错误</title>\r\n" + "</head>\r\n" + 
				"<body>\r\n" + 	"<center><font size=\"35xp\" color=\"blue\">正在执行身份验证...</font></center>\r\n" + 
				"</body>\r\n" + "</html>");

	}

	/*
	 * @Override public void service(ResponseObject response) {
	 * System.out.println("login-service：正在执行身份验证...");
	 * 
	 * // 获取当前线程的输出流对象（也就是当前客户端socket对象对应的输出流对象） PrintWriter out =
	 * response.getWriter();
	 * 
	 * out.append("<html>\r\n" + "<head>\r\n" + "<meta charset=\"UTF-8\">\r\n" +
	 * "<title>404-错误</title>\r\n" + "</head>\r\n" + "<body>\r\n" +
	 * "<center><font size=\"35xp\" color=\"blue\">正在执行身份验证...</font></center>\r\n"
	 * + "</body>\r\n" + "</html>"); }
	 */
}

用户保存的业务处理类

package org.huangyan.oa.servlet;

import java.io.PrintWriter;
import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;

import javax.servlet.Servlet;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

/*
 * 处理登录业务的java程序
 * 该java程序由webapp开发人员编写；由web服务器来调用
 * */
public class UserSaveServlet implements Servlet{

	@Override
	public void service(ServletRequest request,ServletResponse response ) {
		System.out.println("UserSaveServlet：正在执行用户保存");	
		
		String username = null;
		try {
			// 对传递过来的“%e6%96%b0%e5%bb%ba”，这种UTF-8编码的串，用UTF-8进行解码
			username = URLDecoder.decode(request.getParametervalue("username"),"UTF-8");
		} catch (UnsupportedEncodingException e) {
			e.printStackTrace();
		}
		String gender = request.getParametervalue("gender");
		String[] likes = request.getParametervalues("like");
		
		System.out.println("username="+username);
		
		PrintWriter out = response.getWriter();
		out.print("<html>\r\n" + 	"<head>\r\n" + 	"<meta charset=\"UTF-8\">\r\n" + 
				"<title>用户信息</title>\r\n" + "</head>\r\n" + 	"<body>\r\n"
				+"用户名："+username+ "<br>"
				+"性别："+gender+ "<br>"
				+"爱好："+likes[0]+" "+likes[1]+
				"</body>\r\n" + "</html>");
		
	}
	
//	public void service(ResponseObject response) {
//		System.out.println("UserSaveServlet：正在执行用户保存");		
//	}
}

web应用：oa

index.html

<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
<title>oa办公系统</title>
</head>
<body>
	<center><font size="35xp" color="blue">oa办公系统首页</font></center>
</body>
</html>

userSave.html

<!DOCTYPE html>
<html>
<head>
	<title>用户信息-保存用户信息</title>
	<meta content="text/html;charset=utf-8">
</head>
<body>
	<center>
		<form name="userForm" action="/oa/user/save" method="get">
			用户名：
				<input type="text" name="username"/><br><br>
				
			性&nbsp;&nbsp;别：
				<input type="radio" name="gender" value="1"/>男
				<input type="radio" name="gender" value="0"/>女
				<br><br>
				
			性&nbsp;&nbsp;别：
				<input type="checkbox" name="like" value="music"/>音乐
				<input type="checkbox" name="like" value="sport"/>运动
				<input type="checkbox" name="like" value="food"/>美食
				<input type="checkbox" name="like" value="sleep"/>睡觉
				<input type="checkbox" name="like" value="travel"/>旅行
				<br><br>
			
				<input type="submit" value="提交"/>
				<input type="reset" value="重置"/>
		</form>
	</center>
</body>
</html>

web.xml

<?xml version="1.0" encoding="UTF-8"?>
<web-app>
	
	<servlet>
		<servlet-name>LoginServlet</servlet-name>
		<servlet-class>org.huangyan.oa.servlet.LoginServlet</servlet-class>
	</servlet>
	<servlet-mapping>
		<servlet-name>LoginServlet</servlet-name>
		<url-pattern>/login</url-pattern>
	</servlet-mapping>
	
	
	<servlet>
		<servlet-name>UserSaveServlet</servlet-name>
		<servlet-class>org.huangyan.oa.servlet.UserSaveServlet</servlet-class>
	</servlet>
	<servlet-mapping>
		<servlet-name>UserSaveServlet</servlet-name>
		<url-pattern>/user/save</url-pattern>
	</servlet-mapping>
	
</web-app>

web应用：bank

actOpen.html

<html>
	<head>
		<title>银行帐户-开户</title>
		<meta content="text/html;charset=utf-8"/>
	</head>
	<body>
		<form name="actOpenForm" action="/bank/act/open" method="get">
			银行帐户：
				<input type="text" name="actno"/>
				<br><br>
			开户金额：
				<input type="text" name="balance"/>
				<br><br>
				<input type="submit" value="确认开户"/>
				<input type="reset" value="重置"/>
		</form>
	</body>
</html>

actTransfer.html

<html>
	<head>
		<title>银行帐户-转帐</title>
		<meta content="text/html;charset=utf-8"/>
	</head>
	<body>
		<form name="actTransferForm" action="/bank/act/transfer" method="get">
			转出帐号：
				<input type="text" name="actFrom"/>
				<br><br>
			转出金额：
				<input type="text" name="balance"/>
				<br><br>
			转入帐号：
				<input type="text" name="actTo"/>
				<br><br>
				<input type="submit" value="确认转帐"/>
				<input type="reset" value="重置"/>
		</form>
	</body>	
</html>

web.xml

<?xml version="1.0"	encoding="UTF-8"?>
<web-app>
	<servlet>
		<servlet-name>actOpenServlet</servlet-name>
		<servlet-class>org.bjpowernode.bank.servlet.ActOpenServlet</servlet-class>
	</servlet>
	<servlet-mapping>
		<servlet-name>actOpenServlet</servlet-name>
		<url-pattern>/act/open</url-pattern>
	</servlet-mapping>
	
	<servlet>
		<servlet-name>actTransferServlet</servlet-name>
		<servlet-class>org.bjpowernode.bank.servlet.ActTransferServlet</servlet-class>
	</servlet>
	<servlet-mapping>
		<servlet-name>actTransferServlet</servlet-name>
		<url-pattern>/act/transfer</url-pattern>
	</servlet-mapping>
</web-app>

开户的业务处理类

package org.bjpowernode.bank.servlet;

import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;

import javax.servlet.Servlet;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

public class ActOpenServlet implements Servlet {

	@Override
	public void service(ServletRequest request, ServletResponse response) {
		//-----------从页面获取参数值------------
		String actno = request.getParameterValue("actno");
		double balance = Double.parseDouble(request.getParameterValue("balance"));
		
		//---------------连接数据库-------------
		Connection conn = null;
		PreparedStatement ps = null;
		int count = 0;
		try {
			//1.注册驱动
			Class.forName("com.mysql.jdbc.Driver");
			//2.获取数据库连接对象
			conn = DriverManager.getConnection("jdbc:mysql://localhost:3366/bjpowernode", "root", "111");
			//3.定义SQL语句框架
			String sql = "insert into t_act(actno,balance) values(?,?)";
			//4.进行SQL语句预编译
			ps = conn.prepareStatement(sql);
			//5.进行赋值
			ps.setString(1, actno);
			ps.setDouble(2, balance);
			//6.执行SQL语句
			count = ps.executeUpdate();
		} catch (Exception e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}finally{
			//关闭资源
			if(ps != null){
				try {
					ps.close();
				} catch (SQLException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			if(conn != null){
				try {
					conn.close();
				} catch (SQLException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
		
		//获取响应流对象
		PrintWriter out = response.getWriter();
		if(count == 1){
			out.print("<html>");
			out.print("<head>");
			out.print("<title>银行帐户-开户结果</title>");
			out.print("<meta content='text/html;charset=utf-8'/>");
			out.print("</head>");
			out.print("<body>");
			out.print("<center><font size='35px' color='green'>恭喜您，开户成功！</font></center>");
			out.print("</body>");
			out.print("</html>");
		}else{
			out.print("<html>");
			out.print("<head>");
			out.print("<title>银行帐户-开户结果</title>");
			out.print("<meta content='text/html;charset=utf-8'/>");
			out.print("</head>");
			out.print("<body>");
			out.print("<center><font size='35px' color='red'>对不起，开户失败！</font></center>");
			out.print("</body>");
			out.print("</html>");
			
		}
	}

}

转账的业务处理类

package org.bjpowernode.bank.servlet;

import java.io.PrintWriter;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.SQLException;

import javax.servlet.Servlet;
import javax.servlet.ServletRequest;
import javax.servlet.ServletResponse;

public class ActTransferServlet implements Servlet {

	@Override
	public void service(ServletRequest request, ServletResponse response) {
		//------------获取页面请求的参数------------
		String actFrom = request.getParameterValue("actFrom");
		double balance = Double.parseDouble(request.getParameterValue("balance"));
		String actTo = request.getParameterValue("actTo");
		
		//-----------连接数据库---------------
		Connection conn = null;
		PreparedStatement ps = null;
		int count = 0;
		try {
			//1.注册驱动
			Class.forName("com.mysql.jdbc.Driver");
			//2.获取数据库连接
			String url = "jdbc:mysql://127.0.0.1:3366/bjpowernode";
			String user = "root";
			String password = "111";
			conn = DriverManager.getConnection(url, user, password);
			
			//开启事务，关闭自动提交
			conn.setAutoCommit(false);
			
			//3.定义SQL语句框架
			String sql_from = "update t_act set balance = balance - ? where actno = ?";
			//4.进行SQL语句的预编译
			ps = conn.prepareStatement(sql_from);
			//5.进行赋值
			ps.setDouble(1, balance);
			ps.setString(2, actFrom);
			//6.执行SQL语句
			count = ps.executeUpdate();
			
			
			String sql_to = "update t_act set balance = balance + ? where actno = ?";
			ps = conn.prepareStatement(sql_to);
			ps.setDouble(1, balance);
			ps.setString(2, actTo);
			count = count + ps.executeUpdate();
			
			//提交事务
			conn.commit();
		} catch (Exception e) {
			try {
				// 出现异常，则进行事务回滚
				conn.rollback();
			} catch (SQLException e1) {
				e1.printStackTrace();
			}
		}finally{
			//关闭资源
			if(ps != null){
				try {
					ps.close();
				} catch (SQLException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
			if(conn != null){
				try {
					conn.close();
				} catch (SQLException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}
			}
		}
		
		//获取响应流对象
		PrintWriter out = response.getWriter();
		if(count == 2){
			out.print("<html>");
			out.print("<head>");
			out.print("<title>银行帐户-转帐结果</title>");
			out.print("<meta content='text/html;charset=utf-8'/>");
			out.print("</head>");
			out.print("<body>");
			out.print("<center><font size='35px' color='green'>转帐成功！</font></center>");
			out.print("</body>");
			out.print("</html>");
		}else{
			out.print("<html>");
			out.print("<head>");
			out.print("<title>银行帐户-转帐结果</title>");
			out.print("<meta content='text/html;charset=utf-8'/>");
			out.print("</head>");
			out.print("<body>");
			out.print("<center><font size='35px' color='red'>转帐失败！</font></center>");
			out.print("</body>");
			out.print("</html>");
			
		}
	}

}