Jinggg_

Jsp之神笔记

JSP笔记

Tomcat服务器

端口：

端口就是指的某一个程序网络入口，Tomcat的初始化端口为：8080；

端口的个数：256*256=65536个；

一般常见协议的缺省端口为：

http 80

smtp 25

pop3 110

ftp 23

https 443

端口占用查看命令：dos中运行netstat –ano命令

conf文件夹下的server.xml配置文件中的port="8080"protocol="HTTP/1.1" connectionTimeout="20000" redirectPort="8443"/> 标签用于配置Tomcat服务器的端口

环境变量配置：

新增一个JAVA_HOME环境变量配置为JDK的根目录，因为Tomcat服务器是java写的所有也需要JVM来运行

文件共享：标签中的reloadable=”true”属性，设置为true 表示只要文件被修改，就重新发布并加载(不建议使用)(context.xml配置文件中)

第一种：

tomcat服务器会自动扫描webapps这个文件夹，所以我们要共享的web应用目录，就可以放在此文件夹下,也就是说Tomcat服务器webapp目录中的web应用，外界可以直接访问，不需要配置

第二种：

也可以修改conf文件夹下的server.xml配置文件，在Host标签中添加/hello" docBase="E:/Demo/Test" />标签，hello为E:/Demo/Test映射;也就是说hello是一个虚拟的web应用目录地址，而E:/Demo/Test是我们的实际web应用目录地址，如果path=””；就表示是缺省的；

第三种：

也可以在\conf\Catalina\localhost\目录下面创建一个任意文件名的.xml文件，在里面配置E:/Demo/Test" />标签，那么这个web的虚拟目录就是这个文件的名称，实际的目录地址就是docBase所配置的地址；但实际的目录地址不能是\webapps这个目录中的，此方法的好处是配置好了不需要重启；如果这个.xml文件名为ROOT.xml就表示缺省默认的；这样的关系称为映射关系

Tomcat的目录层次结构：

bin目录存放的是启动和关闭Tomcat的脚步文件

conf 存放Tomcat服务器的各种配置文件

lib 存放Tomcat服务器的支持jar包

logs 存放Tomcat服务器的日志文件

temp 存放Tomcat运行时产生的临时文件

webapps web应用所在目录，即可以供外界访问的web资源的存放目录

work Tomcat的工作目录

Tomcat服务器的应用管理：(适用于Tomcat7.0，Tomcat6.0角色名用的是manager)

修改\conf文件中的tomcat-users.xml位置文件，在标签中加上manager-gui"/>admin"password="admin" roles="manager-gui"/>

manager-gui是角色然后在设置账号和密码

然后在Tomcat首页打开ManagerApp输入账号密码进入应用管理页面；Start 开始；Stop 停止；Reload 重装；Undeploy 卸载

当我们打开www.mybaidu.com时，运行E:\practice\JSP\practice1\Test\Demo\1.html文件

第一步：

设置Demo工程下WEB-INF中的web.xml配置文件；将1.html设置为缺省页，<welcome-file-list> <welcome-file>1.htmlwelcome-file> welcome-file-list>

第二步：

配置\conf中server.xml文件；在后面添加；将path设置为””表示缺省

第三步：

设置端口为80端口(只限定HTTP协议)；配置\conf中server.xml文件；; port=”80”

新建一个主机

在conf文件夹下的server.xml配置文件中，添加一个name=”主机名” appBase=”web工程位置”> 映射路径” docBase=”访问路径” />

Tomcat体系结构

Tomcat服务器启动时会启动一个Server服务，Server服务启动时会启动多个连接器(Connector);

浏览器发送一个HTTP协议然后找到Server服务中与HTTP协议对应的连接器(Connector)，然后通过连接器(Connector)找到引擎(Engine)，然后再找主机，主机再找WEB应用，最后找到WEB资源

配置https连接器

web工程(Project)

注意：每次创建一个新的工程都需发布到Tomcat服务器，修改代码后需重新部署(Redeploy)一下

war包

jar –vcf 新的文件名.war 要打包的文件夹；用此命令将web工程打包为war包

当war包的文件，放入Tomcat的webapps文件夹中时，会自动解压

目录层次结构

Myeclipse 2013 工程目录结构

工程目录

存放java文件的目录

存放于java文件对应的class文件

存放Web应用目录

存放jar包

Web应用的配置文件

索引页

Tomcat工程物理结构

web.xml 配置文件

web.xml只能放在WEB-INF这个文件夹中;

设置项目的缺省首页(不能直接将servlet映射为首页，如果首页必须要经过serlvet转发，那么可以在index.jsp文件中转发至serlvet，再通过此servlet转发至首页)

<welcome-file-list>

<welcome-file>index.jspwelcome-file>

welcome-file-list>

在web应用中注册com.scxh.Test这个serlvet，并取名为Test

<servlet-name>Testservlet-name>

<servlet-class>com.scxh.Testservlet-class>

servlet>

当出现此链接到此工程后，出现.com的后缀就交给Test这个类处理；

<servlet-mapping>

<servlet-name>Testservlet-name>

<url-pattern>*.comurl-pattern>//不能在前面加字符了，如：<url-pattern>aa/*.comurl-pattern>;这样也是不允许的

servlet-mapping>

这个Test可以映射成多个URL(伪静态)这就是servlet的映射，如：

<servlet-mapping>

<servlet-name>Testservlet-name>

<url-pattern>/*url-pattern>//表示‘/‘后面不管跟什么都访问这个类（aa/*；这种方式也可以）

servlet-mapping>

一般Servlet在配置映射时，不要将url-pattern标签配置为”/”;因为’/’通配符表示所有缺省的(找不到的资源)都访问此Servlet；在Conf/web.xml文件中，系统向所有的Servlet都配置了此’/’，当我们访问所有静态资源(如直接访问web工程中的1.html)都会被系统配的’/’ 所捕获到，都是访问的系统自带的Servlet对象；然后再通过这个对象去找你web应用中是否有这个静态资源，有就直接返回，没有就抛404异常(如果我们再设置url-pattern标签配置为’/’就会覆盖系统的设置,当我们再访问有些静态资源时就访问不到)

修饰符的优先级(谁最符合就匹配谁；’*’号越在前面,优先级越低)

HTTP协议

请求头(客户端与服务器交互)

客户端连上服务器后，向服务器请求某个web资源，称之为客户端向服务器发生了一个HTTP请求，一个完整的HTTP请求包括：一个请求行、若干请求头、及实体内容

示例：

GET/books/java.html HTTP/1.1 请求行（请求行用于描述客户端的请求方式、请求的资源名称、及使用的HTTP协议版本）

请求方式:GET(缺省,特点:显示提交,在URL地址后附带的参数是有限的,其数据容量通常不能超过1K; 提交数据显示在url栏中”？”后面);

POST(一般用于表单的提交,则可以再请求的实体内容中向发武器发送数据,传送的数据量无限制，隐式提交);

Accept:*/*

Accept-Language:en-ue

Connection:Keep-Alive 多个请求头（用于描述客户端请求的主机

Host:localhost ，及客户端的一些环境信息等）

Referer:thp://localhost/links.asp

User-Agent:Mozilla/4.0

Accept-Encoding:gzip,deflate

Hello world! 实体内容（一般是表单所提交的内容）

请求头的描述：

Accept: 告诉服务器,客户机所支持的数据类型,如：text/html,image/*; 就是说支持text的html，支持所有的image; 如为：*/*;表示什么都支持

Accept-Charset:ISO-8859-1 告诉服务器,客户机所采用的编码格式

Accept-Encoding:gzip,compress 告诉服务器,客户机所支持的压缩格式

Accept-Language: en-us,zh-cn 告诉服务器,客户机的语言环境

Host:localhost:8080 客户机要访问的主机

If-Modified-Since:Tue,11 jul 2000 18:23:51 GMT 告诉服务器,资源的缓存时间; 我们上一次浏览此网页的时间,发送给服务器,服务器用于比对原网站的更新时间,如果原网站在此时间内更新过数据,就重新返回数据，如没有更新就直接用客户机中缓存内的所缓存的网页

Referer:www.baidu.com 告诉服务器,他是从哪个资源来访问服务器的; 这里表示这是从百度访问的该资源（可以用于防盗链）

User-Agent:Mozilla/4.0(compatible;MSIE 5.5;Windows NT 5.0) 告诉服务器,客户机的软件环境(系统，及浏览器版本等)

Cookie: 客户机通过这个可以向服务器带数据

Connection:close/Keep-Alive 告诉服务器,当这个请求完毕后，是保持连接还是关闭连接; close是关闭连接, Keep-Alive是保持连接

Date:Tue,11 jul 2000 18:23:51 GMT 告诉服务器，客户机当前的时间

UA-CPU:X86 告诉服务器，windows的运行平台，如64位，32位等

