[Java_Web] Servlet / Jsp - Learning Notes

*** Servlet / Jsp  -  Learning Notes.  ***
前言@00
 @1, Apache 是 C 语言写的。最纯净的版本只能跑 HTML。装插件能跑 PHP。
      Tomcat 是 java 语言写的，是 servlet 和 jsp 的容器。
 @2, 动态网页 ： 同一页面可以展现不同的东西。
 @3, Servlet 一般在容器中运行。
    **  解释 ：它提供的服务是什么呢？ 为什么要在容器中呢？ {
            因为 Servlet API 为 Servlet 提供了统一的编程接口，由容器来调用这些接口，{                   
              1, tomcat 是一个 web server (一般会占用 80 端口)
              2, tomcat 是一个容器
            } catalina start == startup.bat
			  catalina stop  == shutdown.bat
		JAVA_HOME = D:\Java\jdk1.7;
	> cataline debug
	> run
 @4, 应用服务器 / WEB服务器 / Servlet-Jsp 的容器 的区别？
   IIS    ： 应用服务器 (它可以跑 EJB 的组件，后台能跑一些应用程序)
   Apache ： WEB 服务器, Apache 默认放一些静态网页。
   Tomcat :  严格来讲叫做 Servlet/Jsp 容器，(它不能跑EJB)
 @5, tomcat : 提供的 Web 管理后台不好用。
     Host 是 Engine 的虚拟主机, 一个 Engine 可以配置多个 Host (理解为域名)。
     每个 web app 有一个 context.xml, reload = true. 监控 web app 的相应目录。
     http 明文，其实这时你可以用软件抓住局域网的包。可以看到别人的用户名密码。
 @6,  200(ok!) - 403(禁止) - 404(找不到) - 500(服务器内部错误)
    HTTP 用于从 WWW 服务器 传输超文本到本地浏览器的传输协议。
    HTTP 协议是以 TCP/IP 协议为基础的高层协议。
	现在广泛使用的版本是 HTTP/1.1 (可持续链接), 下面程序体现了 web server 内部给我们提供的方便之处。屏蔽！
	public class TestHTTP { // 协议规定，先说什么，后说什么。
		public static void main(String[] args) throws Exception {
			Socket s = new Socket("127.0.0.1", 8888);
			BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(s.getOutputStream()));
			bw.write("GET / HTTP/1.1");   /***  "/" 根目录下的文件  ***/
			bw.newLine();
			bw.write("Host: 127.0.0.1:8888"); /** 因为一个IP可以对应多个域名，所以这里写域名。**/
			bw.newLine();
			bw.write("Content-Type: text/html");
			bw.newLine();
			bw.newLine();
			bw.flush();
			BufferedReader br = new BufferedReader(new InputStreamReader(s.getInputStream()));
			String str = null;
			while((str = br.readLine()) != null) {
				System.out.println(str);
			}
			bw.close();
			br.close();
			s.close(); } }
 @7, web.xml 的灵活配置 conf 下的 context.xml 配置自动 reload = true.
    <servlet>
      <servlet-name>myfirstservlet</servlet-name>
      <servlet-class>HelloWorldServlet</servlet-class>
    </servlet>
	<servlet-mapping>
        <servlet-name>myfirstservlet</servlet-name>
        <url-pattern>/HWST</url-pattern>
    </servlet-mapping>
    此时在浏览器中访问 ： http://127.0.0.1:8888/my/HWST   servlet = class + web.xml
 @8, Tools 的使用！ @ 张志宇
     05_HelloWorldServlet_3  张志宇 这个视频讲解了 ：
       如何将本地 javadocs 连接到 eclipse 中的方法。F1出现自己设置的很好了。
     06_SERVLET声明周期  张志宇 开头讲解到了 ： 
       如何解决 自动生成 override 方法参数 arg0 而不是 req 的方法。并且F3可以自己带源码。
