servlet入门

一.Servlet简介

1.什么是Servlet:

一个运行在WEB服务器上的小的Java程序（写Servlet就相当于写一个java程序），用来接收和响应从客户端发送过来的请求,通常使用HTTP协议.
Servlet就是SUN公司提供的一个动态网页开发技术
response，request

2.Servlet的作用:

先获得客户端浏览器发送的请求，做一些相应的处理，最后将请求处理的结果响应给浏览器

3.servlet运行原理

总结：Servlet作为补充Web服务器功能的组件,需要依赖于Servlet容器才能运行
过程：浏览器通过输入的IP地址和端口号来找到相对于的web服务器——
如果请求的是静态资源，就直接找到对应的html页面，返回给浏览器——
如果请求的是动态资源，web服务器的通信模块接收请求，将请求进一步传输给Servlet容器，Servlet容器负责创建Servlet实例，并且将请求的数据解析出来，解析出来之后Servlet容器再传给Servlet，在Servlet真正处理完数据之后，响应结果也是由Servlet容器的通信模板负责返回给web服务器端的，web服务器再将servlet返回的结果返回给浏览器，后续的servlet的管理和销毁也是由servlet容器来处理的。

4.servlet容器

Tomcat，weblogic等，这些servlet容器不仅仅具有管理servlet的功能，也具备了web服务器的功能，所以安装一个tomcat就可以具备servlet容器和web服务器的双重功能。

二.Servlet生命周期

1.阶段

Servlet生命周期的四个阶段的执行时机
阶段一:实例化调用Servlet的构造器创建一个具体的Servlet对象的过程
阶段二:初始化在初始化阶段, init ( )方法会被调用
阶段三:就绪Servlet被初始化后就处于能够响应请求的就绪状态, service(req,res)
阶段四:销毁Servlet容器停止或者重新启动都会引起销毁Servlet对象的动作destroy（）

2.HttpServlet抽象类

3.在java中如何编写Servlet

①.File–>New–>Web Project（servlet）

②.创建web包–>New–>Servlet–>LifeServlet.java,会自动实现Servlet接口或继承HttpServlet抽象类，覆盖service方法，再选中init（）and destroy（）方法。

package web;

import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class LifeServlet extends HttpServlet {
	//实例化，空的构造函数
	public LifeServlet() {
		System.out.println("第一阶段——实例化");
	}
	//初始化
	public void init() throws ServletException {
		System.out.println("第二阶段——初始化");
	}
	//就绪
	@Override
	protected void service(HttpServletRequest arg0, HttpServletResponse arg1)throws ServletException, IOException {
		System.out.println("第三阶段——就绪");
	}
	//销毁
	public void destroy() {
		System.out.println("第四阶段——销毁");
	}
}

③.WebRoot–>WEB-INF–>web.xml下配置servlet信息

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" 
	xmlns="http://java.sun.com/xml/ns/javaee" 
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
	http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
  <!--servlet配置-->
  <servlet>
  	<!--servlet的名称,随便起的-->
   	<servlet-name>LifeServlet</servlet-name>
   	<!--servlet的全路径,包.类-->
    <servlet-class>web.LifeServlet</servlet-class>
  </servlet>
  <!--servlet的映射-->
  <servlet-mapping>
  	<!--servlet的名称,对应上面servlet配置中的名称，大小写也要一致-->
    <servlet-name>LifeServlet</servlet-name>
    <!--servlet的具体访问路径-->
    <url-pattern>/life</url-pattern>
  </servlet-mapping>
</web-app>

④.部署项目到Tomcat中，每次修改servlet文件时要重新部署项目，修改web.xml会自动更新，不需要重新部署
Window–>Show View–>Servers
右击你的Tomcat 7.x–>Add Demployment–>选择Project–>Finish
解决每次修改servlet文件时都要重新部署项目的问题？
在tomcat安装目录下–>conf–>contect.xml–>设置<Context reloadable="true"> <Context >

⑤.启动tomcat
右击你的Tomcat7.x–>Run servers

⑥.访问项目
在浏览器中输入http://localhost:8080/项目名/servlet的具体访问路径，例如：http://localhost:8080/servlet/life。
第一次访问之后会直接调用生命周期的前三个阶段，第二次访问就只调用第三个阶段就绪

⑦.移除项目
右击servlet项目–>Remove Demployment
会调用最后一个销毁阶段。

