[技术笔记] 石家庄6期JDBC+WEb核心

JDBC+WEB核心

1、JDBC回顾

第一章、 JDBC的使用
1.1、JDBC的概述
JDBC：Java  Database Connectivity Java数据库的连接
是sun公司统一提供的一套接口规范（jdbc），各个数据库生产商提供实现。
驱动：两个硬件设备之间通信的桥梁
1.2、JDBC的开发步骤
注册驱动
获得连接
获得执行SQL语句对象
释放资源
1.3、单元测试（@Test）
单元测试就是用来替代main方法的
优点：
⑴ 、可以直接通过结果颜色直观放映我们代码有没有问题
⑵ 、一个类中可以测试很多方法，并且多个方法之间没有干扰；
注意事项：
单元测试红色的错误线条什么时候出现？
1、程序出现异常
2、 Assert语句期望值和实际值不一样得我时候
1.4、DButils工具类
工具类的抽取：
public class JDBCUtils {

/**
   * 注册驱动的方法
   */
public static void loadDriver(){
try {
Class.forName("com.mysql.jdbc.Driver");
} catch (ClassNotFoundException e) {
e.printStackTrace();
}
}
/**
   * 获得连接的方法
   */
public static Connection getConnection(){

Connection conn = null;
try {
loadDriver();
conn = DriverManager.getConnection("jdbc:mysql:///web_07", "root", "123");
} catch (SQLException e) {
e.printStackTrace();
}
return conn;
}

/**
   * 释放资源的方法
   */
public static void release(ResultSet rs,Statement stmt,Connection conn){
if (rs != null) {
         try {
            rs.close();
         } catch (SQLException e) {
            e.printStackTrace();
         }
         // 垃圾回收尽快回收对象.
         rs = null;
      }
if (stmt != null) {
         try {
            stmt.close();
         } catch (SQLException e) {
            e.printStackTrace();
         }
         // 垃圾回收尽快回收对象.
         stmt = null;
      }
if (conn != null) {
         try {
            conn.close();
         } catch (SQLException e) {
            e.printStackTrace();
         }
         // 垃圾回收尽快回收对象.
         conn = null;
      }
}

public static void release(Statement stmt,Connection conn){
if (stmt != null) {
         try {
            stmt.close();
         } catch (SQLException e) {
            e.printStackTrace();
         }
         // 垃圾回收尽快回收对象.
         stmt = null;
      }
if (conn != null) {
         try {
            conn.close();
         } catch (SQLException e) {
            e.printStackTrace();
         }
         // 垃圾回收尽快回收对象.
         conn = null;
      }
}
}
1.5、JDBC的APL
1、Connection:创建执行SQL的对象

进行事物管理：

2、Statement:执行SQL语句

执行批处理：

3、ResultSet:获取结果集中的数据：
 获得结果集中的数据：
* getXXX(int idx);
   * select cname,cid from category;
* getXXX(String name);
 默认情况下：next();
* 正常的情况下结果集只能向下的.
第二章、装饰者设计模式
传统JDBC的操作,对连接的对象销毁不是特别好.每次创建和销毁连接都是需要花费时间.可以使用连接池优化的程序.
* 在程序开始的时候,可以创建几个连接,将连接放入到连接池中.用户使用连接的时候,可以从连接池中进行获取.用完之后,可以将连接归还连接池.
2.1、自定义连接池
* SUN公司提供了一个连接池的接口.(javax.sql.DataSource).
* 定义一个连接池:实现这个接口.
* 使用List集合存放多个连接的对象.
2.2、自定义连接池的代码
public class MyDataSource implements DataSource{
// 创建一个List集合用于存放多个连接对象.
private List<Connection> list = new ArrayList<Connection>();
// 在程序开始的时候，初始化几个连接,将连接存放到list中.
public MyDataSource() {
// 初始化3个连接:
for(int i=1;i<=3;i++){
Connection conn = JDBCUtils.getConnection();
list.add(conn);
}
}

@Override
// 获得连接的方法：
public Connection getConnection() throws SQLException {
if(list.size() <= 0){
for(int i=1;i<=3;i++){
Connection conn = JDBCUtils.getConnection();
list.add(conn);
}
}
Connection conn = list.remove(0);
return conn;
}

// 归还连接的方法：
public void addBack(Connection conn){
list.add(conn);
}
...
}
2.3、自定义连接池中的问题及如何解决
 问题?
1.如果使用自定义连接池,那么需要额外记住自定义连接池中的API.
2.能不能使用面向接口的编程方式.
解决：
不额外提供API方法，就可以解决上述两个问题！！！
能不能还调用Connection的close方法.能不能增强Connection的close方法,原有的销毁变为归还!!!
2.3.1、如何增强Connertion的close方法：（3中继承、装饰者设计模式、动态代理的方式）
* 增强一个Java类中的某个方法有几种方式???
* 一种方式：继承的方式.(灵活性太低)
      * 能够控制这个类的构造的时候,才可以使用继承.

* 二种方式：装饰者模式方式.（增强类的功能）
      * 包装对象和被包装的对象都要实现相同的接口.
      * 包装的对象中需要获得到被包装对象的引用.
      ***** 缺点：如果接口的方法比较多,增强其中的某个方法.其他的功能的方法需要原有调用.

* 三种方式：动态代理的方式.
      * 被增强的对象实现接口就可以.
装饰者设计模式就是为了增强功能
增强功能（1、继承
通用性太差了
2、装饰者设计模式
准则：被装饰类和装饰类要继承，实现同一个接口
为什么要实现同一个接口？
保证被装饰类整体功能的完善（拉双眼皮，不要鼻子不好使了）

弊端：接口的方法过多的时候
为了增强一个方法，要重写里面好多没用的方法
就要实现里面所有的方法
3、动态代理）
适配器设计模式：解决操作方法重写的功能
先写一个类把那个类原封不动的重写一遍
装饰类在也不要去实现接口，直接继承适配器挑里面的一个或几个方法就可以了
装饰类一目了然就可以看见哪个类被重写了
2.3.2、继承和装饰者的案例
/**
* 继承的方式增强一个类中某个方法:
*/
class Man{
public void run(){
System.out.println("跑....");
}
}

class SuperMan extends Man{
public void run(){
// super.run();
System.out.println("飞....");
}
}

/**
* 使用装饰者的方式完成类的方法的增强
*/
interface Waiter{
public void server();
}

class Waiteress implements Waiter{

@Override
public void server() {
System.out.println("服务...");
}

}

class WaiteressWrapper implements Waiter{
private Waiter waiter;

public WaiteressWrapper(Waiter waiter) {
this.waiter = waiter;
}

@Override
public void server() {
System.out.println("微笑...");
// this.waiter.server();

}

}
2.3.3、使用装饰者模式增强Connection的close方法
public class MyConnection implements Connection{

private Connection conn;
private List<Connection> list;

public MyConnection(Connection conn,List<Connection> list) {
this.conn = conn;
this.list = list;
}

@Override
public void close() throws SQLException {
list.add(conn);
}
   ...
}

连接池的getConnection方法：
@Override
// 获得连接的方法：
public Connection getConnection() throws SQLException {
if(list.size() <= 0){
for(int i=1;i<=3;i++){
Connection conn = JDBCUtils.getConnection();
list.add(conn);
}
}
Connection conn = list.remove(0);
MyConnection myConn = new MyConnection(conn, list);
return myConn;
}