----------------------------------------------------------------------------------------
Know@01  ** Servlet 的生命周期 **
 * 生命全过程 ：
	   加载       ClassLoader
	   实例化     new 对象
	   初始化     init(ServletConfig)
	    处理请求s   service doGet doPos
	   退出服务   destroy()
 * Servlet 为客户端提供服务的过程当中 ：只有一个Servlet对象,当客户端的第一次请求过来的时候。
 * 过程 ：init() 只执行一次，第一次初始化的时候。
    tomcat 具有线程池，多线程处理多请求。每个线程访问的都是同一个 Servlet 对象。
  public void init (ServletConfig config) throws ServletException
  service()
  public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException
  public void destroy() webapps 退出的时候，停止的时候。就是对象在内存中消失的时候。
    示例程序 ： TestLifeCycleServlet.java
 @1-1 : tomcat 调用 servlet 的流程
	Interface Servle {
		All Known Subinterfaces:   HttpJspPage, JspPage 
		All Known Implementing Classes: 
			GenericServlet, HttpServlet, FacesServlet
	  Method 之一 :
		void service(ServletRequest req, ServletResponse res) 
			Called by the servlet container to allow the servlet to respond to a request. 
	}
	Class GenericServlet {
		abstract void service(ServletRequest req, ServletResponse res) 
			Called by the servlet container to allow the servlet to respond to a request. 
	}
	Class HttpServlet {
	  protected void service(HttpServletRequest req, HttpServletResponse resp) 
		  Receives standard HTTP requests from the public service method and dispatches them to the doXXX. 
	  void service(ServletRequest req, ServletResponse res) 
		  Dispatches client requests to the protected service method. 
	}
	-------- 以上为 tomcat 调用 servlet 的流程。----------
	地址栏直接敲地址 或者 用 form 表单的get提交，都是get方式。
	protected void doGet(HttpServletRequest req, HttpServletResponse resp) 
		throws ServletException, IOException, 这如果不写，就不叫做方法的重载。别手敲，容易错。
 @1-2 配置 web.xml 细节
	 <url-pattern>/HelloWorldServlet</url-pattern> 
	    解答 : 这个 " / " 代表 web app 的访问路径 http://127.0.0.1:8888/my/
	 <servlet-class>com.bjsxt.test.HelloWorldServlet</servlet-class>
	    解答 ： 这是告诉 tomcat 去哪里找 这个类，所以写全包名。
 @1-3 Interface ServletConfig 【Servlet上下文】
          All Known Implementing Classes: GenericServlet, HttpServlet
	init() 只执行一次，第一次初始化的时候。。。
	ServletConfig 初始化Servlet的时候，他会告诉这个Servlet你的配置，我是怎么样配你的
	我是怎么把你给配起来的，怎么配起来的，你想一想，就在
    <servlet>
      <servlet-name>TestLifeCycleServlet</servlet-name>
      ......  TestLifeCycleServlet.java
   所以 ServletConfig 在这个对象里面保存着我们对于这个 Servlet 的配置信息.
 @1-4  Servlet 编程接口
  * GenericServlet 是所有 Servlet 的鼻祖 (在类的层次上) 在接口层次上 Servlet 是鼻祖
  * 用于 HTTP 的 Servlet 编程都通过继承 javax.servlet.http.HttpServlet 实现
  * 请求处理方法： (分别对应 http 协议的7种请求)
     1. doGet    响应Get请求，常用
     2. doPost   响应Post请求，常用
   * 实例的个数 : 在非分布式的情况下，通常一个Servlet在服务器中有一个实例 
	protected void doGet(HttpServletRequest req, HttpServletResponse resp)
	HttpServletRequest req  封装了客户端到服务器端的参数值
	doGet() 这个方法是给 Container 调用的。
	 那么当然是由 Container 来负责把你这个形参的值的实参传过来
	  形参要求的是 Interface HttpServletRequest 这个接口
	   那么传递进来的肯定是实现了这个接口的类对象,实现了这个接口就可以调用这个接口的方法！
 @1-5 Tools / video 记录
	2013-12-24
	一、多行注释快捷键
	1.选中你要加注释的区域，用ctrl+shift+C 或者ctrl+/ 会加上//注释
	2.先把你要注释的东西选中，用shit+ctrl+/ 会加上/*    */注释
	3.以上快捷键在重复按一下就会去掉加上的注释
	 07_SERVLET为什么有2个init方法 张志宇精辟解释阅读 tomcat 源码
	 utf-8 一个汉字三个字节表示+
	 09_SERVLET如何从上一个页面取得参数_02
