JavaWeb笔记 黑马程序员课程

JavaWeb

摘要

主要用于记录JavaWeb的学习过程,希望对大家有所帮助。
该学习是基于黑马的JavaWeb课程,感兴趣的盆友可以在b站搜索javaweb进行观看学习。

Day 01 内容

04/07/2020

* Junit单元测试
* 反射
* 注解

Junit单元测试:

* 测试分类:
	* 黑盒测试:不需要写代码,给输入值,看程序能否输出期望值。
    		* 白盒测试:需要写代码。关注程序具体的执行流程。

* Junit使用:白盒测试
	* 步骤:
		1. 定义一个测试类(测试用例)
        	* 建议:
                * 测试类名:被测试的类名Test	calculatorTest
                * 包名:xxx.xxx.xxx.test
		2. 定义测试方法:可以独立运行

			* 建议:
				* 方法名:test测试的方法名	testadd
                * 返回值:void
                * 参数列表:空参
		3. 给方法加@Test
		4. 导入Junit依赖环境
 
	* 判定结果:
		* 红色:失败
		* 绿色:成功
		* 一般我们会使用断言操作来处理结果:
			* Assert.assertEquals(期望的结果, 运算的结果);
	* 补充
		* @before:
			* 修饰的方法会在测试方法之前被自动执行
		* @after:
			* 修饰的方法会在测试方法执行之后被自动执行

反射:框架设计的灵魂

* 框架:半成品软件。可以在框架的基础上进行软件开发,简化编码
* 反射:将类的各个组成部分封装为其他对象,这就是反射机制
	* 好处:
		1. 可以在程序运行过程中,操作这些对象。
		2. 可以解耦,提高程序的可扩展性

* 获取Class对象的方式:
	1. Class.forName("全类名"); 将字节码文件加载进内存,返回Class对象
		* 多用于配置文件,将类名定义在配置文件中。读取文件,加载类
	2. 类名.class; 通过类名的属性class来获取
		* 多用于参数的传递
	3. 对象.getClass(); getClass()方法在Object类中定义
		* 多用于对象的获取字节码的方式
* 结论:同一个字节码文件(*.class)在一次程序的运行过程中,只会被加载一次,不论通过哪一种方式获取的Class对象都是同一个。


* Class对象功能:
	* 获取功能:
		1. 获取成员变量们
			* Field[] getFileds()
			* Filed getFiled(String name)
            * Field[] getDeclaredFileds()
            * Filed getDeclaredFiled(String name)
		2. 获取构造方法们
			* Constructor[] getConstructors()
            * Constructor\ getConstructor(类\... parameterTypes)
            * Constructor[] getDeclaredConstructors()
            * Constructor\ getDeclaredConstructor(类\... parameterTypes)
		3. 获取成员方法们
			* Method[] getMethods()
            * Method getMethod(String name)
            * Method[] getDeclaredMethods()
            * Method getDeclaredMethod(String name)
		4. 获取类名
			* String getName()


* Field:成员变量
	* 操作:
		1. 设置值
			* void set(Object obj, Object value)
		2. 获取值
			* get(Object obj)
		3. 忽略访问权限修饰符的安全检查
			* setAccessible(true):暴力反射


* Constructor:构造方法
	* 创建对象:
		* T newInstance(Object... initargs)
		* 如果使用空参数构造方法创建对象,操作可以简化:Class对象的newInstance方法


* Method:方法对象
	* 执行方法:
		* Object invoke(Object obj, Object... args)
	* 获取方法名称:
		* String getName()获取方法名


* 案例:
	* 需求:写一个"框架",不能改变该类的任何代码的前提下,可以帮我们创建任意类的对象,并且执行其中任意方法。
	* 实现:
		1. 配置文件
		2. 反射
	* 步骤:
		1. 将需要创建的对象的全类名和需要执行的方法定义在配置文件中
        2. 在程序中去加载读取配置文件
        3. 使用反射技术来加载类文件进内存
        4. 创建对象
        5. 执行方法

注解:

* 概念:说明程序的。给计算机看的。

* 注释:用文字描述程序。给程序员看的。

* 概念描述:
	* jdk1.5之后的新特性
    * 说明程序的
    * 使用注解:@注解名称
  
* 作用分类
	* 编写文档:生成文档【doc文档】
    * 代码分析:通过注解对代码进行分析【使用反射】
    * 编译检查:让编辑器能实现基本的编译检查【@Override】

* JDK中预定义的一些注解
	* @Override:检测被该注解标注的方法是否是继承自父类(接口)的
    * @Deprecated:将该注解标注的内容,表示已过时
    * @SuppressWarnings:压制警告
    	* 一般传递参数all	@SuppressWarnings("all")
  
* 自定义注解
	* 格式:
		* 元注解
        * public @interface 注解名称() {
        	属性列表;
        }
	* 本质:注解本质上就是一个接口,该接口默认继承Annotation

		* public interface 注解名称 extends java.lang.annotation.Annotation {}
	* 属性:接口中的抽象方法
		* 要求:
			1. 属性的返回值类型有下列取值:
				* 基本数据类型
				* String
                * 枚举
                * 注解
                * 以上类型的数组
			2. 定义了属性,在使用时需要给属性赋值
				1. 如果定义属性时,使用default关键字给属性默认初始值,则使用注解时可以不进行属性的赋值
                2. 如果只有一个属性需要赋值,并且属性的名称为value,则value可以省略,直接定义值即可【@SuppressWarnings】
                3. 数组赋值时,值使用{}包裹,如果数组中只有一个值,则{}可以省略

* 元注解:用于描述注解的注解
	* @Target:描述注解能够作用的位置
        * ElementType取值:
        * TYPE:可以作用于类上
        * METHOD:可以作用于方法上
        * FIELD:可以作用于成员变量上
	* @Retention:描述注解被保留的一个阶段
		* @Rentention(RententionPolicy.RUNTIME):当前被描述的注解,会保留到class字节码文件中,并被JVM读取到
	* @Documented:描述注解是否被抽取到api文档中
	* @Inherited:描述注解是否被子类继承
  
* 在程序中使用(解析)注解:获取注解中定义的属性值
	1. 获取注解定义的位置的对象	【Class,Method,Field】
	2. 获取指定的注解
		* getAnnotation(Class)
		* public class ProImpl implements Pro{
              public String className(){
                  return "day01.annotation.Demo1";
              }
              public String methodName(){
                  return "show";
              }
          }

	3. 调用注解中的抽象方法,获取配置的属性值

* 小结
	1. 以后大多数时候,我们会使用注解,而不是自定义注解
    2. 注解给谁用?
    	1. 编译器
    	2. 给解析程序用
    3. 注解不是程序的一部分,可以理解为注解就是一个标签

Day 02 内容

05/07/2020

* 数据库的基本概念
* MySQL数据库软件
	* 安装
    * 卸载
    * 配置
* SQL

数据库的基本概念

1. 数据库的英文单词:DataBase 简称 : DB
2. 什么是数据库?
	* 用于存储和管理数据的仓库。

3. 数据库的特点:
	1. 持久化存储数据的。其实数据库就是一个文件系统
	2. 方便存储和管理数据
	3. 使用了统一的方式来操作数据库 -- SQL

4. 常见的数据库软件	
	* 参见《MySQL基础.pdf》

MySQL数据库软件

1. 安装
	* 参见《MySQL基础.pdf》
2. 卸载
	1. 去mysql的安装目录找到my.ini文件
		* 复制 datadir="C:/ProgramData/MySQL/MySQL Server 5.5/Data"
	2. 卸载MySQL
	3. 删除C:/ProgramData目录下的MySQL文件夹。

