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

 找回密码
 加入黑马

QQ登录

只需一步,快速开始

Day025(JavaWeb - 基础加强)
Junit单元测试
测试分类
        黑盒测试:不需要写代码,给输入值,看程序是否能够输出期望的值。(只看输入和结果)
        白盒测试:需要写代码的。关注程序具体的执行流程。
Junit使用:白盒测试
        步骤:
                1. 定义一个测试类(测试用例)
                        建议:
                                测试类名:被测试的类名Test                CalculatorTest
                                包名:xxx.xxx.xx.test                cn.itcast.test
                2. 定义测试方法:可以独立运行
                        建议:
                                方法名:test测试的方法名                testAdd()  
                                返回值:void
                                参数列表:空参
                3. 给方法加@Test
                4. 导入junit依赖环境
        判定结果:
                红色:失败
                绿色:成功
                一般我们会使用断言操作来处理结果Assert.assertEquals(期望的结果,运算的结果);
        补充:
                @Before:
                        修饰的方法会在测试方法之前被自动执行。(用于资源初始化  init)
                @After:
                        修饰的方法会在测试方法执行之后自动被执行(用于资源释放  close)
反射(重要)
框架设计的灵魂
框架: 半成品软件。可以在框架的基础上进行软件开发,简化编码。
反射: (reflect)将类的各个组成部分封装为其他对象,这就是反射机制。(类加载到内存中是以Class对象的形式存在,反射其实就是在运行时,通过获取Class对象,以此进行操作)
好处:
        1. 可以在程序运行过程中,操作这些对象。
                2. 可以解耦,提高程序的可扩展性。
Java代码在计算机中经历的阶段:三个阶段
        Source源代码阶段(xxx.java -> javac编译 -> xxx.class存储在硬盘中)
                ⬇
        Class类对象阶段(类加载器ClassLoader -> 类对象【成员变量field[] fields\构造方法 Constructor[] constructors\成员方法Method[] methods】)
                ⬇
        Runtime运行时阶段(创建对象)
获取Class对象方式
1.        直接通过 类名.class 可以获取字节码对象。(多用于参数的传递)
2.        可以通过 对象名.getClass() 获取对象所在类的字节码对象。
3.        Class类中的静态方法: Class forName(String className)。(className为类名)
(如: Class c = Class.forName(“cn.itacast.day025.DemoTest01”))
结论
同一个字节码文件(*.class)在一次程序运行过程中,只会被加载一次,不论通过哪一种方式获取的Class对象都是同一个。
Class对象功能
获取功能
1. 获取成员变量们
                Field[] getFields() :获取所有public修饰的成员变量
                Field getField(String name)   获取指定名称的 public修饰的成员变量
                Field[] getDeclaredFields()  获取所有的成员变量,不考虑修饰符
                Field getDeclaredField(String name) 获取指定的成员变量,不考虑修饰符
2. 获取构造方法们
                Constructor<?>[] getConstructors() 获取所有public修饰的构造方法
                Constructor<T> getConstructor(类<?>... parameterTypes) 参数为构造的参数类型.calss
                Constructor<T> getDeclaredConstructor(类<?>... parameterTypes)
                Constructor<?>[] getDeclaredConstructors()
3. 获取成员方法们
                Method[] getMethods()
                Method getMethod(String name, 类<?>... parameterTypes) (方法名,参数类型字节码)
                Method[] getDeclaredMethods()
                Method getDeclaredMethod(String name, 类<?>... parameterTypes)
4. 获取类名
                String getName() 获取全类名(包名.类名)
                String getSimpleName() 获取简单类名
注:包含Declared的方法可以获取到(包含私有的)所有内容,反之只能时public修饰的内容。
Field、Constructor、Method
Field(成员变量)
        操作:
                设置值
                        void set(Object obj, Object value)  
                获取值
                        get(Object obj)
                忽略访问权限修饰符的安全检查(下面两个同理)
                        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. 执行方法

注解(重点)
        注解:说明程序的。给计算机看的
注释:用文字描述程序的。给程序员看的。
定义:
注解(Annotation),也叫元数据。一种代码级别的说明。它是JDK1.5及以后版本引入的一个特性,与类、接口、枚举是在同一个层次。它可以声明在包、类、字段、方法、局部变量、方法参数等的前面,用来对这些元素进行说明,注释。
概念描述:
        JDK1.5之后的新特性
        说明程序的
        使用注解:@注解名称
