Java Web学习笔记（一）-优快云博客

本文介绍了JavaWeb的基础知识，包括JSP的基本元素如声明语句、脚本片段和表达式等，详细阐述了JSP指令元素如page指令、include指令和taglib指令的使用方法。此外，还介绍了JSP动作元素、内置对象以及JavaBean组件的应用。

Java Web学习笔记（一）

JSP声明语句以<%!作为开始，以%>作为结束，使用声明语句声明的变量为全局变量，也就是说如果有多个用户在执行此JSP页面时，将共享该变量。

JSP Scriptlets以<%作为开始，以%>作为结束，其中包含有效的符合java语法规则的java代码，在JSP Scriptlets中可以包含多个变量，语法。

JSP 表达式通过<%=开始，以%>结束，JSP表达式中的代码会首先执行，然后转换成字符串并显示到网页上。

JSP注释分为两类，一类为可以在客户端显示的注释，即HTML注释；一类是不能在客户端显示的注释，即JSP注释。HTML注释使用结束，JSP注释使用<%--开始，以--%>结束。

JSP指令元素：

page指令：主要用来设定JSP页面的全局属性，该配置将作用于整个JSP页面，甚至包括静态包含的文件。语法：

<%@ page 属性1 =“属性值1”属性2 =“属性值2”%>

language属性，主要用来声明所使用的脚本语言种类，目前只能使用java语言。<%@page language=“java”%>

extends属性，用来指定该JSP页面生成的Servlet是集成于哪个父类，设定是必须指定该类的全名，即报名加类名。一般很少使用。

import属性，指定导入的java包，不过有些包在JSP编译时就已经导入了，可以不再导入。默认的导入包如下：

java.lang.*; javax.servlet.*; javax.servlet.jsp.*; javax.servlet.http.*;如<%@page import="java.util.*"%>

session属性，指定该JSP页面中是否可以使用session对象。默认为true。<%@page session="true|false"%>

buffer属性，指定输出流是否具有缓冲区，以及设置缓冲区大小。none表示不具有缓冲功能，设置具体数据，表示缓冲区大小。

autoFlash属性，指定缓冲区是否自动进行强制输出。

isThreadSafe属性，指定该JSP文件是否支持多线程使用，默认为true。

info属性，用来设置该JSP文件的相关信息，可以是任何的信息字符串，并通过Servlet.getServletInfo方法来获取该信息。

errPage属性，用来设置如果当前JSP文件发生异常错误时，网页重新跳转到能够处理异常的JSP文件。<%@ page errPage="错误跳转的页面"%>

isErrorPage属性，用来指定该JSP文件是否为能够处理异常的JSP文件，默认为false。

contentType属性，用来指定该JSP文件MIME格式，以及网页编码格式。<%@ page contentType="text/html";charset="ISO-8859-1"%>

pageEncoding属性，用来指定网页的编码格式。

isELIgnored属性，指定该JSP文件是否支持EL表达式。

include指令

使用include指令包含文件，将会被包含的文件所执行的结果插入到JSP文件放置include指令的位置，只有当被包含的文件执行完成，该JSP文件才会恢复执行。<%@ include file="content.html"%>

taglib指令

用来声明此JSP文件使用了自定义的标签，同事引用所指定的标签库以及设置标签库的前缀。<%@ taglib uri="URIToTagLibrary" prefix = "tagPrefix"%>,其中uri属性用来指定标签库的存放位置，prefix属性用来指定该标签库使用的前缀。例如：

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %> 使用： <c:out value="Hello"></c:out>

JSP动作元素可以用来动态的包含文件、网页跳转以及使用JavaBean组件等等。<jsp:XXX>

第一类是于存取JavaBean有关的，包括三个动作元素：<jsp:useBean>、<jsp:setProperty>、<jsp:getProperty>

第二类是JSP基本动作元素，包括六个动作元素：<jsp:include>如果是静态文件，则单纯的加到JSP页面中不进行任何处理，如果包含动态文件，name先进行处理，然后将处理的结果加到JSP页面中。<jsp:include page="包含文件URL地址" flush="true|false">