3. 配置
	* MySQL服务启动
		1. 手动
		2. cmd--> services.msc 打开服务的窗口
		3. 使用管理员打开cmd
			* net start mysql :启动mysql的服务
			* net stop mysql :关闭mysql的服务
		
	* MySQL登录
		1. mysql -uroot -p【password】
		2. mysql -h【ip】 -uroot -p【连接目标的password】
		3. mysql --host=【ip】 --user=root --password=【密码】
	* MySQL退出
		1. exit
		2. quit

	* MySQL目录结构
		1. MySQL安装目录
			* 配置文件 my.ini
		2. MySQL数据目录
			* 几个概念
				* 数据库:文件夹
				* 表:文件
				* 数据:数据

SQL

1. 什么是SQL?
	Structured Query Language:结构化编程语言
	其实就是定义了操作所有关系型数据库的规则。每一种数据库操作的方式存在不一样的地方,称为"方言"
	
2. SQL通用语法
	1. SQL语句可以单行或多行书写,以分号结尾。
	2. 可使用空格和缩进来增强语句的可读性。
	3. MySQL数据库的SQL语句不区分大小写,关键字建议使用大写。
	4. 3种注释
		* 单行注释:-- 注释内容 或 # 注释内容(mysql 特有)
		* 多行注释:/* 注释 */

3. SQL分类
	1) DDL(Data Definition Language)数据定义语言用来定义数据库对象:数据库,表,列等。关键字:create, drop,alter 等
	2) DML(Data Manipulation Language)数据操作语言用来对数据库中表的数据进行增删改。关键字:insert, delete, update 等
	3) DQL(Data Query Language)数据查询语言用来查询数据库中表的记录(数据)。关键字:select, where 等
	4) DCL(Data Control Language)数据控制语言(了解)用来定义数据库的访问权限和安全级别,及创建用户。关键字:GRANT, REVOKE 等

DDL:操作数据库、表

1. 操作数据库:CRUD
	1. C(Create):创建
		* 创建数据库:
			* create database 数据库名称;
		* 创建数据库,判断不存在,再创建:
			* create database if not exists 数据库名称;
		* 创建数据库,并指定字符集
			* create database 数据库名称 character set 字符集名;
		* 练习: 创建db4数据库,判断是否存在,并制定字符集为gbk
			* create database if not exists db4 character set gbk;
	2. R(Retrieve):查询
		* 查询所有数据库的名称:
			* show databases;
		* 查询某个数据库的字符集:查询某个数据库的创建语句
			* show create database 数据库名称;
	3. U(Update):修改
		* 修改数据库的字符集
			* alter database 数据库名称 character set 字符集名称;
	4. D(Delete):删除
		* 删除数据库
			* drop database 数据库名称;
		* 判断数据库存在,存在再删除
			* drop database if exists 数据库名称;
	5. 使用数据库
		* 查询当前正在使用的数据库名称
			* select database();
		* 使用数据库
			* use 数据库名称;
2. 操作表
	1. C(Create):创建
		1. 语法:
			create table 表名(
				列名1 数据类型1,
				列名2 数据类型2,
				....
				列名n 数据类型n
			);
			* 注意:最后一列,不需要加逗号(,)
			* 数据库类型:
             	1. int:整数类型
					* age int,
                2. double:小数类型
                    * score double(5,2)
                3. date:日期,只包含年月日,yyyy-MM-dd
                4. datetime:日期,包含年月日时分秒	 yyyy-MM-dd HH:mm:ss
                5. timestamp:时间戳类型	包含年月日时分秒	 yyyy-MM-dd HH:mm:ss	
                	* 如果将来不给这个字段赋值,或赋值为null,则默认使用当前的系统时间,来自动赋值
                6. varchar:字符串
                    * name varchar(20):姓名最大20个字符
                    * zhangsan 8个字符  张三 2个字符
 		* 创建表:
            create table student(
                id int,
                name varchar(32),
                age int ,
                score double(4,1),
                birthday date,
                insert_time timestamp
            );
		* 复制表:
            * create table 表名 like 被复制的表名;	  	
    2. R(Retrieve):查询
        * 查询某个数据库中所有的表名称
            * show tables;
        * 查询表结构
            * desc 表名;
    3. U(Update):修改
        1. 修改表名
            alter table 表名 rename to 新的表名;
        2. 修改表的字符集
            alter table 表名 character set 字符集名称;
        3. 添加一列
            alter table 表名 add 列名 数据类型;
        4. 修改列名称 类型
            alter table 表名 change 列名 新列别 新数据类型;
            alter table 表名 modify 列名 新数据类型;
        5. 删除列
            alter table 表名 drop 列名;
    4. D(Delete):删除
        * drop table 表名;
        * drop table if exists 表名 ;                    
  • 客户端图形化工具:SQLYog

    1. 添加数据:

      • 语法:
        • insert into 表名(列名1,列名2,…列名n) values(值1,值2,…值n);
      • 注意:
        1. 列名和值要一一对应。
        2. 如果表名后,不定义列名,则默认给所有列添加值
          insert into 表名 values(值1,值2,…值n);
        3. 除了数字类型,其他类型需要使用引号(单双都可以)引起来
    2. 删除数据:

      • 语法:
        • delete from 表名 [where 条件]
      • 注意:
        1. 如果不加条件,则删除表中所有记录。
        2. 如果要删除所有记录
          1. delete from 表名; – 不推荐使用。有多少条记录就会执行多少次删除操作
          2. TRUNCATE TABLE 表名; – 推荐使用,效率更高 先删除表,然后再创建一张一样的表。
    3. 修改数据:

      • 语法:

        • update 表名 set 列名1 = 值1, 列名2 = 值2,… [where 条件];
      • 注意:

        1. 如果不加任何条件,则会将表中所有记录全部修改。

Day 03 内容

06/07/2020

1. DQL:查询语句
	1. 排序查询
	2. 聚合函数
	3. 分组查询
	4. 分页查询

2. 约束
3. 多表之间的关系
4. 范式
5. 数据库的备份和还原

DQL:查询语句

DQL:查询表中的记录

* select * from 表名;

1. 语法:
    select 
        字段列表
    from
        表名列表
    where
        条件列表
    group by
        分组字段
    having
        分组之后的条件
    order by
        排序
    limit
        分页限定

2. 基础查询
    1. 多个字段的查询
        select 字段名1,字段名2... from 表名;
        * 注意:
            * 如果查询所有字段,则可以使用*来替代字段列表。
    2. 去除重复:
        * distinct
    3. 计算列
        * 一般可以使用四则运算计算一些列的值。(一般只会进行数值型的计算)
        * ifnull(表达式1,表达式2):null参与的运算,计算结果都为null
            * 表达式1:哪个字段需要判断是否为null
            * 表达式2:如果该字段为null后的替换值。
    4. 起别名:
        * as:as也可以省略