4.web.xml的load-on-startup配置
<load-on-startup>1</load-on-startup>，配置在<servlet><servlet>标签中

作用：设置servlet是何时创建的
在web.xml中设置多个servlet，可使用load-on-startup指定servlet加载顺序，服务器会根据load-on-startup的大小依次对servlet进行初始化。不过即使我们将load-on-startup设置重复也不会出现异常，服务器会自己决定初始化顺序。

值：
设置>=0，说明servlet会在服务器启动之前被创建
即在服务器启动之前先执行一二阶段，在第一次浏览器访问时，servlet响应web请求，只调用第三阶段。
设置<=0或者不设置，说明servlet是在被浏览器解读的时候创建
即第一次用浏览器访问时会直接调用一二三阶段，之后再访问只调用第三阶段。
设置正数的值越小，启动servlet的优先级越高，时机越早

好处：
在开发web应用时，都会配置这个参数
1.如果初始化过程失败，容器会提示启动失败，我们能够提前知道相关错误。
2.相当于将初始化servlet的工作转移到容器启动，使得容器只要启动成功后，就可立即响应web请求。

5.web.xml的url-pattern配置

1.完全路径匹配：以/开始，例如: /life，/aaa/life，/aaa/bb/life
<url-pattern>/aa/life</url-pattern>可以通过http://localhost:8080/servlet/aa/life访问
2.目录匹配/通配符匹配：以/开始，以*结束，*代表匹配0个或多个字符，例如：/*，/aaa/*，/aaa/b/*
<url-pattern>/aa/*</url-pattern>通过http://localhost:8080/servlet/aa/a（abc）（写不写都可访问）
<url-pattern>/aa/bbb/*</url-pattern>通过http://localhost:8080/servlet/aa/bbb/a(随意,可不写)来访问
3.后缀匹配：*.任意后缀，目录匹配和后缀匹配不能混合使用，即不能以/开始
<url-pattern>*.do</url-pattern>通过http://localhost:8080/servlet/aa.do访问
<url-pattern>*.action</url-pattern>通过http://localhost:8080/servlet/.action访问
<url-pattern>/.do</url-pattern> <url-pattern>/aaa/bbb/.do</url-pattern>是不正确的
4.完全路径匹配>目录匹配>后缀匹配

6.web.xml的init-param

<init-param></init-param>配置初始化参数
<param-name></param-name>配置初始化参数名
<param-value></param-value>配置初始化参数值
<load-on-startup>必须放在<init-param>后

四.ServletConfig对象

1.作用：获得servlet配置信息
2.java中获得ServletConfig对象：ServletConfig cfg = getServletConfig()；
3.java中获取init-param参数值：
①.String getServletName()；–获得Servlet在web.xml中配置的name的值。
②.String getInitParameter(String name)；–获得Servlet的初始化参数的。
③.Enumeration getInitParameterNames()；—获得所有Servlet的初始化参数的名称。
④.String getServletContexto()；–获得servletContext对象

<?xml version="1.0" encoding="UTF-8"?>
<web-app version="2.5" 
	xmlns="http://java.sun.com/xml/ns/javaee" 
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
	http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd">
  <!--servlet配置-->
  <servlet>
  	<!--servlet的名称,随便起的-->
   	<servlet-name>LifeServlet</servlet-name>
   	<!--servlet的全路径,包.类-->
    <servlet-class>web.LifeServlet</servlet-class>
  	<!--设置初始化参数,可以同时设置多个参数值-->
  	<init-param>
  		<!--初始化参数的参数名-->
  		<param-name>company</param-name>
  		<param-value>keystone</param-value>
  		<!--初始化参数的参数值-->
  	</init-param>
  	<init-param>
  		<param-name>address</param-name>
  		<param-value>zz</param-value>
  	</init-param>
  	<!--设置servlet创建时期-->
  	<load-on-startup>1</load-on-startup>
  	<!---->
  </servlet>
  <!--servlet的映射-->
  <servlet-mapping>
  	<!--servlet的名称,对应上面servlet配置中的名称，大小写也要一致-->
    <servlet-name>LifeServlet</servlet-name>
    <!--servlet的具体访问路径-->
    <!--<url-pattern>/aa/life</url-pattern>-->
    <!--<url-pattern>/aa/ *</url-pattern>-->
    <url-pattern>*.bb</url-pattern>
  </servlet-mapping>
</web-app>

package web;
import java.io.IOException;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class LifeServlet extends HttpServlet {
	//实例化
	public LifeServlet() {
		System.out.println("第一阶段——实例化");
	}
	//初始化
	public void init() throws ServletException {
		System.out.println("第二阶段——初始化");
	}
	//就绪
	@Override
	protected void service(HttpServletRequest arg0, HttpServletResponse arg1)throws ServletException, IOException {
		System.out.println("第三阶段——就绪");
		//获得servletConfig对象,从而获取初始化参数
		ServletConfig config = getServletConfig();
		String company = config.getInitParameter("company");
		String address = config.getInitParameter("address");
		System.out.println("company:"+company+"  address:"+address);
	}
	//销毁
	public void destroy() {
		System.out.println("第四阶段——销毁");
	}
}

五.ServletRequest对象

1.子类：

httpServletRequest对象：浏览器发起请求，httpServletRequest对象接收参数，提交数据到服务器端

2.ServletRequest接收参数

String getParameter(String name)；用于接收一个名称对应一个值的数据.
String getParameterValues(String name)；用于接收一个名称对应多个值的数据.
Map getParameterMap()；于接收表单中的所有的数据,Map的key是表单提交的参数名称Map的value是提交参数的值.
Enumeration getParameterNamesO–用于获取表单中提交的所有的参数的名称

3.请求方式

get请求:在地址栏输入一个地址，超链接，表单的默认提交方式也是get请求.
post请求:将表单的Method属性设置为post时,浏览器会发送post请求
get和post的区别:
get的提交的参数会显示到地址栏上,而post不显示.
get往往是有大小限制的,而post没有大小的限制.
get没有请求体而post有请求体

六.ServletResponse对象

1.子类

httpServletResponse对象：服务器端接收完请求，返回数据给客户端，给客户端做出响应

2.setContentType()作用

①.通知容器,在调用out.println方法输出时,使用指定的字符集生成一个消息头( content-type) ,通知浏览器,服务器返回的数据类型和字符集

3.如何做出响应

获得输出流：PrintWriter out = response.getWriter()；
发送数据：out.println( “html代码”）；

4.乱码问题

产生原因:客户端编码与服务器端解码不一致
解决：
服务器端:request.setCharacterEncoding(“utf-8”)；
response.setContentType(“text/html；charset=utf-8”)；
客户端: <meta http-equiv= “content-type” content="text/html；charset=“utf-8”>

5.过程

在WebRoot下创建一个form.html来测试get和post请求，在浏览器输入http://localhost:8080/servlet/form.html
输入姓名和爱好，点提交，姓名和爱好会被提交到地址栏上，f12，Headers，Status Code（状态码）:200是成功，404是资源不存在，500是服务器内部出现错误，302是重定向，304是查找本地缓存，响应头，请求头，请求参数，post请求多了一个Content-type，用于解决编码问题

<!DOCTYPE html>
<html>
  <head>
    <title>form.html</title>
    //解决客户端乱码
    <meta http-equiv= "content-type" content="text/html;charset=utf-8">
  </head>
  <body>
  	<!--action设置为hello是提交路径，创建的servlet文件的访问路径就是/hello，提取姓名，爱好等数据到达HelloServlet.java中，HelloServlet是将提取的数据用request收集了一些数据并做出了输出-->
    <form action="hello" method="get/post">
    	姓名：<input type="text" name="username">
    	爱好：购物<input type="checkbox" name="habit" value="shopping"/>
    		钓鱼<input type="checkbox" name="habit" value="fishing"/>
    		游泳<input type="checkbox" name="habit" value="swiming"/><br/>
    	<input type="submit" value="提交">
    </form>
  </body>
</html>

在src的web包下创建一个servlet文件HelloServlet.java，不用写init和destory方法，还是继承.HttpServlet抽象类，点Next，将Servlet/JSP Mapping URL直接改成访问路径/hello，即web.xml的url-pattern，会直接在web.xml下生成servlet配置和servlet映射。

package web;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.Map;
import java.util.Map.Entry;
import java.util.Set;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class HelloServlet extends HttpServlet {
	@Override
	protected void service(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {
		//解决服务器端访问时的乱码问题,以utf-8来接收客户端数据
		request.setCharacterEncoding("utf-8");
		//根据参数名来获取参数值
		String username = request.getParameter("username");
		System.out.println(username);
		//根据参数名获取一组参数值
		String[] habits = request.getParameterValues("habit");
		for(String habit:habits){
			System.out.println(habit);
		}
		//接收表单所有的键值对参数
		Map<String, String[]> map = request.getParameterMap();
		Set<Entry<String, String[]>> entrySet = map.entrySet();
		for(Entry<String,String[]> entry:entrySet){
			System.out.println(entry.getKey()+":"+entry.getValue());
		}
		//解决服务器端返回一个页面时的乱码问题
		response.setContentType("text/html;charset=utf-8");
		//将获得的数据以输出流的形式用html页面响应给客户端(浏览器端)
		PrintWriter out = response.getWriter();
		out.println("<h1>"+"hello:"+username+"</h1>");
		//重定向到LifeServlet中，LiseServlet的url-pattern地址是/life
		//response.sendRedirect("life");
		//跳转到index.jsp中
		//response.sendRedirect("index.jsp");
		//跳转到百度中
		response.sendRedirect("http://baidu.com");	
	}
}

  <!--servlet配置-->
  <servlet>
    <servlet-name>HelloServlet</servlet-name>
    <servlet-class>web.HelloServlet</servlet-class>
  </servlet>
  <!--servlet的映射-->
    <servlet-mapping>
    <servlet-name>HelloServlet</servlet-name>
    <url-pattern>/hello</url-pattern>
  </servlet-mapping>

七.ServletContext对象

代表当前web应用,是一个全局的环境变量。
该应用中的任何组件,在任何时候都可以访问到该对象,所以Servlet上下文具有唯一性

1.作用范围:

整个web工程.

2.创建:

服务器启动的时候,tomcat服务器为每个web项目创建一个单独 ServletContext对象

3.销毁:

服务器关闭的时候,或者项目从服务器中移除的时候.

4.ServletContext的作用:

1.用来获得全局初始化参数: String getInitParameter(String name)；
2.用来获得上下文路径: String getContextPath()；
3.作为域对象存取数据: setAttribute(String，Object) getAttribute(String)
4.用来读取web项目下的资源文件: String getRealPath(String path)；

5.如何获得ServletContext对象

ServletContext sctx = getServletContext()；
1.通过GenericServlet提供的getServletContext() ；
2.通过ServletConfig提供的getServletContext()；
3.通过HttpSession提供的getServletContext() ；
4.通过FilterConfig提供的getServletContext()

6.全局初始化参数

<context-param>
	<param-name>account</param-name>
	<param-value>1000</param-value>
<context-param>

7.例子

创建AccountServlet.java的servlet文件使用servletContext对象记录浏览量

package web;
import java.io.IOException;
import java.io.PrintWriter;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class AccountServlet extends HttpServlet {
	@Override
	protected void service(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {
		//创建servletContext对象
		ServletContext context = getServletContext();
		//从作用域中获得值
		Integer account=(Integer)context.getAttribute("account");
		//判断account是否存在，若不存在说明是第一次访问servlet，就设置account为1
		if(account==null){
			//account= 1;
			//获得全局初始化参数
			String init = context.getInitParameter("account");
			int initaccount = Integer.parseInt(init);
			account=initaccount;
		}else{
			account++;
		}
		//将最新的访问量设置到servletContext对象的作用域中
		context.setAttribute("account", account);
		//使用response响应数据到浏览器
		response.setContentType("text/html;charset=utf-8");
		PrintWriter out = response.getWriter();
		out.println("<h1>访问量"+account+"</h1>");
		//关闭流
		out.close();
	}
}

在web.xml下加上以下数据

<!--设置全局servlet的初始化参数-->
<context-param>
	<param-name>account</param-name>
	<param-value>1000</param-value>
</context-param>
<!--设置AccountServlet.java的URL时自动生成的-->
<servlet>
    <servlet-name>AccountServlet</servlet-name>
    <servlet-class>web.AccountServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>AccountServlet</servlet-name>
    <url-pattern>/account</url-pattern>
</servlet-mapping>

八.Servlet与jdbc

1.使用jdbc访问数据库步骤

①.将JDBC驱动jar包和dbcp连接池jar包放到WEB-INF\lib下
原因: ClassLoader找到字节码文件,然后加载到JVM的方法区中,变成一个对象。Tomcat都有自己的类加载器,会去WEB-INF下面lib中找字节码文件。毕竟jar包中都是字节码文件。
②.编写JDBC代码,需要注意异常的处理

九.合并多个servlet

通过request.getRequestURI()方法获取请求资源路径
可以将所有操作请求处理合并到一个Servlet中,实现请求的分发
String action = uri.substring(uri.lastIndexOf( “/” )+ 1，uri.lastIndexOf( " . "))；
修改web.xml

<servlet-mapping>
	<servlet-name>actionServlet</servlet-name>
	<url-pattern>*.do</url-pattern>
</servlet-mapping>

sql语句，创建emp员工表，在src下创建sql包，创建文件emp.sql

create database mybase1;
create table emp(
	id int(4) primary key auto_increment,
	name varchar(20),
	salary double(7,2),
	age int(3)
);
insert into emp values(1,'zs',7000.0,22);
insert into emp values(2,'ls',8000.0,24);

emp实体类，src下创建enity包，创建emp.java类

package enity;

public class Emp {
	private Integer id;
	private String name;
	private Double salary;
	private Integer age;
	//添加set，get方法
	//添加有参构造函数
	//添加无参构造函数
	//重写toString方法
}

Jdbc连接池，src下创建conf包（存配置文件），创建dbcp.properties文件

driverClassName=com.mysql.jdbc.Driver
url=jdbc\:mysql\://localhost\:3306/mybase1
username=root
password=root123
initialSize=10
maxActive=50
maxId=20
minId=5
maxWait=60000
connectionProperties=useUnicode\=true;characterEncoding\=utf-8
defaultAutoCommit=true
defaultTransactionlsolation=READ_COMMITTED

处理结果集，在src下创建rowmapper包，创建RowMapper接口，再创建RowMapperImpl继承类

package rowmapper;

import java.sql.ResultSet;
public interface RowMapper<T> {
	//处理结果集
	public T mapperRow(ResultSet rs);
}

package rowmapper;

import java.sql.ResultSet;
import enity.Emp;

public class RowMapperImpl implements RowMapper {
	//处理结果集，并封装成对象
	@Override
	public Emp mapperRow(ResultSet rs) {
		Emp emp=new Emp();
		try {
			emp.setId(rs.getInt(1));
			emp.setName(rs.getString(2));
			emp.setSalary(rs.getDouble(3));
			emp.setAge(rs.getInt(4));
		} catch (Exception e) {
			e.printStackTrace();
		}
		return emp;
	}
}

封装jdbc加载驱动获取连接，src下创建util包（装工具类），创建JdbcUtil类

package util;

import java.io.IOException;
import java.io.InputStream;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.Properties;
import javax.sql.DataSource;
import org.apache.commons.dbcp.BasicDataSourceFactory;

public class JdbcUtil {
	static DataSource pool=null;
	static Properties pro=new Properties();
	private static ThreadLocal<Connection> tdl=new ThreadLocal<Connection>();
	static{
		InputStream is=null;
		try {
			is = JdbcUtil.class.getResourceAsStream("/conf/dbcp.properties");
			pro.load(is);
			pool=BasicDataSourceFactory.createDataSource(pro);
		} catch (Exception e) {
			e.printStackTrace();
		}finally{
			try {
				is.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}
	}
	public static Connection getConnection() throws Exception{
		Connection conn = tdl.get();
		if(conn==null){
			conn=pool.getConnection();
			tdl.set(conn);
		}
		return conn;
	}
	public static void release(ResultSet rs,PreparedStatement pstm,Connection conn) throws Exception{
		if(rs!=null) rs.close();
		if(pstm!=null) pstm.close();
		if(conn!=null){
			conn.close();
			tdl.remove();
		}
	}
}

封装jdbc增删改查操作，src下创建util包（装工具类），创建JdbcTemplate类

package util;

import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
import rowmapper.RowMapper;

public class JdbcTemplate<T> {
	Connection conn = null;
	PreparedStatement pstm =null;
	ResultSet rs=null;
	//查询一条结果
	public T queryForObject(String sql,RowMapper<T> rm,Object...args){
		T t=null;
		try {
			conn = JdbcUtil.getConnection();
			pstm = conn.prepareStatement(sql);
			if(args.length!=0){
				for(int i=0;i<args.length;i++){
					pstm.setObject(i+1, args[i]);
				}
			}
			rs = pstm.executeQuery();
			if(rs.next()){
				t=rm.mapperRow(rs);
			}
		} catch (Exception e) {
			System.out.println("JdbcTemplate1数据库连接出现异常");
		}finally{
			try {
				JdbcUtil.release(rs, pstm, conn);
			} catch (Exception e) {
				System.out.println("JdbcTemplate1释放资源出现异常");
			}
		}
		return t;
	}
	//查询多条结果
	public List<T> queryForList(String sql,RowMapper<T> rm,Object...args){
		List<T> list=null;
		try {
			conn = JdbcUtil.getConnection();
			pstm = conn.prepareStatement(sql);
			if(args.length!=0){
				for(int i=0;i<args.length;i++){
					pstm.setObject(i+1, args[i]);
				}
			}
			rs = pstm.executeQuery();
			list=new ArrayList();
			while(rs.next()){
				T t=rm.mapperRow(rs);
				list.add(t);
			}
		} catch (Exception e) {
			System.out.println("JdbcTemplate2数据库连接出现异常");
		}finally{
			try {
				JdbcUtil.release(rs, pstm, conn);
			} catch (Exception e) {
				System.out.println("JdbcTemplate2释放资源出现异常");
			}
		}
		return list;
		
	}
	
	//增删改操作
	//如果sql是完整的就不需要有参数，若sql是半成品args.length！=0则需要有参数，Object...args，是可变长参数，可以理解为数组，可以没有参数，也可以有一个两个三个参数
	public void update(String sql,Object...args){
		try {
			conn =JdbcUtil.getConnection();
			pstm = conn.prepareStatement(sql);
			if(args.length!=0){
				for(int i=0;i<args.length;i++){
					pstm.setObject(i+1, args[i]);
				}
			}
			pstm.executeUpdate();
		} catch (Exception e) {
			System.out.println("JdbcTemplate3数据库发生异常");
		}finally{
			try {
				JdbcUtil.release(null, pstm, conn);
			} catch (Exception e) {
				System.out.println("JdbcTemplate3释放资源出现异常");
			}
		}
	}
}

真正的直接来操作数据库，src下创建dao包，创建EmpDao接口，再创建EmpDaoIMpl实现类

package dao;

import java.util.List;
import enity.Emp;

public interface EmpDao {
	//查询所有员工信息
	public List<Emp> queryEmpAll();
	//添加员工信息
	public void addEmp(Emp emp);
	//根据想要修改的id，查询原有的信息
	public Emp queryEmpById(int id);
	//修改员工信息
	public void updateEmp(Emp emp);
	//通过id删除员工信息
	public void deleteEmp(int id);
}

package dao;

import java.util.List;
import rowmapper.RowMapperImpl;
import util.JdbcTemplate;
import enity.Emp;

public class EmpDaoImpl implements EmpDao {
	JdbcTemplate template=new JdbcTemplate();
	//查询所有员工信息
	@Override
	public List<Emp> queryEmpAll() {
		List<Emp> list = template.queryForList("select * from emp", new RowMapperImpl());
		return list;
	}
	//添加员工信息
	@Override
	public void addEmp(Emp emp) {
		template.update("insert into emp(id,name,salary,age) values(?,?,?,?)", emp.getId(),emp.getName(),emp.getSalary(),emp.getAge());
	}
	//根据想要修改的id，查询原有的信息
	@Override
	public Emp queryEmpById(int id) {
		Emp emp = (Emp)template.queryForObject("select * from emp where id=?", new RowMapperImpl(), id);
		return emp;
	}
	//修改员工信息
	@Override
	public void updateEmp(Emp emp) {
		template.update("update emp set name=?,salary=?,age=? where id=?", emp.getName(),emp.getSalary(),emp.getAge(),emp.getId());
	}
	//通过id删除员工信息
	@Override
	public void deleteEmp(int id) {
		template.update("delete from emp where id=?", id);
	}
	
}

WebRoot下创建addEmp.html用来写添加员工信息的页面

<!DOCTYPE html>
<html>
  <head>
    <title>addEmp.html</title>
	<meta http-equiv="content-type" content="text/html;charset=utf-8">
  </head>
  <body style="font-size:30px;text-align:center">
    <h1>添加员工</h1>
    <form method="post" action="addEmp.do">
    	姓名:<input type="text" name="name"/><br/>
    	薪水:<input type="text" name="salary"/><br/>
    	年龄:<input type="text" name="age"/><br/>
    	<input type="submit" value="提交">
    </form>
  </body>
</html>

真正实现jdbc与Servlet结合使用，src下创建web包，在创建ActionServlet的Servlet文件
怎样创建Servlet文件（不是类，虽然后缀都是.java），右击包–>New–>Other–>搜索Servlet

package web;
import java.io.IOException;
import java.io.PrintWriter;
import java.util.List;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import dao.EmpDao;
import dao.EmpDaoImpl;
import enity.Emp;

public class ActionServlet extends HttpServlet {
	@Override
	protected void service(HttpServletRequest request, HttpServletResponse response)throws ServletException, IOException {
		EmpDao empDao=new EmpDaoImpl();
		request.setCharacterEncoding("utf-8");
		response.setContentType("text/html;charset=utf-8");
		PrintWriter out = response.getWriter();
		//获取请求资源路径ems1/addEmp.do
		String url=request.getRequestURI();
		//切分URL地址，保留addEmp
		String uri=url.substring(url.lastIndexOf("/")+1,url.lastIndexOf("."));
		if(uri.equals("queryEmp")){
			//查询所有员工记录
			List<Emp> list=empDao.queryEmpAll();
			out.println("<table border='1' width='60%' cellspacing='0' cellpadding='0' align='center'>");
			out.println("<tr><td>ID</td><td>姓名</td><td>薪水</td><td>年龄</td><td>操作</td></tr>");
			for(Emp emp:list){
				out.println("<tr>");
				out.println("<td>"+emp.getId()+"</td>");
				out.println("<td>"+emp.getName()+"</td>");
				out.println("<td>"+emp.getSalary()+"</td>");
				out.println("<td>"+emp.getAge()+"</td>");
				//根据id删除员工
				out.println("<td><a href='deleteEmp.do?id="+emp.getId()+"' οnclick=\"return confirm('是否确定删除"+emp.getName()+"')\">删除</a>");
				out.println("&nbsp;&nbsp;");
				//根据id跳转到修改页面
				out.println("<a href='loadEmp.do?id="+emp.getId()+"'>修改</a></td>");
				out.println("</tr>");
			}
			out.println("</table>");
			out.println("<br/><br/>");
			//点击添加员工的超链接就直接跳转到addEmp.html的页面中，_blank打开一个新的网页
			out.println("<div style='text-align:center'><a href='addEmp.html' target='_blank'>添加员工</a></div>");
		}else if(uri.equals("loadEmp")){
			//根据id查询员工信息
			String id = request.getParameter("id");
			Emp emp=empDao.queryEmpById(Integer.parseInt(id));
			//将员工信息回显到一个修改表单页面
			out.println("<form method='post' action='updateEmp.do'>");
			out.println("<input type='hidden' name='id' value='"+emp.getId()+"'/>");
			out.println("<input type='text' name='name' value='"+emp.getName()+"'/><br/>");
			out.println("<input type='text' name='salary' value='"+emp.getSalary()+"'/><br/>");
			out.println("<input type='text' name='age' value='"+emp.getAge()+"'/><br/>");
			out.println("<input type='submit' value='提交'/>");
			out.println("</form>");
		}else if(uri.equals("updateEmp")){
			//修改
			//获得修改后的Emp信息
			String id=request.getParameter("id");
			String name = request.getParameter("name");
			String salary = request.getParameter("salary");
			String age = request.getParameter("age");
			Emp emp=new Emp(Integer.parseInt(id),name,Double.parseDouble(salary),Integer.parseInt(age));
			//修改用户信息
			empDao.updateEmp(emp);
			//修改成功后重定向到查询所有员工
			response.sendRedirect("queryEmp.do");
		}else if(uri.equals("addEmp")){
			//添加
			String name = request.getParameter("name");
			String salary=request.getParameter("salary");
			String age = request.getParameter("age");
			Emp emp=new Emp(null,name,Double.parseDouble(salary),Integer.parseInt(age));
			empDao.addEmp(emp);
			//添加成功，重定向到queryEmp
			response.sendRedirect("queryEmp.do");
		}else if(uri.equals("deleteEmp")){
			//通过id删除员工
			String id=request.getParameter("id");
			empDao.deleteEmp(Integer.parseInt(id));
			//删除成功后重定向到查询所有员工
			response.sendRedirect("queryEmp.do");
		}
	}
}