Servlet开发-----基础及MVC设计模式

一、Servlet介绍

 

Servlet本身只是普通的Java类，只有当容器为他创建了ServletConfig和ServletContext时才成为了一个Servlet；

 

Servlet简单的说就是一个Java程序，目的和Javabean差不多，为了使得JSP页面中代码简洁、清晰；

JavaBean不需要配置，只需要放在WEB-INF/classes中即可；

Servlet也是放在 WEB-INF/classes/中，并在web.xml中配置如下形式：

 

 

[html]  view plain  copy

 

1. <servlet>  
2. <servlet-name></servlet-name>  
3. <servlet-class></servlet-class>  
4. </servlet>  
5. <servlet-mapping>  
6. <servlet-name></servlet-name>  
7. <url-pattern></url-pattern>  
8. </servlet-mapping>  

 

 

如果需要设置配置信息，则需要形式如下：

 

[html]  view plain  copy

 

1. <servlet>  
2. <servlet-name></servlet-name>  
3. <servlet-class></servlet-class>  
4. <init-param>  
5. <param-name></param-name>  
6. <param-value></param-value>  
7. </init-param>  
8.   
9. </servlet>  
10. <servlet-mapping>  
11. <servlet-name></servlet-name>  
12. <url-pattern></url-pattern>  
13. </servlet-mapping>  

 

注意：在url-pattern中，主目录为："/"，而不是"\"！

 

Servlet可以处理客户端传来的请求，即request，并且可以返回给客户端回应，即response，这个操作通过

(1)public void service(ServletRequest req,ServletResponse resp)throws ServletExeption,IOException{}

(2)public void doGet(HttpServletRequest req,HttpServletResponse resp)throws ServletExeption,IOException{}

(3)public void doPost(HttpServletRequest req,HttpServletResponse resp)throws ServletExeption,IOException{}

完成；

这里需要注意的是service的参数只是ServletRequest，而其他两个函数的参数是HttpServletRequest；

一般如果我们要自定义Servlet，则需要继承HttpServlet类，并覆盖相应的方法即可；

 

二、Servlet的结构

 

注意：

(1) 一个Servlet类只有一个实例；

(2)一个Servlet类只会调用一次init()方法；

(3)Servlet的一生都是由Web容器所控制，即Web容器调用Servlet类的方法；

(4)Servlet如果没有Web容器，就是一个普通的Java类；

 

Servlet生命周期为：加载-->初始化--->服务--->销毁--->卸载;

加载：web容器加载Servlet，即创建一个Servlet实例；

初始化：调用servlet的init方法，为了完成一些预备动作；

当请求到来时，

服务：创建一个request、response对象，并创建一个线程，调用类service方法；

销毁：调用destroy()方法；当一个Servlet对象长时间不使用或web容器（tomcat）关闭时调用；

卸载：即退出；

继承HttpServlet后，可以覆写以下方法：

1.public void init(ServletConfig config)throws ServletException{}     //初始化Servlet，（1）当需要使用Servlet时调用；（2）如果在web.xml中配置，则可以web容器启动时自动加载；配置如下：

 

[html]  view plain  copy

 

1. <serlvet>  
2.     <serlvet-name></servlet-name>  
3.     <servlet-class></servlet-class>  
4.     <load-on-startup>1</load-on-startup>  
5. </servlet>  

 

 

2.public void init(ServletConfig config)throws ServletExeption{} //初始化Servlet，可以得到配置信息

3.public void doGet(HttpServletRequest req,HttpServletResponse resp)throws ServletExeption,IOException{} 当get方式传递，则调用此方法

4.public void doPost(HttpServletRequest req,HttpServletResponse resp)throws ServletExeption,IOException{}当post方法传递，则调用此方法

5.public void service(HttpServletRequest req,HttpServletResponse resp)throws ServletExeption,IOException{}

6.public void destroy(){}   //销毁时调用

注意：

1.   当1，2同时出现时，2有较高优先级；

2.   当3或4和5同时出现时，5具有较高优先级；

3   .PrintWriter writer = resp.getWriter();可以获得输出流；

注意：writer输出时需要输出HTML结构；

 

三、Servlet常见问题

 

1.在init方法中，通过config.getInitParameter()方法取得配置信息；

2.req.getSession()：取得Session对象;

