A股上市公司传智教育(股票代码 003032)旗下技术交流社区北京昌平校区

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

© 李迪13524 初级黑马   /  2018-2-4 17:25  /  1354 人查看  /  0 人回复  /   0 人收藏 转载请遵从CC协议 禁止商业使用本文

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"?>
<!--
    名称空间:一个XML只能引入一个DTD约束文档.使用了Schema约束XML文档,一个XML可以引入多个Schame的约束!!!
                      如果再多个Schema文档中定义了相同的属性名称 该怎么办?
      * 名称空间类似于java中的package.通过名称空间区分 标签或属性来自于哪个文档的!!!通常名称空间唯一的不重复的即可.一般情况下使用一个URL地址表示一个名称空间.

        xmlns                                :xml name sapace .代表当前的文档应用的名称空间.
        targetNameSpace                :目标名称空间.
        elementFormDefault        :
-->
<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>
          <!-- Servlet的名称 -->
          <servlet-name>test1</servlet-name>
          <!-- SErvlet的全路径 -->
          <servlet-class>com.itheima.a_servlet.ServletDemo1</servlet-class>
  </servlet>

  <!-- Servlet的映射 -->
  <servlet-mapping>
          <!-- Servlet的名称 -->
          <servlet-name>test1</servlet-name>
          <!-- Servlet的访问路径 -->
          <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") %> <!-- 如果没找到 返回null -->
<%=request.getAttribute("name") %>
<%=session.getAttribute("name") %>
<%=application.getAttribute("name") %>
<hr/>
${ pageScope.name } <!-- 返回的是"" -->
${ requestScope.name }
${ sessionScope.name }
${ applicationScope.name }
<hr/>
${ name } <!-- 类似findAttribute("name") 先从page域中查找,没找到去request域中查询,没有找到去session域中找,没有找到就去application域中找 -->
⑵、获得数组的数据       
                <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:控制层



0 个回复

您需要登录后才可以回帖 登录 | 加入黑马