3. 条件查询
    1. where子句后跟条件
    2. 运算符
        * > 、< 、<= 、>= 、= 、<>
        * BETWEEN...AND  
        * IN( 集合) 
        * LIKE:模糊查询
            * 占位符:
                * _:单个任意字符
                * %:多个任意字符
        * IS NULL  
        * and  或 &&
        * or  或 || 
        * not  或 !

            -- 查询年龄大于20岁

            SELECT * FROM student WHERE age > 20;

            SELECT * FROM student WHERE age >= 20;

            -- 查询年龄等于20岁
            SELECT * FROM student WHERE age = 20;

            -- 查询年龄不等于20岁
            SELECT * FROM student WHERE age != 20;
            SELECT * FROM student WHERE age <> 20;

            -- 查询年龄大于等于20 小于等于30

            SELECT * FROM student WHERE age >= 20 &&  age <=30;
            SELECT * FROM student WHERE age >= 20 AND  age <=30;
            SELECT * FROM student WHERE age BETWEEN 20 AND 30;

            -- 查询年龄22岁,18岁,25岁的信息
            SELECT * FROM student WHERE age = 22 OR age = 18 OR age = 25
            SELECT * FROM student WHERE age IN (22,18,25);

            -- 查询英语成绩为null
            SELECT * FROM student WHERE english = NULL; -- 不对的。null值不能使用 = (!=) 判断

            SELECT * FROM student WHERE english IS NULL;

            -- 查询英语成绩不为null
            SELECT * FROM student WHERE english  IS NOT NULL;



            -- 查询姓马的有哪些? like
            SELECT * FROM student WHERE NAME LIKE '马%';
            -- 查询姓名第二个字是化的人

            SELECT * FROM student WHERE NAME LIKE "_化%";

            -- 查询姓名是3个字的人
            SELECT * FROM student WHERE NAME LIKE '___';


            -- 查询姓名中包含德的人
            SELECT * FROM student WHERE NAME LIKE '%德%';

中间的部分内容在这里没有给出,因为本人这部分内容已经掌握,所以未给出。

今日内容

1. 多表查询
2. 事务
3. DCL

多表查询

* 查询语法:
    select
        列名列表
    from
        表名列表
    where....
* 准备sql
    # 创建部门表
    CREATE TABLE dept(
        id INT PRIMARY KEY AUTO_INCREMENT,
        NAME VARCHAR(20)
    );
    INSERT INTO dept (NAME) VALUES ('开发部'),('市场部'),('财务部');
    # 创建员工表
    CREATE TABLE emp (
        id INT PRIMARY KEY AUTO_INCREMENT,
        NAME VARCHAR(10),
        gender CHAR(1), -- 性别
        salary DOUBLE, -- 工资
        join_date DATE, -- 入职日期
        dept_id INT,
        FOREIGN KEY (dept_id) REFERENCES dept(id) -- 外键,关联部门表(部门表的主键)
    );
    INSERT INTO emp(NAME,gender,salary,join_date,dept_id) VALUES('孙悟空','男',7200,'2013-02-24',1);
    INSERT INTO emp(NAME,gender,salary,join_date,dept_id) VALUES('猪八戒','男',3600,'2010-12-02',2);
    INSERT INTO emp(NAME,gender,salary,join_date,dept_id) VALUES('唐僧','男',9000,'2008-08-08',2);
    INSERT INTO emp(NAME,gender,salary,join_date,dept_id) VALUES('白骨精','女',5000,'2015-10-07',3);
    INSERT INTO emp(NAME,gender,salary,join_date,dept_id) VALUES('蜘蛛精','女',4500,'2011-03-14',1);
* 笛卡尔积:
    * 有两个集合A,B .取这两个集合的所有组成情况。
    * 要完成多表查询,需要消除无用的数据