第三章、连接池（c3p0 Dbcp）
3.1、常见的开源的数据连接池
1、DBCP：database Connection pool 数据库连接池
作用：是为了提高效率（不断的创建连接和释放资源是耗费内存的）
 DBCP：
DBCP(DataBase connection pool),数据库连接池。是 apache 上的一个 java 连接池项目，也是 tomcat 使用的连接池组件。单独使用dbcp需要2个包：commons-dbcp.jar,commons-pool.jar由于建立数据库连接是一个非常耗时耗资源的行为，所以通过连接池预先同数据库建立一些连接，放在内存中，应用程序需要建立数据库连接时直接到连接池中申请一个就行，用完后再放回去。
 C3P0：
C3P0是一个开源的JDBC连接池，它实现了数据源和JNDI绑定，支持JDBC3规范和JDBC2的标准扩展。目前使用它的开源项目有Hibernate，Spring等。
 Tomcat内置连接池：
2、DBCP连接池的使用
第一步：引入DBCP连接池的jar包.
第二步：编写DBCP代码：
* 手动设置参数:
* 配置文件设置参数:
3、DBCP连接池的使用
@Test
/**
   * 手动方式:
   */
public void demo1(){
Connection conn = null;
PreparedStatement stmt = null;
ResultSet rs = null;
BasicDataSource dataSource = new BasicDataSource();
dataSource.setDriverClassName("com.mysql.jdbc.Driver");
dataSource.setUrl("jdbc:mysql:///web_07");
dataSource.setUsername("root");
dataSource.setPassword("123");
try{
// 获得连接:
conn = dataSource.getConnection();
// 编写SQL:
String sql = "select * from category";
// 预编译SQL:
stmt = conn.prepareStatement(sql);
// 执行SQL:
rs = stmt.executeQuery();
while(rs.next()){
System.out.println(rs.getInt("cid")+" "+rs.getString("cname"));
}
}catch(Exception e){
e.printStackTrace();
}finally{
JDBCUtils.release(rs,stmt, conn);
}
}

@Test
/**
   * 配置文件方式：
   */
public void demo2(){
Connection conn = null;
PreparedStatement stmt = null;
ResultSet rs = null;
Properties properties = new Properties();

try{
properties.load(new FileInputStream("src/dbcpconfig.properties"));
DataSource dataSource = BasicDataSourceFactory.createDataSource(properties);
// 获得连接:
conn = dataSource.getConnection();
// 编写SQL:
String sql = "select * from category";
// 预编译SQL:
stmt = conn.prepareStatement(sql);
// 执行SQL:
rs = stmt.executeQuery();
while(rs.next()){
System.out.println(rs.getInt("cid")+" "+rs.getString("cname"));
}
}catch(Exception e){
e.printStackTrace();
}finally{
JDBCUtils.release(rs,stmt, conn);
}
}
3.2、C3p0连接池的使用
第一步：引入C3P0连接池的jar包.
第二步：编写代码：
* 手动设置参数:
* 配置文件设置参数：
3.2.1、C3P0改造工具类
public class JDBCUtils2 {
private static final ComboPooledDataSource DATA_SOURCE =new ComboPooledDataSource();
/**
   * 获得连接的方法
   */
public static Connection getConnection(){
Connection conn = null;
try {
conn = DATA_SOURCE.getConnection();
} catch (SQLException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
return conn;
}
...
}
Day 10(2018-1-25)JDBC高级与xml
3.3、DBUtils的工具类
每次进行JDBC的CURP的操作的时候，有很多的代码都是相似的，可以不可以抽取工具类，完成一些通用的代码
3.3.1、【JDBC的元数据MataData】（了解）-- 编写通用性较高的代码.
 DatabaseMetaData：获得数据库连接的信息,获得数据库的表的信息.
* 获得数据库元数据:Connection中getMetaData();

 ParameterMetaData：获得SQL中的参数的个数及类型.
* 获得参数元数据：PreparedStatement中getParameterMetaData()

 ResultSetMetaData：获得结果集中的列名及列的类型.
* 获得结果集元数据：ResultSet中getMetaData ()
3.3.2、元数据的使用(数据库元数据、参数元数据、结果集元数据)
@Test
/**
   * 数据库元数据
   */
public void demo1(){
Connection conn = null;
conn = JDBCUtils2.getConnection();
// 获得数据库元数据:
try {
DatabaseMetaData metaData = conn.getMetaData();
System.out.println("获得驱动名称:"+metaData.getDriverName());
System.out.println("获得驱动URL:"+metaData.getURL());
System.out.println("获得用户名:"+metaData.getUserName());

// 获得表中的主键：
ResultSet rs = metaData.getPrimaryKeys(null, null, "category");
if(rs.next()){
String name = rs.getString("COLUMN_NAME");
System.out.println(name);
}
} catch (SQLException e) {
e.printStackTrace();
}
}

@Test
/**
   * 参数元数据：
   */
public void demo2(){
Connection conn = null;
PreparedStatement stmt = null;
try{
conn = JDBCUtils2.getConnection();
String sql = "update category set cname = ? where cid = ?";
stmt = conn.prepareStatement(sql);
ParameterMetaData metaData = stmt.getParameterMetaData();
int count = metaData.getParameterCount();
System.out.println(count);
}catch(Exception e){

}
}

@Test
/**
   * 结果集元数据：
   */
public void demo3(){
Connection conn = null;
PreparedStatement stmt = null;
ResultSet rs = null;
try{
conn = JDBCUtils2.getConnection();
String sql = "select * from category";
stmt = conn.prepareStatement(sql);
rs = stmt.executeQuery();

ResultSetMetaData metaData = rs.getMetaData();
int count = metaData.getColumnCount();
for(int i = 1;i<=count ;i++){
String name = metaData.getColumnName(i);
String type = metaData.getColumnTypeName(i);
System.out.println(name+type);
}
}catch(Exception e){

}
}
第一章、xml作为配置文件的方式完成模拟Tomcat
1.1、什么是xml？（可扩展标记语言，允许用户自定义标签）

 什么是XML:

**** 允许用户自定义标签的！！！
 XML的作用:
* 传输和存取数据.
* 软件的配置文件.
1.2、xml的作用：（主要作为配置文件）
1、传输和存取数据
2、软件的配置文件
用来描述数据
1.3、xml的使用？
1.3.1、Xml的基本语法
 XML的基本语法:
* XML必须有关闭标签
* 区分大小写
* 属性需要有引号
* 标签必须正确嵌套.

⑴、Xml的文档声明
文档声明：在xml的第一行第一列的位置
《xml version=‘1.0” (版本号)，evcoding=’’, standalone=’’》
Evcoding:字符集，是使用浏览器打开的时候采用的默认的字符集的编码
Standalone：描述xml是否需要依赖其他的文件
⑶ 、Xml的注释
<! –xml的注释  -->
⑷ 、Xml的元素
元素（标签）的命名规范：
名称中不能包含冒号：--
* 元素（标签）的命名规范:

***** 名称中不能包含冒号(:)

⑸ 、Xml的属性
* 属性的名称规范与元素一致.
***** 属性需要使用引号！
⑹ 、Xml的特殊字符和CDATA区
⑺ * XML的特殊字符:

* XML的CDATA区:(CDATA:Character Data)
* <![CDATA[  内容  ]]>

1.4、Dom4J解析xml
JAXP：是SUN公司推出的解析标准实现。
Dom4J：是开源组织推出的解析开发包。(牛，大家都在用，包括SUN公司的一些技术的实现都在用。)
Dom for java four

1.4.1、XML的解析(DOM 、SAX、Xpath)
 XML的解析:从XML文档中获得想要的数据(通过代码完成的.)
 XML的解析的方式(*****):
* DOM解析:DOM:Document Object Model.
* SAX解析:Simple Api for XML.
Xpath解析xml:
* DOM和SAX的区别:

 针对这两种解析的方式，不同的公司提供了不同的API的实现.
* JAXP :SUN公司提供的一套XML的解析的API.
* JDOM :开源组织提供了一套XML的解析的API-jdom.
* DOM4J :开源组织提供了一套XML的解析的API-dom4j.
* pull :主要应用在Android手机端解析XML.

 DOM4J的入门案例步骤:
* 【步骤一】导入jar包.dom4j-1.6.1.jar
* 【步骤二】创建解析器 SaxReader
* 【步骤三】解析文档获得代表文档的Document对象. —— SAXReader 的 read()方法获取Document。
* 【步骤四】获得跟节点.——通过Document对象的getRootElement（）得到根节点
* 【步骤五】从跟节点下查找其他的节点. 使用根节点获取他下面的节点element() elements(“标签名称”)

* 代码实现:
@Test
/**
   * 获得元素的内容:查询的操作.
   */
public void demo1() throws Exception{
// 创建解析器
SAXReader reader = new SAXReader();
// 解析XML的文档
Document document = reader.read("xml/demo1.xml");
// 获得跟节点
Element root = document.getRootElement();
System.out.println(root.getName());
// 查找跟节点下的子节点. element() elements();
Element pElement = root.element("person"); // 查找的是第一个person元素
// root.elements("person").get(1); // 查找的是第二个person元素
Element nElement = pElement.element("name");
Element aElement = pElement.element("age");
Element sElement = pElement.element("sex");
System.out.println(nElement.getText());
System.out.println(aElement.getText());
System.out.println(sElement.getText());
}
 XPath：
* dom4j支持XPath的jar包.
* jaxen-1.1-beta-6.jar
* dom4j的XPath支持的API:
* List document.selectNodes(String xPath);
* Node document.selectSingleNode(String xPath);
* 代码:
@Test
/**
   * DOM4J的XPath的写法:
   */
public void demo2() throws Exception{
// 创建解析器:
SAXReader reader = new SAXReader();
// 解析XML返回Document对象.
Document document = reader.read("xml/demo1.xml");
/*List<Node> list = document.selectNodes("//name");
for (Node node : list) {
Element element = (Element) node;
System.out.println(element.getText());
}*/

List<Node> list = document.selectNodes("//person['@id']");
for (Node node : list) {
Element element = (Element) node;
System.out.println(element.attributeValue("id"));
}
}
【步骤一】：将基础班的Socket编写的代码复制到工程中.
【步骤二】：新建xml.在conf/server.xml
【步骤三】：使用DOM4J解析XML
public class MyServer {

public static void main(String[] args) throws Exception {
// 解析XML:
// 创建解析器
SAXReader reader = new SAXReader();thhtyh
// 解析XML文档:
Document document = reader.read("conf/server.xml");
Element element = (Element)document.selectSingleNode("//Connector['@port']");
String port = element.attributeValue("port");
// ServerSocket 对象可以监听端口
ServerSocket serversocket = new ServerSocket(Integer.parseInt(port));
while(true) {
Socket socket = serversocket.accept(); // 等待客户端的连接请求，一旦有请求过来，就结束阻塞，返回客户端对象
//System.out.println(socket.getInetAddress());
// 一旦有客户来访问，就另开一个新线程去提供服务， main线程继续等待下一个客户的连接
new Thread(new MyService(socket)).start();

}
}

}
1.5、xml的约束：
Xml的约束：用来规范xml的写法
Xml的约束的种类及区别
DTD（文档类型定义）：
DTD引入的方式：
内部的DTD：
外部的DTD：（1、本地的DTD 2、网络DTD）
Scheme：
 XML的约束的额概述:
* 什么是XML的约束 :就是用来约束XML的文档中可以出现哪些标签，不能出现哪些标签，标签中是否有顺序，出现的次数.
* XML的约束 :用来规范XML的写法.
***** XML的约束的种类及区别?
   * DTD 和 Schema :
      * 区别:
         1.DTD语法是自成一体的.Schema语法就是XML的语法.
         2.Schema的语法就是XML的语法所以更容易被解析器所解析.
         3.Schema支持名称空间.
         4.Schema有比DTD更加强大的语义和语法的约束.
 1.5.1、DTD的语法 :(了解)
* DTD的引入方式:
   * 内部的DTD:
<!DOCTYPE persons [

]>
   * 外部的DTD:
      * 一种本地DTD:
      <!DOCTYPE persons SYSTEM "unknown.dtd">
      * 一种网络DTD:
      <!DOCTYPE persons PUBLIC（网络的） "//UNKNOWN/" "unknown.dtd">
* DTD的语法:
   * 元素:
      * <!ELEMENT 元素名元素类型>
         * 元素类型:
               * EMPTY
               * ANY
               * 子元素
                  * 是否有序: 使用逗号(,)或者竖线(|)表示.
                  * 出现的次数：?:零次或一次 +：一次或多次 *：零次或多次
               * PCDATA
* 属性:
      * <!ATTLIST 元素名称属性名称属性的类型属性的约束>
         * 属性的类型:
            * ID类型:表示属性值需要是唯一的.
            * CDATA类型:普通的字符串.
            * 枚举:
         * 属性的约束:

1.5.2、 Schema的语法:(了解)
<?xml version="1.0" encoding="UTF-8"?>

<schema
xmlns="http://www.w3.org/2001/XMLSchema"
targetNamespace="http://www.itheima.com/ee25"
elementFormDefault="qualified">

<element name="persons">

<complexType>
<sequence maxOccurs="unbounded" minOccurs="1">
<element name="person">
<complexType>
<sequence>

<element name="name" type="string"></element>
<element name="age" type="int"></element>
<element name="sex" type="string"></element>
</sequence>
<attribute name="id" type="string" use="required"/>
</complexType>
</element>
</sequence>
</complexType>
</element>
</schema>
Day11(2018-1-27) Tomcat与Servlet入门(web的核心)
第一章、软件的架构（b/s,c/s）
 1.1、C/S架构的软件:
* Client / Server 客户端和服务器端的软件. 都是需要在PC端安装的软件. 比如 QQ,迅雷,暴风...
* 优点:效果炫,一部分代码写到客户端(速度快).
* 缺点:服务器端更新,客户端都需要更新.
1.2、B/s架构的软件：
* Browser / Server 浏览器端和服务器端的软件. 不需要安装到PC端,只需要有一个浏览器即可. 比如京东,网银,WEBQQ,WEB迅雷...
* 优点:服务器端更新,客户端浏览器不需要进行更新.
* 缺点:效果不炫,所有的代码运行都在服务器端,导致服务器压力过大.
* 效果：使用HTML5,CSS3可以做出很炫效果.
* 服务器端压力:搭建服务器的集群.而且还有AJAX技术.
第二章、web的资源
2.1、静态资源
Html\css\js,图片。
2.2、动态资源
PHP：
ASP：
Server/jsp:
2.3、服务器（硬件、软件）
1、硬件：其实就是一台配置很高的电脑
2、软件：必须在电脑上安装服务器软件，这台电脑就是web服务器
2.4、常见的web服务器
Apache:发布php的.LAMP:Linux Apache MYSQL PHP
IIS：发布asp的
WebSphere:IBM公司研发，收费的大型服务器软件，支持EE的所有的开发规范，
WebLogin:BEA公司研发，收发的大型服务器软件，支持EE的所有的开发规范
Tomcat:Apache组织研发，免费的小型的服务器软件，支持Server/JSP的开发规范
JBoss:
2.5、WEB动态资源目录结构
website
|-----静态资源
|-----WEB-INF
            |-----web.xml :必须的
            |-----classes :可选的
            |-----lib :可选的
第三章、Tomcat的安装
3.1、tomcat的安装
解压即可，安装到根目录
3.2、Tomcat的目录结构

* bin :tomcat1的执行的文件.
* conf :tomcat的配置文件.
* lib :tomcat运行的需要的jar包.
* logs :tomcat的运行的日志文件.
* temp :tomcat产生临时文件存放的路径.
* webapps :tomcat发布的web项目的路径.
* work :tomcat运行JSP的时候,JSP翻译成Servlet的代码存放的路径.
第四章、发布一个web到Tomcat中（3中方式）
4.1、直接将工程（项目）copy到Tomcat/webapps中
4.2、配置Tomcat的虚拟路径
* 在tomcat/conf/server.xml文件中进行配置:
* 在<Host>标签下配置:
* <Context path="/itheima" docBase="C:/website"/>
4.3、配置Tomcat的虚拟路径
* 在tomcat/conf/Catalina/localhost/lidi.xml
* 配置<Context docBase="D:/a"/>
* xxx作为虚拟路径的名称.
在地址栏中直接输入localhost：8080/lidi/v.jpg
4.4、总结使用
使用STS工具发布一个WEB工程
4.5、Tomcat常见问题:
1、【没有配置JAVA_HOME引发tomcat一闪消失】
* 一定要配置JAVA_HOME环境变量.
2、【端口号冲突的问题】
* 一种:将占用端口的应用结束.
* netstat -ano
* 打开任务管理器结束：
* 二种:修改自身应用的端口号.
* tomcat/conf/server.xml
第五章、HTTP的协议的概述:
5.1、协议、http协议
规定双方需要遵守的规则
HTTP协议：用来规定浏览器与服务器之间需要遵守的规则