-------------------------------------------------------------------
Know@02 : Servlet 如何从上一个页面取得参数 (08, 09, 10)
   示例程序 ： TestInitServlet.java    ThreeParams.java
   ShowParameters.htm
	  <input type="password" name="cardNum"><BR>
	  Repeat Credit Card Number:
	  <input type="password" name="cardNum"><BR><BR>
  @1, 如何取得具有同一个名字的多个 input 的值？
    解决法1 ：
  		Enumeration paramNames = request.getParameterNames(); // 取得所有参数名字放入枚举容器中。
		while (paramNames.hasMoreElements()) {
			String paramName = (String) paramNames.nextElement();
			String[] paramValues = request.getParameterValues(paramName);
	    但是 Enumeration 是一个比较老的接口了。
	解决法2 ： 
		Map<String, String[]> paramMap = request.getParameterMap();
		Set<Map.Entry<String, String[]> > entries = paramMap.entrySet(); 
		for(Iterator<Map.Entry<String, String[]>> it = entries.iterator(); it.hasNext(); ) {
			Map.Entry<String, String[]> entry = it.next();
			String paramName = entry.getKey();
			out.print("<TR><TD>" + paramName + "\n<TD>");
			String[] paramValues = entry.getValue();			
----------------------------------------------------------------------------------------------
Know@03   Cookie 与 Session 
 * http 协议的无连接性要求出现一种保存 C / S 间状态的机制.
     (借你100W，防止忘，我在你脑门贴个小纸条，下次看到你，我就想起来了。)
 * Cookie: 保存到客户端的一个文本文件，与特定客户相关
 * Cookie 以 "名 - 值 对" 的形式保存数据
 * 创建 Cookie: new Cookie     在客户端记录东西 叫做 Cookie
	  1). 服务器端可以往客户端这边写内容 (Cookie 适合锦上添花)
	  2). 只能是文本内容
	  3). 在客户端这边可以选择阻止对方来写东西
	  4). 只能拿自己的webapp写入的东西
	  5). 每个浏览器有一个独一无二的编号
	     服务器端通过 cookie 可以区分是广州的客户端还是美国的客户端...
 Session , Session 是一个篮子
  只要是同一套有父子关系的窗口，都可以访问到同一个 Session。
  启发 ：默认 session 是依赖 cookie 的。若cookie完全禁用后解决方案 ： 重写URL。
  新浪邮箱 ： 做学问不严谨。不像IBM等这样的大公司。
  	+ "<a href=" + response.encodeURL(request.getRequestURL().toString()) + ">test</a><BR>" 
	+ "<a href=" + request.getRequestURI().toString() + ">test</a>" 
   china-pub买书，例如 ： 最近浏览的列表，一般是写cookie里面了。
Know@04   ServletContext (Servlet上下文)
  ServletContext Servlet 上下文，指的就是 Servlet 怎么和它的运行环境打交道。
  Servlet 所处的是什么环境呢？其实是tomcat。
  ServletContext application = this.getServletContext();
  application 这个篮子比Session大。webapp 下所有的 servlet 访问的都是这同一个篮子。
  示例程序 : TestServletContext.java
Know@05   Servlet 如何连接数据库
	bbs.sql
	create database bbs;
	use bbs;
	set names gbk; -- 解决乱码问题
	drop table if exists article;
	示例程序 : ShowRs.java
Know@06   在Servlet中使用 Java_Bean
	广义javabean = 普通java类
	狭义javabean = 符合Sun JavaBean标准的类 
	         (为了在图形化界面编程的组件可以捞来捞去而提出的javabean的概念，按标准规则来写)
	在Servlet中使用Bean和在通常程序中使用Bean类似
		*1), 属性名称第一个字母必须小写，一般private，比如：private productId
		*2), 一般具有getters and setters
		*3), 要具有一个参数为空的构造方法
		*4), 但Bean不应具有GUI表现
		*5), 一般是用来实现某一业务逻辑或取得特定结果
	将数据库操作封装成一个类DB (非常好的思路，但是这个还封装得不够好)。
	 示例 : ShowRsUseBean.java
      java适合做中间件，但是不太适合开发图形化的程序，但是也有用开发的。
Know@07 总结 ： 掌握Servlet
  (1), 创建Servlet
		从HttpServlet继承
		重写doGet / doPost方法
		在web.xml中配置
  (2), servlet生命周期
  (3), Cookie / Session / Application的概念
  (4), 请求转发
  (5), 使用javabean