作用分类:
1.        编写文档:通过代码里标识的注解生成文档【生成文档doc文档】(javadoc)
2.        代码分析:通过代码里标识的注解对代码进行分析【使用反射】
3.        编译检查:通过代码里标识的注解让编译器能够实现基本的编译检查【Override】
预定义注解
        @Override        :检测被该注解标注的方法是否是继承自父类(接口)的
        @Deprecated:该注解标注的内容,表示已过时
        @SuppressWarnings:压制警告
                * 一般传递参数all  @SuppressWarnings("all")
自定义注解
        格式:
                        元注解
                        public @interface 注解名称 {
                                属性列表;
}
        本质:注解本质上就是一个接口,该接口默认继承Annotation接口
属性:接口中的抽象方法
要求:
        属性的返回值类型有下列取值
                        基本数据类型
                        String
                        枚举 (只能有静态常量,不能给任何修饰符)
                        注解
                        以上类型的数组
        定义了属性,在使用时需要给属性赋值
1. 如果定义属性时,使用default关键字给属性默认初始化值,则使用注解时,可以不进行属性的赋值。
2. 如果只有一个属性需要赋值,并且属性的名称是value,则value可以省略,直接定义值即可。
3. 数组赋值时,值使用{}包裹。如果数组中只有一个值,则{}可以省略。
元注解
用于描述注解的注解(对注解做限定)
                @Target:描述注解能够作用的位置
                         ElementType取值:(多个值时可以传成数组)
                                TYPE:可以作用于类上
                                METHOD:可以作用于方法上
                                FIELD:可以作用于成员变量上
                @Retention:描述注解被保留的阶段
                        @ Retention(RetentionPolicy.SOURCE):注解默认保留到源代码时期
@ Retention(RetentionPolicy.CLASS):注解可保留到类对象时期
@Retention(RetentionPolicy.RUNTIME):当前被描述的注解,会保留到class字节码文件中,并被JVM读取到
                @Documented:描述注解可以被抽取到api文档中
                @Inherited:描述注解可以被子类继承
(解析)注解:获取注解中定义的属性值
        1. 获取注解定义的位置的对象  (Class,Method,Field)
        2. 获取指定的注解
                * getAnnotation(Class)
                //其实就是在内存中生成了一个该注解接口的子类实现对象
                    public class ProImpl implements Pro{
                        public String className(){
                            return "cn.itcast.annotation.Demo1";
                        }
                        public String methodName(){
                            return "show";
                        }
                    }
4.        调用注解中的抽象方法获取配置的属性值
小结
        1. 以后大多数时候,我们会使用注解,而不是自定义注解
        2. 注解给谁用?
                1. 编译器
                2. 给解析程序用
        3. 注解不是程序的一部分,可以理解为注解就是一个标签
Day026(JavaWeb - MySQL)
数据库
        DataBase 用于存储和管理数据的仓库。
特点
        持久化存储数据的,其实数据库就是一个文件系统。
        方便存储和管理数据
        使用了统一的方式操作数据库 – SQL
常见数据库
        MySQL: 开源免费的数据库,小型的数据库,已经被 Oracle 收购了。
        Oracle: 收费的大型数据库,Oracle 公司的产品。
        DB2:IBM 公司的数据库产品,收费的。常应用在银行系统中。
        SQL Server: MicroSoft 公司收费的中型的数据库。C#、.net 等语言常使用。
        SQLite: 嵌入式的小型数据库,应用在手机端,如:Android。
MySQL数据库
配置
服务启动
1.        手动
2.        cmd -> services.msc 打开服务的窗口,MySQL
3.        使用管理员打开cmd
                net start mysql : 启动服务
                net stop mysql : 关闭服务
注: 如果服务未启动,则不能进行登录操作。
登录
1. mysql –u用户名 -p密码
        2. mysql –h地址 –u用户名 -p连接目标的密码
        3. mysql --host=ip --user=root --password=连接目标的密码
退出
1.        exit     2. quit
目录文件
        安装目录