If-None-Match:W/* 182-1303717494234

响应头(服务器与客户端交互)

一个http相应代表服务器向客户端回送的数据它包括：一个状态行、若干消息头、以及实体内容

示例：

HTTP/1.1 200 OK 状态行(状态行用于描述服务器对请求的处理结果)

Server:Microsoft-IIS/5.0

Date:Tue,11 jul 2000 18:23:51 GMT 多个消息头(消息头用于描述服务器的基本信息,

Content-Length:2291 以及数据的描述,服务器通过这写数据的描述信息,

Content-Type:text/html 可以通知客户端如何处理等一会它(服务器)回送的数据。)

Cache-control:private

实体内容(一般是网页代码)

响应头的描述

HTTP/1.1 200 OK 描述返回数据的协议版本号、状态码、原因叙述

状态码用于表示服务器对请求的处理结果,它是一个三位的十进制数.相应状态码分为5类，如：

100~199 表示成功接收请求,要求客户端继续提交下一次请求才能完成整个处理过程

200~299 表示成功接收请求并已完成整个处理过程, 常用200

300~399 为完成请求,客户需进一步细化请求.例如,请求的资源已经移动到一个新的地址,常用302、307、304（307和304表示服务器的资源位做修改，可以用客户机上的缓存，302表示去访问Location: 这个头所返回的地址）

400~499 客户端的请求有误，常用404（404表示服务器没有这个资源；403表示服务器拒绝你访问这个资源,请检查是否有权限访问）

500~599 服务器端出现错误, 常用500,(如同一个response对象同时使用字符流和字节流时服务器就会返回此异常,因为它们是互斥的)

Location:www.baidu.com (请求重定向)这个头配合302状态码使用,用于告诉客户端应该转到的地址

Server:Apache-Coyote/1.1 服务器通过这个头,告诉客户端服务器的类型

Content-Encoding:gzip,compress 服务器通过这个头，告诉客户端数据的压缩格式

Content-Length: 服务器通过这个头，告诉客户端压缩后数据的大小

Content-Type:text/html; charset=UTF-8 服务器通过这个头，告诉客户端数据的类型(如要查询要返回的文件类型的详细请查询conf/web.xml)

Last-Modified:Tue,11 jul 2000 18:23:51 GMT 告诉客户端,当前资源最后发布时间

Refresh:1;[url=’http://www.baidu.com’] 告诉浏览器隔多长时间刷新一次[如果在分号后面加上一个地址,表示隔多久时间跳转到这个网站]

Content-Disposition:attachment;filename=文件名告诉浏览器通过这个头,告诉浏览器以下载方式打开

Transfer-Encoding:chunked 告诉浏览器文件的传送格式

Set-Cookie:ss=Q0=5Lb_nQ;path=/search

Etag:W/”7777-1242234904000” 缓存相关的头

Expires:-1 告诉浏览器,这个资源的缓存时间，-1或0表示不缓存; 如果要缓存,设置为要缓存到的时间

也是控制浏览器要不要缓存数据（浏览器的内核不同，所以响应头比较多）如果要缓存, 设置为要缓存到的时间

Cache-Control:no-cache

Pragma:no-cache

Connection:close/Keep-Alive 告诉浏览器请求完毕后是否断开连接

Date:Tue,11 jul 2000 18:23:51 GMT 告诉浏览器，服务器当前的时间

断点下载

请求头

Range头指示服务器只传输一部分Web资源.这个头可以用来实现断点续传功能,Range字段可以通过三种格式设置要传输的字节范围：

Range: bytes=1000-2000

表示请求服务器发送这个资源中1000字节到2000字节之间的内容

Range: bytes=1000-

表示请求服务器发送这个资源中1000字节以后的所有内容

Range: bytes=1000

表示请求服务器发送这个资源中最后1000字节的内容

响应头

Accept-Ranges: 这个头告诉浏览器这个资源是否支持Ranges(断点下载) 支持返回:bytes 不支持返回:none

Content-Ranges:1000-3000/5000指定了返回的Web资源的字节范围。这里表示返回的数据是1000-3000字节之间的内容，这个资源总共有5000个字节

JSP中的路径（java中的路径相对于src目录）

访问资源：

访问时，如果从客户端访问服务器的资源： /工程名/要访问的资源路径；一般在前端超链接时，后台从定向时使用

访问时，如果直接在服务器端直接访问资源： /要访问的资源路径；一般在服务器端转发时使用；

服务器访问文件：

在web开发中如果要获取到用到一个文件的位置，只有用绝对路径，比如创建文件流、文件对象、等。

通过类加载器的 getClassLoader().getResource("相对路径").getPath();返回此文件的绝对路径；或者用getClassLoader().getResourceAsStream("相对路径”) 直接将文件加载到内存中，并返回一个字节输入流对象。这里的相对路径，相对的是WEB-INF/classes 目录。

如果一个要在一个jar包中访问这个jar包中的文件，那么只能将此文件加载到内存中，通过字节输入流对象来获取此文件的数据，因为文件在jar包中，不能获取到绝对路径。

Servlet开发

Servlet生命周期:

l Servlet一般只会在第一次访问时创建，然后一直停留在内存中，直到服务器停止才会被释放（或者这个web应用被删除时），每产生一次请求都会创建一个request和response对象但它们的生命周期很短,当请求和响应完成后就销毁。但Servlet对象只会创建一个

l 服务器启动时创建servlet，需加上标签（一般不会这样用的，加载框架文件时就是这样用的）

l servlet中尽量使用局部变量，如果要用static全局变量，并要对static变量进行修改的话，就要考虑线程安全问题了，解决线程安全需用线程同步代码块，同步代码块中的代码不能太多，不然会影响性能

<servlet-name>ServletDemo1servlet-name>

<servlet-class>cn.webapp.ServletDemo1servlet-class>

1//如果在web.xml配置文件中在当前Servlet注册标签中加上了当前标签，就会在服务器启动时创建当前的Servlet对象,并调用Servlet对象的init方法；中间这个1表示如果有多个Servlet对象要在服务器启动时加载时,这个值将控制Servlet的加载顺序；越小优先级越高

servlet>

l Servlet创建的时候会调用init方法结束时会调destroy方法

新建一个Servlet类它必须继承HttpServlet类或GenericServlet类

继承GenericServlet类需重写service(ServletRequestarg0, ServletResponse arg1)这个方法

继承HttpServlet类需重写doGet或doPost方法是(修改模板路径：MyEclipse\plugins\com.genuitec.eclipse.wizards_11.0.0.me201303311935.jar中templates\Servlet.java文件中修改doGet和doPost)

地址的用法(最好都在前面加上/)

当给浏览器用时，是相对于当前的主机(要在最前面加上项目名称)

当给服务器用时, 是相对于当前的web应用

线程安全

//线程安全

/*SingleThreadModel接口是一个空的接口;如果实现了此接口就表示此对象时一个线程安全的对象;

当一个用户访问当前的Servlet后，下一个用户访问当前的Servlet时发现Servlet有用户，

就会创建出一个新的Servlet对象，这也是在一个服务器中创建两个Servlet的方法

（此方法不推荐使用；太消耗资源，因为Servlet创建后只有关闭服务器才会销毁）

public class ThreadSafe extends HttpServlet implements ~~SingleThreadModel~~{

public int i = 0;

public void doGet(HttpServletRequest request, HttpServletResponseresponse)

throws ServletException, IOException {

response.setContentType("text/html; charser=utf-8");

response.setCharacterEncoding("utf-8");

request.setCharacterEncoding("utf-8");

i++;

try {

Thread.sleep(10000);

} catch (InterruptedException e) {

// TODO Auto-generatedcatch block

e.printStackTrace();

}

System.out.println(i);

}

public void doPost(HttpServletRequest request, HttpServletResponseresponse)

throws ServletException, IOException {

doGet(request, response);

}

Servlet中的六大对象

ServletConfig(servlet配置对象及servlet对象域)

用于封装Servlet的配置信息

可以在工程下的web.xml配置文件中，注册Servlet标签中加上：标签；

<servlet-name>ConfigDemoservlet-name>

<servlet-class>cn.java.ConfigDemoservlet-class>

<!—此标签的作用域只能在cn.java.ConfigDemo这个servlet中-->

name1

张三

name2

李四

servlet>

获取方法

import java.io.IOException;

import java.util.Enumeration;

import javax.servlet.ServletConfig;

import javax.servlet.ServletException;

import javax.servlet.http.HttpServlet;

import javax.servlet.http.HttpServletRequest;

import javax.servlet.http.HttpServletResponse;

//获取ServletConfig对象中的值(此值需要在web.xml中注册此servlet标签中加)

public class Test extends HttpServlet {

//privateServletConfig config;//方式一所需定义的全局变量

public void doGet(HttpServletRequest request, HttpServletResponseresponse)

throws ServletException, IOException {

response.setContentType("text/html; charser=utf-8");

response.setCharacterEncoding("utf-8");

request.setCharacterEncoding("utf-8");

//第一种方式获取值

//输出config对象中name1和name2中所映射的值

// System.out.println(config.getInitParameter("name1"));

// System.out.println(config.getInitParameter("name2"));

//第二种方式获取(用第二种方式时不能重写init(ServletConfig config)方法)

//先通过this.getServletConfig()获取到config对象,再通过getInitParameter("name1")获取到name1和name2中所映射的值

System.out.println(this.getServletConfig().getInitParameter("name1"));

System.out.println(this.getServletConfig().getInitParameter("name2"));

//第三种方式,使用迭代(获取全部的config值)

ServletConfigconfig1 = this.getServletConfig();//获取config对象

Enumeration en =config1.getInitParameterNames();//获取config1对象中所有的name，并返回一个列表

while(en.hasMoreElements()){//用这个列表的迭代器进行遍历

String key = (String) en.nextElement();

String value =this.getServletConfig().getInitParameter(key);

System.out.println(value);

}

//第四种直接获取

System.out.println(this.getInitParameter("name1"));

}

public void doPost(HttpServletRequest request, HttpServletResponseresponse)

throws ServletException, IOException {

doGet(request, response);

}

//第一种方式：重写HttpServet父类GenericServlet中的init(ServletConfig config)方法

//此方法会在服务器启动时调用，并将config对象传入进来

@Override

public void init(ServletConfig config)throws ServletException {//获取config对象

// TODO Auto-generated method stub

this.config=config;

}

servletContext(代表一个web应用(域))此对象的生命周期为：当web应用发布时创建，卸载web应用时销毁，如果在servlet中要对servletContext域对象中的key值进行更改的话，需考虑线程安全问题

ServletContext.removeAttribute(Stringkey); 删除servletContext对象域中键值的映射关系,不然此键值会一直存活到服务器关闭，会浪费资源

WEB容器在启动时,它会为每个WEB应用程序都创建一个对应的ServletContext对象，它代表”当前web应用”。

SerletConfig对象中维护了ServletContext对象的引用,开发人员在编写servlet时,可以通过servletConfig.getServletContext方法获得ServletContext对象

由于一个WEB应用中的所有Servlet共享同一个ServletContext对象,所以多个Servlet可以通过servletContext对象实现数据共享（ServletContext对象通常也被称之为context域(域就是一个范围,Context域是一个应用范围的域)对象）

n 获取web应用的参数(配置数据库)

<context-param>这是配置整个web应用初始化参数的标签；一个web应用中可以有多个初始化参数的标签-->

<param-name>nameparam-name>

<param-value>haorenparam-value>

context-param>

Stringsex = this.getServletContext().getInitParameter("name");//取出context-param标签中的值；也可以用this.getServletContext().getInitParameterNames();方法获取全部的key；然后再迭代取出value（在ServletConfig对象中有讲过取出value的方式）

System.out.print(sex);

n 数据共享

ServeltDemo1:

this.getServletContext().setAttribute("address", "chengdu");//存入servletContext对象中

ServeltDemo2:

String address =(String) this.getServletContext().getAttribute("address");//取出servletContext对象中的值

n 利用ServletContext对象读取源文件

读取properties文件

//第一种方式

ServletContext servletContext = this.getServletContext();//获取到servletContext对象

InputStream inStream = servletContext.getResourceAsStream("/config.properties");//把/config.properties资源作为一个输入流返回（这里"/" 路径指的是web工程的根目录）

//如果此处的路径写的是相对路径,相对的是Tomcat的bin目录,因为Tomcat的是在此目录中启动的

Properties properties = new Properties();//创建一个properties对象（properties对象中底层是用map集合维护的）

properties.load(inStream);//properties对象中提供了load方法，从流中获取properties文件的值

String name = properties.getProperty("name");//获取properties对象中key是name的value

String url = properties.getProperty("url");//获取properties对象中key是url的value

System.out.println(name+" "+url);

//第二种方式（通过硬盘上的绝对路径访问config.properties文件）,此方法可以获取到文件的名称

ServletContext servletContext = this.getServletContext();//获取到servletContext对象

String path = servletContext.getRealPath("/config.properties");//会返回这个路径在硬盘上的绝对路径；这里会返回

//E:\practice\JSP\practice2\Tomcat7.0\webapps\servletContext\config.properties这个路径

String fileName = path.substring(path.lastIndexOf("\\")+1);//这样可以获取到文件的名称；在下载时需要用到

System.out.println("文件名称为："+fileName);//打印这个文件名称

FileInputStream in = new FileInputStream(path);//有了绝对路径后就可以创建文件字节流了

Properties properties = new Properties();//创建一个properties对象（properties对象中底层是用map集合维护的）

properties.load(in);//properties对象中提供了load方法，从流中获取properties文件的值

in.close();//关闭流

String name = properties.getProperty("name");//获取properties对象中key是name的value

String url = properties.getProperty("url");//获取properties对象中key是url的value

System.out.println(name+" "+url);

//第三种方式(通过一个普通类加载config.properties文件的方式)

//如果在一个普通类中用ServletContext对象来获取；就是前台应用耦合了后台应用;所以我们应该避免这个用法

//在一个普通类中读取config.properties文件;

public class Test4 {

public static void print() throws IOException {

//此方法获取的输入流(in)不能实时更新（因为是类加载器加载器只加载一次到内存中）

InputStream in = Test4.class.getClassLoader().getResourceAsStream("../../config.properties");

//这里相对的是Tomcat中webapps\servletContext\WEB-INF\classes这个文件夹(如果用类加载器加载文件,这个文件不能太大)

//此方法获取的输入流(in)可以实现实时更新(此方法是得到绝对路径后在创建输出流)

URL url1 = Test4.class.getClassLoader().getResource("../../config.properties");//获取到这个文件的URL

String path = url1.getPath();//通过url获取到这个config.properties文件的绝对路径

InputStream in = new FileInputStream(path);//通过这个绝对路径来创建输入流

Properties properties = new Properties();//创建一个Properties对象

properties.load(in);//properties对象中提供了load方法，从流中获取properties文件的值

in.close();//关闭流

String name = properties.getProperty("name");//获取properties对象中key是name的value

String url = properties.getProperty("url");//获取properties对象中key是url的value

System.out.println("Test4："+name+" "+url);

}

public static void main(String[] args) {

try {

Test4.print();

} catch (IOException e) {

// TODO Auto-generatedcatch block

e.printStackTrace();

}

request(请求头对象)用于获取客户端传入的数据

获取表单中的值:

//获取表单提交的数据

public class Test extends HttpServlet {

public void doGet(HttpServletRequest request, HttpServletResponseresponse)//request:请求；response:响应

throws ServletException, IOException{

response.setContentType("text/html; charser=utf-8");//设置浏览器的编码格式

response.setCharacterEncoding("utf-8");//设置响应回传数据的编码格式

request.setCharacterEncoding("utf-8");//设置请求数据的编码格式

//获取表单的参数，除多选框外，其它表单的取值方式都一样

String username = request.getParameter("username");

String password = request.getParameter("password");

String sex = request.getParameter("sex");

String country = request.getParameter("country");

String [] enjoy = request.getParameterValues("enjoy");//多选框用getParameterValues(String arg0)这个方法,并会返回一个String []的数组

String remark = request.getParameter("remark");

PrintWriter out = response.getWriter();//获取到响应对象的输出流

out.print("你的用户名为:"+username+";你的密码为:"+password+";你的性别为:"+sex+";你的国籍为:"+country+";备注为："+remark);

out.println(";你的爱好为:");

for(int i=0; ilength; i++){

out.print(enjoy[i]+" ");

}

public void doPost(HttpServletRequest request, HttpServletResponseresponse)

throws ServletException, IOException {

doGet(request, response);

}

//解决提交表单方式为get时出现的乱码问题

public class getMessyCodeextends HttpServlet {

public void doGet(HttpServletRequest request, HttpServletResponseresponse)

throws ServletException, IOException{

response.setContentType("text/html; charser=utf-8");

response.setCharacterEncoding("utf-8");

request.setCharacterEncoding("utf-8");

String text = request.getParameter("text");//获取提交表单的参数

String temp = new String(text.getBytes("ISO8859-1"),"UTF-8");//将ISO8859-1的参数，转换为字节数组后,再传入一个新的字符串,并重新指定编码格式

response.getWriter().print("你提交的为："+temp);//将数据传送给响应对象的输出流

}

public void doPost(HttpServletRequest request, HttpServletResponseresponse)

throws ServletException, IOException{

doGet(request, response);

}

通过request对象实现转发:

/*转发

请求重定向与转发的区别

请求重定向: 是向客户端发回一个网址,让浏览器重新去访问(向服务器发出了两次请求;并且网址会变。重定向完成后，再刷新,刷新的是重定向后的网页)

转发: 是通过服务器直接转发到某一个网址(向服务器只发出一次请求；网址不会变。当转发完成后,再刷新,由于网址没变,刷新的还是没转发前的资源,并会再次转发(提交数据时要注意));

总结:所以一般不用请求重定向,一般用转发完成,因为请求重定向会向服务器发出两次请求；转发时要避免因刷新而导致数据重复提交的问题；

//通过request对象实现转发,

public class Test1 extends HttpServlet {

public void doGet(HttpServletRequest request, HttpServletResponseresponse)

throws ServletException,IOException {

response.setContentType("text/html; charser=utf-8");

response.setCharacterEncoding("utf-8");

request.setCharacterEncoding("utf-8");

//获取表单中的值

String text = request.getParameter("text");

//向request对象域中存入值

request.setAttribute("text", text);

//如果用转发时不能关闭response对象的流，不然调用forward方法时会抛出异常(但可以设置response响应对象的头,并且转发后还是有效的)

// PrintWriter out = response.getWriter();//Error

//out.print(“asdf”); //Error

//out.close();//Error

//转发到Test12.jsp,并将request, response对象提交过去（最好在跳转完成之后return）

request.getRequestDispatcher("/Test12.jsp").forward(request, response);

return;

}

public void doPost(HttpServletRequest request, HttpServletResponseresponse)

throws ServletException, IOException {

doGet(request, response);

}

通过request对象获取请求头的请求资源和所有请求头的值

public class Test2 extends HttpServlet {

public void doGet(HttpServletRequest request, HttpServletResponseresponse)

throws ServletException, IOException {

response.setContentType("text/html; charser=utf-8");

response.setCharacterEncoding("utf-8");

request.setCharacterEncoding("utf-8");

//获取请求方式(结果为:GET或POST等)

System.out.println(request.getMethod());

//当后缀名为/com/*时,都会访问到此servlet（我输入的是：http://localhost:8080/request/com/1.html ）

//获取请求资源的URI(结果为:/request/com/1.html )

System.out.println(request.getRequestURI());

//获取请求资源的URL(结果为:http://localhost:8080/request/com/1.html )

System.out.println(request.getRequestURL());

//URL代表的是互联网上面的资源地址

//URI代表的是任意一个资源的地址(可以理解为某个服务器上的地址)

//通过request请求头对象,获取一个头的值（这里获取的是客户端所支持的压缩格式）

System.out.println(request.getHeader("Accept-Encoding"));

System.out.println("获取所有的头");

//通过request请求对象得到所有头的名称

Enumeration headerNames =request.getHeaderNames();

while(headerNames.hasMoreElements()){ //判断此枚举是否还有下一个值

String headerName = headerNames.nextElement();//返回它的下一个值

System.out.println(headerName+":"+request.getHeader(headerName));

}

//request.getHeaders("");//当一个头设置了两个值,就用此方法获取

}

public void doPost(HttpServletRequest request, HttpServletResponseresponse)

throws ServletException, IOException {

doGet(request, response);

}

通过request对象防止盗链

//防止盗链

public class Test5 extends HttpServlet {

public void doGet(HttpServletRequest request, HttpServletResponseresponse)

throws ServletException, IOException {

response.setContentType("text/html; charser=utf-8");

response.setCharacterEncoding("utf-8");

request.setCharacterEncoding("utf-8");

//防止重复提交,此处是验证提交的次数

System.out.println("提交的次数");

try {

Thread.sleep(5000);

} catch (InterruptedException e) {

// TODO Auto-generatedcatch block

e.printStackTrace();

}

//获取来访者的url

String path = request.getHeader("referer");

//获取本服务器的主机名

String server = "http://"+request.getServerName();

//判断path的前端是否是server(也就是判断主机名是否相同)

if(path != null && path.startsWith(server)){

//将path和server转入request对象域

request.setAttribute("path", path);

request.setAttribute("server", server);

//转发至Test52.jsp

request.getRequestDispatcher("/Test52.jsp").forward(request, response);

}else{

//不转发

response.getWriter().print("不是本网页的连接");

}

public void doPost(HttpServletRequest request, HttpServletResponseresponse)

throws ServletException, IOException {

doGet(request, response);

}

比较常用的方法:

request.getRequestURL(); 获取完整的URL

request.getRequestURI(); 只获取请求资源的地址

request.getQueryString(); 获取在地址栏中’?’号后面的所有字符串(所以它只针对get的提交方式有效)

request.getRemoteAddr(); 获取客户机的IP地址

request.getRemoteHost(); 获取客户机的完整主机名(但是客户机的IP要在DNS上注册后才能显示主机名,不然还是显示IP地址)

request.getRemotePort(); 获取浏览器所使用的端口号(当浏览器关闭后再重新打开时端口号会随机变化)

request.getLocalAddr(); 获取WEB服务器的IP地址

request.getLocalName(); 获取WEB服务的主机名

request.getServerName(); 获取WEB服务器的主机名

request.getServerPort(); 货物WEB服务器的端口

request.getMethod(); 获取浏览器的请求方式

request.getHeader(headerName); 根据相应的响应头名字来获取响应的值

request.getHeaders(headerName); 如果同一个响应头有多个值,就用此方法获取,并返回一个Enumeration

request.getContextPath(); 得到当前的工程名：如：/dy19

request.getServletContext().getContextPath(); 得到当前的工程名：如：/dy19

request.getServletPath(); 得到web配置文件<url-pattern>/servlet/UploadServleturl-pattern>此标签中的值

URL与URI的区别

www.sina.com/news/1.html 这就是一个URL

news/1.html 这就是一个URI

URL代表的是互联网上面的资源地址

URI代表的是任意一个资源的地址(可以理解为某个服务器上的地址)

通过request对象获取客户端所提交的数据(通过get或post等,提交的数据)（在上面request对象的第一个知识点中已做过笔记）

//通过request对象获取客户端所提交的数据(通过get或post等,提交的数据)（先要检查用户提交的数据中是否有str这个key）

public class Test3 extends HttpServlet {

public void doGet(HttpServletRequest request, HttpServletResponseresponse)

throws ServletException, IOException {

response.setContentType("text/html; charser=utf-8");

response.setCharacterEncoding("utf-8");

request.setCharacterEncoding("utf-8");

System.out.println("-------------------直接通过key获取提交的value--------------------------------");

//客户端用get或post方式提交的数据,都可以用以下方式获取

//如我们在访问时在后面加上数据如：http://localhost:8080/request/servlet/Test3?name=abc&password=123

//或者用表单提交都能获取到

String value = request.getParameter("name");//获取指定名称的值

if(value!=null && !value.trim().equals("")){ //判断是否是没有输入或输入的全部为空格(检查提交的数据合格再使用)

System.out.println("name="+value);//value.trim()方法会删除字符串两边的空格,如果字符串全部都是空格,那么返回的字符串相等于new Stirng("");

}

System.out.println("-------------------先获取到所有请求数据key，再通过迭代取出请求的值--------------------------------");

//获取所有的数据的key,再通过key遍历所有的值

Enumeration names =request.getParameterNames();

while(names.hasMoreElements()){ //判断此枚举是否还有下一个key

String name = names.nextElement();//获取下一个key

String value1 = request.getParameter(name);//通过key遍历所有的value

System.out.println(name+"="+value1);

}

System.out.println("--------------------获取同一个key有两个value的方法-------------------------------");

//如果提交的数据key有多个相同如：http://localhost:8080/request/servlet/Test3?str=abc&str=123

//这里的str有两个值,就用request.getParameterValues("str");来获取

String[] values = request.getParameterValues("str");//返回str中的多个值

for(int i=0; values!=null && ilength; i++){ //遍历这些值（先要检查用户提交的数据中是否有str这个key）

System.out.println(values[i]);

}

System.out.println("----------------------将请求的数据以一个map集合返回-----------------------------");

//将提交的数据返回到一个Map集合中提交方式为:http://localhost:8080/request/servlet/Test3?name=abc&name=111&password=123

Map map =request.getParameterMap();

//遍历输出这个map集合

//获取map中所有的key，以Set集合的方式返回

Set set = map.keySet();

//获取set集合的迭代器

Iterator it = set.iterator();

//遍历这个迭代器

while(it.hasNext()){ //判断迭代器是否还有下一个key值

String key = it.next();//获取下一个key

//输出key

System.out.print(key);

//通过key返回所对应的value;返回一个数组,因为同一个key可能有两个以上value

String [] values = map.get(key);

//遍历输入这个values

for(String s:values){

System.out.print(":"+s);

}

//换行

System.out.println();

}

public void doPost(HttpServletRequest request, HttpServletResponseresponse)

throws ServletException, IOException {

doGet(request, response);

}

通过request.getRequestDispatcher("").include(request,response);方法实现多个页面动态包含(也就是将多个页面的数据同时传给前台)

public class Test6 extends HttpServlet {

public void doGet(HttpServletRequest request, HttpServletResponseresponse)

throws ServletException, IOException {

response.setContentType("text/html; charser=utf-8");

response.setCharacterEncoding("utf-8");

request.setCharacterEncoding("utf-8");

//在response对象的返回数据的尾部加上了/Test61.jsp中的内容

request.getRequestDispatcher("/Test61.jsp").include(request, response);

//在response对象的返回数据的尾部添加了我是servlet

response.getWriter().print("我是servlet
");

//在response对象的返回数据的尾部添加了/Test62.jsp中的内容

request.getRequestDispatcher("/Test62.jsp").include(request, response);

所以输出的结果为：

This is my Test61.JSP page.

我是servlet

This is my Test62.JSP page.

}

public void doPost(HttpServletRequest request, HttpServletResponseresponse)

throws ServletException, IOException {

doGet(request, response);

}

response(响应头对象)用于向客户端返回数据

根据response对象向浏览器发送数据

//通过response对象的字节流返回数据

response.setHeader("Content-type","text/thml;charset=UTF-8"); //设置头的值，这是是设置Content-type告诉浏览器回送的数据，为html格式,它编码格式为UTF-8

response.setContentType("text/html;charser=utf-8");//设置ContentType(返回数据类型)响应头的数据类型为html格式，编码格式为utf-8

//也相当于是告诉浏览器以什么样的编码格式打开这段数据

response.setCharacterEncoding("utf-8");//设置response对象的编码格式(response对象里面也有对数据进行转码，所以也需要编码格式)

request.setCharacterEncoding("utf-8");//设置request对象的编码格式(request对象里面也有对数据进行转码，所以也需要编码格式)

PrintWriter out = response.getWriter();//获取到字符输出流

out.write("中国");//向字符流中写入数据

out.flush();//移除流中的缓存

out.close();//关闭流

//通过response对象的字符流返回数据

public class Test2 extends HttpServlet {

public void doGet(HttpServletRequest request, HttpServletResponseresponse)

throws ServletException, IOException {

response.setContentType("text/html; charser=utf-8");//设置ContentType(返回数据类型)响应头的数据类型为html格式，编码格式为utf-8

//也相当于是告诉浏览器以什么样的编码格式打开这段数据

response.setCharacterEncoding("utf-8");//设置response对象的编码格式(response对象里面也有对数据进行转码，所以也需要编码格式)

request.setCharacterEncoding("utf-8");//设置request对象的编码格式(request对象里面也有对数据进行转码，所以也需要编码格式)

String data = "中国";

PrintWriter out = response.getWriter();//获取到字符输出流

out.write(data);//向字符流中写入数据

out.flush();//移除流中的缓存

out.close();//关闭流

}

public void doPost(HttpServletRequest request, HttpServletResponseresponse)

throws ServletException, IOException {

doGet(request, response);

}

提示: 字符流和字节流是互斥的,如果同一个response对象,用了字符流就不能用字节流了,最好都用字节流（从response或request对象中获取的流不需要关闭，因为当servlet对象在销毁时会自动检测这些流是否调用了close方法，然后关闭，但是如果是我们自己new的流必须关闭它,不然会浪费资源）

从浏览器中下载web应用中的资源

String path = this.getServletContext().getRealPath("/image/美女.zip");//获取这个文件的绝对路径

String fileName = path.substring(path.lastIndexOf(File.separator)+1);//获取到这个文件的名字

fileName = URLEncoder.encode(fileName, "UTF-8");//如果为中文名字需要进行转码

response.setHeader("Content-Disposition", "attachment;filename="+fileName);//设置响应头Content-Disposition的值为attachment表示以下载方式打开,后面跟文件名字

FileInputStream in = new FileInputStream(path);//创建一个字节输入流，并指向这个图片

byte[] buffer = new byte[1024];//创建一个缓冲字节数组

int len=0;//定义一个缓冲大小的变量

OutputStream out = response.getOutputStream();//获取response的字节输出流

while((len=in.read(buffer)) > 0){ //判断从输入流中获取的字节数,如果小于或等于0表示没有读取到字节

out.write(buffer,0,len);//将buffer中的缓存写入到 response的字节输出流中

}

//关闭流

in.close();

out.flush();

out.close();

请求重定向

/*请求重定向

请求重定向与转发的区别

请求重定向: 是向客户端发回一个网址,让浏览器重新去访问(向服务器发出了两次请求,并且网址会变)

转发: 是通过服务器直接转发到某一个网址(向服务器只发出一次请求,网址不会变)

总结:所以一般不用请求重定向,一般用转发完成,因为请求重定向会向服务器发出两次请求；

public class Test7 extends HttpServlet {

public void doGet(HttpServletRequest request, HttpServletResponseresponse)

throws ServletException, IOException {

response.setContentType("text/html; charser=utf-8");

response.setCharacterEncoding("utf-8");

request.setCharacterEncoding("utf-8");

response.setStatus(302);//设置response对象中状态行的状态码为302，表示请求重定向

response.setHeader("Location","/response/welcome.jsp");//Location此头为请求重定向头，重定向到welcomem.jsp文件

//此方法也可以直接重定向到welcomem.jsp文件

response.sendRedirect("/response/welcome.jsp");

}

public void doPost(HttpServletRequest request, HttpServletResponseresponse)

throws ServletException, IOException {

doGet(request, response);

}

设置浏览器定时反复刷新页面或定时重定向

public class Test5 extends HttpServlet {

public void doGet(HttpServletRequest request, HttpServletResponseresponse)

throws ServletException, IOException {

response.setContentType("text/html; charser=utf-8");

response.setCharacterEncoding("utf-8");

request.setCharacterEncoding("utf-8");

//不停的刷新

response.setHeader("refresh","3");//表示每隔3秒钟就访问一次此servlet

//产生一个随机数并通过字符流返回

PrintWriter out = response.getWriter();

out.write(new Random().nextInt()+"");

//3秒钟以后可以重定向到其他的网页

response.setHeader("refresh", "3;url='http://www.baidu.com'");//设置refresh(刷新头,设置其值，表示3秒钟后跳转至百度)

PrintWriter out = response.getWriter();

out.write("本网页将在3秒钟后重定向到百度;如果未跳转，情点击href='http://www.baidu.com'>百度");

//最实用的方式，用jsp文件控制页面跳转

//通过meta表示设置jsp文件response对象的响应头,隔3秒跳转至/response/welcome.jsp网页

String str = "" +

"本网页将在3秒钟后跳转;如果未跳转，情点击超链接";

//将数据存入ServletContext应用域对象中

this.getServletContext().setAttribute("str", str);

//跳转至MyJsp网页;但先要在web工程下建一个MyJsp.jsp文件，并在body标签中用java代码获取ServletContext应用域对象str中的value如：

//<%//获取servletContext应用域对象中的值String str =(String)application.getAttribute("str"); //通过流向当前的位置输出数据 out.write(str);%>

this.getServletContext().getRequestDispatcher("/MyJsp.jsp").forward(request, response);

}

public void doPost(HttpServletRequest request, HttpServletResponseresponse)

throws ServletException, IOException {

doGet(request, response);

}

请求重定向时,通过url方式将数据提交给Test41.jsp

Servlet中的代码

//请求重定向时,通过url方式将数据提交给Test41.jsp

public class Test4 extends HttpServlet {

public void doGet(HttpServletRequest request, HttpServletResponseresponse)

throws ServletException, IOException {

response.setContentType("text/html; charser=utf-8");

response.setCharacterEncoding("utf-8");

request.setCharacterEncoding("utf-8");

//第一种方式：

//数据

String str = new String("中国");

str = new String(str.getBytes("utf-8"),"ISO-8859-1");

//请求重定向,并将数据传过去

response.sendRedirect("/request/Test41.jsp?str="+str);

//第二种方式:

String value = new String("四川");//数据

String value1 = URLEncoder.encode(value, "UTF-8");//加码

response.sendRedirect("/request/Test41.jsp?value="+value1); //如果直接在url后面跟中文数据,需要对中文进行转码

//加码与解码

String temp = new String("中文数据");

//加码(就是将temp这个UTF-8编码的字符串转换为ISO-8859-1;当某些时候进行中文数据传输时,需要进行加码与解码)

String temp1 = URLEncoder.encode(temp, "UTF-8");

//也就是说加码过后,将temp的值的存储格式变为了默认的ISO-8859-1编码格式

System.out.println(temp1);//打印为：%E4%B8%AD%E6%96%87%E6%95%B0%E6%8D%AE

//解码(将加码过的字符串（ISO-8859-1），转换为对应的编码格式)

String temp2 = URLDecoder.decode(temp1, "UTF-8");

System.out.println(temp2);//打印为：中文数据

}

public void doPost(HttpServletRequest request, HttpServletResponseresponse)

throws ServletException, IOException {

doGet(request, response);

}

Jsp中的代码

<body>

<%=new String(request.getParameter("value").getBytes("ISO-8859-1"), "UTF-8") %>

body>

通过修改服务器配置文件，来设置服务器默认的编码格式(但此方法一般不用)

在apache-tomcat-7.0.6\conf\servlet.xml文件中的标签末尾添加一个属性: URIEncoding=”UTF-8”；

或者在末尾添加一个useBodyEncodingForURI=”true”；这个属性是设置URL地址的默认编码格式

控制浏览器对数据的缓存

public class Test6 extends HttpServlet {

public void doGet(HttpServletRequest request, HttpServletResponseresponse)

throws ServletException, IOException {

response.setContentType("text/html; charser=utf-8");

response.setCharacterEncoding("utf-8");

request.setCharacterEncoding("utf-8");

//设置浏览器不要缓存（为了使更多的浏览器兼容，所以设置的头比较多）

response.setHeader("expires","-1");

response.setHeader("cache-Control","no-cache");

response.setHeader("pragma","no-cache");

//设置浏览器缓存数据

//设置数据缓存的时间为当前时间加上1小时

response.setDateHeader("expires", System.currentTimeMillis()+(1000*3600));//1000毫秒*3600 ==一小时

String data = new String("aaaaaaaaa");//数据

response.getWriter().write(data);//data的数据会被保存1小时

}

public void doPost(HttpServletRequest request, HttpServletResponseresponse)

throws ServletException, IOException {

doGet(request, response);

}

将数据压缩后才传给客户端

public class Test8 extends HttpServlet{

public void doGet(HttpServletRequest request, HttpServletResponseresponse)//request为请求；response为响应头

throws ServletException, IOException {

response.setContentType("text/html; charser=utf-8");

String str = new String("要压缩的数据");

//创建一个字节缓存输出流

ByteArrayOutputStream bout = newByteArrayOutputStream();

//把输出流作为参数，创建一个gzip压缩对象，将压缩后的数据放到缓存流中

GZIPOutputStream gout = new GZIPOutputStream(bout);

//将要压缩数据的字节数组传入压缩对象的write方法中进行压缩

gout.write(str.getBytes());

//关闭压缩

gout.close();

//从缓存输出流中获取压缩后的byte数组数据

byte[] gzip = bout.toByteArray();

//关闭缓存输出流

bout.close();

//设置Content-Encoding(服务器返回数据的压缩格式)响应头的返回值

response.setHeader("Content-Encoding", "gzip");

//设置Content-Length(服务器返回数据压缩后的长度)响应头的返回值

response.setHeader("Content-Length", String.valueOf(gzip.length));

//设置response的传出数据

response.getOutputStream().write(gzip);

//传送过去后浏览器会自动解压显示

}

public void doPost(HttpServletRequest request, HttpServletResponseresponse)

throws ServletException, IOException {

doGet(request, response);

}

cookie(缓存数据)

把数据缓存在客户端的硬盘上,一个Cookie只能表示一种信息,它至少含有一个键值

一个WEB站点可以给一个WEB浏览器发送多个Cookie,一个浏览器也可以存储多个WEB站点提供的Cookie

可以调用Cookie对象的setMaxAge()方法设置此Cookie的存储时间即生命周期（单位秒）,设置为0表示删除该Cookie;如果不设置保存时间，此Cookie只会保存在用户的内存中，当浏览器关闭释放内存，此Cookie会被删除,删除cookie时,path必须一致,否则不会被删除

浏览器一般只允许存放300个Cookie,每个站点最多存放20个Cookie,每个Cookie的大小限制为4KB

输出用户访问此servlet的次数

public class Test1 extends HttpServlet {

public void doGet(HttpServletRequest request, HttpServletResponseresponse)

throws ServletException, IOException {

response.setContentType("text/html; charser=utf-8");

response.setCharacterEncoding("utf-8");

request.setCharacterEncoding("utf-8");

//获得本web应用(/cookie)存储在客户端的cookie

Cookie [] cookies = request.getCookies();

//标记访问的次数

int time = 1;

//判断本web应用是否在客户端存有cookie

if(cookies!=null && cookies.length>0){

//遍历这些cookie

for(int i=0; ilength; i++){

//判断是否是numberOfTimes(次数)这个key

if("numberOfTimes".equals(cookies[i].getName())){

//获得numberOfTimes这个key的值(上次访问的次数)

String value = cookies[i].getValue();

//并删除当前的Cookie

cookies[i].setMaxAge(0);//将存储时间设置为0表示删除此cookie

//将获取的值转换为int类型

int temp = Integer.valueOf(value);

//上次访问的次数加上1，并赋值给time标记

time = ++temp;

}

//创建一个新的cookie并把numberOfTimes的值设为本次的次数

Cookie cookie = new Cookie("numberOfTimes",time+"");

//设置cookie的保留时间,单位为秒

cookie.setMaxAge(3600);

//设置标识(表示当前cookie是/cookieWEB工程的)

cookie.setPath("/cookie");

//向浏览器返回此cookie(保存在客户机的硬盘上)

response.addCookie(cookie);

//打印用户访问的次数

response.getWriter().print("你是第"+time+"次访问本servlet");

}

public void doPost(HttpServletRequest request, HttpServletResponseresponse)

throws ServletException, IOException {

doGet(request, response);

}

session(会话对象)

把数据缓存在服务器端

在WEB开发中,服务器可以为每个用户浏览器创建一个会话对象(session对象),也就是说一个浏览器独占一个session对象(默认情况下).因此，在需要保存用户数据时，服务器可以把用户数据写到用户浏览器独占的session对象中,当用户用浏览器访问其他程序时,其他程序可以从用户的session中取出该用户的数据,为用户服务

Session对象是由服务器创建,我们可以调用request对象的getSession方法得到用户的session对象

Session与cookie的区别：

Cookie是把用户的数据写在用户本地硬盘上

Session是把用户的数据写到服务器为每个用户单独分配的session对象中

当session对象超过30分钟(默认)无访问，就销毁此session对象;调用session对象的getLastAccessedTime()方法返回此session对象最后的访问时间(时间戳)

Session对象的生命周期设置

Session也是依附于cookie的，当服务器新建了一个session对象,就会生成一个id,然后通过cookie将此id返回到客户端上id的key为”JSESSIONID”,然后当用户下次来访问此web应用时是带着session对象的id来的,通过此id我们就可以找到与之对应的session对象 ; 但此cookie对象没有设置保存时间，所以并没有写到客户机的硬盘上,而是在客户机的内存中,当用户关闭浏览器时,此cookie会被自动释放，再打开浏览器就访问不到原有的session对象了; 为了解决此问题我们需要重写一个key为”JSESSIONID”，并设置了保存时间(一般与在web.xml配置文件中配置了的时间一致)的cookie 覆盖掉原有的cookie；session的id可以通过session对象的getId()方法获得; 作用域：此session对象只在本工程中有效

在WEB工程的配置文件web.xml文件中添加一个标签: <session-config>

<session-timeout>10session-timeout>

session-config>

表示session对象在10分钟无人使用的情况下,将被自动销毁

也可以直接调用session对象的invalidate();方法，立即销毁此用户的session对象

通过一个servlet向session对象中存值,一个servlet输出session对象中的值的例题：

Jsp中的代码：

<body>

body>

存值的servlet的代码:

//用户访问此Test1 servlet时，向此用户的session对象中存入一个值,当用户访问Test2 servlet时取出用户的session对象所存入的值

//也就是说，当我们第一此获取用户的session对象时,服务器如果没有给此用户创建session对象,那么就给用户新建一个

//session对象的生命周期是：服务器第一次获取用户的session对象到此session对象30分钟(默认)不用时就自动释放

public class Test1 extends HttpServlet {

public void doGet(HttpServletRequest request, HttpServletResponseresponse)

throws ServletException, IOException {

response.setContentType("text/html; charser=utf-8");

response.setCharacterEncoding("utf-8");

request.setCharacterEncoding("utf-8");

//获取在服务器中获取用户的session对象,如果有就返回，没有就创建一个新的session对象再返回

HttpSession session = request.getSession();

//向此用户的session对象总存入值

String str = "hello";

session.setAttribute("data", str);

//打印此值

response.getWriter().print("存入了："+str);

Session也是依附于cookie的，当服务器新建了一个session对象,就会生成一个id,

然后通过cookie将此id返回到客户端上id的key为”JSESSIONID”,然后当用户下次来

访问此web应用时是带着session对象的id来的,通过此id我们就可以找到与之对应的session对象 ;

但此cookie对象没有设置保存时间，所以并没有写到客户机的硬盘上,而是在客户机的内存中,

当用户关闭浏览器时,此cookie会被自动释放，再打开浏览器就访问不到原有的session对象了;

为了解决此问题我们需要重写一个key为”JSESSIONID”，并设置了保存时间(一般与在web.xml配置文件中配置了的时间一致)

的cookie 覆盖掉原有的cookie；session的id可以通过session对象的getId()方法获得;

//下面就是覆盖原有cookie的代码

//获取到session对象的id

String sessionId = session.getId();

//创建一个新的cookie对象(并设置一个键值，key必须为JSESSIONID才能覆盖原有的cookie，value为当前session对象的id)

Cookie cookie = new Cookie("JSESSIONID",sessionId);

//设置cookie的存活时间(一般和web.xml配置的session对象的存活时间一致,缺省为30分钟)

cookie.setMaxAge(1800);//存活时间为30分钟，不调用此方法设置值，此cookie将不会被写入客户机的硬盘上

//设置此cookie的站点

cookie.setPath("/session");

//返回给客户机

response.addCookie(cookie);

}

public void doPost(HttpServletRequest request, HttpServletResponseresponse)

throws ServletException, IOException {

doGet(request, response);

}

取值的servlet的代码:

//用户访问取出Test1 servlet存在session对象中的值

public class Test2 extends HttpServlet {

public void doGet(HttpServletRequest request, HttpServletResponseresponse)

throws ServletException, IOException {

response.setContentType("text/html; charser=utf-8");

response.setCharacterEncoding("utf-8");

request.setCharacterEncoding("utf-8");

//取出此用户的session对象

HttpSession session = request.getSession(false);//传入一个false，表示此方法只获取session对象,并不创建session对象(当没有session对象时)

//HttpSessionsession = request.getSession();//此方法虽然也可以,但如果此用户没有session对象时，此处并不需要创建一个session对象,所以最好用上面这种方法,(可以增加效率)

//再取出此session对象中的data的值

String str = "no";

//判断是否获取到了session对象

if(session != null){

str = (String)session.getAttribute("data");

}

//打印此值

response.getWriter().print("取出了："+str);

}

public void doPost(HttpServletRequest request, HttpServletResponseresponse)

throws ServletException, IOException {

doGet(request, response);

}

当用户禁用cookie后怎么解决传入session对象的id问题（通过url想servlet带入session对象的id，但用户关闭浏览器后将失去session对象，无法避免(上面用cookie可以避免)）

上面的servlet中的代码不变 jsp中代码为:

<body>

//当访问首页时就创建此session对象

request.getSession();

//encodeURL()是本应用级别的,encodeRedirectURL()是跨应用的

//此方法会在servlet/Test1后面自动加上session对象的id（重要：如果在servlet重定向跳转时，这里重写url的方法是：response.encodeRedirectURL("servlet/Test1")

Stringurl1 = response.encodeURL("servlet/Test1"); //这里是重写在jsp中跳转页面的url 所以用response.encodeURL("servlet/Test1")）

//此方法会在servlet/Test2后面自动加上session对象的id

Stringurl2 = response.encodeURL("servlet/Test2");

body>

还有在做登录时需要用到session对象,当用户登录成功后就把user对象存入session中，当注销时就需要调用session对象的invalidate();方法，立即销毁此session对象，也可用session.removeAttribute("user");值删除指定的映射关系(推荐)

base64编码

如果一个字符串用dase64编码, 会将这个字符串的二进制代码的3个字节转换为4个字节,在最高位补0的形式;

如：

10100110 11110010 00010100

dase64编码后：

00101001 00101111 00001000 00010100

这样每个字节的第值就在0-63之间了，再经过dase64的码表转换过来后就是只有包括了键盘上的所有字符

在java中获得dase64编码对象

sun.misc.BASE64Encoder base64Encoder = new sun.misc.BASE64Encoder();//获得dase64编码对象

String str = base64Encoder.encode(byte[] arg0);//传入一个byte[]数组,将将这个数组用dase64编码，并返回一个新的字符串

在java 中获得dase64解码对象

sun.misc.BASE64Decoderbase64Decoder = new BASE64Decoder();//创建解码对象

byte[] buff =base64Decoder.decodeBuffer(str);//将要解码字符串传入,返回一个byte数组

String token = new String(buff);//通过这个byte数组创建一个字符串

一般在MyEclipse不能用，需用以下方法进行设置

只需要在projectbuild path中的JRE System Library中的Accessible，再重新添加库JRE System Library 的Accessible，Rule Pattarn为**，重新编译后就一切正常了（如下图）

JSP开发

jsp是SUN公司定义的一种用于开发动态web页面的计算，和html不同的是，jsp允许在页面中编写java代码及在页面中获取request、response等对象实现与浏览器交互,所以jsp也是一种web资源开发技术

jsp文件在访问时服务器会将其转换为servlet的java文件(转换后文件的位置Tomcat7.0\work\Catalina\localhost\工程名\org\apache\jsp;

一、jsp中的代码转换后,会被放到此java文件中的_jspService( )方法中

二、因为第一次访问一个jsp文件时,会将此jsp翻译成servlet，所以 jsp文件在第一次访问时会很慢，第二次访问时引擎(就是将jsp转换为servlet的程序)发现jsp文件没有改变就不在翻译,直接访问此servlet所以速度快

三、并且JSP引擎在调用_jspService( )方法时,会传入9个隐式对象(下面JSP隐式对象中讲)

JSP模版元素

JSP中的模板元素定义了网页的基本骨架,即定义了页面的结构和外观

JSP表达式

JSP表达式用于将程序数据输出到客户端语法<%=变量或表达式 %> 也就是直接在此位置输出数据

服务器会将此语法直接转换为 out.print(变量或表达式);

JSP脚本片断

就是在jsp文件中嵌套<% java代码 %>这就是脚本片断, 可以出现在jsp中的任意位置，脚本片断中只能出现java代码;

Jsp中可以出现多个脚本片断,在两个脚本片断之间可以嵌套文本、HTML标签及其他jsp元素

多个脚本片断中的代码可以相互访问，单个脚本片断中的java语句可以是不完整的,但是多个脚本片断组合后的结果必须是完整的java语句,例如:

for(inti=0; i<5; i++){

hello world!

}

这表示把

hello world!

输出5遍

JSP声明

如果在用以下方式定义脚本片断,表示把此脚本片断中的代码放到_jspService( )方法的外面去，例如：

<%!

Publicstatic void fun(){

System.out.println(“helloworld!”);

}

，如果不将此java代码放到_jspService( )方法的外面去,相当于在_jspService()方法的内部定义了一个fun()方法，这样java语法是不允许的；这样我们就也可以在JSP中定义一个成员变量或静态域等功能了

JSP注释

在JSP中的注释方法是<%--被注释的内容 --%>

此方法注释是，当服务器将jsp文件转换为servlet时，会丢弃此注释,并不会向用户返回此注释的代码；如果用此方法注释,服务器会将此代码发送给客户,会增加网络数据；用此种注释,被注释的javaBean标签也会被servlet翻译，所以在jsp中尽量注意

JSP模板更改

修改模板路径：MyEclipse\plugins\com.genuitec.eclipse.wizards_11.0.0.me201303311935.jar中templates\jsp\Jsp.vtl文件中修改

JSP指令

Jsp指令是为了JSP引擎(就是将jsp转换为servlet的程序)而设计的,它们并不是直接生产任何可见输出,而只告诉引擎如何将jsp页面翻译成servlet,指令只是用于传给引擎,并不会发送给客户机，在jsp2.0中共定义了三个指令：

page指令

语法<%@ 指令属性名=”值” %>

示例:

<%@ page contentType=”text/html;charset=gb2312” %>

表示告诉引擎此文件的格式及编码

多个属性可以写在一个指令中(用空格分隔),也可以写在多个指令中

示例:

<%@page contentType=”text/html; charset=gb2312” %>

<%@page import=”java.Util.Date” %>

和

<%@ pagecontentType=”text/html; charset=gb2312” import=”java.Util.Date” %>

是一样的效果

page指令和存放在jsp中的任意位置,但最好放在JSP页面的起始位置

page指令的属性

language=”java” 表示在JSP脚本片断中的代码是java代码

extends=”package.class” 表示此jsp翻译成servlet后继承谁(一般不改)

import=”java.util.Date，java.sql.* ” 表示在此jsp中的脚本片断中的java代码需要导入的包，多个包可以用”，”隔开,也可以写多个page指令导入

jsp中以下包会自动导入

java.lang.*;

javax.servlet.*;

javax.servlet.jsp.*;

javax.servlet.http.*;

session=”true| false” 是否获取此用户的session对象(默认值为true, 获取)，如果设为不自动获取, 我们也可以手动通过request对象来获取session对象

buffer=”none| 20kb” 设置out隐式对象的缓存，缺省默认为8KB的缓存，none为不缓存

autoFlush=”true| false” 设置out隐式对象的缓存满后是否自动刷新,一般不改(默认为true, 自动刷新)

isThreadSafe=”true| false” 设置此jsp的线程是否是安全的(默认为true, 是线程安全的)，如果设置为false 那么此jsp翻译成servlet后会实现SingleThreadModel接口以确保线程安全(SingleThreadModel接口上面已讲过);

info=”text” 可以通过此属性带信息

errorPage=”relative_url” 指定当此jsp页面出现异常后，转向哪个页面，此路径必须使用相对路径,如果以”/”开头表示相对于当前应用的程序的根目录, 否则相对于当前的页面位置

此属性只是设置此jsp异常时跳转的页面,也可以再web.xml文件中配置全局的异常跳转页面,如：

<error-page>

<exception-type>java.lang.ArithmeticExceptionexception-type>

<location>/error.jsplocation>

error-page>

表示当前web应用中所有的serlvet及jsp文件抛出java.lang.ArithmeticException异常后将跳转至/error.jsp这个jsp文件

<error-page>

<error-code>404error-code>

<location>/error.jsplocation>

error-page>

表示当前web应用抛出404(找不到资源)异常后，就跳转至/error.jsp这个jsp文件

如果在一个jsp文件中设置了errorPage的属性，那么在web.xml文件中设置的异常跳转，将不对此jsp页面起作用

isErrorPage=”true | false” 设置当前页面是否为错误处理页面（默认值为false,不是错误处理页面），如果将此属性设为true,那么此jsp会接收一个异常对象(exception)

contentType=”text/html;charset=ISO-8859-1” 告诉告诉浏览器打开此文件的格式及编码 (也就是设置response的Content-Type头属性的值)

pageEncoding=”characterSet |ISO-8859-1” 也是设置编码格式的

isELIgnored="true | false" 是否忽略EL表达式，默认为false(不忽略)；

include指令

语法<%@ includefile=” /Test1/head.jsp” %>

用此指令包含属于静态包含

静态包含，在将jsp转换为servlet时就将要包含的jsp文件整合成一个servlet，在返回给客户机，所以静态包含只有一个serlvet,效率高

用request.getRequestDispatcher("/Test1/head.jsp").include(request,response);方法包含就是动态包含

动态包含，就是包含者需要访问被包含者时,再去访问被包含者的servlet,所以包含了多少个jsp文件就会多出多少个servlet,效率低

注意事项: 被包含者不能有外部的框架(框架代码) ,因为包含时会将被包含者文件中的所有字符都包含到其中

taglib指令

taglib指令用于在JSP页面中导入标签库,语法：<%@ taglib url=” http://java.sun.com/jsp/jstl/core” prifix=”c”%>

JSP隐式对象

JSP引擎在调用_jspService()方法时,会传入9个隐式对象（注意cookie不是一个隐式对象）

request 请求对象(已讲)

response 响应对象(已讲)

session 回话对象(已讲)

application servletContext对象(已讲)

config servletConfig对象(已讲)

page 当前的servlet(this)对象,因接收时转换成了Object对象,所以用时要强转为org.apache.jasper.runtime.HttpJspBase(已讲)

exception 错误对象，当只有page指令的isErrorPage属性设置为”true”(表示此页面是错误处理页面)时才会传入此对象(此对象继承了Exception对象, 已讲)

out

out 隐式对象用于向客户发送字符数据

out对象通过pageContext对象的getOut方法获得,其作用和用法与response.getWriter()方法非常相似。

此out隐式对象的类型为JspWriter，JspWriter相当于一种带缓存功能的PringtWriter，设置JSP页面的page指令的buffer属性可以调整此out对象的缓存大小,也可以关闭缓存

只有向此out对象中写入了内容，且满足以下任何一个条件, out对象才去调用response.getWriter()方法,并通过该方法返回的PrintWriter输出流对象将out对象的缓冲区的内容正真写入到Servlet引擎提供的缓冲区域中；

1、设置page指令的buffer属性的值为：none，关闭out对象的缓存

2、out对象的缓存区已满

3、jsp页面结束

注意事项: 此out对象不要和response.getWriter流对象一起使用 ,不然会出现输出顺序不一致的异常

pageContext

1、 pageContext对象是JSP技术中最中意的一个对象，它代表JSP页面的运行环境

2、 pageContext对象封装了其他8大隐式对象的引用

3、 pageContext对象它自身就是一个域对象,可以用来存储数据

4、 pageContext对象还封装了web开发中经常涉及到的一些常用的操作, 如包含和转发到其他资源, 检索其他域对象中的属性等

5、生命周期: 当jsp文件执行完成后，此域就被销毁了

获取其它隐式对象的方法

pageContext.getEcception(); 获取exception隐式对象

pageContext.getPage(); 获取page隐式对象(this)

pageContext.getRequest(); 获取request(请求)隐式对象

pageContext.getResponse(); 获取response(响应)隐式对象

pageContext.getServletConfig(); 获取servletConfig隐式对象

pageContext.getServletContext(); 获取servletContext隐式对象

pageContext.getSession(); 获取session隐式对象

pageContext.getOut(); 获取out隐式对象

pageContext对象中域方法

pageContext.setAttribute(Stringkey,String value); 向pageContext域中存入值,注意pageContext对象的生命周期是:当前的jsp文件执行完成后就消失了,所以要注意pageContext的使用范围

pageContext.getAttribute(Stringkey); 获取pageContext对象域中的映射值

pageContext.removeAttribute(Stringkey); 删除pageContext对象中的映射关系

pageContext对象中访问其它三个域的方法

pageContext对象中有代表各个域的常量(int 类型)

pageContext.APPLICATION_SCOPE 表示application (servletContext)对象

pageContext.SESSION_SCOPE 表示session对象

pageContext.REQUEST_SCOPE 表示request对象

pageContext.PAGE_SCOPE 表示当前的pageContext对象

pageContext对象中有获取其他域中键值的方法

pageContext.getAttribute(Stringkey, pageContext.SESSION_SCOPE); 表示获取session对象中的映射关系pageContext.SESSION_SCOPE这个常量代表session对象

pageContext.setAttribute(Stringkey, String value, pageContext.SESSION_SCOPE); 表示设置session对象中的映射关系

pageContext.removeAttribute(Stringkey, pageContext.SESSION_SCOPE); 表示删除session对象中的映射关系

pageContext.findAttribute方法

pageContext.findAttribute(String key); 此方法是遍历获取所有域中的键值关系（顺序: pageContext-> request -> session -> application(servletContext)）如果在request对象中找到了此映射关系的值,那么将不会在向下继续寻找，如四个域中都没找到此键值关系，就返回一个“”字符串，并不是“null”

pageContext对象中定义了forward(转发)方法和include(动态包含)方法分别用来简化和代替request.getRequestDispatcher(“url”).forward(request, response)方法；参数是要转发的url(加”/”表示当前的web应用根目录)。但这两个方法，会将除了pageContext这个域对象以外的所有对象转发或包含过去

servlet中的四大域对象有：

pageContext 当jsp文件执行完成后，此域就被销毁了

request 当request对象销毁是，此域就被销毁了

session session对象域的存活时间是可以调整的，默认情况下30分钟无操作自动销毁

servletContext 当前web应用中的所有资源都可以访问此域，此对象的存活时间为, 当服务器启动就创建, 当服务器关闭时销毁(一般存储在此域中的键值在不用时都要用.removeAttribute(String key)方法来删除此键值，不然会浪费资源)

JSP标签

JSP标签页称为JSP Action(JSP动作)元素，它用于在jsp页面中提供业务逻辑功能,避免在JSP页面中直接编写java代码造成jsp页面难以维护

jsp中有如下三个常用的标签:

标签

语法:(动态包含和pageContext.include(“/url”)是一样的)会将除了pageContext这个域对象以外的所有对象转发或包含过去

标签

语法:(转发和pageContext.forward(“url”)是一样的)会将除了pageContext这个域对象以外的所有对象转发或包含过去

标签(配合前面两个标签一起使用)

语法：

用法:

//可传入多个键值

这样我们就可以在/servlet中用request. getParameter("key");方法来获取key的值, 也就是说可以通过标签传值给转发或包含的jsp或serlvet

JSP映射与serlvet的映射

servlet的映射(前面已讲过)

在web应用中注册com.scxh.Test这个serlvet，并取名为Test

<servlet-name>Testservlet-name>

<servlet-class>com.scxh.Testservlet-class>//不加“/”相对于classes目录，加上相对于当前的web目录，此处不用加

1//如果在web.xml配置文件中在当前Servlet注册标签中加上了当前标签，就会在服务器启动时创建当前的Servlet对象,并调用Servlet对象的init方法；

servlet>

serlvet的映射

<servlet-mapping>

<servlet-name>Testservlet-name>

<url-pattern>*.comurl-pattern>//不能在前面加字符了，如：<url-pattern>aa/*.comurl-pattern>;这样也是不允许的

servlet-mapping>

JSP的映射

在web应用中注册这个head.jsp文件并取名为head

<servlet-name>headservlet-name>

<jsp-file>/Test1/head.jspjsp-file>//不加“/”相对于classes目录，加上相对于当前的web目录,此处需加上

1//如果在web.xml配置文件中在当前JSP注册标签中加上了当前标签，就会在服务器启动时创建当前的JSP所对应的Servlet对象,并调用Servlet对象的init方法；

servlet>

映射这个jsp

<servlet-mapping>

<servlet-name>headservlet-name>

<url-pattern>/head.htlmurl-pattern>//这样我们就可以再浏览器值直接工程名/head.htlm 访问head.jsp文件了

servlet-mapping>

JavaBean

JavaBean一般用于封装数据的实体，JavaBean是一个遵循特定写法的java类, 它通常具有如下特点:

1. 这个java类必须具有一个无参的构造函数

2. 属性必须私有化

3. 私有化的属性必须有public类型的set和get方法(set方法称为对属性的修改器,get方法称为属性的访问)

4. 必须放在一个java文件中并且此类必须为public类型的

JSP中提供了三个标签用于操作javaBean

示例：

JSP中的代码：

<jsp:useBean id="ren" class="cn.Demo1" scope="page">jsp:useBean> <%--如果这个scope属性不缺省，默认值为“page“--%>

<%=ren.getName() %>

转换为servlet后的代码

cn.Demo1ren= null; //创建一个cn.Demo1这个类的引用变量，取名为

//到pageContext域对象中去取ren这个映射关系

ren =(cn.Demo1)_jspx_page_context.getAttribute("ren", PageContext.PAGE_SCOPE);

//判断是否取到，没有取到就在内存中创建个新的对象

if (ren == null){

//创建一个新的对象

ren = new cn.Demo1();

//并把此对象存入pageContext域中,key值为引用的变量名

_jspx_page_context.setAttribute("ren",ren, PageContext.PAGE_SCOPE);

}

也就是说当我们在标签中把id设置”ren” 并把class设置为一个类(带有包名的完整名称)时,那么系统会自动创建这个类名为ren的引用变量, 如果scope属性的值为page，表示到pageContext域中去获取key为ren的Bean对象，如果没有获取到就创建一个这个类的新对象,并存入scope域对象中key的值就是id的值(“ren”)；scope的值可以使四大域中的任何一个;

注意事项：

嵌套的代码

在标签中嵌套的代码只有当这个标签创建一个新对象时,此代码才会执行；如果在域中获取到了此对象(此标签就不创建新对象)，中间嵌套的代码将不会执行

通过Bean对象的属性名来给此属性赋值(配合标签来用)

<%--标签的用法（配合标签来用） --%>

<%-- 通过Bean为"ren"对象中的"gender"属性赋值为”女“ --%>

<jsp:setProperty name="ren" property="gender"value="女"/>

<%=ren.getGender() %><%-- 打印的值为：”女“ --%>

<%="
1-----------------------------------------------------------------
" %>

<%-- 可以用字符串为8大基本类型赋值(会自动将字符串转换为向对应的类) --%>

<jsp:setProperty name="ren" property="id"value="13"/><%--这里的id属性为int类型，赋值字符串会自动转换 --%>

<%=ren.getId() %><%-- 打印的值为：”13“ --%>

<%="
2-----------------------------------------------------------------
" %>

<%-- 通过请求参数为ren对象的password赋值 --%>

<%-- 提交的方式为:http://localhost:8080/javaBean/Test1/Demo1.jsp?password=abc123 --%>

<jsp:setProperty name="ren" property="password"param="password"/>

<%=ren.getPassword() %><%-- 打印的值为：”abc123“ --%>

<%--param="password" 这句话会被翻译成 request.getParameter("password");

也就是所从我们提交的数据中去找password这可以key的值，找到了就赋值，没有这个key就不赋值--%>

<%="
3-----------------------------------------------------------------
" %>

<%-- 通过请求参数为ren对象的date赋值（date为Date日期对象） --%>

<%-- 提交的方式为:http://localhost:8080/javaBean/Test1/Demo1.jsp?date=2012-5-19 --%>

<%-- Date date = newSimpleDateFormat("yyyy-MM-dd").parse(request.getParameter("date"));--%>

<%-- --%>

<%=ren.getDate() %><%--打印的值为：Sat May 19 00:00:00 CST 2012 --%>

<%--从以上value="<%=date %>代码出可以看出，value的值可以引用java代码所返回的值 --%>

<%="
4-----------------------------------------------------------------
" %>

<%-- 通过请求参数自动为ren对象对应的属性赋值 --%>

<%-- 提交的方式为:http://localhost:8080/javaBean/Test1/Demo1.jsp?name=lishi&gender=nan

注意此处用中文会出现get方式提交乱码问题(前面已讲过怎么解决)--%>

<jsp:setProperty name="ren"property="*" /><%--还可以写为<jsp:setProperty name="ren"property="name" />表示从请求中找到name这个key，并赋值给ren这个对象-->

<%=ren.getName() %><%--打印的值为：lishi --%>

<%=ren.getGender() %><%--打印的值为：nan --%>

<%-- 如果property="*"的话，那么表示根据名称自动匹配请求参数的key给ren对象中和此key一样的属性赋值--%>

此标签用于读取JavaBean对象的属性，也就是调用属性的get方法,然后将读取属性的值转换成字符串后插入响应的正文中，如果某个属性的值为null,那么输出的内容为字符串”null”

语法：

<jsp:getProperty name="ren" property="name"/>

<%--表示直接输出ren这个Bean对象的name属性，如果此属性的值为null，那么将输出"null"字符串 --%>

JSP设计模式

JSP+JavaBean模式

此模式适合开发逻辑不太复杂的web应用程序,这种模式下,JavaBean用于封装业务数据,JSP即负责处理用户请求,又显示数据

Servlet(controller)+JSP(view)+JavaBean(model)称为MVC模式

此模式适合开发复杂的web应用,在这种模式下,serlvet复杂处理用户请求,JSP负责显示数据，JavaBean负责封装数据，采用此MVC模式各个模块之间层次清晰,web开发推荐采用此模式

此模式分为三层：web层、业务逻辑层(service)、数据访问层（dao）

Web层分

处理用户请求

Service(业务逻辑层)

处理dao层返回的数据，及封装这些数据

Dao(数据访问层)

访问数据库

包名规范

cn.itcast.domain 存放javaBean的类

cn.itcast.dao 存放Dao层的类

cn.itcast.dao.impl 存放Dao层的接口

cn.itcast.servce 存放Service层的类

cn.itcast.servce.impl 存放servlce层的接口

cn.itcast.web.serlvet名存放处理用户请求的servlet+JSP

cn.itcast.web.listener

cn.itcast.web.filter

cn.itcast.utils 存放工具类的包

Junit.test 存放测试的程序

在MVC模式下的jsp文件必须放在WEB-INF/jsp目录中防止客户端直接访问

MVC模式开发的流程图：

EL表达式

EL表达式语法：${date }如果在jsp中用此语句，那么表示到每个域中去找date的映射关系，找到了就返回此date的value,如果没有找到就返回一个“”为空的字符串；

此表达式会翻译成servlet的代码：pageContext.findAttribute(date); 此方法是遍历获取所有域中的键值关系（顺序: pageContext-> request -> session -> application(servletContext)）如果在request对象中找到了此映射关系的值,那么将不会在向下继续寻找，如四个域中都没找到此键值关系，就返回一个“”字符串，并不是“null”（上面已讲过）（可以从指定域中获取指定的映射关系）

如果存入的是一个key键所对应的是一个Bean对象，EL表达式语法为:${date.name}; 那么当取出date对象后会去调用name属性的get方法，并返回其值

在WEB开发中，如果JS中要用到EL表达式，在JSP引入JS文件时，可以把js文件命名为.jsp文件就可以了，这样里面el就能运行，也就是服务器可以执行这个文件了。无非页面引用的时候引用jsp就可以了。

如：

你可能感兴趣的:(Jsp之神笔记)

10月|愿你的青春不负梦想-读书笔记-01 Tracy的小书斋
本书的作者是俞敏洪，大家都很熟悉他了吧。俞敏洪老师是我行业的领头羊吧，也是我事业上的偶像。本日摘录他书中第一章中的金句：『一个人如果什么目标都没有，就会浑浑噩噩，感觉生命中缺少能量。能给我们能量的，是对未来的期待。第一件事，我始终为了进步而努力。与其追寻全世界的骏马，不如种植丰美的草原，到时骏马自然会来。第二件事，我始终有阶段性的目标。什么东西能给我能量？答案是对未来的期待。』读到这里的时候，我便
《投行人生》读书笔记小蘑菇的树洞
《投行人生》----作者詹姆斯-A-朗德摩根斯坦利副主席40年的职业洞见-很短小精悍的篇幅，比较适合初入职场的新人。第一部分成功的职业生涯需要规划1.情商归为适应能力分享与协作同理心适应能力，更多的是自我意识，你有能力识别自己的情并分辨这些情绪如何影响你的思想和行为。2.对于初入职场的人的建议，细节，截止日期和数据很重要截止日期，一种有效的方法是请老板为你所有的任务进行优先级排序。和老板喝咖啡的好
【一起学Rust | 设计模式】习惯语法——使用借用类型作为参数、格式化拼接字符串、构造函数广龙宇一起学Rust #Rust设计模式 rust 设计模式开发语言
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档文章目录前言一、使用借用类型作为参数二、格式化拼接字符串三、使用构造函数总结前言Rust不是传统的面向对象编程语言，它的所有特性，使其独一无二。因此，学习特定于Rust的设计模式是必要的。本系列文章为作者学习《Rust设计模式》的学习笔记以及自己的见解。因此，本系列文章的结构也与此书的结构相同（后续可能会调成结构），基本上分为三个部分
git常用命令笔记咩酱-小羊 git 笔记
###用习惯了idea总是不记得git的一些常见命令，需要用到的时候总是担心旁边站了人~~~记个笔记@_@，告诉自己看笔记不丢人初始化初始化一个新的Git仓库gitinit配置配置用户信息gitconfig--globaluser.name"YourName"gitconfig--globaluser.email"[email protected]"基本操作克隆远程仓库gitclone查看
509. 斐波那契数(每日一题) lzyprime
lzyprime博客(github)创建时间：2021.01.04qq及邮箱：2383518170leetcode笔记题目描述斐波那契数，通常用F(n)表示，形成的序列称为斐波那契数列。该数列由0和1开始，后面的每一项数字都是前面两项数字的和。也就是：F(0)=0，F(1)=1F(n)=F(n-1)+F(n-2)，其中n>1给你n，请计算F(n)。示例1：输入：2输出：1解释：F(2)=F(1)+
拥有断舍离的心态，过精简生活--《断舍离》读书笔记爱吃丸子的小樱桃
不知不觉间房间里的东西越来越多，虽然摆放整齐，但也时常会觉得空间逼仄，令人心生烦闷。抱着断舍离的态度，我开始阅读《断舍离》这本书，希望从书中能找到一些有效的方法，帮助我实现空间、物品上的断舍离。《断舍离》是日本作家山下英子通过自己的经历、思考和实践总结而成的，整体内涵也从刚开始的私人生活哲学的“断舍离”升华成了“人生实践哲学”，接着又成为每个人都能实行的“改变人生的断舍离”，从“哲学”逐渐升华成“
四章-32-点要素的聚合彩云飘过
本文基于腾讯课堂老胡的课《跟我学Openlayers--基础实例详解》做的学习笔记，使用的openlayers5.3.xapi。源码见1032.html，对应的官网示例https://openlayers.org/en/latest/examples/cluster.htmlhttps://openlayers.org/en/latest/examples/earthquake-clusters.
高端密码学院笔记285 柚子_b4b4
高端幸福密码学院（高级班）幸福使者：李华第（598）期《幸福》之回归内在深层生命原动力基础篇——揭秘“激励”成长的喜悦心理案例分析主讲：刘莉一，知识扩充:成功=艰苦劳动+正确方法+少说空话。贪图省力的船夫，目标永远下游。智者的梦再美，也不如愚人实干的脚印。幸福早课堂2020.10.16星期五一笔记:1，重视和珍惜的前提是知道它的价值非常重要，当你珍惜了，你就真正定下来，真正的学到身上。2，大家需要
Day17笔记-高阶函数 ~在杰难逃~ Python 笔记 python 开发语言 pycharm 数据分析
高阶函数【重点掌握】函数的本质：函数是一个变量，函数名是一个变量名，一个函数可以作为另一个函数的参数或返回值使用如果A函数作为B函数的参数，B函数调用完成之后，会得到一个结果，则B函数被称为高阶函数常用的高阶函数：map(),reduce(),filter(),sorted()1.map()map(func,iterable)，返回值是一个iterator【容器，迭代器】func:函数iterab
Day1笔记-Python简介&标识符和关键字&输入输出 ~在杰难逃~ Python python 开发语言大数据数据分析数据挖掘
大家好，从今天开始呢，杰哥开展一个新的专栏，当然，数据分析部分也会不定时更新的，这个新的专栏主要是讲解一些Python的基础语法和知识，帮助0基础的小伙伴入门和学习Python，感兴趣的小伙伴可以开始认真学习啦！一、Python简介【了解】1.计算机工作原理编程语言就是用来定义计算机程序的形式语言。我们通过编程语言来编写程序代码，再通过语言处理程序执行向计算机发送指令，让计算机完成对应的工作，编程
node.js学习小猿L node.js node.js 学习 vim
node.js学习实操及笔记温故node.js，node.js学习实操过程及笔记~node.js学习视频node.js官网node.js中文网实操笔记githubcsdn笔记为什么学node.js可以让别人访问我们编写的网页为后续的框架学习打下基础，三大框架vuereactangular离不开node.jsnode.js是什么官网：node.js是一个开源的、跨平台的运行JavaScript的运行
数据仓库——维度表一致性墨染丶eye 背诵数据仓库
数据仓库基础笔记思维导图已经整理完毕，完整连接为：数据仓库基础知识笔记思维导图维度一致性问题从逻辑层面来看，当一系列星型模型共享一组公共维度时，所涉及的维度称为一致性维度。当维度表存在不一致时，短期的成功难以弥补长期的错误。维度时确保不同过程中信息集成起来实现横向钻取货活动的关键。造成横向钻取失败的原因维度结构的差别，因为维度的差别，分析工作涉及的领域从简单到复杂，但是都是通过复杂的报表来弥补设计
【Git】常见命令(仅笔记) 好想有猫猫 Git Linux学习笔记 git 笔记 elasticsearch linux c++
文章目录创建/初始化本地仓库添加本地仓库配置项提交文件查看仓库状态回退仓库查看日志分支删除文件暂存工作区代码远程仓库使用`.gitigore`文件让git不追踪一些文件标签创建/初始化本地仓库gitinit添加本地仓库配置项gitconfig-l#以列表形式显示配置项gitconfiguser.name"ljh"#配置user.namegitconfiguser.email"[email protected]
为什么你总是对下属不满意? ZhaoWu1050
【ZhaoWu的听课笔记】大多数公司，都存在两种问题。我创业四年，更是体会深切。这两种问题就是：老板经常不满意下属的表现；下属总是不知道老板想要什么；虽然这两种问题普遍存在，其实解决方法并不复杂。这节课，我们再聊聊第一个问题：为什么老板经常不满意下属表现?其实，这背后也是一条管理常识。管理学家德鲁克先生早就说过：管理者的任务，不是去改变人。*来自《卓有成效的管理者》只是大多数老板和我一样，都是一边
母亲节如何做小红书营销美橙传媒
小红书的一举一动引起了外界的高度关注。通过爆款笔记和流行话题，我们可以看到“干货”类型的内容在小红书中偏向实用的生活经验共享和生活指南非常受欢迎。根据运营社的分析，这种现象是由小红书用户心智和内容社区背后机制共同决定的。首先，小红书将使用“强搜索”逻辑为用户提供特定的“搜索场景”。在“我必须这样生活”中，大量使用了满足小红书站用户喜好和需求的内容。内容社区自制的高质量内容也吸引了寻找营销新途径的品
读书笔记|《遇见孩子，遇见更好的自己》5 抹茶社长
为人父母意味着放弃自己的过去，不要对以往没有实现的心愿耿耿于怀，只有这样，孩子们才能做回自己。985909803.jpg孩子在与父母保持亲密的同时更需要独立，唯有这样，孩子才会成为孩子，父母才会成其为父母。有耐心的人生往往更幸福，给孩子留点余地。认识到养儿育女是对耐心的考验。为失败做好心理准备，教会孩子控制情绪。了解自己的底线，说到底线，有一点很重要，父母之所以发脾气，真正的原因往往在于他们自己，
基于Python给出的PDF文档转Markdown文档的方法程序媛了了 python pdf 开发语言
注：网上有很多将Markdown文档转为PDF文档的方法，但是却很少有将PDF文档转为Markdown文档的方法。就算有，比如某些网站声称可以将PDF文档转为Markdown文档，尝试过，不太符合自己的要求，而且无法保证文档没有泄露风险。于是本人为了解决这个问题，借助GPT（能使用GPT镜像或者有条件直接使用GPT的，反正能调用GPT接口就行）生成Python代码来完成这个功能。笔记、代码难免存在
语文主题教学学习笔记之87 东哥杂谈
“语文主题教学”学习笔记之八十七（0125）今天继续学习小学语文主题教学的实践样态。板块三：教学中体现“书艺”味道。作为四大名著之一的《水浒传》，堪称我国文学宝库之经典。对从《水浒传》中摘选的单元，教师就要了解其原生态，即评书体特点。这也要求教师要了解一些常用的评书行话术语，然后在教学时适时地加入一些，让学生体味其文本中原有的特色。学生也要尽可能地通过朗读的方式，而不单是分析讲解的方式进行学习。细
Armv8.3 体系结构扩展--原文版代码改变世界ctw ARM-TEE-Android armv8 嵌入式 arm架构安全架构芯片 Trustzone Secureboot
快速链接:.ARMv8/ARMv9架构入门到精通-[目录]付费专栏-付费课程【购买须知】:个人博客笔记导读目录(全部)TheArmv8.3architectureextensionTheArmv8.3architectureextensionisanextensiontoArmv8.2.Itaddsmandatoryandoptionalarchitecturalfeatures.Somefeat
springboot+vue项目实战一-创建SpringBoot简单项目苹果酱0567 面试题汇总与解析 spring boot 后端 java 中间件开发语言
这段时间抽空给女朋友搭建一个个人博客，想着记录一下建站的过程，就当做笔记吧。虽然复制zjblog只要一个小时就可以搞定一个网站，或者用cms系统，三四个小时就可以做出一个前后台都有的网站，而且想做成啥样也都行。但是就是要从新做，自己做的意义不一样，更何况，俺就是专门干这个的，嘿嘿嘿要做一个网站，而且从零开始，首先呢就是技术选型了，经过一番思量决定选择-SpringBoot做后端，前端使用Vue做一
阅读《认知觉醒》读书笔记就看看书
本周阅读了周岭的《认知觉醒开启自我改变的原动力》，启发较多，故做读书笔记一则，留待学习。全书共八章，讲述了大脑、潜意识、元认知、专注力、学习力、行动力、情绪力及成本最低的成长之道。具体描述了大脑、焦虑、耐心、模糊、感性、元认知、自控力、专注力、情绪专注、学习专注、匹配、深度、关联、体系、打卡、反馈、休息、清晰、傻瓜、行动、心智宽带、单一视角、游戏心态、早起、冥想、阅读、写作、运动等相关知识点。大脑
阅读笔记：阅读方法中的逻辑和转念施吉涛
聊聊一些阅读的方法论吧，别人家的读书方法刚开始想写，然后就不知道写什么了，因为作者写的非常的“精致”我有一种乡巴佬进城的感觉，看到精美的摆盘，精致的食材不知道该如何下口也就是《阅读的方法》，我们姑且来试一下强劲的大脑篇，第一节：逻辑通俗的来讲，也就是表达的排列和顺序，再进一步就是因果关系和关联实际上书已经看了大概一遍，但直到打算写一下笔记的时候，才发现作者讲的推理更多的是阅读的对象中呈现出的逻辑也
《转介绍方法论》学习笔记小可乐的妈妈
一、高效转介绍的流程：价值观---执行----方案一）转介绍发生的背景：1、对象：谁向谁转介绍？全员营销，人人参与。①员工的激励政策、客户的转介绍诱因制作客户画像：a信任；支付能力；意愿度；便利度（根据家长具备四个特征的个数分为四类）B性格分类C职业分类D年龄性别②执行：套路，策略，方法，流程2、诱因：为什么要转介绍？认同信任；多方共赢；传递美好；零风险承诺打动人心，超越期待。选择做教育，就是选择
JAVA学习笔记之23种设计模式学习 victorfreedom Java技术设计模式 android java 常用设计模式
博主最近买了《设计模式》这本书来学习，无奈这本书是以C++语言为基础进行说明，整个学习流程下来效率不是很高，虽然有的设计模式通俗易懂，但感觉还是没有充分的掌握了所有的设计模式。于是博主百度了一番，发现有大神写过了这方面的问题，于是博主迅速拿来学习。一、设计模式的分类总体来说设计模式分为三大类：创建型模式，共五种：工厂方法模式、抽象工厂模式、单例模式、建造者模式、原型模式。结构型模式，共七种：适配器
解决Obsidian写笔记中的＜img＞标签无法显示图片的问题全能全知者笔记
Obsidian中写md笔记如果使用标签会显示不出图案，后来才知道因为Obsidian的问题导致只能用绝对路径定位。所以我本人写了一个py插件，将md笔记里的img标签批量替换成Obsidian能够读取的形式。安装FixObsImgDpy:pipinstallFixObsImgDpy安装完成后在需要修复的md文件的父目录下运行命令:FixObsImgDpy就会自动修复父目录以下的全部md文件仓库
2021年周总结 03 Ruby之家
这周的生活过得也是比较快，因为暂时住的离公司有点距离，所以通勤时间相对较长一点，而在地铁上的一个半小时如何充分利用起来，则是我最近一直在思考的问题，2021年想让自己的生活都运行在计划中。(有时候自己想干一件事情就总是给自己找很多借口，想着以后怎么怎么样？然而哪有那么多的以后，能够方便当下的工作生活就立马执行就OK，这仅仅只是我此时想到背的很重的老人机笔记本电脑，也算是陪伴我快8年的—当时买的时候
2021-12-11 人生导演
今天读到佛学书籍的一段话：初学者很难直接体验到无我，但可以经常提醒自己：一切事物都是无我的。不断强化这个观念，也会相当有帮助。比如生病了我们一般会说：“我不舒服！我很痛！我很惨！”这时候如果我们提醒自己：没有我，只是这个肉体的某些部分、某些功能出了问题，不舒服、疼痛也只是一时的感受，而感受随时在变化。仅仅是知道没有一个实存的我在生病、在受苦。然后把“一切事物都是无我的”这句话，记到笔记上，并且朗读
新能源汽车 BMS 学习笔记篇—BMS 基本定义及分类 WPG大大通其他笔记汽车 BMS 经验分享新能源电池
一、BMS定义1、概念：BMS（BatteryManagementSystem）即电池管理系统，其管理对象是二次电池（充电电池或蓄电池），其主要目的是电池的利用率，防止电池出现过度充电和过度放电，可应用于电动汽车、电瓶车、机器人、无人机等图片来源：腾讯网https://new.qq.com《标准普尔警告，电动汽车电池生产面临供应链和地缘政治风险》2、四大功能①感知和测量：检测电池的电压、电流、温度
机器学习-聚类算法不良人龍木木机器学习机器学习算法聚类
机器学习-聚类算法1.AHC2.K-means3.SC4.MCL仅个人笔记，感谢点赞关注！1.AHC2.K-means3.SC传统谱聚类：个人对谱聚类算法的理解以及改进4.MCL目前仅专注于NLP的技术学习和分享感谢大家的关注与支持！
LeetCode github集合，附CMU大神整理笔记 Wesley@ LeetCode github
GithubLeetCode集合本人所有做过的题目都写在一个java项目中，同步到github中了，算是见证自己的进步。github目前同步的题目是2020-09-17日之后写的题。之前写过的题会陆续跟新到github中。目前大概400个题目Github项目链接：https://github.com/sunliancheng/leetcode_github附上一份优秀的教材整合：这是卡内基梅隆(C
xml解析小猪猪08 xml
1、DOM解析的步奏准备工作： 1.创建DocumentBuilderFactory的对象 2.创建DocumentBuilder对象 3.通过DocumentBuilder对象的parse(String fileName)方法解析xml文件 4.通过Document的getElem
每个开发人员都需要了解的一个SQL技巧 brotherlamp linux linux视频 linux教程 linux自学 linux资料
对于数据过滤而言CHECK约束已经算是相当不错了。然而它仍存在一些缺陷，比如说它们是应用到表上面的，但有的时候你可能希望指定一条约束，而它只在特定条件下才生效。使用SQL标准的WITH CHECK OPTION子句就能完成这点，至少Oracle和SQL Server都实现了这个功能。下面是实现方式： CREATE TABLE books ( id &
Quartz——CronTrigger触发器 eksliang quartz CronTrigger
转载请出自出处：http://eksliang.iteye.com/blog/2208295 一.概述 CronTrigger 能够提供比 SimpleTrigger 更有具体实际意义的调度方案，调度规则基于 Cron 表达式，CronTrigger 支持日历相关的重复时间间隔（比如每月第一个周一执行），而不是简单的周期时间间隔。二.Cron表达式介绍 1）Cron表达式规则表 Quartz
Informatica基础 18289753290 Informatica Monitor manager workflow Designer
1. 1）PowerCenter Designer：设计开发环境，定义源及目标数据结构；设计转换规则，生成ETL映射。 2）Workflow Manager：合理地实现复杂的ETL工作流，基于时间，事件的作业调度 3）Workflow Monitor：监控Workflow和Session运行情况，生成日志和报告 4）Repository Manager：
linux下为程序创建启动和关闭的的sh文件，scrapyd为例酷的飞上天空 scrapy
对于一些未提供service管理的程序每次启动和关闭都要加上全部路径，想到可以做一个简单的启动和关闭控制的文件下面以scrapy启动server为例，文件名为run.sh： #端口号，根据此端口号确定PID PORT=6800 #启动命令所在目录 HOME='/home/jmscra/scrapy/' #查询出监听了PORT端口
人--自私与无私永夜-极光
今天上毛概课,老师提出一个问题--人是自私的还是无私的,根源是什么? 从客观的角度来看,人有自私的行为,也有无私的
Ubuntu安装NS-3 环境脚本随便小屋 ubuntu
将附件下载下来之后解压，将解压后的文件ns3environment.sh复制到下载目录下（其实放在哪里都可以，就是为了和我下面的命令相统一）。输入命令： sudo ./ns3environment.sh >>result 这样系统就自动安装ns3的环境，运行的结果在result文件中，如果提示 com
创业的简单感受 aijuans 创业的简单感受
2009年11月9日我进入a公司实习，2012年4月26日，我离开a公司，开始自己的创业之旅。今天是2012年5月30日，我忽然很想谈谈自己创业一个月的感受。当初离开边锋时，我就对自己说：“自己选择的路，就是跪着也要把他走完”，我也做好了心理准备，准备迎接一次次的困难。我这次走出来，不管成败
如何经营自己的独立人脉 aoyouzi 如何经营自己的独立人脉
独立人脉不是父母、亲戚的人脉，而是自己主动投入构造的人脉圈。“放长线，钓大鱼”，先行投入才能产生后续产出。现在几乎做所有的事情都需要人脉。以银行柜员为例，需要拉储户，而其本质就是社会人脉，就是社交！很多人都说，人脉我不行，因为我爸不行、我妈不行、我姨不行、我舅不行……我谁谁谁都不行，怎么能建立人脉？我这里说的人脉，是你的独立人脉。以一个普通的银行柜员
JSP基础百合不是茶 jsp 注释隐式对象
1,JSP语句的声明 <%! 声明 %> 　　声明：这个就是提供java代码声明变量、方法等的场所。表达式 <%= 表达式 %> 　　这个相当于赋值，可以在页面上显示表达式的结果，程序代码段/小型指令　<% 程序代码片段 %> 2,JSP的注释
web.xml之session-config、mime-mapping bijian1013 java web.xml servlet session-config mime-mapping
session-config 1.定义： <session-config> <session-timeout>20</session-timeout> </session-config> 2.作用：用于定义整个WEB站点session的有效期限，单位是分钟。 mime-mapping 1.定义： <mime-m
互联网开放平台（1） Bill_chen 互联网 qq 新浪微博百度腾讯
现在各互联网公司都推出了自己的开放平台供用户创造自己的应用，互联网的开放技术欣欣向荣，自己总结如下： 1.淘宝开放平台(TOP) 网址：http://open.taobao.com/ 依赖淘宝强大的电子商务数据，将淘宝内部业务数据作为API开放出去，同时将外部ISV的应用引入进来。目前TOP的三条主线： TOP访问网站：open.taobao.com ISV后台：my.open.ta
【MongoDB学习笔记九】MongoDB索引 bit1129 mongodb
索引可以在任意列上建立索引索引的构造和使用与传统关系型数据库几乎一样,适用于Oracle的索引优化技巧也适用于Mongodb 使用索引可以加快查询,但同时会降低修改,插入等的性能内嵌文档照样可以建立使用索引测试数据 var p1 = { "name":"Jack", "age&q
JDBC常用API之外的总结白糖_ jdbc
做JAVA的人玩JDBC肯定已经很熟练了，像DriverManager、Connection、ResultSet、Statement这些基本类大家肯定很常用啦，我不赘述那些诸如注册JDBC驱动、创建连接、获取数据集的API了，在这我介绍一些写框架时常用的API，大家共同学习吧。 ResultSetMetaData获取ResultSet对象的元数据信息
apache VelocityEngine使用记录 bozch VelocityEngine
VelocityEngine是一个模板引擎，能够基于模板生成指定的文件代码。使用方法如下： VelocityEngine engine = new VelocityEngine();// 定义模板引擎 Properties properties = new Properties();// 模板引擎属
编程之美-快速找出故障机器 bylijinnan 编程之美
package beautyOfCoding; import java.util.Arrays; public class TheLostID { /*编程之美假设一个机器仅存储一个标号为ID的记录，假设机器总量在10亿以下且ID是小于10亿的整数，假设每份数据保存两个备份，这样就有两个机器存储了同样的数据。 1.假设在某个时间得到一个数据文件ID的列表，是
关于Java中redirect与forward的区别 chenbowen00 java servlet
在Servlet中两种实现： forward方式：request.getRequestDispatcher(“/somePage.jsp”).forward(request, response); redirect方式：response.sendRedirect(“/somePage.jsp”); forward是服务器内部重定向，程序收到请求后重新定向到另一个程序，客户机并不知
[信号与系统]人体最关键的两个信号节点 comsci 系统
如果把人体看做是一个带生物磁场的导体,那么这个导体有两个很重要的节点,第一个在头部,中医的名称叫做百汇穴, 另外一个节点在腰部,中医的名称叫做命门如果要保护自己的脑部磁场不受到外界有害信号的攻击,最简单的
oracle 存储过程执行权限 daizj oracle 存储过程权限执行者调用者
在数据库系统中存储过程是必不可少的利器，存储过程是预先编译好的为实现一个复杂功能的一段Sql语句集合。它的优点我就不多说了，说一下我碰到的问题吧。我在项目开发的过程中需要用存储过程来实现一个功能，其中涉及到判断一张表是否已经建立，没有建立就由存储过程来建立这张表。 CREATE OR REPLACE PROCEDURE TestProc IS fla
为mysql数据库建立索引 dengkane mysql 性能索引
前些时候，一位颇高级的程序员居然问我什么叫做索引，令我感到十分的惊奇，我想这绝不会是沧海一粟，因为有成千上万的开发者（可能大部分是使用MySQL的）都没有受过有关数据库的正规培训，尽管他们都为客户做过一些开发，但却对如何为数据库建立适当的索引所知较少，因此我起了写一篇相关文章的念头。最普通的情况，是为出现在where子句的字段建一个索引。为方便讲述，我们先建立一个如下的表。
学习C语言常见误区如何看懂一个程序如何掌握一个程序以及几个小题目示例 dcj3sjt126com c 算法
如果看懂一个程序，分三步 1、流程 2、每个语句的功能 3、试数如何学习一些小算法的程序尝试自己去编程解决它，大部分人都自己无法解决如果解决不了就看答案关键是把答案看懂，这个是要花很大的精力，也是我们学习的重点看懂之后尝试自己去修改程序，并且知道修改之后程序的不同输出结果的含义照着答案去敲调试错误
centos6.3安装php5.4报错 dcj3sjt126com centos6
报错内容如下: Resolving Dependencies --> Running transaction check ---> Package php54w.x86_64 0:5.4.38-1.w6 will be installed --> Processing Dependency: php54w-common(x86-64) = 5.4.38-1.w6 for
JSONP请求 flyer0126 jsonp
使用jsonp不能发起POST请求。 It is not possible to make a JSONP POST request. JSONP works by creating a <script> tag that executes Javascript from a different domain; it is not pos
Spring Security（03）——核心类简介 234390216 Authentication
核心类简介目录 1.1 Authentication 1.2 SecurityContextHolder 1.3 AuthenticationManager和AuthenticationProvider 1.3.1 &nb
在CentOS上部署JAVA服务 java--hhf java jdk centos Java服务
本文将介绍如何在CentOS上运行Java Web服务，其中将包括如何搭建JAVA运行环境、如何开启端口号、如何使得服务在命令执行窗口关闭后依旧运行第一步：卸载旧Linux自带的JDK ①查看本机JDK版本 java -version 结果如下 java version "1.6.0"
oracle、sqlserver、mysql常用函数对比[to_char、to_number、to_date] ldzyz007 oracle mysql SQL Server
oracle &n
记Protocol Oriented Programming in Swift of WWDC 2015 ningandjin protocol WWDC 2015 Swift2.0
其实最先朋友让我就这个题目写篇文章的时候，我是拒绝的，因为觉得苹果就是在炒冷饭，把已经流行了数十年的OOP中的“面向接口编程”还拿来讲，看完整个Session之后呢，虽然还是觉得在炒冷饭，但是毕竟还是加了蛋的，有些东西还是值得说说的。通常谈到面向接口编程，其主要作用是把系统设计和具体实现分离开，让系统的每个部分都可以在不影响别的部分的情况下，改变自身的具体实现。接口的设计就反映了系统
搭建 CentOS 6 服务器(15) - Keepalived、HAProxy、LVS rensanning keepalived
（一）Keepalived （1）安装 # cd /usr/local/src # wget http://www.keepalived.org/software/keepalived-1.2.15.tar.gz # tar zxvf keepalived-1.2.15.tar.gz # cd keepalived-1.2.15 # ./configure # make &a
ORACLE数据库SCN和时间的互相转换 tomcat_oracle oracle sql
SCN（System Change Number 简称 SCN）是当Oracle数据库更新后，由DBMS自动维护去累积递增的一个数字，可以理解成ORACLE数据库的时间戳，从ORACLE 10G开始，提供了函数可以实现SCN和时间进行相互转换；　　用途：在进行数据库的还原和利用数据库的闪回功能时，进行SCN和时间的转换就变的非常必要了；　　操作方法：　　1、通过dbms_f
Spring MVC 方法注解拦截器 xp9802 spring mvc
应用场景，在方法级别对本次调用进行鉴权，如api接口中有个用户唯一标示accessToken,对于有accessToken的每次请求可以在方法加一个拦截器，获得本次请求的用户，存放到request或者session域。 python中，之前在python flask中可以使用装饰器来对方法进行预处理，进行权限处理先看一个实例,使用@access_required拦截： ?

按字母分类： A B C D E F G H I J K L M N O P Q R S T U V W X Y Z 其他