3.super.getServletContext();取得application对象；因为GenericServlet中有getServletContext方法；

4.resp.getWriter()返回一个PrintWriter用以输出文本数据、resp.getOutputStream()输出二进制数据，并且两者不能同时调用；

5.在init(ServletConfig config)方法中需要调用super.init(config);

6. 在service()方法中getServletConfig()返回 ServletConfig;

 

 

四、Servlet跳转

 

1.客户端跳转：resp.sendRedirect("1.jsp") ;    //类似于内置对象中的跳转；

2.服务器跳转：req.getRequestDispatcher("/hello.jsp").forward(req,resp);能够跳转到hello.jsp中；     

注意：客户端跳转和服务器端跳转的区别；

注意：这里的getRequestDispatcher中的网页一定要加“  /    ”   

 

五、MVC设计模式

JAVA WEB中，有两种设计模式：

（1）MODE 1: DAO;

（2）MODE 2: MVC;

 

在之前我们讲过JSP+JAVABEAN的DAO开发模式，这个适用于小型开发；

MVC最早是由SmallTalk提出的；

Controller: Servlet 负责接收客户请求并转发给Model；

Model ：JavaBean  负责真正处理业务逻辑；

View：JSP 负责输出结果；

 

EJB(Enterprise JavaBean);

MVC（Model View Control）是一种以Servlet为核心的开发模式，流程如下：

 

 

 

步骤如下：

1.客户端发送请求给Servlet；

2.Servlet接收请求后处理，并可以调用JavaBean（即进行数据库操作，并返回结果）；

3.Servlet返回结果给JSP显示；（通过设置request属性后调用RequestDispatcher方法跳转，并在JSP页面中接收request属性）;

因此JSP只是用于显示，而JavaBean只和Servlet通信；

注意：在MVC中，使用requestDispatcher的机会很多，我们都是通过这个类进行服务器跳转的；

 

六、MVC实例

 

功能：登录功能

1.JavaBean部分

User.java

 

[java]  view plain  copy

 

1. package org.vo;  
2. public class User{  
3.     private String id;  
4.     private String name;  
5.     private String password;  
6.     public String getId(){  
7.         return id;  
8.     }  
9.     public void setId(String id){  
10.         this.id = id;  
11.     }  
12.     public String getName(){  
13.         return name;  
14.     }  
15.     public void setName(String name){  
16.         this.name = name;  
17.     }  
18.     public void setPassword(String password){  
19.         this.password = password;  
20.     }  
21.     public String getPassword(){  
22.         return password;  
23.     }  
24. }  

IUserDAO.java

 

 

[java]  view plain  copy

 

1. package org.dao;  
2. import org.vo.*;  
3. public interface IUserDAO{  
4.     public boolean findLogin(User user)throws Exception;  
5. }  

 

 

UserDAOImpl.java

[java]  view plain  copy

 

1. package org.dao.impl;  
2. import java.sql.*;  
3. import org.vo.*;  
4. import org.dao.*;  
5. public class UserDAOImpl implements IUserDAO{  
6.     private Connection con;  
7.     public UserDAOImpl(Connection con){  
8.         this.con = con;  
9.     }  
10.     public boolean findLogin(User user)throws Exception{  
11.         boolean flag = false;  
12.         String sql = "SELECT name FROM user WHERE id=? AND password=?";  
13.         PreparedStatement stat = con.prepareStatement(sql);  
14.         stat.setString(1,user.getId());  
15.         stat.setString(2,user.getPassword());  
16.         ResultSet rs = stat.executeQuery();  
17.         if(rs.next()){  
18.             user.setName(rs.getString(1));  
19.             flag = true;  
20.         }  
21.         return flag;  
22.     }  
23. }  

UserDAOProxy.java

 

[java]  view plain  copy

 

1. package org.dao.proxy;  
2. import org.dao.*;  
3. import org.vo.*;  
4. import org.dao.impl.*;  
5. import org.dbc.*;  
6. public class UserDAOProxy implements IUserDAO{  
7.     private DatabaseConnection dbc;  
8.     private IUserDAO idao;  
9.     public UserDAOProxy(){  
10.         dbc = new DatabaseConnection();  
11.         idao = new UserDAOImpl(dbc.getConnection());  
12.     }  
13.     public boolean findLogin(User user)throws Exception{  
14.         if(user==null){  
15.             return false;  
16.         }  
17.         boolean flag = idao.findLogin(user);  
18.         dbc.close();  
19.         return flag;  
20.     }  
21. }  