<jsp:forward>用来转移用户的请求，使得用户的请求的页面从一个页面跳转到另一个页面。这种跳转为服务器段跳转，所以用户的地址栏不会发生任何的变化。<jsp: forward page="跳转文件URL地址">

<jsp:param>用来传递参数，一般与<jsp:include><jsp:forward>联合使用。例如：<jsp:include page="contentDemo.jsp"> <jsp:param name="age" value="19"></jsp:include>。contentDemo.jsp中：<% String strAge = request.getParameter("age")%>

<jsp:plugin><jsp:params><jsp:fallback>

第三类是JSP2.0新增的动作元素，主要与JSP document有关：<jsp:root><jsp:declaration><jsp:scriptlet><jsp:expression><jsp:text><jsp:output>

第四类，主要用来动态的生成XML元素标签的值：<jsp:attribute><jsp:body><jsp:element>

第五类，主要用来Tag File中：<jsp:invoke><jsp:doBody>

JSP内置对象，包括request、response、out、session等等。分类：1、与Servlet有关，page和config。2、与Input/Output有关，out、request和response。3、与Context有关，session、application和pageContext对象。4、与Error有关，exception。

简单的登陆成功失败例子：Login.jsp

<%@ page language="java"  import="java.util.*" pageEncoding="gb2312"%>	
<html>
  <head>
    <title>My JSP </title>
  </head>
  <body>
   <center>
   	<form action="LoginConfig.jsp" method="post">
   	<table>
   		<tr>
   			<td>用户名：</td>
   			<td><input type="text" name="username"></td>
   		</tr>
   		<tr>
   			<td>密  码</td>
   			<td><input type="password" name="userpassword"/></td>
   		</tr>
   		<tr>
   			<td colspan="2">
   			<input type="submit" value="登录"/>
   			<input type="reset" value="重置"/>
   			</td>
   		</tr>	
   	</table>	
   	</form>
   </center>
  </body>
</html>

LoginConfig.jsp

<%@ page language="java" pageEncoding="ISO-8859-1"%>
<html>
  <head>
        <title>My JSP 'LoginConfig.jsp'</title>
  </head>
  <body>
   	<center>
   		 <%
   			String username = request.getParameter("username");
   			String userpassword = request.getParameter("userpassword");
   		 %>
   		 <%
   		 	if("James".equals(username)&&"1234".equals(userpassword))
   		 	{
   		  %>
   		  <jsp:forward page="LoginSuccess.jsp" />
   		  <%
   		  }
   		  else{
   		   %>
   		   <jsp:forward page="LoginFailure.jsp" />
   		   <%} %>
   	</center>
  </body>
</html>

JSP和JavaBean

JavaBean是为java语言设计的软件组件模型，具有可重复使用和跨平台的特点。可以通过javabean来封装业务逻辑，进行数据库操作等。从而很好的实现业务逻辑和前后台程序的分离。Javabean其实就是一个简单的Java类，这也就意味着，Java类的一切特征，Javabean也都具有。Javabean同样可以使用封装、继承、多态等特性。Javabean可以分为两类，一类是有用户接口（UI）的Javabean，一类是没有用户接口的Javabean。一般在JSP中使用的都是没有用户接口的Javabean，这类JavaBean知识简单的进行业务封装，如数据运算和处理、数据库操作等。

一个标准的JavaBean应该具有如下几个特点。

1、JavaBean必须是一个公开的类，也就是说JavaBean的类访问权限必须是public的。

2、JavaBean必须具有一个无参数的构造方法。如果在JavaBean中定义了自定义的有参构造方法，则可以利用编译器自动添加的无参构造方法。

3、JavaBean一般将属性设置成私有的，通过使用getXXX()方法和setXXX()方法来进行属性的取得和设置。

要想在JSP中使用JavaBean，就需要使用到<jsp: useBean>动作指令，格式如下：

<jsp:useBean id="对象名称" scope="储存范围" class="类名"></jsp:useBean>

设置JavaBean属性：JSP中提供了一个<jsp:setProperty>动作指令来设置JavaBean属性，其有如下四种语法格式：

<jsp:setProperty name="实例化对象名"property="*" />

<jsp:setProperty name="实例化对象名"property="属性名称" />

<jsp:setProperty name="实例化对象名"property=" 属性名称 " param="参数名称"/>

