1. JDBC

1.1 基本使用

概念：Java DataBase Connectivity Java 数据库连接

JDBC本质：其实是官方（sun公司）定义的一套操作所有关系型数据库的规则，即接口。各个数据库厂商去实现这套接口，提供数据库驱动jar包。我们可以使用这套接口（JDBC）编程，真正执行的代码是驱动jar包中的实现类。

导入驱动jar包：mysql-connector-java-5.1.37-bin.jar

将文件复制到项目包libs下，然后右击libs —> Add As Library

类详解：

1. DriverManager：驱动管理对象

   1. 注册驱动：告诉程序该使用哪一个数据库驱动jar
      static void registerDriver(Driver driver) :注册与给定的驱动程序DriverManager 。
      写代码使用： Class.forName("com.mysql.jdbc.Driver");
      通过查看源码发现：在com.mysql.jdbc.Driver类中存在静态代码块

      static {
        try {
            java.sql.DriverManager.registerDriver(new Driver());
        } catch (SQLException E) {
            throw new RuntimeException("Can't register driver!");
        }
      }

注意：mysql5之后的驱动jar包可以省略注册驱动的步骤。

1. 获取数据库连接：
   方法：static Connection getConnection(String url, String user, String password)
   参数：url：指定连接的路径, user：用户名password：密码
   语法：jdbc:mysql://ip地址(域名):端口号/数据库名称
   例子：jdbc:mysql://localhost:3306/db3
   细节：如果连接的是本机mysql服务器，并且mysql服务默认端口是3306，则url可以简写为：jdbc:mysql:///db3

1. Connection：数据库连接对象

   1. 获取执行sql的对象

      • Statement createStatement()
      • PreparedStatement prepareStatement(String sql) 一般都使用这种方式去定义，更加安全，防止SQL注入

   2. 管理事务：为了对一套操作完整性的保证

      • 开启事务：setAutoCommit(boolean autoCommit)：调用该方法设置参数为false，即开启事务,默认为true，表示开启自动commit()，使用位置为执行SQL前
      • 提交事务：commit()使用位置在执行完所有SQL后
      • 回滚事务：rollback()使用位置在抓取的异常处，抓一个Exception较大的异常类防止因其他异常产生

2. Statement：执行SQL对象

3. PreparedStatement：执行sql的对象

   • SQL注入问题：在拼接sql时，有一些sql的特殊关键字参与字符串的拼接。会造成安全性问题
     输入用户随便，输入密码：a’ or ‘a’ = ‘a
     sql：select * from user where username = 'fhdsjkf' and password = 'a' or 'a' = 'a'
     为了解决注入问题，在定义SQL语句是通过?来对变量占位：select * from user where username = ? and password = ?
     然后通过preparedStatement.setXxx(位置几, 参数)设置参数pstmt1.setDouble(1,500);位置编号从1开始

   • int executeUpdate(String sql) ：执行DML（insert、update、delete）语句、DDL(create，alter、drop)语句
     返回值：影响的行数，可以通过这个影响的行数判断DML语句是否执行成功 返回值>0的则执行成功，反之，则失败。

   • ResultSet executeQuery(String sql)：执行DQL（select)语句

4. ResultSet：查询SQL后执行的结果集

   • boolean next(): 游标向下移动一行，判断当前行是否是最后一行末尾(是否有数据)，如果是，则返回false，如果不是则返回true

   • getXxx(参数):获取数据

   • Xxx：代表数据类型 如： int getInt(), String getString()

   • 参数：

     1. int：代表列的编号,从1开始 如：getString(1)
     2. String：代表列名称。 如： getDouble("balance")

// 基本的通过JDBC接口连接数据库，更新数据库
        Connection con = null;  // 定义在try外部方便后面的finally释放资源
        Statement stam = null;
        try{
            // 1. 注册程序
            Class.forName("com.mysql.jdbc.Driver");
            // 2. 连接数据库
            // 如果本地默认连接可以写成 jdbc:mysql:///test
            con = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "1598");
            // 3. 创建SQL语句
            String s = "update student set sname = '孙七' where sid = 13";
            // 4. 创建SQL对象
            stam = con.createStatement();
            // 5. 执行SQL
            // stam.executeUpdate(s)执行SQL语句后，返回修改的行数，如果大于0则产生了修改
            int count = stam.executeUpdate(s);
            // 6. 处理结果
            if(count > 0) System.out.println("successd!!!");
            else System.out.println("failed!!!");
        }catch (ClassNotFoundException e){
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            // 7. 释放资源，关闭连接
            // 避免空指针异常
            if(stam != null) {
                try {
                    stam.close();
                } catch (SQLException e) {
                    e.printStackTrace();
                }
            }
            if(con != null){
                try{
                    con.close();
                }catch(SQLException e){
                    e.printStackTrace();
                }
            }
        }

// 对数据库访问用户和年龄，将获取的数据封装成Student类的列表，供后续使用
// 1. 先定义学生类，有姓名和年龄属性
public class Student {
    private String sname;
    private Date sage;
    public String getSname() { return sname; }
    public void setSname(String sname) { this.sname = sname;}
    .....
}
// 2. 定义JDBCDemo3类，一个main方法来使用getEmp()方法返回的学生列表
public static void main(String[] args) {
        List<Student> ls = new JDBCDemo3().getEmp();
        for(Student e: ls){
//            System.out.println(e.getSname() +"---" +e.getSage());
            System.out.println(e);
        }
    }
    // 返回学生类的列表