------------------------------------------------------------------------
17 JSP -- (推出原因 : Servlet写标签非常麻烦！)
JSP@01 
 JSP简介
  (1), JSP---Java Server Pages
  (2), 拥有 servlet 的特性与优点(本身就是一个 servlet )
  (3), 直接在 HTML 中内嵌 JSP 代码
  (4), JSP 程序由 JSP Engine 先将它转换成 Servlet 代码，接着将它编译成类文件载入执行
         只有当客户端第一次请求 JSP 时，才需要将其转换、编译
  JSP中可直接嵌入 java 代码。
  http://127.0.0.1:8888/docs/
  http://127.0.0.1:8888/docs/api/index.html 联网才能看到文档
  JSP 看起来不像 html, 所以推出 JSTL(jsp2.0) - JSF(jsp3.0), sun一向情愿的想法。
JSP@02   
 JSP编程—基本语法
  JSP传统语法
	Declaration
	Scriptlet
	Expressionz
	Comment
	Directives
	Action动作指令
	内置对象
 (1), JSP编程---Declaration
   基本语法 ： <%!  %>
   说明：在此声明的变量、方法都会被保留成唯一的一份，直到 JSP 程序停止执行.(成员变量,不是局部)
    例 ：<%!
           int i;
           public void setName(){… …}
         %>
		 示例程序 : AccessCounts.jsp
  (2), Scriptlet
	基本语法 ：<% 程序代码区 %>
	可以放入任何的 Java 程序代码
	例： <%
	        for (int i = 0; i < 10; i++) {
		        … …
	        }
	     %>
	其他 ： 程序猿经常与 IE 缓存做斗争。
            html的注释，无法阻止java jsp代码<%%>的执行，但是不会在html的浏览器中显示
            <%%> 是在服务端执行的java代码。
    HttpJspBase
  (3), 表达式
	基本语法 ： <%= … … %>
	=后面必须是字符串变量或者可以被转换成字符串的表达式
	不需要以;结束
	只有一行
	例：
	<%=“hello world”%>
	<%=i+1%>
	<%=request.getParameter(“name”)%>  示例程序 ： Expressions.jsp
  (4), Directive (编译指令)相当于在编译期间的命令
    格式 ： <%@Directive 属性=“属性值”%>
    常见的Directive：
       *1, page
       *2, include
       *3, taglib
	**1), Directive--page
		指明与JSP Container 的沟通方式
		基本格式：
		<%@page language=“script language”|  -- 默认就是 java
			extends=“className”|             -- 基本用不上
			import=“importList”|             -- 很好, 可以用
			buffer=“none|kb size”|   --none:不缓冲，默认8k
			session=“true|false”|   --是否可以使用session，默认true
			autoFlush=“true|false”  --缓冲器是否自动清除，默认true
			isThreadSafe=“true|false”|  --默认false(永远不要设成true)
			errorPage=“errorPageUrl”|
			isErrorPage=“true|false”|
			contentType=“contentTyepInfo” | pageEncoding=“gb2312” 很好！
			  相当于这句话 (response.setContentType("text/html;charset=gb2312");)
		%>
    示例程序 : TestDirective.jsp
		<%@page import="java.util.*" session="false"%>
		<%@page contentType="text/html;charset=gb2312"%>
		<%= new Date() %>
		<%
			out.println("你好!");
		%>
JSP@03  JSP-静态,动态包含
  @3-1  静态包含
       TestBar.jsp  TitleBar.jsp  两个合在一起生成一个servlet class, 
       但是 TitleBar.jsp(被包含页面)这样无法传参数，因为编译之前传参数无意义。	
  @3—2  动态包含
       被包含的 request 对象比包含的 request 对象能取出的东西还要多点。分别产生两个class可以传参数，怎么传，怎么取都可以。
			包含页面 ： date.jsp 源码如下 ：
			  <%@ page import="java.util.*" %>
			  <%= (new Date()).toLocaleString() %>
			  <%= request.getParameter("user") %>	
    (1), 被包含页面 可以取得 包含页面(主页面)传递的参数 http://127.0.0.1:8888/my/include/include.jsp?user=456789
	(2), 包含页面与被包含页面的 request 是不同的。不是同一对象。虽然不是一个对象，但是可以看成是。设计成这样，是因为为了Action可以传递参数.
    (3), include.jsp 中 <jsp:include page="date.jsp？dept=80" flush="true"/> 在date.jsp中可以把dept取出来。
	     在包含页面传递的参数，被包含页面也可以将其取出。静态包含则不允许。
	总结 ： 只要当前页面能取到的参数，date.jsp页面也可以取到。包含页面传的参数下一页面(date.jsp)还能取到。
	        被包含的页面，request对象要大一些。	
	静态包含经常用到, 动态包含不常用。