 HTTP协议的作用：规范浏览器和服务器之间的数据传递.
 HTTP协议的特点：
* 基于请求和响应的模型.
* 必须先有请求后有响应.
* 请求和响应必须成对出现.
* 默认的端口号是80.
 HTTP协议的版本:
* 1.0 :每次响应后即刻关闭了连接.
* 1.1 :现在使用.不是每次响应后挂断,等待长时间以后没有请求会挂断.

5.2、HTTP协议的演示
5.3、HTTP协议的详解
5.3.1、请求部分
请求行
* 提交方式:
      * 提交方式有很多,常用的GET和POST:
      * GET和POST的区别:
         * GET的提交的参数会显示到地址栏上,而POST不显示.
         * GET往往是有大小限制的,而POST没有大小的限制.
         * GET没有请求体,而POST有请求体.
* 提交路径:
* 协议版本:
* 请求头
* 都是键值对的形式显示的.一般一个key对应一个value,也有个别的是一个key对应多个value.
* User-Agent :代表浏览器的类型. --- 文件下载:下载中文文件:IE使用URLEncodor进行编码,而Firefox使用Base64编码.
* Referer :代表的是网页的来源. --- 防盗链.
* If-Modified-Since :通常与响应中的头Last-Modified一起使用查找本地缓存.
* 请求体
* 就是POST提交方式的提交的参数.

5.3.2、响应部分
* 响应行:
* 协议版本
* 状态码：
      * 200 ：成功
      * 302 ：重定向
      * 304 ：查找本地缓存
      * 404 ：资源不存在
      * 500 ：服务器内部错误
* 状态码描述
* 响应头：键值对,一般一个key对应一个value,也有一个key对应多个value.
* Last-Modified :与请求中的If-Modified-Since一起使用查找本地缓存.
* Content-Dispostion :文件下载的使用使用的一个头信息.
* Location :重定向的跳转的路径.
* Refresh :定时刷新/定时跳转.
* 响应体:显示浏览器的页面的内容.
第六章、Servlet的概述
6.1、什么是Servlet:
* 就是一个运行在WEB服务器上的小的Java程序,用来接收和响应从客户端发送过来的请求,通常使用HTTP协议.
* Servlet就是SUN公司提供的一个动态网页开发技术.
 6.2、Servlet的作用：
* 用来处理从客户端浏览器发送的请求,并且可以对请求作出响应
 6.3、Servlet的入门:
* 编写类：
public class ServletDemo1 implements Servlet{

@Override
/**
   * 为用户处理请求和响应的方法.
   */
public void service(ServletRequest req, ServletResponse res) throws ServletException, IOException {
res.getWriter().println("Hello Servlet...");
}
...
}
* 配置:
  
  <servlet>
    
    <servlet-name>test1</servlet-name>
    
    <servlet-class>com.itheima.a_servlet.ServletDemo1</servlet-class>
  </servlet>

  
  <servlet-mapping>
    
    <servlet-name>test1</servlet-name>
    