DatabaseConnection.java

 

 

[java]  view plain  copy

 

1. package org.dbc;  
2. import java.sql.*;  
3. public class DatabaseConnection{  
4.     public static final String DRIVER = "com.mysql.jdbc.Driver";  
5.     public static final String URL = "jdbc:mysql://localhost:3306/mldn";  
6.     public static final String USER = "root";  
7.     public static final String PASS = "123456";  
8.     private Connection con;  
9.     public DatabaseConnection(){  
10.         try{  
11.             Class.forName(DRIVER);  
12.             con = DriverManager.getConnection(URL,USER,PASS);  
13.         }  
14.         catch(Exception e){}  
15.     }  
16.     public Connection getConnection(){  
17.         return con;  
18.     }  
19.     public void close(){  
20.         try{  
21.             if(con!=null){  
22.                 con.close();  
23.             }  
24.         }  
25.         catch(Exception e){}  
26.     }  
27. }  

DAOFactory.java

 

 

[java]  view plain  copy

 

1. package org.factory;  
2. import org.dao.*;  
3. import org.dao.proxy.*;  
4. public class DAOFactory{  
5.     public static IUserDAO getInstance(){  
6.         return new UserDAOProxy();  
7.     }  
8. }  

以上代码是JavaBean部分；MVC的特点是用Servlet调用JavaBean，而不是JSP调用JavaBean；

 

 

2.Servlet部分

 

以下是Servlet部分：Servlet是接收客户端请求，并调用JavaBean进行数据库操作；并把结果通过设置request属性传给JSP进行显示；（贯穿核心）

LoginServlet.java

 

[java]  view plain  copy

 

1. package org.servlet;  
2. import java.util.*;  
3. import javax.servlet.*;  
4. import javax.servlet.http.*;  
5. import org.factory.*;  
6. import org.vo.*;  
7. import java.io.*;  
8. public class LoginServlet extends HttpServlet{  
9.     public void doGet(HttpServletRequest req,HttpServletResponse resp)throws ServletException,IOException{  
10.         String path = "login.jsp";  
11.         String id = req.getParameter("id");  
12.         String pass = req.getParameter("pass");  
13.         List<String> info = new ArrayList<String>();  
14.         if(id==null||"".equals(id)){  
15.             info.add("id不能为空");  
16.         }  
17.         if(pass==null||"".equals(pass)){  
18.             info.add("密码不能为空");  
19.         }  
20.         if(info.size()==0){  
21.             User user = new User();  
22.             user.setId(id);  
23.             user.setPassword(pass);  
24.             try{  
25.                 if(DAOFactory.getInstance().findLogin(user)==true){  
26.                     info.add("欢迎光临");  
27.                 }  
28.                 else{  
29.                     info.add("错误的用户名和密码");  
30.                 }  
31.             }  
32.             catch(Exception e){}  
33.         }  
34.         req.setAttribute("info",info);  
35.         req.getRequestDispatcher(path).forward(req,resp);  
36.     }  
37.     public void doPost(HttpServletRequest req,HttpServletResponse resp)throws ServletException,IOException{  
38.         this.doGet(req,resp);  
39.     }  
40. }  

Login.jsp

 

 

[java]  view plain  copy

 

1. <%@page contentType="text/html" pageEncoding="GBK" import="java.util.*"%>  
2. <html>  
3.     <head>  
4.         <title>A</title>  
5.     </head>  
6.     <script language="Javascript">  
7.         function validate(f){  
8.             if(!(/^\w{5,15}$/.test(f.id.value))){  
9.                 alert("id长度不对");  
10.                 f.id.focus();  
11.                 return false;  
12.             }  
13.             if(!(/^\w{5,15}$/.test(f.pass.value))){  
14.                 alert("密码长度不对");  
15.                 f.pass.focus();  
16.                 return false;  
17.             }  
18.             return true;  
19.         }  
20.     </script>  
21.     <body>  
22.         <h2>用户登录程序</h2>  
23.         <%  
24.             request.setCharacterEncoding("GBK");  
25.             List<String> info = (List<String>)request.getAttribute("info");  
26.             if(info!=null){  
27.                 Iterator<String>iter = info.iterator();  
28.                 while(iter.hasNext()){  
29.         %>  
30.                     <h4><%=iter.next()%></h4>  
31.         <%  
32.                 }  
33.             }  
34.         %>  
35.         <form action="LoginServlet" method="post" onSubmit="return validate(this)">  
36.         用户ID：<input type="text" name="id"/><br />  
37.         密码：<input type="password" name="pass"/><br />  
38.         <input type="submit" value="提交"/>  
39.         </form>  
40.     </body>  
41. </html>  