JSP@04  jsp:forward 与 sendRedirect
    test.jsp 源码如下 ：
	<%
		response.sendRedirect("forforward1.jsp"); // forforward1.jsp 相对路径
		System.out.println("ddd"); // 输出在服务器端了，在tomcat窗口中显示了。
	%>
    response 是内置对象
   @1, response.sendRedirect("forforward1.jsp"); 告诉客户端浏览器，你在IE中，打上 forforward1.jsp ， 再访问。后面代码继续执行。
      send后的语句会继续执行，除非 return, 速度慢, 需要到客户端的往返，可以转到任何页面, 转时参数可直接写在被转url后面.但是
	  当前页面不能取到上一个页面传递的参数。/代表的是http://127.0.0.1/
   @2, jsp:forward -> 转走后，后面的代码不会被执行，但是可以取参数。
      虽然是不同的对象，但是，可以取到上一个页面的内容, forward后的语句不会继续发送给客户端
      速度快, 服务器内部转换, 地址栏没有变化, 可以传参数, /代表的是http://127.0.0.1/my
      并且只能以/开头, 转走后，后面的代码不会被执行。
    示例程序 ： test.jsp, forforward.jsp, forward.jsp, forward1.jsp, forforward1.jsp
   forward1.jsp 源码如下 ： 
	<html>
	 <head>
	  <title>forward example</title>
	 <body bgcolor=red>
	    welcome to here!
	  <jsp:forward page="forforward1.jsp">
		 <jsp:param name="name" value="m" />
		 <jsp:param name="oldName" value='<%=request.getParameter("name")%>' />
		 <jsp:param name="ccc" value="manager" />
	  </jsp:forward>
	  <%System.out.println("eee");%>
	 </body>
	</html>
   forforward.jsp 源码如下 ：
    <html>
	 <head><title>forforward1.jsp</title></head>
	 <body bgcolor=blue>
	   here is the forforward1 page
		<br>
		<%=request.getParameter("name")%>
		<%=request.getParameter("oldName")%>
		<%=request.getParameter("ccc")%>
	 </body>
	</html>