bin 可执行的二进制文件
my.ini 配置文件
数据目录(datadir = “C:/ProgramData/MySQL/MySQL Server 5.5/Data/")
        数据库 – 文件夹          表 – 文件        数据 – 数据
SQL
Structured Query Language:结构化查询语言
        其实就是定义了操作所有关系型数据库的规则。每一种数据库操作的方式存在不一样的地方,称为“方言”。
通用语法
        1. SQL 语句可以单行或多行书写,以分号结尾。
        2. 可使用空格和缩进来增强语句的可读性。
        3. MySQL 数据库的 SQL 语句不区分大小写,关键字建议使用大写。
        4. 3 种注释
                * 单行注释: -- 注释内容 或 # 注释内容(mysql 特有)
                * 多行注释: /* 注释 */
SQL分类
DDL 定义语言(*)
定义数据库对象:数据库,表,列等。关键字:create, drop,alter 等
DML操作语言(**)
                对数据库中表的数据进行增删改。关键字:insert, delete, update 等
        DQL查询语言 (***)
                查询数据库中表的记录(数据)。关键字:select, where 等
DCL控制语言(了解)
                定义数据库的访问权限和安全级别,及创建用户。关键字:GRANT,REVOKE等
DDL – 操作数据库、表
操作数据库: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 数据库名称;(*****)
操作表 CRUD(增删改查)
        1. C(Create):创建
                语法:
                create table 表名(  (*****)
                        列名1 数据类型1,
                        列名2 数据类型2,
                        ....
                        列名n 数据类型n
                );
                注意:最后一列,不需要加逗号(,)
                数据类型:
                        1 int:整数类型
                                age int,
                        2. double: 小数类型
                                score double(4,1) : 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 表名;
DML – 增删改表中数据
添加数据:
        语法:
                insert into 表名(列名1,列名2,...列名n) values(值1,值2,...值n);
        注意:
                1. 列名和值要一一对应。
                2. 如果表名后,不定义列名,则默认给所有列添加值
                        insert into 表名 values(值1,值2,...值n);
                3. 除了数字类型,其他类型需要使用引号(单双都可以)引起来
删除数据:
        语法:
                delete from 表名 [where 条件]
        注意:
                1. 如果不加条件,则删除表中所有记录。
                2. 如果要删除所有记录
                        1. delete from 表名; -- 不推荐使用。有多少条记录就会执行多少次删除操作
                        2. TRUNCATE TABLE 表名; -- 推荐使用,效率更高 先删除表,然后再创建一张一样的表。
修改数据:
        语法:
                update 表名 set 列名1 = 值1, 列名2 = 值2,... [where 条件];
        注意:
1.        如果不加任何条件,则会将表中所有记录全部修改。
DQL – 查询表中的记录
select * from 表名;  (*表示所有字段)
语法
        slect 段列表 from 表名列表 where 条件列表 group by 分组字段 having  分组之后的条件 order by 排序 limit 分页限定
基础查询
        1. 多个字段的查询
                select 字段名1,字段名2... from 表名;
        注意: 如果查询所有字段,则可以使用*来替代字段列表。
        2. 去除重复:
                distinct
        3. 计算列
                一般可以使用四则运算计算一些列的值。(一般只会进行数值型的计算)
                ifnull(表达式1,表达式2):null参与的运算,计算结果都为null
                        表达式1:哪个字段需要判断是否为null
                        如果该字段为null后的替换值。
        4. 起别名:
                as:as也可以省略
        如:select name,math,English,math + ifnull(English,0) as 总分 from student;
条件查询
        1. where子句后跟
        2. 运算符
                > 、< 、<= 、>= 、= 、<> 、!=
                BETWEEN...AND  在XX到XX范围之间
                IN( 集合)     
                LIKE:模糊查询
                        占位符:
                                _:单个任意字符
                                %:多个任意字符
                IS NULL  
                and  或 &&
                or  或 ||
                not  或 !

Day027(JavaWeb - MySQL)
DQL查询语句
排序
        语法:order by 字句
                order by 排序字段1 排序方式1,排序字段2 排序方式2…
        排序方式:
                ASC: 升序(默认)     DESC:降序
注意:如果有多个排序条件,则当前边的条件值一样时,才会判断第二条件。
        (单列排序: 一个字段排序;   组合排序: 多个字段排序)
如:SELECT * FROM employee WHERE deptno IN(20,30) ORDER BY deptno ASC, sal DESC;
聚合函数
        将一列数据作为一个整体,进行纵向的计算。
count(列名)        统计这一列有多少条记录(非空列:主键)        select count(id) from student;
max(列名)        求这一列的最大值        select max(math) from student;
min(列名)        求这一列的最小值        select min(english) from student;
sum(列名)        求这一列的总和        select sum(math) from student;
avg(列名)        求这一列的平均值        select avg(english) from student;
注意:聚合函数的计算,排除null值。
                解决方案:
                        1. 选择不包含非空的列进行计算          2. IFNULL函数
                        3. 如果加了一个分组查询,按照分组条件,内容相同的为一组进行聚合。
分组
        语法: group by 分组字段 [having 条件]
        注意:
1.        分组之后查询的字段:分组字段、聚合函数。
2.        where 和 having 的区别
        where在分组之前进行限定,如果不满足条件,则不参与分组。having在分组之后进行限定,如果不满足结果,则不会被查询出来。
        where后不可以跟着聚合函数,having可以进行聚合函数的判断。
如: 按照性别分组。分别查询男、女同学的平均分,人数 要求:分数低于70分的人,不参与分组,分组之后。人数要大于2个人
SELECT sex , AVG(math),COUNT(id) 人数 FROM student WHERE math > 70 GROUP BY sex HAVING 人数 > 2;
分页
        语法: limit 开始索引,每页查询的条数;
        公式: 开始的索引 = (当前的页码 - 1) 每页显示的条数
SELECT * FROM student LIMIT 0,3; -- 第1页
                SELECT * FROM student LIMIT 3,3; -- 第2页
                注: limit 是一个MySQL “方言”
约束
        对表中的数据进行限定,保证数据的准确性、有效性、完整性。
分类
        主键约束: primary key
        非空约束: not null     此列字段如果被非空约束限定了那么就不能给nulld数据
        唯一约束: unique      此列字段如果被唯一约束限定了那么就不能给重复的数据
        外键约束: foreign key
非空约束
not null,某一列的值不能为null
1. 创建表时添加约束
                CREATE TABLE stu(
                        id INT,
                        NAME VARCHAR(20) NOT NULL -- name为非空
                );
2. 创建表完后,添加非空约束
                ALTER TABLE stu MODIFY NAME VARCHAR(20) NOT NULL;
3. 删除name的非空约束
                ALTER TABLE stu MODIFY NAME VARCHAR(20);
注: 对非空约束可以做默认值设置
        格式: 字段名 字段类型 DEFAULT 默认值
        create table st9 (   id int,   name varchar(20),   address varchar(20)  default '广州' );
唯一约束
unique,某一列的值不能重复
注意: 唯一约束可以有NULL值,但是只能有一条记录为null
1. 在创建表时,添加唯一约束
                CREATE TABLE stu(
                        id INT,
                        phone_number VARCHAR(20) UNIQUE -- 手机号
                );
2. 在表创建完后,添加唯一约束
        ALTER TABLE stu MODIFY phone_number VARCHAR(20) UNIQUE;
3. 删除唯一约束
        ALTER TABLE stu DROP INDEX phone_number;
主键约束
        pimary key(具有唯一且非空的约束,选择没有实际使用价值的数据列)
注意:
        一张表只能有一个字段为主键;
        主键就是表中记录的唯一标识。
        联合(复合)主键可以指定多列作为主键
1.        在创建表时,添加主键约束
                create table stu(
                        id int primary key,-- 给id添加主键约束
                        name varchar(20)
                );
2. 删除主键
                -- 错误 alter table stu modify id int ;
                ALTER TABLE stu DROP PRIMARY KEY;
3. 创建完表后,添加主键
                ALTER TABLE stu MODIFY id INT PRIMARY KEY;
                ALTER TABEL stu ADD PRIMARY KEY(id);
4. 自动增长:
        概念:如果某一列是数值类型的,使用 auto_increment 可以来完成值得自动增长
        在创建表时,添加主键约束,并且完成主键自增长
                create table stu(
                        id int primary key auto_increment,-- 给id添加主键约束
                        name varchar(20)
                ) auto_increment = 1;  (指定自增长起始值)
        删除自动增长
                ALTER TABLE stu MODIFY id INT;
        添加自动增长
                ALTER TABLE stu MODIFY id INT AUTO_INCREMENT;
外键约束
foreign key,让表于表产生关系,从而保证数据的正确性。(解耦)
1. 在创建表时,可以添加外键
        语法:
                create table 表名(
                        ...
                外键列,
                [constraint 外键名称] foreign key (外键列名称) references 主表名称(主表列名称)
        );
2. 删除外键
        ALTER TABLE 表名 DROP FOREIGN KEY 外键名称;
(从表存在外键的数据关联存在,则不能直接删除主表中的数据,可以使用级联操作解决)
3. 创建表之后,添加外键
        ALTER TABLE 表名 ADD [CONSTRAINT 外键名称] FOREIGN KEY (外键字段名称) REFERENCES 主表名称(主表列名称);
        查询外键名称:SELECT * FROM information_schema.TABLE_CONSTRAINTS  t WHERE t.TABLE_NAME='表名' AND CONSTRAINT_TYPE='FOREIGN KEY';
4. 级联操作(需十分谨慎)
        1. 添加级联操作
                语法:ALTER TABLE 表名 ADD CONSTRAINT 外键名称
                        FOREIGN KEY (外键字段名称) REFERENCES 主表名称(主表列名称) ON UPDATE CASCADE ON DELETE CASCADE ;
        2. 分类:
                1. 级联更新:ON UPDATE CASCADE
                2. 级联删除:ON DELETE CASCADE
数据库表的设计
多表之间的关系
        分类:
                1. 一对一(了解):    如:人和身份证
                2. 一对多(多对一):  如:部门和员工
                3. 多对多:         如:学生和课程
        实现关系:
                1. 一对多(多对一):
                        实现方式:在多的一方建立外键,指向一的一方的主键。
                2. 多对多:
                        实现方式:多对多关系实现需要借助第三张中间表。中间表至少包含两个字段,这两个字段作为第三张表的外键,分别指向两张表的主键。
                3. 一对一(了解):
                        实现方式:一对一关系实现,可以在任意一方添加唯一外键指向另一方的主键。
        数据库设计的范式
概念:设计数据库时,需要遵循的一些规范。要遵循后边的范式要求,必须先遵循前边的所有范式要求
设计关系数据库时,遵从不同的规范要求,设计出合理的关系型数据库,这些不同的规范要求被称为不同的范式,各种范式呈递次规范,越高的范式数据库冗余越小。
目前关系数据库有六种范式:第一范式(1NF)、第二范式(2NF)、第三范式(3NF)、巴斯-科德范式(BCNF)、第四范式(4NF)和第五范式(5NF,又称完美范式)。
分类:
        1. 第一范式(1NF):每一列都是不可分割的原子数据项
        2. 第二范式(2NF):在1NF的基础上,非码属性必须完全依赖于码(在1NF基础上消除非主属性对主码的部分函数依赖)
        7几个概念:
1. 函数依赖:A-->B,如果通过A属性(属性组)的值,可以确定唯一B属性的值。则称B依赖于A
                        例如:学号-->姓名。  (学号,课程名称) --> 分数
2. 完全函数依赖:A-->B, 如果A是一个属性组,则B属性值得确定需要依赖于A属性组中所有的属性值。
                        例如:(学号,课程名称) --> 分数
3. 部分函数依赖:A-->B, 如果A是一个属性组,则B属性值得确定只需要依赖于A属性组中某一些值即可。
                        例如:(学号,课程名称) -- > 姓名
4. 传递函数依赖:A-->B, B -- >C . 如果通过A属性(属性组)的值,可以确定唯一B属性的值,在通过B属性(属性组)的值可以确定唯一C属性的值,则称 C 传递函数依赖于A
                        例如:学号-->系名,系名-->系主任
5. 码:如果在一张表中,一个属性或属性组,被其他所有属性所完全依赖,则称这个属性(属性组)为该表的码
                        例如:该表中码为:(学号,课程名称)
                        主属性:码属性组中的所有属性
                        非主属性:除过码属性组的属性
3. 第三范式(3NF):在2NF基础上,任何非主属性不依赖于其它非主属性(在2NF基础上消除传递依赖)
总结: 一张表只描述一个事情,降低的耦合性,尽量数据冗余少。
数据库备份与还原(命令行)
备份
        格式:mysqldump -u 用户名 -p 密码 数据库 > 文件的路径
        操作:
-- 备份day27数据库中的数据到d:\day27.sql文件中
mysqldump -uroot -proot day27 > d:/day27.sql
导出结果:数据库中的所有表和数据都会导出成 SQL 语句  
还原
        还原 day27 数据库中的数据
注意:还原的时候需要先登录 MySQL,并选中对应的数据库。
1) 删除 day27 数据库中的所有表
2) 登录 MySQL
3) 选中数据库
4) 使用 SOURCE 命令还原数据
5) 查看还原结果 use day26; source d:/day26.sql;
Day028(JavaWeb - MySQL)¬¬¬¬
多表查询
语法:  select 列名列表 from 表名列表 where ...
笛卡尔积:
有两个集合A,B .取这两个集合的所有组成情况。(要完成多表查询,需要消除无用的数据)
多表查询分类
内连接查询
         从哪些表中查询数据?表连接条件? 条件是什么? 查询哪些字段?