<jsp:setProperty name="实例化对象名"property=" 属性名称 " param="参数名称" value="属性值"/>

UserForm.jsp例子中：

<form action="SetPropertyDemo.jsp" method="post">
    		<table>
    			<tr>
    				<td colspan="2">用户表单</td>
    			</tr>
    			<tr>
    				<td>用户名：</td>
    				<td><input type="text" name="username"/></td>
    			
    			</tr>
    			<tr>
    				<td>密   码：</td>
    				<td><input type="password" name="userpassword"/></td>
    			</tr>
    			<tr>
    				<td colspan="2"><input type="submit" value="提交"/><input type="reset" value="重置">
    				</td>
    			</tr>
    		</table>
    	</form>

SetPropertyDemo.jsp中

<body>
    <jsp:useBean id="user" scope="application" class="com.javaweb.ch07.UserBean"></jsp:useBean>
    <jsp:setProperty property="*" name="user"/>
    <%
    	out.println("用户名："+user.getUsername()+"<br>");
    	out.println("用户密码："+user.getUserpassword());
     %>
  </body>

com.javaweb.ch07包中UserBean.java

public class UserBean {
	private String username;
	private String userpassword;
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getUserpassword() {
		return userpassword;
	}
	public void setUserpassword(String userpassword) {
		this.userpassword = userpassword;
	}
}

EL表达式（Expression Language）

算术运算符，+-*、% 示例 ${1 +1}结果为2

关系运算符 ${1==1}或${1 eq 1} ${11=1}或${1 ne 1} ${1<2}或${1 lt 2} ${1> 2}或${1 gt 2} ${1<=2}或${1 le 2} ${1>=2}或${1 ge 2}

逻辑运算符 ${A && B}或${A and B} ${A || B}或${A or B} ${！A}或${not A}

条件运算符 ${A ? B : C}

EL提供了验证运算法empty，其对于验证数据特别有用，empty运算法采用单个表达式作为其变量即${empty input} ，并返回一个布尔值，该布尔值表示对表达式求值的结果是不是“空”值。求值结果为null的表达式被认为是空，如无元素的集合或数组。如果参数是对长度为零的String求值所得的结果，则empty运算法也将返回true。

JSTL标签库

JSTL标签库分为五类，分别是JSTL核心标签库、数据库标签库、I18N格式化标签库、XML标签库和JSTL函数标签库。

JSTL核心标签库：在JSP页面中要使用到核心标签，必须使用<%@ taglib %>指令，指定核心标签。代码如下：

<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>

JSTL提供了能方便定义变量的标签<c:set>，能够将变量存储在JSP反问中或者JavaBean属性中。

数据库标签库：在JSP中要使用SQL标签库，必须先使用<%@ taglib%>指定，代码如下：

<%@ taglib prefix="sql" uri="http://java.sun.com/jsp/jstl/sql"%>

<sql:setDataSource>标签设定数据源。语法格式：<sql:setDataSource url="jdbcUrl" driver="driverClassName" user="userName" password="password" [var="varName"][scope="{page|request|session|application}"]>

用JSTL连接mysql数据库示例：

<sql:setDataSource url="jdbc:mysql://localhost:3306/datainfo"
    	var="ds"
    	driver="com.mysql.jdbc.Driver"
    	user="root"
    	password="root"
    />
<sql:query var="comicinfo" dataSource="${ds}" sql="SELECT * FROM first" /> 
<table>
<c:forEach items="${comicinfo.rows}" var="row">
 <c:forEach items="${row}" var="column">
  <tr>
  	<td align="right">${column.key}</td>
  	<td align="left">${column.value}</td>
  </tr>
 </c:forEach>
</c:forEach>
</table>

I18N格式化标签库，代码如下：<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt"%>

XML标签库，主要分为三类：

1、XML核心操作，用来解析XML文件、显示XML文件中的信息。

2、XML流程控制操作，用来对XML中信息进行判断，循环操作。

3、XML转换操作，使用XML搭配XSLT显示在JSP页面上。

要想通过JSTL对XML进行操作还必须下载并安装“xalan.jar”和"serializer.jar"。如果没有安装该JAR文件的话，在进行XML操作时会出现错误提示。