JSP@05, JSP使用javabean
   java 做技术，可玩的东西比较多。java页面，总把简单的问题弄复杂。显摆技术。
   jsp:useBean 通过 jsp:useBean，可以在 JSP 中使用定义好的 Bean
  Bean 的基本要素：
      必须要有一个不带参数的构造器。在 JSP 元素创建 Bean 时会调用空构造器
      Bean 类应该没有任何公共实例变量，也就是说，不允许直接访问实例变量，变量名称首字母必需小写
      通过 getter/setter 方法来读/写变量的值，并且将对应的变量首字母改成大写
  基本用法 : test.jsp/CounterBean.java 不要使用裸体类(规范要求)
  jsp:useBean(con.)
  jsp:useBean各项参数含义：
	id    : 对象实例名称
	scope : Bean作用的范围，默认为page，对整个jsp页面有效
	class : Bean类名称(全名）
	type  : Bean实例类型，可以是本类，或其父类，或实现的接口，默认为本类
	Scope 各项参数的意义：
	page  : 仅涵盖使用JavaBean的页面
	  （PageBean.jsp/CounterBean.java）
	request : 有效范围仅限于使用JavaBean的请求
	  （RequestBean.jsp/RequestBean2.jsp/CounterBean.java）
	session : 有效范围在用户整个连接过程中（整个会话阶段均有效）
	  （SessionBean.jsp/Session2.jsp/CounterBean.java）
application : 有效范围涵盖整个应用程序。也就是对整个网站均有效
	  （Application.jsp/Application2.jsp/CounterBean.java）
-----------------------------------------------------------------
JSP@06, JSP 内置对象
  JSP的内置对象
		out
		request
		response
		pageContext ?用的很少
		session
		application
		config ?用的很少
		exception
		Page?用的很少
  *0) JSP编程---out
	Out内置对象是一个缓冲的输出流，用来给客户端返回信息。它是javax.servlet.jsp.JspWriter的一个实例
	典型应用：向客户端输出内容
	例：向客户端输出一个字符串“Hello World”
	  * (HelloWorld.jsp)
	常用方法：
		println()：向客户端输出各种类型数据
		newLine()：输出一个换行符
		close()：关闭输出流
		flush()：输出缓冲区里的数据
		clearBuffer()：清除缓冲区里的数据，同时把数据输出到客户端
		clear()：清除缓冲区里的数据，但不把数据输出到客户端
		getBufferSize()：返回缓冲区的大小
  *1), JSP--request
   request内置对象表示的是调用JSP页面的请求。通常，request对象是javax.servlet.http.HttpServletRequest接口的一个实例
   典型应用：通过request.getParameter(“paramName”)可以获得Form提交过来的参数值

   可以用此对象取得请求的Header、信息（如浏览器版本、语言和编码等）、请求的方式（get/post）、请求的参数名称、参数值、客户端的主机名称等
	常用方法：
	getMethod()：返回客户端向服务器端传送数据的方法
	getParameter(String paramName)：返回客户端向服务器端传送的参数值，该参数由paramName指定
	getParameterNames()：获得客户端传送给服务器端的所有参数的名字，结果是一个枚举类型数据（Enumeration）
	getParameterValues(String  name)：获得指定参数的所有值，由name指定
	getRequestURI（）：获得发出请求字符串的客户端地址
	getRemoteAddr()：获取客户端的IP地址
	getRemoteHost()：获取客户端机器名称
	getServerName()：获取服务器的名字
	getServletName()：客户端所请求的脚本文件路径
	getServerPort()：获取服务器端的端口
	对应类: javax.servlet.http.HttpServletRequest
  *2), JSP-response
   表示的是返回给客户端的响应
	是javax.servlethttp.HttpServletResponse接口的一个实例
	经常用于设置HTTP标题，添加cookie、设置响应内容的类型和状态、发送HTTP重定向和编码URL
	常用方法：
	addCookie(Cookie cookie)：添加一个Cookie对象，用于在客户端保存特定的信息
	addHeader(String name,String value)：添加HTTP头信息，该Header信息将发送到客户端
	containsHeader(String name)：判断指定名字的HTTP文件头是否存在
	sendError(int)：向客户端发送错误的信息
	sendRedirect(String url)：重定向JSP文件
	和<jsp:forward>的区别
	sendRedirect通过客户端发起二次申请,不同的request对象
	Jsp:forward是同一个request,在服务器内部转发
	setContentType(String contentType)：设置MIME类型与编码方式
  *3) JSP-Cookie
    Http协议的无连接性要求出现一种保存C/S间状态的机制
	Cookie：保存到客户端的一个文本文件，与特定客户相关
	Cookie以“名-值”对的形式保存数据
	通过getName和getValue的方式得到相应的名字和值
  *4) JSP—session & application
	  <% @page session=“true”%>（默认）--表示session功能已经在jsp页面中启动
		session常用方法：
		void setAttribute(String name,Object value)
		Object getAttribute(String name)
		boolean isNew()
		application 
		ServletContext
JSP@07 ： Servlet和JSP的通信
	* 从JSP调用Servlet可用<jsp:forward>请求信息自动传递到Servlet
	   * 或者通过sendRedirect

	* 从Servlet调用JSP使用
	   * RequestDispatcher接口的forward(req, res)方法
	   * 请求信息需要显式传递(在req、res参数中）
	   * 或者通过sendRedirect

	* 例如:
	   * FromJspToServlet.jsp / ServletToJsp.java / ServletUseJsp.jsp
	* forward可以用 ”/” 路径, 是指web app的根路径, servlet forward jsp的时候一定要用 “/”开头
	* jsp sendRedirect到servlet应该用相对路径,因为这里”/”指网站的根路径
	* servlet sendRedirect jsp也是
		* request.getContextPath起作用了
Know其他 ： tomcat 解决乱码问题
  b.jsp 源码
	 <%@ page contentType="text/html;charset=GBK"%>  <!-- 解决 get 方式乱码问题，这句话 -->
	 <%request.setCharacterEncoding("GBK");%>  <!-- 解决 post 方式乱码问题，这句话 -->
	 <!-- 以上两句话加上，非常好，可以兼顾不出乱码 -->
	 <%=request.getParameter("user") %>
	 <%String s = "哈哈哈";%>
	 <%=s%>
	具体核心 ：见 csdn, robby_chan 本博。
 

转载于:https://www.cnblogs.com/robbychan/p/3786857.html