    <url-pattern>/ServletDemo1</url-pattern>
  </servlet-mapping>
* 访问:
http://localhost:8080/day09/ServletDemo1
6.4、ServleRequest接受参数

* String getParameter(String name); ---用于接收一个名称对应一个值的数据.
* String[] getParameterValues(String name);---用于接收一个名称对应多个值的数据.
* Map getParameterMap(); ---用于接收表单中的所有的数据,Map的key是表单提交的参数名称,Map的value是提交参数的值.
* Enumeration getParameterNames() ---用于获取表单中提交的所有的参数的名称.
Day12(2018-1-28)Servlet

第一章、Servlet的实现的关系
1.1、Servlet的实现的关系
Servlet :接口
|
GenericServlet :通用的Servlet
|
HttpServlet :HttpServlet
* 编写一个类继承HttpServlet，重写doGet和doPost方法.
* 配置

1.2、三层架构（表现层、业务逻辑层、数据访问层）
目的：为了软件程序的高内聚低耦合的体现，
表现层：前台页面
业务逻辑层：针对具体问题的操作，也可以说是对数据层的操作，对数据业务进行逻辑处理。
数据访问层：该层所做事物直接操作数据库，针对数据的增，删，改，查（调用数据库里面的数据）
1.3、重点Servlet的生命周期（面试经常问）
 生命周期:就是一个对象从创建到销毁的过程.
 Servlet（Servlet是一个接口）生命周期:Servlet从创建到销毁的过程.
* 何时创建:用户第一次访问Servlet创建Servlet的实例
* 何时销毁:当项目从服务器中移除的时候，或者关闭服务器的时候.
 用户第一次访问Servlet的时候,服务器会创建一个Servlet的实例,那么Servlet中init方法就会执行.任何一次请求服务器都会创建一个新的线程访问Servlet中的service的方法.在service方法内部根据请求的方式的不同调用doXXX的方法.(get请求调用doGet,post请求调用doPost).当Servlet中服务器中移除掉,或者关闭服务器,Servlet的实例就会被销毁,那么destroy方法就会执行.
1.4、Servlet的相关的配置
1.4.1、启动时创建Servlet
Servlet默认是在第一次访问的时候创建的.现在让Servlet在服务器启动的时候创建好.进行对Servlet的配置:
在web.xml中在<servlet></servlet>标签中配置:
* <load-on-startup>2</load-on-startup>  --- 传入正整数,整数越小,被创建的优先级就越高.
1.4.2、url-pattern的配置
url-pattern配置方式共有三种:
1.完全路径匹配：以 / 开始例如: /ServletDemo4 , /aaa/ServletDemo5 , /aaa/bbb/ServletDemo6
2.目录匹配：以 / 开始需要以 * 结束. 例如: /* ,/aaa/* ,/aaa/bbb/*
3.扩展名匹配：不能以 / 开始以 * 开始的. 例如: *.do , *.action
***** 错误的写法： /*.do
有如下的配置:
  <servlet>
<servlet-name>ServletDemo4</servlet-name>
<servlet-class>com.itheima.a_servlet.ServletDemo4</servlet-class>
  </servlet>
  <servlet-mapping>
<servlet-name>ServletDemo4</servlet-name>
<url-pattern>/ServletDemo4</url-pattern>
  </servlet-mapping>

  <servlet>
<servlet-name>ServletDemo5</servlet-name>
<servlet-class>com.itheima.a_servlet.ServletDemo5</servlet-class>
  </servlet>
  <servlet-mapping>
<servlet-name>ServletDemo5</servlet-name>
<url-pattern>/*</url-pattern>
  </servlet-mapping>

  <servlet>
<servlet-name>ServletDemo6</servlet-name>
<servlet-class>com.itheima.a_servlet.ServletDemo6</servlet-class>
  </servlet>
  <servlet-mapping>
<servlet-name>ServletDemo6</servlet-name>
<url-pattern>*.do</url-pattern>
  </servlet-mapping>

如果访问地址:
http://localhost:8080/day09/ServletDemo4 :第一个
http://localhost:8080/day09/aaa.do :第二个
*****　完全路径匹配 > 目录匹配 > 扩展名匹配
1.4.3、开发中的路径的编写
 相对路径:都是需要找位置相对关系.不能以 / 开始的.
* ./ 当前路径  ../上一级目录
* 使用相对路径访问:
* http://localhost:8080/day09/demo4-url/demo1.html
* http://localhost:8080/day09/ServletDemo6
 绝对路径:不需要找位置相对关系. 以 / 开始的.
* 绝对路径中分为客户端路径和服务器端路径:
* 客户端路径一定要加工程名. /day09/ServletDemo6
* 服务器端路径不需要加工程名. /ServletDemo6
第二章、案例
2.1、登录成功5 秒中跳转到其他页面（使用Http协议中的Refresh头信息）
Refresh之前已经介绍可以定时页面跳转.需要使用程序设置头信息才可以.
2.1.1、response中设置响应头

* addHeader(String name,String value); --- 针对一个key对应多个value的响应头.
* addDateHeader(String name,long date);
* addIntHeader(String name,int value);

* setHeader(String name,String value); --- 针对一个key对应一个value的响应头.
* setDateHeader(String name,long date);
* setIntHeader(String name,int value);

例如:头信息: xxx:aaa
* addHeader(“xxx”,”bbb”); -->xxx:aaa,bbb
* setHeader(“xxx”,”bbb”); -->xxx:bbb
2.2、记录网站的登录成功的人数
登录成功后,5秒后跳转到某个页面,在页面中显示您是第x位登录成功的用户.
2.2.1、ServletContext对象
***** ServletContext对象存取数据,存的数据都是有一定的作用的范围的.这种对象称为是域对象.
* 用来存取数据:

* 用来向ServletContext中存入数据.

* 用来从ServletContext中获取数据.

* 用来从ServletContext中移除数据.
2.2.2、获得Servlet的配置信息

* String getServletName(); ---获得Servlet在web.xml中配置的name的值.
* String getInitParameter(String name); ---获得Servlet的初始化参数的.
* Enumeration getInitParameterNames(); ---获得所有Servlet的初始化参数的名称.
2.2.3、ServletContext的其他作用
* 1.用来获得全局初始化参数.
* 2.用来获得文件的MIME的类型.
* 3.作为域对象存取数据.
ServletContext是一个域对象.
* 作用范围:整个web工程.
* 创建:服务器启动的时候,tomcat服务器为每个web项目创建一个单独ServletContext对象.
* 销毁:服务器关闭的时候,或者项目从服务器中移除的时候.

* 4.用来读取web项目下的文件.
第三章、老师的笔记
3.1、Servlet运行在服务器端的小程序
3.2、Servlet作用？用来处理用户的请求并作出相应
3.3、定义的方式：⑴、定义一个类去实现Servlet接口--》现在是定义一个类去继承HttpServlet,要求会创建模板就可以
⑵、以前需要去web.xml自己动手配置，现在不需要要求大家能够配置
3.4、Servlet的生命周期：
⑴、什么时候创建
第一个人访问Servlet的时候，服务会创建Servlet对象，而且是单例的，并且创建的时候init(只有第一次执行)方法执行，所有的访问Servlet方法会执行，服务器关闭或者项目被移除的时候Servlet销毁并且destroy的方法会执行，
3.5、注意事项：
url-pattern虚拟路径的编写???
1.完全路径    例如:/DemoServlet
2.目录匹配    例如:/aaa/*
3.后缀名匹配: 例如  *.txt
完全路径 >目录匹配>后缀名匹配
2.编写的a的访问路径或者是form的访问路径的问题
相对路径和绝对路径:  不能以/开头
建议以后都使用绝对路径 ;  例如 /项目名称/资源目录
3.6、服务器定时跳转
1、设置响应头
响应头属性名：Refresh
相应属性值”秒数，url=要跳转的绝对路径”
response.setHeader("Refresh","2;url=/day12/succest.tml");
2、可以调用js中的Location对象中的href属性
if(time==0){
location.href="/day12/index.html";
}
3、在页面添加meta标签
<meta http-equiv="Refresh"content="3;url=/day12/WEB01/index.html">
4、重定向：
需要设置响应码302，需要设置一个头Location的头---值是要跳转的绝对路径
response.setStatus(302);
response.setHeader("Location","/day12/succest.html");
3.7、ServletContext（创建的时候是唯一的一个，可以被所有的共享）
是一个域对象：ServletContext的生命周期
出生：服务器启动的时候为每一个web项目工程创建单独的一个ServletContext的域对象有且只有一个，这个被整个工程所共享，
死亡：服务器关闭或者项目被移除
作用：
1、获取全局参数
2、获取文件mime类型
3、做为域对象存储全局变量（数据）（setAttribute,getAttribute,removeAttribute
4、读取web下的文件
getResouceAsStream("服务器路径(不加工程名)")
day13(2018-1-30) request和response
第一章、使用ServletContext对象读取WEB项目下的文件
1.1、
/**
   * 传统方式读取文件:
   * * 使用的是相对路径，相对的JVM的路径.
   * * 但是现在是一个web项目,相对于JVM的路径的.现在JVM已经交给tomcat管理.
   * @throws FileNotFoundException
   * @throws IOException
   */
private void test1() throws FileNotFoundException, IOException {
InputStream is = new FileInputStream("src/db.properties");
Properties properties = new Properties();
properties.load(is);

String driverClass = properties.getProperty("driverClass");
String url = properties.getProperty("url");
String username = properties.getProperty("username");
String password = properties.getProperty("password");

System.out.println(driverClass);
System.out.println(url);
System.out.println(username);
System.out.println(password);
}

* InputStream getResourceAsStream(String path); --- 根据提供路径读取文件返回一个文件的输入流.

* String getRealPath(String path); --- 返回一个路径的磁盘绝对路径.

1.1.1、使用getResourceAsStream读取
/**
   * 使用ServletContext中的getResourceAsStream读取.
   * @throws FileNotFoundException
   * @throws IOException
   */
private void test2() throws FileNotFoundException, IOException {

// 获得ServletContext:
ServletContext context = this.getServletContext();
InputStream is = context.getResourceAsStream("/WEB-INF/classes/db.properties");
Properties properties = new Properties();
properties.load(is);

String driverClass = properties.getProperty("driverClass");
String url = properties.getProperty("url");
String username = properties.getProperty("username");
String password = properties.getProperty("password");

System.out.println(driverClass);
System.out.println(url);
System.out.println(username);
System.out.println(password);
}
1.1.2、使用getRealPath读取文件
/**
   * 使用ServletContext中的getRealPath读取.
   * @throws FileNotFoundException
   * @throws IOException
   */
private void test3() throws FileNotFoundException, IOException {
// 获得ServletContext:
ServletContext context = this.getServletContext();
String realPath = context.getRealPath("/WEB-INF/classes/db.properties");
// 获得该文件的磁盘绝对路径.
System.out.println(realPath);
InputStream is = new FileInputStream(realPath);

Properties properties = new Properties();
properties.load(is);

String driverClass = properties.getProperty("driverClass");
String url = properties.getProperty("url");
String username = properties.getProperty("username");
String password = properties.getProperty("password");

System.out.println(driverClass);
System.out.println(url);
System.out.println(username);
System.out.println(password);
}
1.3、ServletContext的功能
1.3.1、读取全局初始化参数

配置全局初始化参数:
  <context-param>
    <param-name>username</param-name>
    <param-value>root</param-value>
  </context-param>
<context-param>
    <param-name>password</param-name>
    <param-value>123</param-value>
  </context-param>

代码:
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
String username = this.getServletContext().getInitParameter("username");
String password = this.getServletContext().getInitParameter("password");

System.out.println(username+" "+password);

Enumeration<String> e = this.getServletContext().getInitParameterNames();
while(e.hasMoreElements()){
String name = e.nextElement();
String value = this.getServletContext().getInitParameter(name);
System.out.println(name+" "+value);
}
}