SERVLET采用java代码直接编写，通过CGI的方式与Web server进行沟通，具有跨平台特性。

servlet其实就是一个java类，所以其创建方法和创建java类完全相同。所有的servlet类都必须继承HttpServlet类。

第一个servlet中：

public void doGet(HttpServletRequest request, HttpServletResponse response)
			throws ServletException, IOException {

		response.setContentType("text/html");
		PrintWriter out = response.getWriter();
		out.println("<!DOCTYPE HTML PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\">");
		out.println("<HTML>");
		out.println("  <HEAD><TITLE>A Servlet</TITLE></HEAD>");
		out.println("  <BODY>");
		out.print("    This is ");
		out.print(this.getClass());
		out.println(", using the GET method");
		out.println("  </BODY>");
		out.println("</HTML>");
		out.flush();
		out.close();
	}

在web.xml中配置：

<servlet>
    <servlet-name>FirstServlet</servlet-name>
    <servlet-class>com.javaweb.ch07.FirstServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>FirstServlet</servlet-name>
    <url-pattern>/servlet/FirstServlet</url-pattern>
  </servlet-mapping>

生命周期

1、生成servlet，加载到servlet engine中，并通过调用其init()方法来进行初始化。

2、通过提供的响应方法来处理客户端的请求。

3、调用destroy()方法进行销毁，通过垃圾回收器回收。

servlet与cgi的区别在于servlet处于服务器进程中，它通过多线程方式运行其service方法，一个实例可以服务于多个请求，并且其实例一般不会销毁，而CGI对每个请求都产生新的进程，服务完成后就销毁，所以效率上低于servlet。

HttpServlet接口包含非常多的方法，这些方法除了init()和destroy()方法用来处理Servlet初始化和销毁。还包括一些常用方法，如doGet方法、doPost方法以及Service方法等等。

doGet方法用来处理客户端浏览器直接访问和表单get方式提交的表单。

doPost方法用来处理表单post方式提交的表单，不能处理客户端浏览器直接访问。

service方法用来处理客户端浏览器直接访问和表单get方式提交的表单以及表单post方式提交的表单。servlet包含大量的接口，这些接口的应用和JSP中内置对象的应用非常类似。如Servlet中的HttpServletRequest接口和JSP内置对象的request对象。servlet中的HttpServletResponse接口和JSP内置对象的response对象。

HttpSession接口的使用和JSP内置对象的session对象非常类似。session对象就是HttpSession的一个实例。

ServletContext接口和JSP内置对象的application对象非常类似。在servlet中application对象必须通过HttpServlet接口的getServletContext方法。

Filter过滤器

功能 1、过滤非法文字和信息。

2、设置统一字符编码。

3、对用户进行登录验证。

4、改变图片文件格式。

5、对相应做压缩处理。

6、对XML的输出使用XSLT来进行转换。

filter生命周期

1、生成filter，并通过调用其init()方法来进行初始化

2、过滤用户请求，调用其doFilter()方法。

3、调用destroy()方法进行销毁，并通过垃圾收集器进行收集清理。

非法文字过滤器，首先通过filter类中doFilter()方法的request参数来获得客户端的输入。然后通过对输出的文字进行判断并进行处理，如替换该非法文字或者提示输出非法文字要求重新输出等等。最后通过chain的doFilter方法来调用下一个Filter，或者调用原始的JSP或者Servlet等其他内容。

字符编码过滤器，这时就不需要再每个JSP页面中添加设置参数字符编码格式代码了。

登录验证过滤器，这时就不需要再每个JSP页面中添加判断用户合法性验证的代码了。

Listener

ServletContext有关的-->ServletContextListener和HttpSessionListener.

HttpSession有关的-->HttpSessionListener、HttpSessionAttributeListener、HttpSessionBindingListener、HttpSessionActivationListener.

ServletRequest有关-->ServletRequestListener和ServletRequestAttributeListener.

DAO设计模式

属于J2EE数据层的操作。DAO包含几个重要部分：1、DAO接口2、DAO实现类3、DAO工厂类4、VO类5、数据库连接类

数据库连接类的主要功能是连接数据库并获得连接对象，以及关闭数据库。通过数据库连接类可以大大的渐变开发，在需要进行数据库连接时，只需创建该类的实例，并调用其中的方法就可以获得数据库连接对象和关闭数据库，不必再进行重复操作。