隐式内连接
使用where条件消除无用数据
例如:(emp:员工表,dept:部门表)
        -- 查询所有员工信息和对应的部门信息
        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`;
显示内连接
语法: 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`;
外连接查询
左外连接
语法: 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`;
右外连接
语法: select 字段列表 from 表1 right [outer] join 表2 on 条件;
内外连接的对比:
        1.  内连接查询的是交集,两个表的条件都需要满足的数据才会被查询出来(两张表平等)
2.  外连接查询的是交集和主要表的数据,有一个主次表之分,会将主要表的所有数据查询出来,次要表则要满足条件才会被查询出来
子查询
将一次查询的结果再次作为其他查询的一部分
概念:查询中嵌套查询,称嵌套查询为子查询。
        -- 查询工资最高的员工信息
        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 * 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';
多表查询案列
        员工表:emp  职务表:job  部门表:dept  工资等级表:salarygrade
emp表的外键job_id 关联 job表的id;
emp表的外键dept_id 关联 dept表的id;
salarygrade表的主键为grade.

事务
概念:如果一个包含多个步骤的业务操作,被事务管理,那么这些操作要么同时成功,要么同时失败。(如转账模型)
操作:
        1. 开启事务: start transaction;
        2. 回滚:rollback;
        3. 提交:commit;
四大特性:(面试)
        原子性:一个事物,要么成功要么失败,不会成功一半失败一半
        持久性:能持久化保存事务操作的数据
        隔离性:期望事务之间不会相互影响
        一致性:数据总量守恒
执行增删改会涉及到事务的操作
        如果开启事务了,不会默认提交事务了,当执行多个事务中的操作,如果有任意一个步骤出问题,应该回滚
        当执行多个事务中的操作,如果都没有出问题,则再提交事务
事务提交的两种方式
        自动提交:
                mysql就是默认自动提交事务
                一条DML(增删改)语句会自动提交一次事务。
        手动提交:
                Oracle 数据库默认是手动提交事务
                需要先开启事务,再提交
修改事务的默认提交方式
        查看事务的默认提交方式:SELECT @@autocommit; -- 1 代表自动提交 0 代表手动提交
        修改默认提交方式: set @@autocommit = 0;
隔离级别(了解)
概念:多个事务之间隔离的,相互独立的。但是如果多个事务操作同一批数据,则会引发一些问题,设置不同的隔离级别就可以解决这些问题。
存在问题:
        脏读:一个事务,读取到另一个事务中没有提交的数据
        不可重复读(虚读):在同一个事务中,两次读取到的数据不一样。
        幻读:一个事务操作(DML)数据表中所有记录,另一个事务添加了一条数据,则第一个事务查询不到自己的修改。
隔离级别:
        1. read uncommitted:读未提交
                产生的问题:脏读、不可重复读、幻读
        2. read committed:读已提交 (Oracle)  不允许读没有提交的数据
                产生的问题:不可重复读、幻读
        3. repeatable read:可重复读 (MySQL默认)  可以做到同一个事务每次读取的数据是一致的
                产生的问题:幻读
        4. serializable:串行化  相当于多线程中的锁,一个事务在操作的时候,其他事务不能进行操作
                可以解决所有的问题
注意:隔离级别从小到大安全性越来越高,但是效率越来越低
                数据库查询隔离级别:
                        select @@tx_isolation;
                数据库设置隔离级别:
                        set global transaction isolation level 级别字符串;
DCL-管理用户、授权
DBA:数据库管理员
DCL:管理用户,授权
管理用户
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;
        通配符: % 表示可以在任意主机使用用户登录数据库
权限管理
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'@'%';
Day029(JavaWeb - MySQL)
JDBC
概念:Java DataBase Connectivity  Java 数据库连接, Java语言操作数据库
JDBC本质:其实是官方(sun公司)定义的一套操作所有关系型数据库的规则,即接口。各个数据库厂商去实现这套接口,提供数据库驱动jar包。我们可以使用这套接口(JDBC)编程,真正执行的代码是驱动jar包中的实现类。
快速入门
步骤:
        1. 导入驱动jar包 mysql-connector-java-5.1.37-bin.jar
                1.复制mysql-connector-java-5.1.37-bin.jar到项目的libs目录下(创建目录方便管理)
                2.右键-->Add As Library
        2. 注册驱动
        3. 获取数据库连接对象 Connection
        4. 定义sql
        5. 获取执行sql语句的对象 Statement
        6. 执行sql,接受返回结果
        7. 处理结果
        8. 释放资源

各个对象
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包可以省略注册驱动的步骤。
        2. 获取数据库连接:
        方法:static Connection getConnection(String url, String user, String password)
        参数:
                url:指定连接的路径
                语法:jdbc:mysql://ip地址(域名):端口号/数据库名称(jdbc:mysql://localhost:3306/db3)
                细节:如果连接的是本机mysql服务器,并且mysql服务默认端口是3306,则url可以简写为:jdbc:mysql:///数据库名称
                user:用户名
                password:密码
Connection:数据库连接对象
功能:
        1. 获取执行sql 的对象
                Statement createStatement()
                PreparedStatement prepareStatement(String sql)  
        2. 管理事务:
                开启事务:setAutoCommit(boolean autoCommit) :调用该方法设置参数为false,即开启事务
                提交事务:commit()
                回滚事务:rollback()
Statement:执行sql的对象
1. 执行sql
                1. boolean 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. 练习:

ResultSet:结果集对象,封装查询结果
boolean next(): 游标向下移动一行,判断当前行是否是最后一行末尾(是否有数据),如果是,则返回false,如果不是则返回true (类似迭代器)
        getXxx(参数):获取数据
        Xxx:代表数据类型   如: int getInt() ,        String getString()
        参数:
                1. int:代表列的编号,从1开始   如: getString(1)
                2. String:代表列名称。 如: getDouble("balance")
        注意:
                使用步骤:
                        1. 游标向下移动一行   2. 判断是否有数据     3. 获取数据

PreparedStatement:执行sql的对象
        1. SQL注入问题:在拼接sql时,有一些sql的特殊关键字参与字符串的拼接。会造成安全性问题
                1. 输入用户随便,输入密码:a' or 'a' = 'a
                2. sql:select * from user where username = 'fhdsjkf' and password = 'a' or 'a' = 'a'
        2. 解决sql注入问题:使用PreparedStatement对象来解决
        3. 预编译的SQL:参数使用?作为占位符
        4. 步骤:
                1. 导入驱动jar包 mysql-connector-java-5.1.37-bin.jar            
2. 注册驱动
                3. 获取数据库连接对象 Connection
                4. 定义sql
注意:sql的参数使用?作为占位符。 如:select * from user where username = ? and password = ?;
5. 获取执行sql语句的对象PreparedStatement Connection.prepareStatement(String sql)
                6. 给?赋值:
                        方法: setXxx(参数1,参数2)
                                参数1:?的位置编号 从1 开始
                                参数2:?的值
                7. 执行sql,接受返回结果,不需要传递sql语句
                8. 处理结果  9. 释放资源
        5. 注意:后期都会使用PreparedStatement来完成增删改查的所有操作
                1. 可以防止SQL注入
                2. 效率更高
JDBCUtils – 抽取JDBC工具类
package Utils;
/**
* JDBCUtils一个工具类,可以简化JDBC操作数据库的代码
* 功能:在工具类中注册驱动;关闭释放资源
*/
import java.io.InputStream;
import java.sql.*;
import java.util.Properties;
public class JDBCUtils {
    private static String className = null;
    private static String url = null;
    private static String user = null;
    private static String password = null;
    //静态代码随着类只加载一次
    static {
        try {
            //读取配置文件
            Properties properties = new Properties();
            InputStream input = JDBCUtils.class.getClassLoader().getResourceAsStream("Utils\\info.properties");
            properties.load(input);
            //给驱动类名赋值
            className = properties.getProperty("className");
            url = properties.getProperty("url");
            user = properties.getProperty("user");
            password = properties.getProperty("password");
            //注册驱动
            Class.forName(className);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    //开闭原则:对扩展开放,对修改关闭
    public static Connection getConnection() throws SQLException {
        Connection conn = DriverManager.getConnection(url,user,password);
        return conn;
    }
    public static void close(ResultSet rs, Statement st,Connection conn){
        if(rs != null){
            try {
                rs.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(st != null){
            try {
                st.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
        if(conn != null){
            try {
                conn.close();
            } catch (SQLException e) {
                e.printStackTrace();
            }
        }
    }
}
JDBC控制事务
事务:一个包含多个步骤的业务操作。如果这个业务操作被事务管理,则这多个步骤要么同时成功,要么同时失败。
操作:
        1. 开启事务
        2. 提交事务
        3. 回滚事务
使用Connection对象来管理事务
        开启事务:setAutoCommit(boolean autoCommit) :调用该方法设置参数为false,即开启事务
        在执行sql之前开启事务
        提交事务:commit()
        当所有sql都执行完提交事务
        回滚事务:rollback()
        在catch中回滚事务
Day030(javaWeb - MySQL)
数据库连接池
概念:其实就是一个容器(集合),存放数据库连接的容器。
          当系统初始化好后,容器被创建,容器中会申请一些连接对象,当用户来访问数据库时,从容器中获取连接对象,用户访问完之后,会将连接对象归还给容器。
好处:节约资源;用户访问高效。
实现:
        1. 标准接口:DataSource   javax.sql包下的
                方法:
                        获取连接:getConnection()
        归还连接:Connection.close()。如果连接对象Connection是从连接池中获取的,那么调用Connection.close()方法,则不会再关闭连接了。而是归还连接
        2. 一般我们不去实现它,有数据库厂商来实现
                C3P0:数据库连接池技术
                Druid:数据库连接池实现技术,由阿里巴巴提供的
C3P0
步骤:
        1. 导入jar包 (两个) c3p0-0.9.5.2.jar mchange-commons-java-0.2.12.jar ,
                -- 不要忘记导入数据库驱动jar包
        2. 定义配置文件:(此类定义方式,可以自动读取配置文件)
                名称: c3p0.properties 或者 c3p0-config.xml
                路径:直接将文件放在src目录下即可。
        3. 创建核心对象 数据库连接池对象 ComboPooledDataSource
        4. 获取连接: getConnection
代码:
         //1.创建数据库连接池对象
     DataSource ds  = new ComboPooledDataSource();
     //2. 获取连接对象
     Connection conn = ds.getConnection();
Druid
步骤:
        1. 导入jar包 druid-1.0.9.jar
        2. 定义配置文件:(需要手动读取加载)
                是properties形式的
                可以叫任意名称,可以放在任意目录下
        3. 加载配置文件。Properties
        4. 获取数据库连接池对象:通过工厂来来获取 DruidDataSourceFactory
        5. 获取连接:getConnection
代码:
定义工具类
        1. 定义一个类 JDBCUtils
        2. 提供静态代码块加载配置文件,初始化连接池对象
        3. 提供方法
                1. 获取连接方法:通过数据库连接池获取连接
                2. 释放资源
                3. 获取连接池的方法

Spring JDBC
Spring框架对JDBC的简单封装。提供了一个JDBCTemplate对象简化JDBC的开发
步骤:
        1. 导入jar包
        2. 创建JdbcTemplate对象。依赖于数据源DataSource
                JdbcTemplate template = new JdbcTemplate(ds);
        3. 调用JdbcTemplate的方法来完成CRUD的操作
                update():执行DML语句。增、删、改语句
                queryForMap():查询结果将结果集封装为map集合,将列名作为key,将值作为value 将这条记录封装为一个map集合
                注意:这个方法查询的结果集长度只能是1
                queryForList():查询结果将结果集封装为list集合
                注意:将每一条记录封装为一个Map集合,再将Map集合装载到List集合中
                query():查询结果,将结果封装为JavaBean对象
                        query的参数:RowMapper
                一般我们使用BeanPropertyRowMapper实现类。可以完成数据到JavaBean的自动封装
                        new BeanPropertyRowMapper<类型>(类型.class)
                queryForObject:查询结果,将结果封装为对象
                        一般用于聚合函数的查询(queryForObject(String sql,Class type))

0 个回复

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