1.3.2、获得文件的MIMe的类型

* 获得文件的MIME的类型.

代码实现:
/**
   * 获得文件的MIME的类型
   */
private void test2() {
String type = this.getServletContext().getMimeType("1.html");
System.out.println(type);
}

第二章、类加载器读取文件
2.1、类的加载器是用来读取文件
第三章、文件的下载
3.1、response的概述
Response：代表响应的对象，从服务器向浏览器输出内容
3.2、response的常用的api
 响应行:

* 设置状态码.
 响应头:

* 针对一个key对应多个value的头信息.

* 针对一个key对应一个value的头信息.
 响应体

3.3、【文件下载的方式】
 一种：超链接下载.直接将文件的路径写到超链接的href中.---前提:文件类型,浏览器不支持.
 A标签是get方式提交
 二种：手动编写代码的方式完成文件的下载.
* 设置两个头和一个流:
* Content-Type :文件的MIME的类型.
* Content-Disposition :以下载的形式打开文件.
* InputStream :文件的输入流.
第四章、response输出响应内容的方法
向页面响应的方法：
GetoutputStream();字节流
getWrite()字符流
这两个方法时互斥的：  做出响应的时候只能使用其中的一种流响应
* 输出中文乱码的处理:
* 字节流:
      * 设置浏览器默认打开的编码:
         * resposne.setHeader(“Content-Type”,”text/html;charset=UTF-8”);
      * 设置中文字节取出的时候编码.
         * “中文”.getBytes(“UTF-8”);
* 字符流:
      * 设置浏览器打开的时候的编码
         * resposne.setHeader(“Content-Type”,”text/html;charset=UTF-8”);
      * 设置response的缓冲区的编码
         * response.setCharacterEncoding(“UTF-8”);

      ***** 简化的写法:response.setContentType(“text/html;charset=UTF-8”);
第五章、请求（Request）
5.1、request的APL
5.1.1、获得客户机的信息
功能一：获得客户机相关的信息
 获得请求方式：

 获得请求的路径:

 获得客户机相关的信息:

 获得工程名:

5.1.2、获得从页面中提交的数据

5.1.3、作为域对象存取数据

【演示request获得客户机的信息】
public class RequestServlet extends HttpServlet {
private static final long serialVersionUID = 1L;

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// 获得请求方式：
String method = request.getMethod();
System.out.println("请求方式:"+method);
// 获得客户机的IP地址：
String ip = request.getRemoteAddr();
System.out.println("IP地址:"+ip);
// 获得用户的请求的路径:
String url = request.getRequestURL().toString();
String uri = request.getRequestURI();
System.out.println("获得请求的URL:"+url);
System.out.println("获得请求的URI:"+uri);
// 获得发布的工程名：
String contextPath = request.getContextPath();
System.out.println("工程名:"+contextPath);

}

protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
doGet(request, response);
}

}
5.2、处理request接收参数的中文乱码的问题
现在无论是GET还是POST提交中文的时候,都会出现乱码的问题.
解决:
 POST的解决方案:
* POST的参数在请求体中,直接到达后台的Servlet.数据封装到Servlet中的request中.request也有一个缓冲区.request的缓冲区也是ISO-8859-1编码.
* 设置request的缓冲区的编码:
* request.setCharacterEncoding(“UTF-8”);  --- 一定要在接收参数之前设置编码就OK.
 GET的解决方案:
* 1.修改tomcat的字符集的编码.(不推荐)
* 2.使用URLEncoder和URLDecoder进行编码和解码的操作.
* 3.使用String的构造方法:
5.3、Request作为域对象存取数据
使用request对象存取数据:
* setAttribute(String name,String value);
* Object getAttribute(String name);

request的作用范围:
* 作用范围就是一次请求的范围.
* 创建和销毁:
* 创建:客户端向服务器发送了一次请求以后,服务器就会创建一个request的对象.
* 销毁:当服务器对这次请求作出了响应之后.
5.4、重定向和转发的区别（redirect和forward的区别）
// 重定向:
// response.sendRedirect("/day10/ForwardServlet2");