* 多表查询的分类:
    1. 内连接查询:
        1. 隐式内连接:使用where条件消除无用数据
            * 例子:
            -- 查询所有员工信息和对应的部门信息

            SELECT * FROM emp,dept WHERE emp.`dept_id` = dept.`id`;

            -- 查询员工表的名称,性别。部门表的名称
            SELECT emp.name,emp.gender,dept.name FROM emp,dept WHERE emp.`dept_id` = dept.`id`;

            SELECT 
                t1.name, -- 员工表的姓名
                t1.gender,-- 员工表的性别
                t2.name -- 部门表的名称
            FROM
                emp t1,
                dept t2
            WHERE 
                t1.`dept_id` = t2.`id`;


        2. 显式内连接:
            * 语法: select 字段列表 from 表名1 [inner] join 表名2 on 条件
            * 例如:
                * SELECT * FROM emp INNER JOIN dept ON emp.`dept_id` = dept.`id`;	
                * SELECT * FROM emp JOIN dept ON emp.`dept_id` = dept.`id`;	

        3. 内连接查询:
            1. 从哪些表中查询数据
            2. 条件是什么
            3. 查询哪些字段
    2. 外链接查询:
        1. 左外连接:
            * 语法:select 字段列表 from 表1 left [outer] join 表2 on 条件;
            * 查询的是左表所有数据以及其交集部分。
            * 例子:
                -- 查询所有员工信息,如果员工有部门,则查询部门名称,没有部门,则不显示部门名称
                SELECT 	t1.*,t2.`name` FROM emp t1 LEFT JOIN dept t2 ON t1.`dept_id` = t2.`id`;
        2. 右外连接:
            * 语法:select 字段列表 from 表1 right [outer] join 表2 on 条件;
            * 查询的是右表所有数据以及其交集部分。
            * 例子:
                SELECT 	* FROM dept t2 RIGHT JOIN emp t1 ON t1.`dept_id` = t2.`id`;
    3. 子查询:
        * 概念:查询中嵌套查询,称嵌套查询为子查询。
            -- 查询工资最高的员工信息
            -- 1 查询最高的工资是多少 9000
            SELECT MAX(salary) FROM emp;

            -- 2 查询员工信息,并且工资等于9000的
            SELECT * FROM emp WHERE emp.`salary` = 9000;

            -- 一条sql就完成这个操作。子查询
            SELECT * FROM emp WHERE emp.`salary` = (SELECT MAX(salary) FROM emp);

        * 子查询不同情况
            1. 子查询的结果是单行单列的:
                * 子查询可以作为条件,使用运算符去判断。 运算符: > >= < <= =
                * 
                -- 查询员工工资小于平均工资的人
                SELECT * FROM emp WHERE emp.salary < (SELECT AVG(salary) FROM emp);
            2. 子查询的结果是多行单列的:
                * 子查询可以作为条件,使用运算符in来判断
                -- 查询'财务部'和'市场部'所有的员工信息
                SELECT id FROM dept WHERE NAME = '财务部' OR NAME = '市场部';
                SELECT * FROM emp WHERE dept_id = 3 OR dept_id = 2;
                -- 子查询
                SELECT * FROM emp WHERE dept_id IN (SELECT id FROM dept WHERE NAME = '财务部' OR NAME = '市场部');

            3. 子查询的结果是多行多列的:
                * 子查询可以作为一张虚拟表参与查询
                -- 查询员工入职日期是2011-11-11日之后的员工信息和部门信息
                -- 子查询
                SELECT * FROM dept t1 ,(SELECT * FROM emp WHERE emp.`join_date` > '2011-11-11') t2
                WHERE t1.id = t2.dept_id;

                -- 普通内连接
                SELECT * FROM emp t1,dept t2 WHERE t1.`dept_id` = t2.`id` AND t1.`join_date` >  '2011-11-11'

    * 多表查询练习

            -- 部门表
            CREATE TABLE dept (
              id INT PRIMARY KEY PRIMARY KEY, -- 部门id
              dname VARCHAR(50), -- 部门名称
              loc VARCHAR(50) -- 部门所在地
            );

            -- 添加4个部门
            INSERT INTO dept(id,dname,loc) VALUES 
            (10,'教研部','北京'),
            (20,'学工部','上海'),
            (30,'销售部','广州'),
            (40,'财务部','深圳');



            -- 职务表,职务名称,职务描述
            CREATE TABLE job (
              id INT PRIMARY KEY,
              jname VARCHAR(20),
              description VARCHAR(50)
            );

            -- 添加4个职务
            INSERT INTO job (id, jname, description) VALUES
            (1, '董事长', '管理整个公司,接单'),
            (2, '经理', '管理部门员工'),
            (3, '销售员', '向客人推销产品'),
            (4, '文员', '使用办公软件');



            -- 员工表
            CREATE TABLE emp (
              id INT PRIMARY KEY, -- 员工id
              ename VARCHAR(50), -- 员工姓名
              job_id INT, -- 职务id
              mgr INT , -- 上级领导
              joindate DATE, -- 入职日期
              salary DECIMAL(7,2), -- 工资
              bonus DECIMAL(7,2), -- 奖金
              dept_id INT, -- 所在部门编号
              CONSTRAINT emp_jobid_ref_job_id_fk FOREIGN KEY (job_id) REFERENCES job (id),
              CONSTRAINT emp_deptid_ref_dept_id_fk FOREIGN KEY (dept_id) REFERENCES dept (id)
            );

            -- 添加员工
            INSERT INTO emp(id,ename,job_id,mgr,joindate,salary,bonus,dept_id) VALUES 
            (1001,'孙悟空',4,1004,'2000-12-17','8000.00',NULL,20),
            (1002,'卢俊义',3,1006,'2001-02-20','16000.00','3000.00',30),
            (1003,'林冲',3,1006,'2001-02-22','12500.00','5000.00',30),
            (1004,'唐僧',2,1009,'2001-04-02','29750.00',NULL,20),
            (1005,'李逵',4,1006,'2001-09-28','12500.00','14000.00',30),
            (1006,'宋江',2,1009,'2001-05-01','28500.00',NULL,30),
            (1007,'刘备',2,1009,'2001-09-01','24500.00',NULL,10),
            (1008,'猪八戒',4,1004,'2007-04-19','30000.00',NULL,20),
            (1009,'罗贯中',1,NULL,'2001-11-17','50000.00',NULL,10),
            (1010,'吴用',3,1006,'2001-09-08','15000.00','0.00',30),
            (1011,'沙僧',4,1004,'2007-05-23','11000.00',NULL,20),
            (1012,'李逵',4,1006,'2001-12-03','9500.00',NULL,30),
            (1013,'小白龙',4,1004,'2001-12-03','30000.00',NULL,20),
            (1014,'关羽',4,1007,'2002-01-23','13000.00',NULL,10);



            -- 工资等级表
            CREATE TABLE salarygrade (
              grade INT PRIMARY KEY,   -- 级别
              losalary INT,  -- 最低工资
              hisalary INT -- 最高工资
            );

            -- 添加5个工资等级
            INSERT INTO salarygrade(grade,losalary,hisalary) VALUES 
            (1,7000,12000),
            (2,12010,14000),
            (3,14010,20000),
            (4,20010,30000),
            (5,30010,99990);

            -- 需求:

            -- 1.查询所有员工信息。查询员工编号,员工姓名,工资,职务名称,职务描述
            /*
                分析:
                    1.员工编号,员工姓名,工资,需要查询emp表  职务名称,职务描述 需要查询job表
                    2.查询条件 emp.job_id = job.id

            */
            SELECT 
                t1.`id`, -- 员工编号
                t1.`ename`, -- 员工姓名
                t1.`salary`,-- 工资
                t2.`jname`, -- 职务名称
                t2.`description` -- 职务描述
            FROM 
                emp t1, job t2
            WHERE 
                t1.`job_id` = t2.`id`;



            -- 2.查询员工编号,员工姓名,工资,职务名称,职务描述,部门名称,部门位置
            /*
                分析:
                    1. 员工编号,员工姓名,工资 emp  职务名称,职务描述 job  部门名称,部门位置 dept
                    2. 条件: emp.job_id = job.id and emp.dept_id = dept.id
            */

            SELECT 
                t1.`id`, -- 员工编号
                t1.`ename`, -- 员工姓名
                t1.`salary`,-- 工资
                t2.`jname`, -- 职务名称
                t2.`description`, -- 职务描述
                t3.`dname`, -- 部门名称
                t3.`loc` -- 部门位置
            FROM 
                emp t1, job t2,dept t3
            WHERE 
                t1.`job_id` = t2.`id` AND t1.`dept_id` = t3.`id`;

            -- 3.查询员工姓名,工资,工资等级
            /*
                分析:
                    1.员工姓名,工资 emp  工资等级 salarygrade
                    2.条件 emp.salary >= salarygrade.losalary and emp.salary <= salarygrade.hisalary
                        emp.salary BETWEEN salarygrade.losalary and salarygrade.hisalary
            */
            SELECT 
                t1.ename ,
                t1.`salary`,
                t2.*
            FROM emp t1, salarygrade t2
            WHERE t1.`salary` BETWEEN t2.`losalary` AND t2.`hisalary`;



            -- 4.查询员工姓名,工资,职务名称,职务描述,部门名称,部门位置,工资等级
            /*
                分析:
                    1. 员工姓名,工资 emp , 职务名称,职务描述 job 部门名称,部门位置,dept  工资等级 salarygrade
                    2. 条件: emp.job_id = job.id and emp.dept_id = dept.id and emp.salary BETWEEN salarygrade.losalary and salarygrade.hisalary

            */
            SELECT 
                t1.`ename`,
                t1.`salary`,
                t2.`jname`,
                t2.`description`,
                t3.`dname`,
                t3.`loc`,
                t4.`grade`
            FROM 
                emp t1,job t2,dept t3,salarygrade t4
            WHERE 
                t1.`job_id` = t2.`id` 
                AND t1.`dept_id` = t3.`id`
                AND t1.`salary` BETWEEN t4.`losalary` AND t4.`hisalary`;



            -- 5.查询出部门编号、部门名称、部门位置、部门人数

            /*
                分析:
                    1.部门编号、部门名称、部门位置 dept 表。 部门人数 emp表
                    2.使用分组查询。按照emp.dept_id完成分组,查询count(id)
                    3.使用子查询将第2步的查询结果和dept表进行关联查询

            */
            SELECT 
                t1.`id`,t1.`dname`,t1.`loc` , t2.total
            FROM 
                dept t1,
                (SELECT
                    dept_id,COUNT(id) total
                FROM 
                    emp
                GROUP BY dept_id) t2
            WHERE t1.`id` = t2.dept_id;


            -- 6.查询所有员工的姓名及其直接上级的姓名,没有领导的员工也需要查询

            /*
                分析:
                    1.姓名 emp, 直接上级的姓名 emp
                        * emp表的id 和 mgr 是自关联
                    2.条件 emp.id = emp.mgr
                    3.查询左表的所有数据,和 交集数据
                        * 使用左外连接查询

            */
            /*
            select
                t1.ename,
                t1.mgr,
                t2.`id`,
                t2.ename
            from emp t1, emp t2
            where t1.mgr = t2.`id`;

            */

            SELECT 
                t1.ename,
                t1.mgr,
                t2.`id`,
                t2.`ename`
            FROM emp t1
            LEFT JOIN emp t2
            ON t1.`mgr` = t2.`id`;

事务

1. 事务的基本介绍
    1. 概念:
        * 如果一个包含多个步骤的业务操作,被事务管理,那么这些操作要么同时成功,要么同时失败
    2. 操作:
        1. 开启事务:start transection
        2. 回滚:rollback
        3. 提交:commit
    3. MySQL数据库中事务默认提交
        * 事务提交的两种方式:
            * 自动提交:
                * mysql就是自动提交的
                * 一条DML(增删改)语句会自动提交一次事务。
            * 手动提交:
                * Oracle数据库默认是手动提交事务
                * 需要先开启事务,再提交
        * 修改事务的默认提交方式:
            * 查看事务的默认提交方式:SELECT @@autocommit; -- 1 代表自动提交  0 代表手动提交
            * 修改默认提交方式: set @@autocommit = 0;