public List<Student> getEmp(){
        Connection con = null;
        Statement stat = null;
        ResultSet rs = null;
        List<Student> ls = null;
        try {
            Class.forName("com.mysql.jdbc.Driver");
            con = DriverManager.getConnection("jdbc:mysql://localhost:3306/test", "root", "1598");
            // stat.executeQuery()查询SQL语句，返回结果集ResultSet，通过next()指针访问行，通过getString("列名称"),或者getString(1)第一列，很特殊第一列不是从0开始而是1。获取该列的字符串，如果该列为Int类型则getInt("列名称")
            String sql = "select * from student where sid = ? ";
            pstat = con.prepareStatement(sql);
            pstat.setString(1, "01");
            rs = pstat.executeQuery(); // 这里面不用再加SQL语句，已经加载了
            Student stu = null;
            ls = new ArrayList<Student>();
            while(rs.next()){
                stu = new Student();
                // 将查询的结果给Student对象，并生成Student的列表，最后返回该列表
                String sname = rs.getString("sname");
                Date sage = rs.getDate("sage");
                stu.setSage(sage);
                stu.setSname(sname);
                ls.add(stu);
            }
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } catch (SQLException e) {
            e.printStackTrace();
        }finally {
            try {
                assert rs != null;
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                assert stat != null;
                stat.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
            try {
                assert con != null;
                con.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        return ls;
    }

1.2 通过JDBC工具类：JDBCUtils

为了简化书写，自己写一个工具类将一些重复性较强的代码抽取为一个类

通过读取配置文件来方便以后对数据库的一些修改，而且Java代码还不需要变动，只需要修改配置文件即可

在src包下新建jdbc.properties文件

url=jdbc:mysql://localhost:3306/test
user=root
passwd=root
driver=com.mysql.jdbc.Driver

public class JDBCUtils2 {
    private static String url;
    private static String user;
    private static String passwd;
    private static String driver;
    static{
        try {
            Properties pro = new Properties();
            // pro.load(new FileReader("idea_demo\\src\\jdbc.properties"));
            // 自动寻找加载，不会因为后面项目迁移而改动代码
            pro.load( JDBCUtils.class.getClassLoader().getResource("jdbc.properties") );
            url = pro.getProperty("url");
            user = pro.getProperty("user");
            passwd = pro.getProperty("passwd");
            driver = pro.getProperty("driver");
            Class.forName(driver);
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
    }
    // 连接数据库
    public static Connection getConnect() throws SQLException {
        return DriverManager.getConnection(url, user, passwd);
    }
    // 关闭释放资源
    public static void close(Connection con, PreparedStatement pstat, ResultSet rs){
        if(rs != null){
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(pstat != null){
            try{
                pstat.close();
            }catch (SQLException e){
                e.printStackTrace();
            }
        }
        if( con != null){
            try{
                con.close();
            }catch(SQLException e){
                e.printStackTrace();
            }
        }
    }
    public static void close(Connection con, PreparedStatement pstat){
        close(con, pstat, null); // 当只有更新数据等没有ResultSet返回值时
    }
}

        Connection con = null;
        PreparedStatement pstat1 = null;
        PreparedStatement pstat2 = null;
        try {
            con = JDBCUtils2.getConnect();  // 使用自定义的类连接
            // 开启手动提交
            con.setAutoCommit(false);
            String sql1 = "update users set user = ? where id = ? ";
            String sql2 = "update users set user = ? where id = ? ";
            pstat1 = con.prepareStatement(sql1);
            pstat2 = con.prepareStatement(sql2);
            pstat1.setString(1, "zhang");
            pstat1.setInt(2, 1);
            pstat2.setString(1,"ahang");
            pstat2.setInt(2,3);
            int i = pstat1.executeUpdate();
            int s = 3/0;
            int j = pstat2.executeUpdate();
            if(i>0 && j>0) System.out.println("successd");
            else System.out.println("failed");
            // 成功执行后提交
            con.commit();
        } catch (Exception e) {
            e.printStackTrace();
            //事务回滚
            try {
                if(conn != null) {
                    conn.rollback();
                }
        } finally {
            JDBCUtils2.close(con, pstat1, pstat2); //使用自定义的类关闭， 这里可以再JDBCUtils中再加一个close
        }
    }

1.3 数据库连接池

• 概念：其实就是一个容器(集合)，存放数据库连接的容器。
  当系统初始化好后，容器被创建，容器中会申请一些连接对象，当用户来访问数据库时，从容器中获取连接对象，用户访问完之后，会将连接对象归还给容器。

• 优点：节约资源、访问高效

• 实现：

  • 标准接口（自己定义实现）：DataSource的getConnection()获取连接和Connection.close()归还连接而不是关闭连接
  • 由数据库厂商实现：C3P0, Druid

• C3P0实现

  • 导入jar包：c3p0-0.9.5.2.jar 和mchange-commons-java-0.2.12.jar，以及数据库驱动MySQL包，并add as library

  • 定义配置文件：c3p0.properties或者 c3p0-config.xml放在src下

    <c3p0-config>
    <!-- 使用默认的配置读取连接池对象 -->
    <default-config>
     <!--  连接参数 -->
    <property name="driverClass">com.mysql.jdbc.Driver</property>
    <property name="jdbcUrl">jdbc:mysql://localhost:3306/test</property>
    <property name="user">root</property>
    <property name="password">root</property>
    <!-- 连接池参数 -->
    <!--初始化申请的连接数量-->
    <property name="initialPoolSize">5</property>
    <!--最大的连接数量-->
    <property name="maxPoolSize">10</property>
    <!--超时时间-->
    <property name="checkoutTimeout">3000</property>
    </default-config>

• ComboPooledDataSource ds = new ComboPooledDataSource();  // 资源池连接对象
  for (int i = 0; i < 11; i++) {
  Connection con = ds.getConnection();  // 获取连接
  System.out.println(i + ":" + con);
  if(i == 5) con.close();  // 归还连接
  }

• Druid实现

  • 导入jar包 druid-1.0.9.jar

  • 定义配置文件druid.properties

    driverClassName=com.mysql.jdbc.Driver
    url=jdbc:mysql:///test
    username=root
    password=root
    # 初始化连接数量
    initialSize=5
    # 最大连接数
    maxActive=10
    # 最大等待时间
    maxWait=3000

• 实现代码

  // 先定义一个工具类，供Druid方便使用
  public class DruidUtils {
  private static DataSource ds;
  static{
     Properties pro = new Properties();
     try {
         // 加载配置文件
         pro.load( DruidUtils.class.getClassLoader().getResourceAsStream("druid.properties") );
         // 创建资源池
         ds = DruidDataSourceFactory.createDataSource(pro);
     } catch (IOException e) {
         e.printStackTrace();
     } catch (Exception e) {
         e.printStackTrace();
     }
  }
  public static Connection getConnect() throws SQLException {
     return ds.getConnection();
  }
  // 归还连接
  public static void close(Connection con, PreparedStatement pstat, ResultSet rs){
     if(con != null){
         try {
             con.close();
         } catch (SQLException e) {
             e.printStackTrace();
         }
     }
     if(pstat != null){
         try {
             pstat.close();
         } catch (SQLException e) {
             e.printStackTrace();
         }
     }
     if(rs != null){
         try {
             rs.close();
         } catch (SQLException e) {
             e.printStackTrace();
         }
     }
  }
  public static void close(Connection con, PreparedStatement pstat){
     close(con, pstat, null);
  }
  }

        Connection con = null;
        PreparedStatement pstat = null;
        try {
            // 使用自定义的工具类获取连接
            con = DruidUtils.getConnect();
            String sql = "update users set user = 'ahang' where id = 1";
            pstat = con.prepareStatement(sql);
            int count = pstat.executeUpdate();
            if(count > 0) System.out.println("succeed");
        } catch (SQLException e) {
            e.printStackTrace();
        } finally {
            // 使用自定义的工具类归还资源
            DruidUtils.close(con,pstat);
        }

1.4 Spring JDBC

• Spring框架对JDBC的简单封装。提供了一个JDBC Template对象简化JDBC的开发

• 导入jar包：spring-beans-5.0.0.RELEASE.jar,spring-core-5.0.0.RELEASE.jar,spring-jdbc-5.0.0.RELEASE.jar,spring-tx-5.0.0.RELEASE.jar,commons-logging-1.2.jar

• 创建JdbcTemplate对象。依赖于数据源DataSource

• JdbcTemplate template = new JdbcTemplate(ds);

• 调用JdbcTemplate的方法来完成CRUD的操作 | 方法 | 用途 | | —- | —- | | update() | 执行DML语句。增、删、改语句 | | queryForMap() | 查询结果将结果集封装为map集合，将列名作为key，将值作为value 将这条记录封装为一个map集合，注意：这个方法查询的结果集长度只能是1 | | queryForList() | 查询结果将结果集封装为list集合，注意：将每一条记录封装为一个Map集合，再将Map集合装载到List集合中 | | query() | 查询结果，将结果封装为JavaBean对象，query的参数：RowMapper一般我们使用BeanPropertyRowMapper实现类。可以完成数据到JavaBean的自动封装，new BeanPropertyRowMapper<类型>(类型.class), 对于类型为对象时，如果出现查询的结果有null类型数据，在定义对象的变量时使用引用数据类型Integer,Double而不是int,double基本数据类型 | | queryForObject | 查询结果，将结果封装为对象，一般用于聚合函数的查询 |

public class SpringDemo1 {
    private JdbcTemplate template = new JdbcTemplate(DruidUtils.getDataSource());
    // 使用template.update来更新
    @Test
    public void test1(){
        String sql = "update users set passwd = 'root' where id = 2";
        int count = template.update(sql);
        System.out.println(count);
    }
    // 使用template.update来插入
    @Test
    public void test2(){
        String sql = "insert into users(user, passwd) values(?,?)";
        int count = template.update(sql,"root1", "root");
        System.out.println(count);
    }
    // 使用template.update来删除
    @Test
    public void test3(){
        String sql = "delete from users where id = ?";
        int count = template.update(sql, 4);
        System.out.println(count);
    }
    // 使用template.queryForMap来查询一行数据
    @Test
    public void test4(){
        String sql = "select * from users where id = ?;";
        Map<String, Object> map = template.queryForMap(sql, 3);
        System.out.println(map);  // {user=zhang, passwd=root, id=3}
    }
    // 使用template.queryForList来查询多行数据，每行数据以map存在
    @Test
    public void test5(){
        String sql = "select * from users";
        List<Map<String, Object>> maps = template.queryForList(sql);
        for(Map<String, Object> e: maps){
            System.out.println(e); 
            //{user=ahang, passwd=root, id=1}, {user=root, passwd=root, id=2}
        }
    }
    // 使用template.query来查询多行数据，每行数据以对象形式存在
    @Test
    public void test6(){
        String sql = "select * from student";
        List<Student> list = template.query(sql, new BeanPropertyRowMapper<Student>(Student.class));
        for(Student e: list){
            System.out.println(e);
        }
    }
    // 使用template.queryForObject将结果封装为对象
    @Test
    public void test7(){
        String sql = "select count(*) from student";
        Long count = template.queryForObject(sql, Long.class);
        System.out.println(count);
    }
}

2. HTML

3. CSS

4. JavaScript

• 概念：一门客户端脚本语言

  • 运行在客户端浏览器中的。每一个浏览器都有JavaScript的解析引擎
  • 脚本语言：不需要编译，直接就可以被浏览器解析执行了

• 功能：可以来增强用户和html页面的交互过程，可以来控制html元素，让页面有一些动态的效果，增强用户的体验。

JavaScript = ECMAScript + JavaScript自己特有的东西(BOM+DOM)

4.1 基本语法

4.1.1 使用位置

内联<script> 语句 </script>

外联<script src="myScript.js"></script>

<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
    <script>alert(a4)</script>  // 可以放在任意位置，但是放在<body>前会先执行脚本后输出HTML页面
</head>
<script>alert(5)</script>
<body>
<script>alert(6)</script>  // 放在<body>后会先输出HTML页面后执行脚本
</body>
<script>alert(7)</script>
</html>

4.1.2 输出

alert(abc)弹出警告框abc

document.write(10)页面输出文字

<body>
<h2>我的第一张网页</h2>
<p>我的第一个段落。</p>
<p id="demo"></p>  // 在body内通过id定位输出内容， 11
<script>
document.getElementById("demo").innerHTML = 5 + 6;
</script>
</body>

4.1.3 变量

• 原始数据类型(基本数据类型)：

  • number：数字。 整数/小数/

    • NaN(not a number 一个不是数字的数字类型),用来表示非法的数字，
    • var x = 100 / "String"此时x表示NaN
    • var x = 100 / "10"此时x = 10，自动转化类型后相除
    • 与NaN做运算的结果也为NaN：a = NaN; b = 10; c = 10 + NaN;
    • 通过toFixed(i)精确小数点个数，x = 9.656; x.toFixed(4);// 返回 9.6560

  • string：字符串。 字符串 “abc” “a” ‘abc’,用单引号''和双引号""相同

    • 获取字符串长度str.length
    • 特殊字符通过加\如：\'，\",\\
    • 转义字符：\r回车，\t水平制表符\v垂直制表符
    • 当写一行字符串过长产生自动换行，为了方便书写，建议写出"aaaa bbb" 换行 + "ccc ddd"
  • boolean: true和false
  • null：一个对象为空的占位符
  • undefined：未定义。如果一个变量没有给初始化值，则会被默认赋值为undefined

• 引用数据类型：对象var x = {firstName:"Bill", lastName:"Gates"};

• 数组:var cars = ["Porsche", "Volvo", "BMW"];

• 在开辟变量存储空间时，不定义空间将来的存储数据类型，可以存放任意类型的数据。

  • var 变量名 = 初始化值;

  • typeof(变量)：获取变量的类型。

4.1.4 运算符

• 一元运算符：

  • ++,--自增自减；

  • +,-正负号。

    • var b1 = +"10"; // 1. String转化为number,通过给字符前加一个+
      var b2 = +"20";
      var b3 = b1+b2;  // 2. 结果为两个number相加 30
            var bb1 = +"10";
            var bb2 = "20";
            var bb3 = bb1 + bb2; // String和number相加结果为"1020"字符串，此时+号表示连接符在两个字符串之间 
      var c1 = false;
      var c2 = +true;  // boolean转化为number类型：false = 0, true = 1;
      document.write(c1+c2); // boolean + number = number : 0+1=1结果为 1

• 算数运算符：+,-,*,/

• 赋值运算符：=,+=,-=

• 比较运算符：>,<,>=,<=,==,===全等于。。。

  • 同类型：直接比较，字符串按照字典序逐个字符比较

  • 类型不同：先类型转换后比较

    • var d1 = "123";
      var d2 = 123;
      document.write(d1 == d2,"<br>");  // 不同类型，先转换同类型后比较相同
      document.write(d1 === d2,"<br>"); // === 全等于，不同类型直接判定为false

• 逻辑运算符：&&,||,!

  • 其他类型转boolean类型：

    • number: 0或NaN为false，其余为true
    • string:除了（””)空字符其余为true
    • null和undefined: false
    • 对象：true

        var f1 = !!"";
        var f2 = !!new Date();
        document.write(f1,"<br>");  // false
        document.write(f2, "<br>");  // true

• 三元运算符：var a = b > c ? b : c

4.1.5 JS不同于Java语法

        function f() {
            s3 = 30      // 1. 可以省略结束分号; 2. 在函数内，如果不加var 声明则声明的是全局变量，函数外部也可以使用
            var s4 = 40;  // 函数内的局部变量之能在函数内使用
            document.write(s3);
        }
        f()
        document.write(s3);
        document.write(s4); // 该条语句错误，不能使用函数内局部变量
        switch (a) {  // 这里面的 a 可以为任意类型变量
            case 1: break;
            case "abc":break;
            case true:break;
            case null:break;
            case undefined: break;
            default:break;
        }

4.1.6 对象

一个拥有属性和方法的变量 ==》 对象

        var obj = {
            firstName : "Ahang",  // 属性
            lastName : "Haha",
            fullName : function(){   // 方法
                return this.firstName + this.lastName;
            }
        };
        document.write("<br>", obj.firstName);  // 对象.属性 "Ahang"
        document.write("<br>", obj.fullName());  // 对象.方法() 得到 "AhangHaha"
        document.write("<br>", obj.fullName); // 对象.方法  输出function(){ return this.firstName + this.lastName; }

new一个对象var date = new Date()

4.1.7 事件

// 通过点击触发事件
<button onclick="document.getElementById('time1').innerHTML = Date()">点击获取时间</button>
<p id="time1"></p>
// 通过点击调用函数
<button onclick="getDate()">点击获取时间</button>
<script>
    function getDate() {
        document.getElementById("time2").innerHTML = Date();
    }
</script>
<p id="time2"></p>
<button onmouseover="this.innerHTML = Date()">移动鼠标到该点上获取时间</button>

4.1.8 字符串详解

var str = "HELLO WORLD";
str[0] = "A";       //可以访问，但不能修改。 不产生错误，但不会工作
str[0];             // 返回 H
// 创建String对象,通过全局函数String()
new String(s);
var str = String(s);
// 转换字符串为数值,通过全局函数parseInt()
var i = parseInt("10");
var f = parseFloat("10.5");

String 对象方法

4.1.9 数组详解

        var arr = ["10", 20, true, null, f(), "abc"];   // 可以存储多个不同类型的变量及函数
        for(var i = 0; i < arr.length; i++){
            document.write("<br>")
            document.write(arr[i]);
            document.write(" : " + typeof(arr[i]));
        }

数组长度：arr.length

Array 对象方法

4.1.10 数学

使用方式：Math.abs(-10)

Math 对象方法

4.1.11 正则表达式

语法： /表达式/修饰符 ==》 /haha/i对haha匹配，且由于修饰符为i对大小写忽略

使用：str.search(/w3school/i);,str.replace(/microsoft/i, "W3School");

RegExp 对象方法

支持正则表达式的 String 对象的方法

5. MAVEN安装使用

5.1 安装

1. 下载安装包后解压缩至无中文路径的文件夹中
2. 设置系统变量：MAVEN_HOME为D:\develop\apache-maven-3.5.2
3. 设置PATH添加%MAVEN_HOME%\bin
4. 通过cmd输入mvn -v测试

5.2 使用

• 对于第一次使用创建项目，然后在项目里面创建多个module模块
• 不同的模块下pom.xml之间默认相互独立，项目下的pom.xml和模块下的pom.xml默认时相互独立的，也就是说子模块下的依赖包和主项目下的依赖包默认相互独立，不共享
• 子模块在创建时IDE中选择继承自主项目，则子模块下的会显示有主项目的jar包；也可以选择继承另一个子模块，则会有另一个子模块下的jar包
• 子模块可以自主选择继承的父模块

    <!--此处设置父模块的信息：id和组id-->
    <parent>
        <artifactId>MyBatis</artifactId>
        <groupId>MyBatis</groupId>
        <version>1.0-SNAPSHOT</version>
    </parent>
    <modelVersion>4.0.0</modelVersion>
    <!--此处设置本模块的Id-->
    <artifactId>MyBatis_3</artifactId>

新建项目后—新建模块—-为了后面的JavaWeb，使用现成的webapp去建立

5.3 Tomcat安装使用

下载：http://tomcat.apache.org/

安装：直接解压缩文件即可

使用：通过bin\startup.bat，浏览器通过http://localhost:8080即可访问，关闭：bin/shutdown.bat

部署项目的方式：

        1. 直接将项目放到`webapps`目录下即可。
        * /hello：项目的访问路径-->虚拟目录
            * 简化部署：将项目打成一个war包，再将war包放置到webapps目录下。
                * war包会自动解压缩

1. 配置conf/server.xml文件,在标签体中配置
   `docBase:项目存放的路径
   path：虚拟目录

2. 推荐：在conf\Catalina\localhost创建任意名称的xml文件。
   在文件中编写<Context docBase="D:\hello" />
   虚拟目录：xml文件的名称

5.4 配置Tomcat

新建一个maven的module后配置TomCat服务器

如果没有war包需要手动打包一个教程：手动war包

1. 6. Servlet使用

6.1 基本概念

Servlet就是一个接口，定义了Java类被浏览器访问到(tomcat识别)的规则。

定义一个类实现servlet接口：public class ServletDemo1 implements Servlet

然后在web.xml中配置：

        <!--配置Servlet -->
        <servlet>
            <servlet-name>demo1</servlet-name>
            <servlet-class>cn.itcast.web.servlet.ServletDemo1</servlet-class>
        </servlet>
        <servlet-mapping>
            <servlet-name>demo1</servlet-name>
            <url-pattern>/demo1</url-pattern>
        </servlet-mapping>

执行原理

1. 当服务器接受到客户端浏览器的请求后，会解析请求URL路径，获取访问的Servlet的资源路径

2. 查找web.xml文件，是否有对应的<url-pattern>标签体内容。

3. 如果有，则在找到对应的<servlet-class>全类名

4. tomcat会将字节码文件加载进内存，并且创建其对象

5. 调用其方法
   在Servlet 3.0中无需web.xml，通过注解配置

   1. 创建JavaEE项目，选择Servlet的版本3.0以上，可以不创建web.xml
   2. 定义一个类，实现Servlet接口
   3. 复写方法

   4. 在类上使用@WebServlet注解，进行配置

      • @WebServlet(“资源路径”)

Servlet中的生命周期方法：

1. 被创建：执行init方法，只执行一次
   Servlet什么时候被创建？
   默认情况下，第一次被访问时，Servlet被创建
   可以配置执行Servlet的创建时机。
   在<servlet>标签下配置

   1. 第一次被访问时，创建<load-on-startup>的值为负数
   2. 在服务器启动时，创建<load-on-startup>的值为0或正整数
      Servlet的init方法，只执行一次，说明一个Servlet在内存中只存在一个对象，Servlet是单例的
      多个用户同时访问时，可能存在线程安全问题。
      解决：尽量不要在Servlet中定义成员变量。即使定义了成员变量，也不要对修改值

2. 提供服务：执行service方法，执行多次
   每次访问Servlet时，Service方法都会被调用一次。

3. 被销毁：执行destroy方法，只执行一次
   Servlet被销毁时执行。服务器关闭时，Servlet被销毁
   只有服务器正常关闭时，才会执行destroy方法。
   destroy方法在Servlet被销毁之前执行，一般用于释放资源

// 在项目的src下创建Java文件，
@WebServlet("/demo") 
// 通过WebServlet("资源路径")注解配置，给该Java资源起的名称，也叫做网页访问的资源路径，在web上通过http://localhost:8080/demo访问该资源
public class servlet_demo1 implements Servlet {
    @Override // 初始化，默认在第一次访问时使用
    public void init(ServletConfig servletConfig) throws ServletException {System.out.println("init...");}
    @Override
    public ServletConfig getServletConfig() {return null;}
    @Override  // 每次web调用该服务，便执行该方法
    public void service(ServletRequest servletRequest, ServletResponse servletResponse) throws ServletException, IOException {
        System.out.println("service...");
    }
    @Override
    public String getServletInfo() {return null;}
    @Override  // 最后正常结束时销毁
    public void destroy() {System.out.println("destroy...");}
}

6.2 maven中使用servlet具体使用步骤：

6.2.1 构建Maven项目

删掉里面的src目录，以后我们的学习就在这个项目里面建立Moudel；这个空的工程就是Maven主工程；

关于Maven父子工程的理解：

父项目中会有

<modules>
    <module>servlet-01</module>
</modules>

子项目会有 (local history ——>accept)

<parent>
    <artifactId>javaweb-02-servlet</artifactId>
    <groupId>com.kuang</groupId>
    <version>1.0-SNAPSHOT</version>
</parent>

父项目中的jar包子项目可以直接使用

6.2.2 Maven环境优化

• 修改web.xml为最新的

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="http://xmlns.jcp.org/xml/ns/javaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/javaee
                             http://xmlns.jcp.org/xml/ns/javaee/web-app_4_0.xsd"
         version="4.0"
         metadata-complete="true">
</web-app>

• 在maven的pom文件中添加依赖，为了后面使用jsp和servlet作准备

  <dependencies>
        <dependency>
            <groupId>javax.servlet</groupId>
            <artifactId>javax.servlet-api</artifactId>
            <version>4.0.1</version>
        </dependency>
        <dependency>
            <groupId>javax.servlet.jsp</groupId>
            <artifactId>jsp-api</artifactId>
            <version>2.0</version>
        </dependency>
    </dependencies>

• 在maven的pom中添加资源路径，防止导入资源失败

    <build>
        <resources>
            <resource>
                <directory>src/main/resources</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
            <resource>
                <directory>src/main/java</directory>
                <includes>
                    <include>**/*.properties</include>
                    <include>**/*.xml</include>
                </includes>
                <filtering>true</filtering>
            </resource>
        </resources>
    </build>

• 将maven的结构搭建完整

6.2.3 编写一个Servlet程序

编写一个普通类 HelloServlet

实现Servlet接口，这里我们直接继承HttpServlet

重写方法（ctrl+o 快捷键）

package com.kuang.servlet;
public class HelloServlet extends HttpServlet {
    //由于get或者post只是请求实现的不同的方式，可以相互调用，业务逻辑都一样；
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //ServletOutputStream outputStream = resp.getOutputStream();
        PrintWriter writer = resp.getWriter(); //响应流
        writer.print("Hello,Serlvet");
    }
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);
    }
}

6.2.4 编写Servlet的映射

为什么需要映射：我们写的是JAVA程序，但是要通过浏览器访问，而浏览器需要连接web服务器(web.xml)，所以我们需要再web服务中注册我们写的Servlet，还需给他一个浏览器能够访问的路径；

    <!--注册Servlet-->
    <servlet>
        <servlet-name>hello</servlet-name>
        <servlet-class>com.ylw.servlet.HelloServlet</servlet-class>
    </servlet>
    <!--Servlet的请求路径，上面的name和下面的name要一样-->
    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>

6.2.5 配置Tomcat

详见 5.4

6.2.6 启动测试

详见6.4

6.3 web.xml的配置mapper问题

1. 一个Servlet可以指定一个映射路径

<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello</url-pattern>
</servlet-mapping>

2.一个Servlet可以指定多个映射路径

    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/hello</url-pattern>
    </servlet-mapping>
    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/hello1</url-pattern>
    </servlet-mapping>

1. 一个Servlet可以指定通用映射路径

   <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/hello/*</url-pattern>
    </servlet-mapping>

1. 默认请求路径

  <!--默认请求路径-->
    <servlet-mapping>
        <servlet-name>hello</servlet-name>
        <url-pattern>/*</url-pattern>
    </servlet-mapping>

1. 指定一些后缀或者前缀等等….注意：这时候 * 前面就不要加路径了

<!--可以自定义后缀实现请求映射
    注意点，*前面不能加项目映射的路径
    hello/sajdlkajda.qinjiang
    -->
<servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>*.do</url-pattern>
</servlet-mapping>

1. 优先级问题 指定了固有的映射路径优先级最高，如果找不到就会走默认的(/*)处理请求；

<!--404-->
<servlet>
    <servlet-name>error</servlet-name>
    <servlet-class>com.kuang.servlet.ErrorServlet</servlet-class>
</servlet>
<servlet-mapping>
    <servlet-name>error</servlet-name>
    <url-pattern>/*</url-pattern>
</servlet-mapping>

1. 如果默认(/)和前后缀的(.do)同时存在时，会使用默认的

6.4 TomCat服务重启热加载

• Tomcat服务重启 ——-> 加载新添加的Java文件和资源文件properties

• 如果仅仅对Java文件进行了修改，而没有添加新的Java，可以通过热加载不重启服务

                                                                                                首先使用debug

• 如果只对web.xml配置文件进行了修改，可以通过redeploy来更新

• 如果同时添加了新文件Java和修改了web.xml的话，需要重启服务，然后redeploy

6.5 ServletContext 常用方法

web容器在启动的时候，它会为每个web程序都创建一个对应的ServletContext对象，它代表了当前的web应用；
主要方法：

ServletContext context = this.getServletContext();

1、共享数据

用到的主要方法：

//设置
context.setAttribute("参数名",参数值（可以是变量名）);
//获取,如果没有先set直接get会创建一个，并赋值为null
context.getAttribute("参数名");

在这个Servlet中保存的数据，可以在另外一个servlet中拿到；

在HelloServlet 里设置上下文数据

package com.kuang.servlet;
public class HelloServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //this.getInitParameter() 初始化参数
        //this.getServletConfig() Servlet配置
        //this.getServletContext() Servlet上下文
        ServletContext context = this.getServletContext();
        String username = "ahang"; //数据
        context.setAttribute("username",username); //将一个数据保存在了ServletContext，数据的名字为username，值为变量username的值
        System.out.println("Hello,进入doGet");
    }
}

在GetServlet里获取上下文

package com.kuang.servlet;
public class GetServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext context = this.getServletContext(); //这里获取的上下文就是HellServlet里设置的
        String username = (String) context.getAttribute("username"); //获取上下文中名为username的值
        resp.setContentType("text/html"); //设置文本类型
        resp.setCharacterEncoding("utf-8"); //设置编码
        resp.getWriter().print("用户名："+username); //写在网页上
    }
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp); //注意这里改成doGet(req, resp)，形成一个规范
    }
}

web.xml里的注册

 <servlet>
    <servlet-name>hello</servlet-name>
    <servlet-class>com.kuang.servlet.HelloServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>hello</servlet-name>
    <url-pattern>/hello</url-pattern>
  </servlet-mapping>
  <servlet>
    <servlet-name>getContext</servlet-name>
    <servlet-class>com.kuang.servlet.GetServlet</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>getContext</servlet-name>
    <url-pattern>/getContext</url-pattern>
  </servlet-mapping>

重启Tomcat。
然后打开浏览器，先访问/hello进行设置，再访问/getContext进行获取

2、获取初始化参数

用到的主要方法：

context.getInitParameter("参数名");

先在web.xml文件里配置初始参数

    <!--配置一些web应用的初始化参数-->
    <context-param>
        <param-name>url</param-name>
        <param-value>jdbc:mysql://localhost:3306/mybatis</param-value>
    </context-param>

写一个类获取

package com.kuang.servlet;
public class ServletDemo03 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext context = this.getServletContext(); //这里获取的上下文就是HellServlet里设置的
        String url = context.getInitParameter("url"); //获取上web.xml文件中设置的参数<context-param>
        resp.getWriter().print(url); //写在网页上
    }
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);//注意这里改成doGet(req, resp)，形成一个规范
    }
}

在web.xml里注册这个类

<servlet>
    <servlet-name>gp</servlet-name>
    <servlet-class>com.kuang.servlet.ServletDemo03</servlet-class>
  </servlet>
  <servlet-mapping>
    <servlet-name>gp</servlet-name>
    <url-pattern>/gp</url-pattern>
  </servlet-mapping>

重启Tomcat。
然后打开浏览器，访问/gp进行获取

3、请求转发

A要访问C中的资源：有两种方式

用到的主要方法：

context.getRequestDispatcher("转发路径").forward(req,resp);

转发代码

package com.kuang.servlet;
public class ServletDemo04 extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        ServletContext context = this.getServletContext(); //这里获取的上下文就是HellServlet里设置的
        System.out.println("进入了Demo04");
//        RequestDispatcher requestDispatcher = context.getRequestDispatcher("/gp"); //设置转发路径
//        requestDispatcher.forward(req,resp); //调用forward实现请求转发
        //合并上面两句
        context.getRequestDispatcher("/gp").forward(req,resp);
    }
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp);//注意这里改成doGet(req, resp)，形成一个规范
    }
}

在web.xml里注册类

    <servlet>
        <servlet-name>sd4</servlet-name>
        <servlet-class>com.ylw.servlet.ServletDemo04</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>sd4</servlet-name>
        <url-pattern>/sd4</url-pattern>
    </servlet-mapping>

重启Tomcat，
打开浏览器，进入/sd4，发现路径没有变，但是显示的是/gp的页面，这就是转发的作用（重定向才会改变路径）

由于我们设置了输出语句，在控制台里可以看到，确实进入了demo04，只不过显示的是转发页面

4、读取资源文件 getResourceAsStream()

用到的主要方法：

//获取文件，变成流
this.getServletContext().getResourceAsStream("文件路径"）
//加载流
Properties prop = new Properties();
prop.load(inputStream); //加载上面文件转化成的流
prop.getProperty("属性名"); //获取文件中的一个属性

Properties

比较分析：

• 在java目录下新建properties
• 在resources目录下新建properties

发现：都被打包到了同一个路径下：classes，我们俗称这个路径为classpath:

在java目录下的properties，发现导出的target中没有该文件，就需要在pom.xml中添加配置，详见博客https://blog.csdn.net/qq_43594119/article/details/106199248中的**解决资源导出失败问题**

读取资源文件：
1在resources目录下新建一个db.properties文件作为资源文件

username=wuxinyu
password=123456

2.写一个类用来读取这个资源文件，下面是截图和代码

package com.kuang.servlet;
public class PropertiesServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        //获得资源，变成一个流  路径是target下面的路径
        InputStream inputStream = this.getServletContext().getResourceAsStream("/WEB-INF/classes/db.properties");
        Properties prop = new Properties();
        prop.load(inputStream); //加载上面文件转化成的流
        String user = prop.getProperty("username"); //获取文件中的一个属性
        String pwd = prop.getProperty("password"); //获取文件中的一个属性
        //在网页上显示出来
        resp.getWriter().print("user: " + user +'\n' + "pwd: " + pwd);
    }
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        doGet(req, resp); //注意这里改成doGet(req, resp)，形成一个规范
    }
}

注意这里的路径是 /WEB-INF/classes/db.properties 第一个 / 代表当前项目

3.在web.xml中注册该类

    <servlet>
        <servlet-name>sd5</servlet-name>
        <servlet-class>com.ylw.servlet.ServletDemo05</servlet-class>
    </servlet>
    <servlet-mapping>
        <servlet-name>sd5</servlet-name>
        <url-pattern>/sd5</url-pattern>
    </servlet-mapping>

4.重启tomcat，访问/sd5

6.6、HttpServletResponse

web服务器接收到客户端的http请求，针对这个请求，分别创建一个代表请求的HttpServletRequest对象，代表响应的一个HttpServletResponse；

• 如果要获取客户端请求过来的参数：找HttpServletRequest
• 如果要给客户端响应一些信息：找HttpServletResponse

1、简单分类

负责向浏览器发送数据的方法

 servletOutputstream getOutputstream() throws IOException;
 Printwriter getwriter() throws IOException;

负责向浏览器发送响应头的方法

2、下载文件

1. 向浏览器输出消息（一直在讲，就不说了）

2. 下载文件

   1. 要获取下载文件的路径
   2. 下载的文件名是啥？
   3. 设置想办法让浏览器能够支持下载我们需要的东西
   4. 获取下载文件的输入流
   5. 创建缓冲区
   6. 获取OutputStream对象
   7. 将FileOutputStream流写入到bufer缓冲区
   8. 使用OutputStream将缓冲区中的数据输出到客户端！

package com.kuang.servlet;
public class FileServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
//        1. 要获取下载文件的路径
        String realPath = "D:\\WorkingSpace\\Idea_workingspace\\JavaWeb\\javaweb-02-servlet\\response\\src\\main\\resources\\1.png";
        System.out.println("下载文件的路径为："+realPath);
//        2. 下载的文件名是啥？
        String fileName = realPath.substring(realPath.lastIndexOf("\\") + 1);
//        3. 设置想办法让浏览器能够支持下载我们需要的东西
        System.out.println(fileName);
        resp.setHeader("Content-Disposition","attachment;filename="+ URLEncoder.encode(fileName,"UTF-8"));
//        4. 获取下载文件的输入流
        FileInputStream fileInputStream =new FileInputStream(realPath);
//        5. 创建缓冲区
        int len = 0;
        byte[] buffer = new byte[1024];
//        6. 获取OutputStream对象
        ServletOutputStream out = resp.getOutputStream();
//        7. 将FileOutputStream流写入到bufer缓冲区
        while((len=fileInputStream.read(buffer))!=-1){
            out.write(buffer,0,len);
        }
        fileInputStream.close();
        out.close();
//        8. 使用OutputStream将缓冲区中的数据输出到客户端！
    }
    @Override
    protected void doPost(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
        super.doPost(req, resp);
    }
}

<servlet>
      <servlet-name>FileServlet</servlet-name>
      <servlet-class>com.kuang.servlet.FileServlet</servlet-class>
    </servlet>
  <servlet-mapping>
    <servlet-name>FileServlet</servlet-name>
    <url-pattern>/fs</url-pattern>
  </servlet-mapping>

3. 实现重定向

常见场景:

• 用户登录