数据库脚本：

 

 

[java]  view plain  copy

 

1. CREATE TABLE user(  
2.     id      varchar(30) PRIMARY KEY,  
3.     name        varchar(30) ,  
4.     password    varchar(30)  
5. );  
6. INSERT INTO user VALUES('XIAZDONG','xiazdong','12345');  

 

 

因此最后再强调一下Mode1和Mode2的区别：

Mode1是通过JSP调用JavaBean；Mode2是通过Servlet调用JavaBean；

Mode1在JSP中仍然有处理的部分，而Mode2中JSP只负责显示；

 

补充：Servlet调用过程顺序图 

 

 

 

ServletContext介绍

 

ServletContext对象在web服务器启动时创建，即在服务器启动时，为每个web应用创建一个ServletContext;

 

1.获得途径： this.getServletContext() 可以取得 ServletContext 对象;

2.获得web应用的初始化参数： context.getInitParameter("...");

在web.xml中通过类似：

[html]  view plain  copy

 

1. <context-param>  
2.     <param-name></param-name>  
3.     <param-value></param-value>  
4.   </context-param>  

配置;

3.转发

[java]  view plain  copy

 

1. context.getRequestDispatcher("/1.html").forward(request,response);  

4.获取资源文件数据： 

[java]  view plain  copy

 

1. InputStream in = context.getResourceAsStream("*.properties");  
2. Properties props = new Properties();  
3. props.load(in);  

 

补充：web开发中地址书写问题

 

地址书写时常用到“/”开头，而“/”有两个宗旨：

1.面向浏览器，则"/"表示http://localhost:8080/

2.面向服务器，则"/"表示当前web应用；

面向浏览器的意思是：是否会让浏览器地址栏改变；其余的都是面向服务器；

 

 

在Servlet开发中会在以下几种情况下存在地址书写问题：

1. request.getRequestDispatcher("地址A");
2.response.sendRedirect("地址B")；

3.this.getServletContext().getRealPath("地址C");

4.this.getServletContext().getResourceAsStream("地址D")；

5.<a href="地址E">

6.<form action="地址F">

 

地址A：转发不会使浏览器地址栏改变，因此是面向服务器的，“/”表示当前web应用；

地址B：重定向会使浏览器地址栏改变，因此是面向浏览器的；

同样分析，得出结果：

A、C、D属于面向服务器；

B、E、F属于面向浏览器；

 

补充：在提供客户发出请求之前的过程

1.从web.xml中读出Servlet初始化参数和上下文初始化参数；

2.创建一个ServletConfig对象和ServletContext对象；

3.将Servlet初始化参数的引用赋给ServletConfig对象，把上下文初始化参数赋值给ServletContext对象；

4.创建ServletContextListener监听器实例；

5.调用contextInitialized()方法；

6.创建这个Servlet实例；

7.调用init方法；

 

注意：

(1)在Servlet构造函数中还没有ServletConfig对象，虽然能够调用getServletConfig()方法；

(2)ServletConfig对象在Servlet实例创建之前就已经创建；

(3)web.xml的初始化参数只会读一次，如果需要更新，则需要重新部署；

 

 

 

上下文初始化参数：整个web应用都能够访问的初始化参数；

<context-param>

    <param-name>name</param-name>

    <param-value>value</param-value>

</context-param>

 

getServletContext().getInitParameter("name")即可；

 

每个Servlet有一个ServletConfig，每个web应用有一个ServletContext；

 

如果web应用时分布式的，则每个JVM都有一个ServletContext；

 

 

注意：getAttribute()返回的是Object；

Person  p = getServletContext().getAttribute("person");是错误的！！！！！！！！！！！！！！！！！！！！！

Person  p = (Person)getServletContext().getAttribute("person");是正确的；