2. 事务的四大特征
    1. 原子性:是不可分割的最小操作单位,要么同时成功,要么同时失败。
    2. 持久性:当事务提交或回滚后,数据库会持久化的保存数据。
    3. 隔离性:多个事务之间。相互独立。
    4. 一致性:事务操作前后,数据总量不变
3. 事务的隔离级别(了解)
    * 概念:多个事务之间隔离的,相互独立的。但是如果多个事务操作同一批数据,则会引发一些问题,设置不同的隔离级别就可以解决这些问题。
    * 存在问题:
        1. 脏读:一个事务,读取到另一个事务中没有提交的数据
        2. 不可重复读(虚读):在同一个事务中,两次读取到的数据不一样。
        3. 幻读:一个事务操作(DML)数据表中所有记录,另一个事务添加了一条数据,则第一个事务查询不到自己的修改。
    * 隔离级别:
        1. read uncommitted:读未提交
            * 产生的问题:脏读、不可重复读、幻读
        2. read committed:读已提交 (Oracle)
            * 产生的问题:不可重复读、幻读
        3. repeatable read:可重复读 (MySQL默认)
            * 产生的问题:幻读
        4. serializable:串行化
            * 可以解决所有的问题

        * 注意:隔离级别从小到大安全性越来越高,但是效率越来越低
        * 数据库查询隔离级别:
            * select @@tx_isolation;
        * 数据库设置隔离级别:
            * set global transaction isolation level  级别字符串;

    * 演示:
        set global transaction isolation level read uncommitted;
        start transaction;
        -- 转账操作
        update account set balance = balance - 500 where id = 1;
        update account set balance = balance + 500 where id = 2;

DCL

* SQL分类:
    1. DDL:操作数据库和表
    2. DML:增删改表中数据
    3. DQL:查询表中数据
    4. DCL:管理用户,授权

* DBA:数据库管理员

* DCL:管理用户,授权
    1. 管理用户
        1. 添加用户:
            * 语法:CREATE USER '用户名'@'主机名' IDENTIFIED BY '密码';
        2. 删除用户:
            * 语法:DROP USER '用户名'@'主机名';
        3. 修改用户密码:

            UPDATE USER SET PASSWORD = PASSWORD('新密码') WHERE USER = '用户名';
            UPDATE USER SET PASSWORD = PASSWORD('abc') WHERE USER = 'lisi';

            SET PASSWORD FOR '用户名'@'主机名' = PASSWORD('新密码');
            SET PASSWORD FOR 'root'@'localhost' = PASSWORD('123');

            * mysql中忘记了root用户的密码?
                1. cmd -- > net stop mysql 停止mysql服务
                    * 需要管理员运行该cmd

                2. 使用无验证方式启动mysql服务: mysqld --skip-grant-tables
                3. 打开新的cmd窗口,直接输入mysql命令,敲回车。就可以登录成功
                4. use mysql;
                5. update user set password = password('你的新密码') where user = 'root';
                6. 关闭两个窗口
                7. 打开任务管理器,手动结束mysqld.exe 的进程
                8. 启动mysql服务
                9. 使用新密码登录。
        4. 查询用户:
            -- 1. 切换到mysql数据库
            USE myql;
            -- 2. 查询user表
            SELECT * FROM USER;

            * 通配符: % 表示可以在任意主机使用用户登录数据库

    2. 权限管理:
        1. 查询权限:
            -- 查询权限
            SHOW GRANTS FOR '用户名'@'主机名';
            SHOW GRANTS FOR 'lisi'@'%';

        2. 授予权限:
            -- 授予权限
            grant 权限列表 on 数据库名.表名 to '用户名'@'主机名';
            -- 给张三用户授予所有权限,在任意数据库任意表上

            GRANT ALL ON *.* TO 'zhangsan'@'localhost';
        3. 撤销权限:
            -- 撤销权限:
            revoke 权限列表 on 数据库名.表名 from '用户名'@'主机名';
            REVOKE UPDATE ON db3.`account` FROM 'lisi'@'%';

Day 04 内容:

07/07/2020

1. JDBC基本概念
2. 快速入门
3. 对JDBC中各个接口和类详解

JDBC

1. 概念:Java DataBase Connectivity	Java数据库连接,Java语言操作数据库
    * JDBC本质:其实是官网(sun公司)定义的一套操作所有关系型数据库的规则,即接口。各个数据库厂商可以去实现这套接口,提供数据库驱动jar包。我们可以使用这套接口(JDBC)编程,真正执行的代码是驱动jar包中的实现类

2. 快速入门:
    * 步骤:
        1. 导入驱动jar包 mysql-connnector-java-x.x.x-bin.jar
            1. 复制mysql-connnector-java-x.x.x-bin.jar包到项目libs目录下
            2. 右键-->Add as library
        2. 注册驱动
        3. 获取数据库的连接对象 Connection
        4. 定义sql
        5. 获取执行sql语句的对象 Statement
        6. 执行sql,接收返回结果
        7. 处理结果
        8. 释放资源

    * 代码实现:
        // 1.导入驱动jar包
        // 2.注册驱动
        Class.forName("com.mysql.jdbc.Driver");
        // 3.获取数据库连接对象
        Connection connection = DriverManager.getConnection("jdbc:mysql://localhost:3306/db1",
                "root", "********");
        // 4.定义sql语句
        String sql = "insert into test values(1, \"test\")";
        // 5.获取执行sql的对象Statement
        Statement statement = connection.createStatement();
        // 6.执行sql
        int count = statement.executeUpdate(sql);
        // 7.处理结果
        System.out.println(count);
        // 8.释放资源
        statement.close();
        connection.close();