DAO设计模式举例：

DatabaseConnection数据库连接类：

package com.javaweb.ch08;
import java.sql.DriverManager;
import com.mysql.jdbc.Connection;
//主要功能就是连接数据库、关闭数据库
public class DatabaseConnection {
	//定义数据库驱动类
	private final String DBDRIVER = "com.mysql.jdbc.Driver";
	//定义数据库连接URL
	private final String DBURL = "jdbc:mysql://localhost:3306/javaweb";//最后的javaweb是数据库名
	//定义数据库连接用户名
	private final String DBUSER = "root";
	//定义数据库连接密码
	private final String DBPASSWORD = "root";
	//定义数据库连接对象
	private Connection conn = null;
	//构造方法，加载驱动
	public DatabaseConnection(){
		try {
			Class.forName(DBDRIVER);
			this.conn = (Connection) DriverManager.getConnection(DBURL, DBUSER,DBPASSWORD);
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
	//取得数据库连接
	public Connection getConnection(){
		return conn;
	}
	//关闭数据库连接
	public void close(){
		try {
			conn.close();
		} catch (Exception e) {
			e.printStackTrace();
		}
	}
}

VO类，是一个包含属性和表中字段完全对应的类。并在该类中提供setter和getter方法来设置并获得该类中的属性。

package com.javaweb.ch08;
public class User {
	//用户id
	private int userid;
	//用户姓名
	private String username;
	//用户密码
	private String password;	
	public int getUserid() {
		return userid;
	}
	public void setUserid(int userid) {
		this.userid = userid;
	}
	public String getUsername() {
		return username;
	}
	public void setUsername(String username) {
		this.username = username;
	}
	public String getPassword() {
		return password;
	}
	public void setPassword(String password) {
		this.password = password;
	}
}

DAO接口，DAO接口中定义了所有的用户的操作，如添加记录、删除记录以及查询记录等。不过因为是接口，所以仅仅是定义，需要子类来实现。

package com.javaweb.ch08;
import java.util.List;
//定义数据库操作方法
public interface UserDAO {
	//增加操作
	public void insert(User user) throws Exception;
	//修改操作
	public void update(User user) throws Exception;
	//删除操作
	public void delete(User user) throws Exception;
	//按ID查询操作
	public User queryById(int userid) throws Exception;
	//查询全部
	public List queryAll() throws Exception;
}

UserDAOImpl：

package com.javaweb.ch08;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
public class UserDAOImpl implements UserDAO {
	//删除操作
	public void delete(User user) throws Exception {
		String sql = "DELETE FROM user WHERE userid=?" ;
		PreparedStatement pstmt = null ;
		DatabaseConnection dbc = null ;
		// 下面是针对数据库的具体操作
		try{
			// 连接数据库
			dbc = new DatabaseConnection() ;
			pstmt = dbc.getConnection().prepareStatement(sql) ;			
			pstmt.setInt(1,user.getUserid()) ;
			// 进行数据库更新操作
			pstmt.executeUpdate() ;
			pstmt.close() ;
		}catch (Exception e){
			throw new Exception("操作出现异常") ;
		}
		finally{
			// 关闭数据库连接
			dbc.close() ;
		}
	}
	//增加操作
	public void insert(User user) throws Exception {
		String sql = "INSERT INTO user(username, password) VALUES(?, ?)";
		PreparedStatement pstmt = null;
		DatabaseConnection dbc = null;
		//下面是针对数据库的具体操作
		try {
			//连接数据库
			dbc = new DatabaseConnection();
			pstmt = dbc.getConnection().prepareStatement(sql);
			pstmt.setString(1, user.getUsername());
			pstmt.setString(2, user.getPassword());
			//运行数据库更新操作
			pstmt.executeUpdate();
			pstmt.close();
		} catch (Exception e) {
			throw new Exception("添加操作出现异常");
		}  finally{
			dbc.close();
		}
	}
	//查询全部
	public List<User> queryAll() throws Exception {
		List<User> all = new ArrayList<User>();
		String sql = "SELECT * FROM user ";
		PreparedStatement pstmt = null;
		DatabaseConnection dbc = null;
		//下面是针对数据库的具体操作
		try {
			//连接数据库
			dbc = new DatabaseConnection();
			pstmt = dbc.getConnection().prepareStatement(sql);
			//进行数据库查询操作
			ResultSet rs = pstmt.executeQuery();
			while(rs.next())
			{
				//查询出内容，之后将查询出的内容赋值给user对象
				User user = new User();
				user.setUserid(rs.getInt(1));
				user.setUsername(rs.getString(2));
				user.setPassword(rs.getString(3));
				//将查询出来的数据加入到List对象中
				all.add(user);
			}
			rs.close();
			pstmt.close();
		} catch (Exception e) {
			throw new Exception("操作出现异常");
		} finally{
			dbc.close();
		}
		return all;
	}
	//按ID查询操作
	public User queryById(int userid) throws Exception {
		User user = null;
		String sql = "SELECT * FROM user WHERE userid = ?";
		PreparedStatement pstmt = null;
		DatabaseConnection dbc = null;
		//下面是针对数据库的具体操作
		try {
			//连接数据库
			dbc = new DatabaseConnection();
			pstmt = dbc.getConnection().prepareStatement(sql);
			pstmt.setInt(1, userid);
			//运行数据库查询操作
			ResultSet rs = pstmt.executeQuery();
			if(rs.next())
			{
				//查询出内容，之后将查询出的内容赋值给user对象
				user = new User();
				user.setUserid(rs.getInt(1));
				user.setUsername(rs.getString(2));
				user.setPassword(rs.getString(3));
			}
			rs.close();
			pstmt.close();
		} catch (Exception e) {
			throw new Exception("按ID查询操作异常");
		} finally{
			dbc.close();
		}
		return user;
	}
	//修改操作
	public void update(User user) throws Exception {
		String sql = "UPDATE user SET username = ?, password = ? WHERE userid = ?";
		PreparedStatement pstmt = null;
		DatabaseConnection dbc = null;
		//下面是针对数据库的具体操作
		try {
			//连接数据库
			dbc = new DatabaseConnection();
			pstmt = dbc.getConnection().prepareStatement(sql);
			pstmt.setString(1, user.getUsername());
			pstmt.setString(2, user.getPassword());
			pstmt.setInt(3, user.getUserid());
			//运行数据库更新操作
			pstmt.executeUpdate();
			pstmt.close();
		} catch (Exception e) {
			throw new Exception("更新操作出现异常");
		} finally{
			dbc.close();
		}	
	}
}

DAO工厂类：

package com.javaweb.ch08;
public class DAOFactory {
	public static UserDAO getUserDAOInstance(){
		return new UserDAOImpl();
	}
}

AddUserDemo.jsp举例：

<%@ page language="java" import="com.javaweb.ch08.*" pageEncoding="gb2312"%>
<html>
  <head>
    <title>添加用户操作</title>
  </head>
  <body>
    <% 
    	//通过DAO工厂获得DAO实现类实例
    	UserDAO userDAO = DAOFactory.getUserDAOInstance();
    	UserDAO userDAO1 = new UserDAOImpl();
    	//设置需要添加的用户
    	User user = new User();
    	user.setUsername("dao");
    	user.setPassword("123");
    	userDAO.insert(user);
     %>
  </body>
</html>

MVC设计模式

1、模型部分，它是软件所处理问题逻辑在独立于外在显示内容和形式情况下的内在抽象，封装了问题的核心数据、逻辑和功能的计算关系，它独立于具体的界面表达和I/O操作。

2、视图部分，他是表示模型数据及逻辑关系和状态的信息及特定形式展示给用户。它从模型获得现实信息，对于相同的信息可以有多个不同的显示形式或视图。

3、控制器部分，它是用来处理用户与软件的交互操作的，其职责是控制提供模型中任何变化的传播，确保用户界面于模型间的对应联系；它接受用户的输入，将输入反馈给模型，进而实现对模型的计算控制，是使模型和视图协调工作的部件。通常一个视图具有一个控制器。

什么是model1和model2？

以前编写的那个登陆项目为例，那就是典型的使用model1模式开发的，整个web项目都是有JSP页面构成。其中登陆判断页LoginConf.jsp既要接受客户端的请求，还必须对其用户信息判断进行跳转。JSP页面既要负责显示还要负责控制，将控制逻辑和表现逻辑混在一起了。

model2是基于MVC架构的设计模式。JSP只用负责显示，而控制器则由servlet充当，模型有javabean充当。

使用MVC模式改进用户登录案例

使用MVC模式，那么控制器要使用servlet，具体的逻辑判断则交给业务逻辑组件来判断，而将业务逻辑组件判断的结果返回给servlet来判断并实现调整。

1、登录页面和以前一样,登录成功和失败也一样。

<form action="LoginConfig" method="post">
    		<table>
    			<tr>
    				<td>用户名：</td>
    				<td><input type="text" name="username"/></td>
    			</tr>
    			<tr>
    				<td>密   码：</td>
    				<td><input type="password" name="password"/></td>    			
    			</tr>
    			<tr>
    				<td colspan="2"><input type="submit" value="提交"/><input type="reset" value="重置">
    				</td>    			
    			</tr>
    		</table>
    	</form>

2、业务逻辑组件

LoginCheck.java

package com.javaweb.ch08;
public class LoginCheck {
	//判断是否为合法用户
	public boolean isLogin(String username,String password)
	{
		if("James".equals(username) && "1234".equals(password))
		{
			return true;
		}else{
			return false;
		}
	}
}

3、Servlet控制器部分

package com.javaweb.ch08;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;
public class LoginConfig extends HttpServlet {
	public void doGet(HttpServletRequest request, HttpServletResponse response)
	throws ServletException, IOException {
	//接受用户参数
	String username = request.getParameter("uname");
	String password = request.getParameter("upassword");
	//获得session对象
	HttpSession session = request.getSession();
	//new一个LoginCheck对象
	LoginCheck lc = new LoginCheck();
	//调用业务逻辑组件的判断功能来判断
	if(lc.isLogin(username,password)){
		//如果为合法用户，在request范围中添加属性login，其属性值为true，并跳转到登录成功页
		session.setAttribute("login", "true");
		request.getRequestDispatcher("Login_success.jsp").forward(request, response);
	}else{
		//如果非法用户跳转到登陆失败页
		request.getRequestDispatcher("Login_failure.jsp").forward(request, response);
	}
}
public void doPost(HttpServletRequest request, HttpServletResponse response)
	throws ServletException, IOException {
	doGet(request, response);
    }
}

Struts2基础

struts2是struts的下一代产品。struts2是以webwork为核心，采用拦截器的机制来处理用户的请求，可以使得业务逻辑控制器能够与servlet API完全的脱离开。首先下载struts2框架，到官网下载压缩文件。将解压文件下lib文件夹下的common-loggin-1.0.4.jar、freemarker-2.3.8.jar、struts2-core-2.0.11.1.jar、xwork-2.0.4.jar和ognl-2.6.11.jar类库拷贝到web项目的WEB-INF/lib目录下。这些库文件是构建struts2应用的必须库文件，如果要使用struts2的更多功能，还需要拷贝更多的JAR.

编辑web项目中的web.xml，增加struts2核心filter配置：

        <filter>
		<filter-name>struts2</filter-name>
		<filter-class>org.apache.struts2.dispatcher.FilterDispatcher</filter-class>
	</filter>
	
	<filter-mapping>
		<filter-name>struts2</filter-name>
		<url-pattern>/*</url-pattern>
	</filter-mapping>

Struts有如下的主要功能：

1、包含一个controller servlet，能将用户的请求发送到相应的Action对象。

2、JSP自由tag库，并且在controller servlet中提供关联支持，帮助开发员创建交互式表单应用。

3、提供了一系列实用对象：XML处理、通过Java reflection APIs自动处理JavaBeans属性、国际化的提示和消息。

基于struts2的登陆案例

应用struts标签的login.jsp登陆界面：

<%@page contentType="text/html;charset=gb2312"%>
<%@taglib prefix="s" uri="/struts-tags"%>
<html>
<head>
	<title>用户登录</title>
</head>
<body>
<center>
	<h2>用户登录</h2>
	<%--登录表单,提交到login.action--%>
	<s:form action="login">
		<%-- 用户名输入框 --%>
		<s:textfield name="uname" label="用户名"></s:textfield>
		<%-- 密码输入框 --%>
		<s:password name="upassword" label="密码"></s:password >
		<%-- 登陆按钮 --%>
		<s:submit value="登陆"></s:submit>
		<%-- 重置按钮 --%>
		<s:reset value="重置"></s:reset>
	</s:form>
</center>
</body>
</html>

在国际化中上面的login界面写成如下形式：

<%@page contentType="text/html;charset=gb2312"%>
<%@taglib prefix="s" uri="/struts-tags"%>
<html>
<head>
	<title><s:text name="login.title"></s:text></title>
</head>
<body>
<center>
	<s:text name="login.title"></s:text>
	<%--登录表单--%>
	<s:form action="login">
		<s:textfield name="uname" key="login.username"></s:textfield>
		<s:password name="upassword" key="login.password"></s:password>
		<s:submit value="登录"></s:submit>
		<s:reset value="重置"></s:reset>
	</s:form>
</center>
</body>

LoginCheck.java

package com.javaweb.ch15;
public class LoginCheck {
	//判断是否为合法用户
	public boolean isLogin(String name,String password){
		if("James".equals(name)&&"123456".equals(password)){
			return true;
		}else{
			return false;
		}
	}	
}

LoginAction.java

package com.javaweb.ch15.action;
import com.javaweb.ch15.LoginCheck;
public class LoginAction2 implements Action{
	private String uname;
	private String upassword;	
	//获得uname值
	public String getUname() {
		return uname;
	}	
	//设置uname值
	public void setUname(String uname) {
		this.uname = uname;
	}	
	//获得password值
	public String getUpassword() {
		return upassword;
	}	
	//设置password值
	public void setUpassword(String upassword) {
		this.upassword = upassword;
	}	
	public String execute() throws Exception {
		//new一个LoginCheck对象
		LoginCheck lc = new LoginCheck();
		//调用业务逻辑组件的判断功能来判断
		if(lc.isLogin(getUname(),getUpassword())){
			//如果为合法用户，在session范围中添加属性login，其属性值为true，
			ActionContext.getContext().getSession().put("login", "true");
			return SUCCESS;
		}else{			
			return ERROR;
		}
	}
}

国际化

package com.javaweb.ch15.action;
import com.javaweb.ch15.LoginCheck;
import com.opensymphony.xwork2.ActionContext;
import com.opensymphony.xwork2.ActionSupport;
public class LoginAction3  extends ActionSupport {
	private String uname;
	private String upassword;	
	//获得uname值
	public String getUname() {
		return uname;
	}	
	//设置uname值
	public void setUname(String uname) {
		this.uname = uname;
	}	
	//获得password值
	public String getUpassword() {
		return upassword;
	}	
	//设置password值
	public void setUpassword(String upassword) {
		this.upassword = upassword;
	}
	//执行输入校验
	public void validate() {
		//如果用户名为null，或者为空的话，那么提示错误信息
		if(getUname() == null || "".equals(getUname().trim())){
			this.addFieldError("uname", this.getText("username.required"));
		}		
		//如果密码为null，或者为空的话，那么提示错误信息
		if(getUpassword() == null || "".equals(getUpassword().trim())){
			this.addFieldError("upassword", this.getText("password.required"));
		}
	}
	public String execute() throws Exception {
		//new一个LoginCheck对象
		LoginCheck lc = new LoginCheck();
		//调用业务逻辑组件的判断功能来判断
		if(lc.isLogin(getUname(),getUpassword())){
			//如果为合法用户，在session范围中添加属性login，其属性值为true，
			ActionContext.getContext().getSession().put("login", "true");
			return "success";
		}else{			
			return "failure";
		}
	}
}

messageResource_en_US.properties：

login.title    = login
login.password = password
login.username = username
password.required = password is requested
username.required = username is requested

messageResource_zh_CN.properties：

login.password = \u5BC6\u7801
login.title    = \u767B\u5F55
login.username = \u7528\u6237\u540D
password.required = \u5BC6\u7801\u5FC5\u987B\u8F93\u5165
username.required = \u7528\u6237\u540D\u5FC5\u987B\u8F93\u5165