// 转发:
request.setAttribute("name", "李旭华");
// request.getRequestDispatcher("/ForwardServlet2").forward(request, response);
1、重定向的地址栏会发生变化，转发的地址栏不变
2、重定向两次请求两次响应，转发一次请求一次响应
3、重定向路径需要加过程名，转发的路径不需要加工程名
4、重定向可以跳转到任意网站，转发只能在服务器内部进行转发
Day14(cookie绘画和Session绘画)
第一章、会话技术Cookie（只能存储string类型的数据）
1.1、什么是会话：
用户打开一个浏览器访问页面，访问网站很多页面，访问完成后将浏览器关闭的过程称为是一次会话。
1.2、常见的会话技术
Cookie将数据保存到客户端浏览器
Session：将数据保存到服务器端
1.3、为什么会使用会话技术？
私有的数据，购物信息数据保存在会话技术中
第二章、 Cookie技术的使用
2.1、向浏览器保存数据
HTTPServletResponse
Void addcookie（）
2.2、获得浏览器带过来的Cookie
HTTPServletrequest
Cookie【】 getcookie（）；
2.3、创建一个Cookie对象
Cookie（String name，Sring，value）
第三章、jsp
3.1、什么是jsp
Java  Server pages(java服务器端页面)  jap=Java代码+HTML的元素+jsp内置东西
3.2、Sun公司为什么推出jsp动态网页开发技术
Sun公司推出的Servlet技术进行动态网页开发，发现Servlet自身有不足没有办法与Asp,php技术竞争，现在动态页面中输出表单，在Servlet中获得
PrintWrite out= response.getWrite（）;
Out.println(“<form action=”” method=’ ’”);
Out .println(“</form>”)

3.3、jsp的执行过程
Jsp也会被翻译成Servlet，编译成Class进行执行
3.4、JSP的嵌入Java代码
<%! %>:翻译成类中的成员部分，定义变量，定义方法，定义类Servlet是线程不安全的，尽量少在类中定义成员属性
<%%>:翻译成类中的service方法内部的内容，定义变量，定义类，直接写代码块
<%=  %>:翻译成Servlet方法内部的out.print（）;
3.5、Cookie的常用API：
getname（）
getvalue()
setDomain()
setpath（）
setMaxAge():
3.6、Cookie的分类：
会话级别的Cookie：默认的cookie，关闭浏览器Cookie就会销毁
持久级别的cookie：可以设置cookie的有效时间，那么关闭浏览器cookie还会存在，手动销毁持久性Cookie，setMaxAge（0）--前提是有效路径必须一致
第四章、今天的主要2道题
1、显示用户的上次访问时间
2、登录系统以后显示商品浏览记录
Day15(2018-2-2)Session和jsp
第一章、Session的概述
1.1、Cookie和session的区别
Cookie本身是由大小和个数的限制的，Session没有限制，cookie的数据保存在客户端，Session数据保存在服务器端
Session的执行原理，基于cookie的
使用Session：获得session
Request.getSession()  如果携带的cookie有JSEID的话，就会打开对应的区域，如果没有就会创建一个区域
1.2、加入购物车的功能
1.3、 Session是域对象，作用范围（多次请求）一次会话
Session的创建：服务器端第一次调用getsession()创建session
Session的销毁：有三种方式
⑴ 、session过期，默认是30分钟

⑵ 、非正常关闭服务器，如果正常关闭  session序列化到硬盘

如果session中存储有对象，这个对象要实现序列化接口
⑶ 、手动调用session.invalidate（）；
这个方法时将session销毁，一般用不到，我们平时要销毁数据是通过removeAttribute
1.4、验证码的生成
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// 校验验证码程序:
String code1 = request.getParameter("code");
String code2 = (String) request.getSession().getAttribute("code");
request.getSession().removeAttribute("code");
if(!code1.equalsIgnoreCase(code2)){
request.setAttribute("msg", "验证码输入错误！");
request.getRequestDispatcher("/demo2/login.jsp").forward(request, response);
return ;
}
...
}
第二章、Jsp
2.1、什么是jsp
Java Server Pages(java 服务器端的页面)
2.2、为什么要学习jsp
Sum公司推出Servlet自身有缺陷，没有办法与ASP，PHP进行竞争，推出了动态网页开发技术jsp
2.3、使用jsp：
Jsp=HTML+Java代码+jsp内置对象
2.4、jsp的执行过程：
Jsp翻译成Servlet，编译这个servlet的类，生成Class文件，得到执行
2.5、jsp的脚本：
⑴、<%! %>Servlet中的成员内容，定义变量，方法，类  有线程安全问题
⑵、<% %>Servlet中Service方法内部的内容，定义类，变量
⑶、<%= %>Servlet中service方法中out.print（）；
2.6、jsp的注释
Html的注释<!—注释-->
Java代码的注释：单行//，多行/*  */ 文档/** */
Jsp的注释：只会存在于jsp的源代码中，翻译成Servlet后，jsp的注释就消失了，<%--jsp的注释--%>
2.7、jsp的指令：（3个）
指令语法：<%@ 指令名称  属性名称=“属性值” 属性名称=“属性值” %>
⑴ 、page指令：<%@ page%>
Language: jsp脚本中使用的语言，现在只能写java
ContentType: 设置浏览器打开这个jsp的时候采用的是默认的字符集的编码
   PageEncoding: 设置文件保存到本地硬盘，以及生成Servlet后，Servlet保存到硬盘上的编码
   Import：在jsp中引入类对象，但是import可以出现多次
  Extends:    设置jsp翻译成Servlet后继承的类，默认值：org.apache.jasper.runtime.HttpJspBase,这个值要想修改,这个类必须是HttpServlet的子类
AutoFlush:设置缓冲区自动刷新，true自动刷新
Buffer:    设置jsp缓冲区的大小，默认8kb
Session:    设置jsp中是否可以直接使用session对象，默认值是true
isElIgnored: 设置jsp中是否忽略El表达式，默认值是false不忽略。
errorpage:    设置错误友好页面的提示
isErrorpage :通过这个设置显示jsp的错误信息
⑵ 、include指令：指示：jsp包含其他的页面
<%@ include file="logo.jsp" %>
⑶ 、taglib指令：指示jsp引入标签库
<%@ taglib uri="标签的URI的路径" prefix="标签的别名" %>
2.8、jsp的内置对象
Jsp的内置对象就是在jsp中可以直接使用的对象
Jsp的9大内置对象
Request
Response
Application:
pageContext:
Session
out :
exception:
config:
2.9、jsp的动作标签(6个)
标签的作用：简化代码
<jsp:forword/>:用于页面的转发
<jsp:include/>:用于页面的包含（动态包含）
<jsp:parem/>:用于带有路径的标签下，传递参数
<jsp:useBean/> ：    用于在jsp中使用JavaBean
<jsp:setProperty/>:  用于在jsp中向JavaBean设置属性
<jsp：getProperty/>: 用于在jsp中获得JavaBean的属性
第三章、老师总结
1、jsp = html + java + 内置对象 + 指令 + 动作标签
1.1、Java ：
<% service方法内部 %><%！成员位置 %><%=输出语句，不能有分号%>
1.2、指令（3个）：
Page:
Contexttype---设置浏览器默认打开的编码
PageEnconding ---用来设置jsp生成Servlet的保持是用的编码
Import---用来导包的，可以出现多个
Include:能够将其他页面包含进来 file---用的是相对路径
Taglib:
1.3、内置对象（9个）
Request： HttpServletRequest
① 、作为域对象 ②、获取客户机相关的信息（请求方式，请求路径，请求的Ip地址）
Session: HTTPSession
① 作为域对象，会话技术  注意：需要使用一把钥匙才能打开session，这个钥匙其实就是cookie的名字JSESSIONID
Application：  ServletContext（公共域对象）
① 获取全局参数②、获取mimn的类型③、作为全局域对象④、读取web资源下的文件
PageContext:
⑴ 、获取其他八个内置对象
⑵ 可以向四个域中存储东西
RequestScope
SessionScope
ApplicationScope
PageScope
⑶ findAttribute---从小范围开始找
Response:    ①设置响应头②设置响应体③设置状态码
Page:       代表jsp生成Servlet的对象，他是单例的
Out:JSPWrite和response.getwrite（）是有区别的  response.getwrite（）才能真的设置响应体
Config:
Exception:    exception.printStackTrice();
1.4、动作标签(6个)：
用来简化我们的书写
<jsp:forword>：转发
<jsp：include>静态包含和动态包含的区别
:静态包含相当于复制原码(相当于多个jsp在同一个类中)
:动态包含只要运行结果(多个jsp分别在不同类中)
<jsp：param name=”” value=””>  作用：一般和路径结合使用，携带参数
<jsp:useBean>  用于在给jsp中使用JavaBean
<jsp:setProperty>  用于在jsp中向JavaBean设置属性
<jsp:getProperty>  用于在jsp中获得JavaBean的属性
Day16（2018-2-3）EL表达式，JSTL（标签库）MVC
第一章、什么是EL