3. 详解各个对象
    1. DriverManager: 驱动管理对象
        * 功能:
            1. 注册驱动:告诉程序该使用哪一个数据库驱动jar包
                static void registerDriver(Driver driver): 注册给定的驱动程序 DriverManager
                写代码使用: Class.forName("com.mysql.jdbc.Driver");
                通过查看源码发现: 在com.mysql.jdbc.Driver类中存在静态代码块
                static {
                    try {
                        DriverManager.registerDriver(new Driver());
                    } catch (SQLException var1) {
                        throw new RuntimeException("Can't register driver!");
                    }
                }

                注意:mysql5之后的驱动jar包可以省略注册驱动的步骤
            2. 获取数据库连接:
                * 方法: static Connerction getConnection(String url, String user, String password)
                * 参数:
                    * url:指定连接的路径
                        * 语法: jdbc:mysql://ip地址(域名):端口号/数据库名称
                        * 例子: jdbc:mysql://localhost:3306/db1
                        * 细节: 如果连接的是本机mysql服务器,并且mysql服务默认端口为3306,则url可以简写为jdbc:mysql:///数据库名称
                    * user:用户名
                    * password:密码

    2. Connection: 数据库连接对象
        1. 功能:
            1. 获取执行sql的对象
                * Statement createStatement()
                * PreparedStatement prepareStatement(String sql)
            2。 管理事务:
                * 开启事务: void setAutoCommit(boolean autoCommit)	: 调用该方法设置参数为false,即开启事务
                * 提交事务: void commit()
                * 回滚事务: void rollback()

    3. Statement: 执行sql的对象
        1. 执行sql
            1. booleann execute(String sql) : 可以执行任意的sql 了解
            2. int executeUpdate(String sql) : 执行DML(insert、update、delete)语句、DDL(create、alter、drop)语句
                * 返回值:影响的行数,可以通过这个影响的行数判断DML语句是否执行成功 返回值>0执行成功 反之失败
            3. ResultSet executeQuery(String sql) : 执行DQL(select)语句
        2. 练习:
            1. account表 添加一条记录
            2. account表 修改记录
            3. account表 删除一条记录

            代码:
                Connection connection = null;
                Statement statement = null;
                try {
                    // 1.注册驱动
                    Class.forName("com.mysql.cj.jdbc.Driver");
                    // 2.定义sql
                    String sql = "insert into account values(null, '王五', 3000)";
                    // 3.获取Connection对象
                    connection= DriverManager.getConnection("jdbc:mysql:///db1",
                            "root", "******");
                    // 4.获取执行sql的对象
                    statement = connection.createStatement();
                    // 5.执行sql
                    int count = statement.executeUpdate(sql);
                    // 6.处理结果
                    System.out.println(count);
                    if(count > 0){
                        System.out.println("添加成功");
                    }else{
                        System.out.println("添加失败");
                    }
                } catch (ClassNotFoundException | SQLException e) {
                    e.printStackTrace();
                } finally {
                    // 避免空指针异常
                    if(statement != null){
                        try {
                            statement.close();
                        } catch (SQLException throwables) {
                            throwables.printStackTrace();
                        }
                    }
                    if(connection != null){
                        try {
                            connection.close();
                        } catch (SQLException throwables) {
                            throwables.printStackTrace();
                        }
                    }
                }

    4. ResultSet: 结果集对象,封装查询结果
        * next():游标向下移动一行,判断当前行是否是最后一行末尾(是否有数据),返回boolean值
        * getXxx(参数):获取数据
            * Xxx代表数据类型	如: int getInt()
            * 参数:
                1. int: 代表列的编号,从1开始
                2. String: 代表列名称
        * 注意:
            * 使用步骤:
                1. 游标向下移动一行
                2. 判断是否有数据
                3. 获取数据
            while(rs.next()){...}

        * 练习:
            * 定义一个方法,查询emp表的数据将其封装为对象,然后装载集合,返回。
                1. 定义Emp类
                2. 定义方法 public List findAll(){}
                3. 实现方法 select * from emp;

    5. PreparedStatement: 执行sql的对象
        1. SQL注入问题: 在拼接SQL时,有一些sql的特殊关键字参与字符串的拼接,会造成安全性问题
            1. 输入用户随便,输入密码:a' or 'a' = 'a
            2. sql : select * from USER where username = 'xxx' and password = 'a' or 'a' = 'a';

        2. 解决sql注入问题:使用PreparedStatement来解决
        3. 预编译的SQL:参数使用?作为占位符
        4. 步骤:
            1. 导入驱动jar包 mysql-connnector-java-x.x.x-bin.jar
            2. 注册驱动
            3. 获取数据库的连接对象 Connection
            4. 定义sql
                * 注意:sql的参数使用?作为占位符。如: select * from user where username = ? and password = ?
            5. 获取执行sql语句的对象 PreparedStatement	Connection.preparedStatement(String sql)
            6. 给?赋值:
                * 方法:setXxx(参数1, 参数2)
                    * 参数1: ?的位置编号 从1 开始
                    * 参数2: ?的值
            7. 执行sql,接收返回结果,不需要传递sql语句
            8. 处理结果
            9. 释放资源
        5. 注意:后期都会使用PreparedStatement来完成增删改查的所有操作
            1. 可以防止sql注入
            2. 效率更高

抽取JDBC工具类 : JDBCUtils

* 目的:简化书写
* 分析:
    1. 注册驱动也抽取
    2. 抽取一个方法获取连接对象
        * 需求:不想传递参数(麻烦),还得保证工具类的通用性。
        * 解决:配置文件
            jdbc.properties
                url=
                user=
                password=
    3. 抽取一个方法释放资源