1.2、为什么学习EL：
简化jsp代码，而且减少<% %>
1.3、使用EL表达式：
语法：${ EL表达式}
1.4、EL的功能
1.4.1、获取数据（jsp的四个域）
⑴、获取普通的单值数据
<%
//pageContext.setAttribute("name", "pValue");
//request.setAttribute("name", "rValue");
//session.setAttribute("name", "sValue");
application.setAttribute("name", "aValue");
%>
<%=pageContext.getAttribute("name") %> 
<%=request.getAttribute("name") %>
<%=session.getAttribute("name") %>
<%=application.getAttribute("name") %>
<hr/>
${ pageScope.name } 
${ requestScope.name }
${ sessionScope.name }
${ applicationScope.name }
<hr/>
${ name } 
⑵、获得数组的数据
<h3>获取数组中的数据</h3>
<%
String[] arrs = { "李迪", "李二", "李立三" };
pageContext.setAttribute("arrs", arrs);
%>
${arrs[0]} ${arrs[1]} ${arrs[2]}
⑶、获得集合中的数据
<%
List<String> list = new ArrayList();
list.add("李一");
list.add("李二");
list.add("李三");
pageContext.setAttribute("list", list);
%>/* El表达式是可以获取四个域中的值 */ ${  list[0]} ${  list[1]} ${  list[2]}
⑷ 、获取Map集合中的数据
<%
Map<String, String> map1 = new HashMap();
map1.put("李迪", "美女");
map1.put("李子轩", "大美女");
map1.put("萌萌", "大大美女");
pageContext.setAttribute("map1", map1);
%>
${map1.李迪 } ${map1.李子轩 } ${map1.萌萌 }
⑸ 、获取对象的数据
<%
User user = new User(1, "aaa", "123");
pageContext.setAttribute("user", user);
%>
${ user.id } ${ user.username } ${ user.password }
⑹ 、.和[]的区别：
[]用于有下标的数据（数组，List集合），.用于有属性的数据（map，对象）
如果属性名中包含特殊的字符，必须使用[]
1.4.2、执行运算
⑴、执行算数运算
<%
pageContext.setAttribute("n1", "20");
pageContext.setAttribute("n2", "30");
%>
${n1+n2 } ${n1-n2 } ${n1*n2 } ${n1/n2 }
⑵、执行逻辑运算
${n1>n2 } ${n1<n2 } ${n1>=n2 } ${n1<=n2 }
⑶、执行关系运算
${ n1<n2 && n3 < n4 } - ${ n1<n2 and n3 < n4 }<br/>
${ n1<n2 || n3 < n4 } - ${ n1<n2 or n3 < n4 }<br/>
${ !(n1 < n2) } - ${ not(n1<n2) }
⑷ 、执行三元运算
${n1>n2?"正确":"错误" }
${n1==n2?"男":"女" }
1.4.3、操作Web开发的常用的对象（11个）
PageScope, requeatScope,SessionScope,applicationScope –获得jsp中域中的数据
Param，paramValues —---接收参数
${ param.id }${ param.name }
Header,headerValues  -----获取请求头信息
Jsp形式获取请求头  <%=request.getHeader("User-Agent") %>
EL表达式的形式获得请求头 ${header["User-Agent"] }
InitParam------获取全局初始化参数（全局初始化是在web.xml中配置的）
cookie-----Web开发中的cookie
${ cookie.history.value}
pageCountext----Web开发中的pageCountext
IP地址：${ pageContext.request.remoteAddr }
工程路径:${ pageContext.request.contextPath }
1.4.4、调用java中的方法---很少用
第二章、JSTL标签库
2.1、什么是jstl

2.2、为什么学习JSTL
JSTL和EL结合，替换页面中<% %>
2.3、JSTL的版本
JSTL 1.0 不支持EL表达式
JSTL1.1/1.2  支持EL表达式
2.4、JSTL的标签库（5类标签）
Core（核心标签） fmt（国际化标签） xml（xml标签） sql（SQL标签） fn（JSTL提供EL函数库）
2.5、使用JSTL：
引入JSTL的相关jar包
在页面中引入标签库<%@ taglib uri=” ” prefix=” ”%>
2.6、jstl的核心标签的用法
<c:set>设置各种web域中的属性
属性名是否支持EL 属性类型属性描述
value true Object 用于指定属性值
var false String 用于指定要设置的Web域属性的名称
scope false String 用于指定属性所在的Web域
target true Object 用于指定要设置属性的对象，这个对象必须是JavaBean对象或java.util.Map对象
property true string 用于指定当前要为对象设置的属性名称

If：进行条件判断
属性名是否支持EL 属性类型属性描述
test true boolean 决定是否处理标签体中的内容的条件表达式
var false String 用于指定将test属性的执行结果保存到某个Web域中的某个属性的名称
scope false String 指定将test属性的执行结果保存到哪个Web域中

ForEach：对集合对象进行循环迭代操作
属性名是否支持EL 属性类型属性描述
var false String 指定将当前迭代到的元素保存到page这个Web域中的属性名称
items true 任何支持的类型将要迭代的集合对象
varStatus false String 指定将代表当前迭代状态信息的对象保存到page这个Web域中的属性名称
begin true int 如果指定items属性，就从集合中的第begin个元素开始进行迭代，begin的索引值从0开始编号；如果没有指定items属性，就从begin指定的值开始迭代，直到end值时结束迭代
end true int 参看begin属性的描述
step true int 指定迭代的步长，即迭代因子的迭代增量

2.7、JSTL的提供EL的函数库（可以参考day16/资料/标准标签库）
<h1>JSTL提供的EL的函数库</h1>
${ fn:contains("Hello World","Hello") }
${ fn:length("HelloWorld") }
${ fn:toLowerCase("ABCDE") }
<c:forEach var="i" items='${ fn:split("a-b-c-d","-") }'>
${ i }
</c:forEach>
第三章、MVC
3.1、使用MVC完成转账功能
3.2、jsp的开发模式一、jsp+JavaBean

3.3、jsp的开发模式二、jsp+JavaBean+servlet（MVC模式）
M:Model:模型层
V:view：视图层
C:Controller:控制层

帐号		自动登录	找回密码
密码			加入黑马

[技术笔记] 石家庄6期JDBC+WEb核心

0 个回复