* 代码实现:
    public class JDBCUtils {
        private static String url;
        private static String user;
        private static String password;
        private static String driver;
        /**
         * 文件的读取只需要读取一次即可拿到这些值,使用静态代码块完成
         */
        static {
            try {
                // 读取资源文件,获取值。

                // 1.创建Properties集合类
                Properties pro = new Properties();

                // 获取src路径下的文件的方式--->ClassLoader 类加载器
                ClassLoader classLoader = JDBCUtils.class.getClassLoader();
                URL result = classLoader.getResource("jdbc.properties");
                String path = result.getPath();

                // 2.加载文件
                pro.load(new FileReader(path));
                // 3.获取属性赋值
                url = pro.getProperty("url");
                user = pro.getProperty("user");
                password = pro.getProperty("password");
                driver = pro.getProperty("driver");
                // 4.注册驱动
                try {
                    Class.forName(driver);
                } catch (ClassNotFoundException e) {
                    e.printStackTrace();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }


        /**
         * 获取连接
         * @return 连接对象
         */
        public static Connection getConnection() throws SQLException {
            return DriverManager.getConnection(url, user, password);
        }

        /**
         * 释放资源
         * @param statement
         * @param connection
         */
        public static void close(Statement statement, Connection connection){
            if(statement != null){
                try {
                    statement.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }

            if(connection != null){
                try {
                    connection.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
        }

        public static void close(ResultSet resultSet, Statement statement, Connection connection){
            if(statement != null){
                try {
                    statement.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }

            if(connection != null){
                try {
                    connection.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }

            if(resultSet != null){
                try {
                    resultSet.close();
                } catch (SQLException throwables) {
                    throwables.printStackTrace();
                }
            }
        }
    }

    * 练习:
        * 需求:
            1. 通过键盘录入用户名和密码
            2. 判断用户是否登录成功
                * select * from USER where username = '' and password = '';
                * 如果这个sql有查询结果,则成功,反之失败

        * 步骤:
            1. 创建数据库表 user
                CREATE TABLE USER(
                    id INT PRIMARY KEY AUTO_INCREMENT,
                    username varchar(32),
                    password varchar(32)
                );

                INSERT INTO USER VALUES(NULL,'zhangsan','123');
                INSERT INTO USER VALUES(NULL,'lisi','234');

            2. 创建一个类
            ......

JDBC控制事务

1. 事务:一个包含多个步骤的业务操作。如果这个业务操作被事务管理,则者多个步骤要么同时成功,要么同时失败。
2. 操作:
    1. 开启事务
    2. 提交事务
    3. 回滚事务
3. 使用Connection对象来管理事务
    * 开启事务: void setAutoCommit(boolean autoCommit)	: 调用该方法设置参数为false,即开启事务
        * 在执行sql之前开启事务(在获得连接后开启)
    * 提交事务: void commit()
        * 当所有sql都执行完提交事务
    * 回滚事务: void rollback()
        * 在catch中回滚事务

Day 05 内容:

1. 数据库连接池
2. Spring JDBC : JDBC Template

数据库连接池

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

2. 好处:
	1. 节约资源
	2. 用户访问高效

3. 实现:
	1. 标准接口:DataSource	javax.sql包下的
		1. 方法:
			* 获取连接:getConnection()
			* 归还连接:Connection.close()
				如果连接对象Connection是从连接池中获取的,那么调用Connection.close(),则不会再关闭连接,而是归还连接。

	2. 一般我们不去实现它,由数据库厂商实现
		1. C3P0:数据库连接池技术
		2. Druid:数据库连接池实现技术,由阿里巴巴提供的

4. C3P0:数据库连接池技术
	* 步骤:
		1. 导入jar包 (两个)c3p0-0.6.5.2.jar mchange-commons-java-0.2.12.jar
			* 不要忘记导入数据库驱动jar包
		2. 定义配置文件:
			* 名称:c3p0.properties 或者 c3p0-config.xml
			* 路径:直接将文件放在src目录下即可
		
		3. 创建核心对象:数据库连接池对象 ComboPooledDataSource
		4. 获取连接:getConnection()

5. Druid:数据库连接池实现技术,由阿里巴巴提供的
	1. 步骤:
		1. 导入jar包 druid-1.0.9.jar
		2. 定义配置文件:
			* 是properties形式的
			* 可以叫任意名称,可以放在任意目录下
		3. 加载配置文件 	Properties
		4. 获取数据库连接池对象:通过工厂类来获取	DruidDataSourceFactory
		5. 获取连接:getConnection()

	2. 定义工具类
		1. 定义一个类 JDBCUtils
		2. 提供静态代码块加载配置文件,初始化连接池对象
		3. 提供方法
			1. 获取连接方法:通过数据库连接池获取连接
			2. 释放资源
			3. 获取连接池的方法
			代码:
				/**
                 * Druid连接池的工具类
                 */
                public class JDBCUtils {

                    // 1.定义成员变量 DataSource
                    private static DataSource ds;

                    static {
                        try {
                            // 1.加载配置文件
                            Properties pro = new Properties();
                            pro.load(JDBCUtils.class.getClassLoader().getResourceAsStream("druid.properties"));
                            // 2.获取DataSource
                            ds = DruidDataSourceFactory.createDataSource(pro);
                        } catch (Exception e) {
                            e.printStackTrace();
                        }
                    }

                    /**
                     * 获取连接
                     */
                    public static Connection getConnection() throws SQLException {
                        return ds.getConnection();
                    }

                    /**
                     * 释放资源
                     * @param statement
                     * @param connection
                     */
                    public static void close(Statement statement, Connection connection){
                        if(statement != null){
                            try {
                                statement.close();
                            } catch (SQLException throwables) {
                                throwables.printStackTrace();
                            }
                        }

                        if(connection != null){
                            try {
                                connection.close();
                            } catch (SQLException throwables) {
                                throwables.printStackTrace();
                            }
                        }
                    }

                    public static void close(ResultSet resultSet, Statement statement, Connection connection){
                        if(statement != null){
                            try {
                                statement.close();
                            } catch (SQLException throwables) {
                                throwables.printStackTrace();
                            }
                        }

                        if(connection != null){
                            try {
                                connection.close();
                            } catch (SQLException throwables) {
                                throwables.printStackTrace();
                            }
                        }

                        if(resultSet != null){
                            try {
                                resultSet.close();
                            } catch (SQLException throwables) {
                                throwables.printStackTrace();
                            }
                        }
                    }

                    /**
                     * 获取连接池方法
                     */
                    public static DataSource getDataSource(){
                        return ds;
                    }
                }

Spring JDBC

* Spring框架对JDBC的简单封装。提供了JDBC Template对象简化JDBC的开发
* 步骤:
	1. 导入jar包
	2. 创建JdbcTemplate对象。依赖于数据源DataSource
		* JdbcTemplate template = new JdbcTemplate(ds);

	3. 调用JdbcTemplate的方法来完成CRUD的操作
		* update(): 执行DML语句。增、删、改语句
		* queryForMap(): 查询结果,将结果集封装为Map集合,将列名作为key,将值作为value,将这条记录封装为value
			* 注意:这个方法查询的结果集长度只能是1
		* queryForList(): 查询结果,将结果集封装为list集合
			* 注意:将每一条记录封装为Map集合,再将Map集合装载在List集合中
		* query(): 查询结果,将结果封装为JavaBean对象
			* query方法的参数:RowMapper
				* 一般使用BeanPropertiyRowMapper实现类。可以完成数据到JavaBean的自动封装。
				* new BeanPropertyRowMapper<类型>(类型.class)
		* queryForObject(): 查询结果,将结果封装为对象
			* 一般用于聚合函数的查询 

	4. 练习:
		* 需求:
			1. 修改1号数据的 salary 为 10000
			2. 添加一条记录
			3. 删除刚才添加的记录
			4. 查询id为1的记录,将其封装为Map集合
			5. 查询所有的记录,将其封装为List集合
			6. 查询所有记录,将其封装为Emp对象的List集合
			7. 查询总的记录数

Day 06 内容:

1. web概念概述
2. HTML

web概念概述

* JavaWeb:
	* 使用Java语言开发基于互联网的项目

* 软件的架构:
	1. C/S:Client/Server 客户端/服务器端
		* 在用户本地有一个客户端程序,在远程有一个服务器端程序
		* 如:QQ,迅雷...
		* 优点:
			1. 用户体验好
		* 缺点:
			1. 开发、安装、部署、维护麻烦
	2. B/S:Browser/Server 浏览器/服务器端
		* 只需要一个浏览器,用户通过不同的网址(URL),可以访问远程不同的服务器端程序
		* 优点:
			1. 开发、安装、部署、维护简单
		* 缺点:
			1. 如果应用过大,用户的体验可能会受到影响
			2. 对硬件要求过高

* B/S架构详解
	* 资源分类:
		1. 静态资源:
			* 使用静态网页开发技术发布的资源
			* 特点:
				* 所有用户访问,得到的结果是一样的
				* 如:文本、图片、音频、视频,HTML,CSS,JavaScript
				* 如果用户请求的是静态资源,那么服务器会直接将静态资源发送给浏览器,浏览器中内置了静态资源的解析引擎
		2. 动态资源:
			* 使用动态网页技术发布的资源
			* 特点:
				* 所有用户访问,得到的结果可能不一样
				* 如:jsp/servlet,php,asp...
				* 如果用户请求的是动态资源,那么服务器将会执行动态资源,转换为静态资源,再发送给浏览器

	* 我们要学习动态资源,必须先学习静态资源!
	
	* 静态资源:
		* HTML:用于搭建基础网页,展示页面的内容
		* CSS:用于美化页面,布局页面
		* JavaScript:控制页面的元素,让页面有一些动态的效果

HTML

1. 概念:是最基础的网页开发语言
	* Hyper Text Markup Language 超文本标记语言
		* 超文本:
			* 超文本是用超链接的方法,将各种不同空间的文字信息组织在一起的网状文本。
		* 标记语言:
			* 由标签构成的语言。<标签名称> 如html, xml
			* 标记语言不是编程语言

2. 快速入门:
	* 语法:
		1. html文档后缀名 .html 或者 .htm
		2. 标签分为
			1. 围堵标签:有开始标签和结束标签。如  
			2. 自闭和标签:开始标签和结束标签在一起。 如 
3. 标签可以嵌套: 需要正确嵌套,不能你中有我,我中有你 错误: 正确: 4. 在开始标签中可以定义属性。属性是由键值对组成,值需要用引号(单双都可)引起来 5. html的标签不区分大小写,建议使用小写。 3. 标签学习: 1. 文件标签:构成html最基本的标签 * html:html文档的根标签 * head:头标签。用于指定html文档的一些属性。引入外部的资源 * title:标题标签 * body:体标签 * :html5中定义改文档是html文档 2. 文本标签:和文本有关的标签 * 注释: *

to

:标题标签 * h1~h6字体大小主键递减 *

:段落标签 *
:换行标签 *


:展示一条水平线 * 属性: * color:颜色 * width:宽度 * size:高度 * align:对齐方式 * center:居中 * left:左对齐 * right:右对齐 * :字体加粗 * :字体斜体 * :字体标签 * 属性: * color:颜色 * size:大小 * face:字体 *
:文本居中 * 属性定义: * color: 1. 英文单词:red,green,blue 2. rgb(值1, 值2, 值3):值的范围:0~255 如 rgb(0,0,2555) 3. #值1值2值3:值的范围:00~FF。 如: #FF00FF * width: 1. 数值:width='20',数值的单位,默认是 px(像素) 2. 数值% :占比相对于父元素的比例 * 案例 ... 3. 图片标签 * img:展示图片 * 属性: * src:指定图片位置 * 相对路径: * 以.开头的路径 * ./: 代表当前目录 ./image/1.jpg * ../: 代表上一级目录 4. 列表标签: * 有序列表: * ol * li * 无序标签: * ul * li 5. 链接标签 * a:定义一个超链接 * 属性: * href:指定访问资源的URL(统一资源定位符) * target:指定打开资源的方式 * _self:默认值,在当前页面打开 * _blank:在空白页面打开 6. div和span: * div:每个div占满一整行。块级标签 * span:文本信息在一行展示,行内标签,内联标签。 7. 语义化标签:html5中为了提高程序的可读性,提供了一些标签 1.
: 页眉 2.
: 页脚 8. 表格标签 * table:定义表格 * width:宽度 * border:边框 * cellpadding:定义内容和单元格的距离 * cellspacing:定义单元格之间的距离。如果指定为0,则单元格的线会合为一条。 * bgcolor:背景色 * align:对齐方式 * tr:定义行 * bgcolor:背景色 * align:对齐方式 * td:定义单元格 * colspan:合并行 * rowspan:合并列 * th:定义表头单元格 * :表格标题 * :表示表格的头部分 * :表示表格的体部分 * :表示表格的脚部分

案例:旅游网站首页

1. 确定使用table来完成布局
2. 如果某一行只有一个单元格,则使用
3. 如果某一行有多个单元格,则使用
	
		
			

Day 07 内容:

1. HTML标签:表单标签
2. CSS:

HTML标签:表单标签

* 表单:
	* 概念:用于采集用户输入的数据的。用于和服务器进行交互。
	* form: 用于定义表单的。可以定义一个范围,范围代表用户采集数据的范围
		* 属性:
			* action:指定提交数据的URL
            * method:指定提交方式
                * 分类:一共七种,两种比较常用
                    * GET:
                    	1. 请求参数会在地址栏中显示,会封装到请求行中(HTTP协议后讲解)
                    	2. 请求参数的大小是有限制的
                    	3. 不太安全
                    * POST:
                    	1. 请求参数不会在地址栏中显示,会封装在请求体中(HTTP协议后讲解)
                    	2. 请求参数的大小没有限制
                    	3. 较为安全

        * 表单项中的数据要想被提交,必须指定其name属性

* 表单项标签:
	* input:可以通过type属性值,改变元素展示的样式
		* type属性:
			* text:文本输入框,默认值
				* placeholder:指定输入框的提示信息,当输入框的内容发生变化,会自动清楚提示信息
			* password:密码输入框
			* radio:单选框
				* 注意:
					1. 要想让多个单选框实现单选的效果,则多个单选框的name属性值必须一样
					2. 一般会给每一个单选框提供value属性,指定其被选中后提交的值
					3. checked属性,可以指定默认值
			* checkbox:复选框
				* 注意:
					1. 一般会给每一个单选框提供value属性,指定其被选中后提交的值
					2. checked属性,可以指定默认值
			* file:文件选择框
			* hidden:隐藏域,用于提交一些信息
			* 按钮:
				* submit: 提交按钮,用于提交表单
				* button:普通按钮
				* image:图片提交按钮

		* label:指定输入项的文字描述信息
			* 注意
				* label的for属性一般会和input的id属性值对应。如果对应了,则点击label区域,会让input输入框获取焦点
	* select:下拉列表
		* 子元素option,指定列表项
	* textarea:文本域
		* cols:指定列数
		* rows:指定行数

CSS: 页面美化和布局控制

1. 概念:Cascading Style Sheets 层叠样式表
	* 层叠:多个样式可以作用在同一个html的元素上,同时生效

2. 好处:
	1. 功能强大
	2. 将内容展示和样式控制分类
		* 降低耦合度,解耦
		* 让分工合作更容易
		* 提高开发效率

3. CSS的使用:CSS和HTML结合方式
	1. 内联样式
		* 在标签内使用style属性指定css代码
		* 如	
2. 内部样式 * 在head标签内部定义style标签,style的标签内容就是css代码 * 如
3. 外部样式 1. 定义css资源文件 2. 在head标签内定义link标签,引入外部资源文件 * 注意: * 1、2、3种方式,作用范围越来越大 * 1方式不常用,后期常用2、3 * 第3种格式可以写为: 4. css语法: * 格式: 选择器 { 属性名1:属性值1; 属性名2:属性值2; ... } * 选择器:筛选具有相似特征的元素 * 注意: * 每一对属性需要用分号隔开,最后一对属性可以不加 5. 选择器: * 分类: 1. 基础选择器 1. id选择器:选择具体的id属性值的元素,建议在一个html界面中id值唯一 * 语法:#id属性值{} 2. 元素选择器:选择具有相同标签的元素 * 语法:标签名称{} * 注意:id选择器优先级高于元素选择器 3. 类选择器:选择具有相同的class属性的元素 * 语法:.class属性值{} * 注意:类选择器优先级高于元素选择器 2. 扩展选择器: 1. 选择所有元素 * 语法:* {} 2. 并集选择器 * 语法:选择器1,选择器2 {} 3. 子选择器:筛选选择器1元素下的选择器2 * 语法:选择器1 选择器2 {} 4. 父选择器:筛选选择器2父元素选择器1 * 语法:选择器1 > 选择器2 {} 5. 属性选择器:选择元素名称,属性名=属性值的元素 * 语法:元素名称[属性名="属性值"] {} 6. 伪类选择器:选择一些元素具有的状态 * 语法:元素:状态 {} * 如: * 状态: * link:初始化的状态 * visited:被访问过的状态 * active:正在访问状态 * hover:鼠标悬浮状态 6. 属性 1. 字体、文本 * font-size:字体大小 * color:文本颜色 * text-alion:对齐方式 * line-height:行高 2. 背景 * background:复合属性 3. 边框 * border:设置边框,复合属性 4. 尺寸 * width:宽度 * height:高度 5. 盒子模型:控制布局 * margin:外边距 * padding:内边距 * 默认情况下内边距会影响整个盒子的大小 * box-sizing: border-box * float:浮动 * left * right

Day 08 内容:

1. JavaScript基础

JavaScript:

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

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

* JavaScript发展史:
	1. 1992年,Nombase公司,开发出第一门客户端脚本语言,专门用于表单的校验。命名为:C--,后来更名为:ScriptEase
	2. 1995年,Netscape(网景)公司,开发了一门客户端脚本语言:LiveScript。请来SUN公司的专家,修改LiveScript,命名为JavaScript
	3. 1996年,微软抄袭JavaScript开发出JScript语言
	4. 1997年,ECMA(欧洲计算机制造商协会),ECMAScript,就是所有客户端脚本语言的标准。

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

* ECMAScript:客户端脚本语言的标准
	1. 基本语法:
		1. 与HTML结合方式
			1. 内部JS:
				* 定义