常用API

获取一个类的字节码对象的3种方式:
1. Class.forName("全类名")
2. 类名.class                         .
3. 对象.getClass()

java.lang.Class<T>类: 表示一个类的字节码对象, 其中包含该类中定义的内容
// 获取功能
// 1. 获取成员变量们
Field[] getFields(): 获取所有 public 的成员变量
Field getField(String name): 获取指定名称的 public 的成员变量
Field[] getDeclaredFields(): 获取所有的成员变量, 不考虑权限修饰符
Field getDeclaredField(String name): 获取指定名称的成员变量, 不考虑权限修饰符
// 2. 获取构造方法们
Constructor<?>[] getConstructors(): 获取所有 public 的构造方法
Constructor<T> getConstructor(Class<?>... parameterTypes): 获取指定的 public 构造方法
Constructor<?>[] getDeclaredConstructors(): 获取所有的构造方法, 不考虑权限修饰符
Constructor<T> getDeclaredConstructor(Class<?>... parameterTypes): 获取指定的构造方法, 不考虑权限修饰符
// 3. 获取成员方法们:
Method[] getMethods(): 获取所有 public 的成员方法
Method getMethod(String name, Class<?>... parameterTypes) : 获取指定的 public 成员方法
Method[] getDeclaredMethods(): 获取所有的成员方法, 不考虑权限修饰符
Method getDeclaredMethod(String name, Class<?>... parameterTypes): 获取指定的成员方法, 不考虑权限修饰符
// 4. 获取Class对象代表的类的全类名
String getName(): 获取当前Class对象代表的类的全类名
// 其他
T newInstance(): 使用当前类的空参构造创建一个对象
A getAnnotation(Class<A> annotationClass): 获取当前类的注解对象
ClassLoader getClassLoader(): 返回该类的类加载器
java.lang.reflect.Field: 表示一个成员变量
// 成员方法
void set(Object obj, Object value): 设置指定对象的成员变量的值
Object get(Object obj): 获取指定对象的成员变量的值
void setAccessible(boolean flag): 传true时忽略访问权限修饰符的安全检查. 暴力反射
java.lang.reflect.Constructor<T>: 表示一个构造方法
// 成员方法
T newInstance(Object... initargs): 使用当前构造方法传入参数, 创建对象
void setAccessible(boolean flag): 注意: 构造方法不能利用此方法忽略权限, 会抛异常
java.lang.reflect.Method类: 表示一个成员方法
// 成员方法
Object invoke(Object obj, Object... args): 使用指定对象和指定参数值调用此方法
String getName(): 获取方法名
void setAccessible(boolean flag): 传true时忽略访问权限修饰符的安全检查. 暴力反射
java.lang.ClassLoader: 类加载器
// 成员方法
InputStream getResourceAsStream(String name): 读取相对于bin目录中的文件, 返回一个字节流
常用元注解:
@Target: 描述注解能够作用的位置
ElementType枚举的常用取值:
TYPE:可以作用于类上
METHOD:可以作用于方法上
FIELD:可以作用于成员变量上
示例: @Target(value = {ElementType.TYPE, ElementType.METHOD})
@Retention: 描述注解被保留的阶段
RetentionPolicy枚举的取值:
SOURCE: 保留到源代码阶段
CLASS: 保留到类对象阶段
RUNTIME: 保留到运行时阶段
示例: @Retention(RetentionPolicy.RUNTIME):保留注解到class字节码文件中并被JVM读取到
@Documented: 加上后, 当前注解会被抽取到api文档中
@Inherited: 加上后, 当前注解会被子类继承
今日目标
能够通过反射获取成员方法对象,并且调用方法

1. 先获取字节码对象
2. 通过字节码对象 Method getDeclaredMethod(String name, Class... cls)
3. Object result = method.invoke(对象, 实际参数...);
了解可以通过反射获取属性对象且能够给其赋值和获取其值

1. 先获取字节码对象
2. 通过字节码对象 Field getDeclaredField(String name)
   field.setAccessible(true);
3. field.set(对象, 值);
4. Object result = field.get(对像)
能够说出注解的作用

1. 生成文档 (@author @param @return )
2. 分析代码 (自己写的测试框架)
3. 编译检测 (@Override)
能够自定义注解和使用注解

定义
元注解
public @interface 注解名 {
属性; (接口的抽象方法)
属性 default 默认值;
}

基本类型
String
枚举
注解
以上的数组

使用
@注解名(属性名 = 属性值, 属性名 = 属性值)
能够说出常用的元注解及其作用

@Target: 约束当前注解的使用位置
ElementType.TYPE  METHOD  FILED
@Retention: 规定当前注解的保留时期
RetentionPolicy.RUNTIME
@Documented: 将当前注解抽取到文档中
@Inherited: 子类也可以继承该注解
能够解析注解并获取注解中的数据
1. 获取被注解位置的对象 Class, Method, Field
2. 通过位置对象获取注解对象 注解对象 = getAnnotation(注解名.class)
3. 通过注解对象调用抽象方法(属性)获取返回值, 返回值就是属性值
-
Day02
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 等
一.库database(DDL)
1.创建:create database if not exists db1 character set gbk;如果不存在创建db1,
指定字符集gbk
2.删除:drop database if exists db1; 终止数据库db1
3.修改:alter database db1 character set gbk; 修改数据库字符集
4.查询:show databases 显示所有数据库名称
5.使用:use db1 使用db1数据库
二.表结构(DDL)
1.创建:create table student(id int, 创建student表
name varchar(6),
score double(5,2), --小数点后2位共5位
birthday date --'yyyy-MM-dd'
insert_time timestamp --默认获取系统值
);
2.删除:drop table if exists student 终止student表
3.修改:
修改表名:alter table student rename to stu; 表名student修改为stu
修改表字符集:alter table student character set gbk;修改表字符集为gbk
修改列名,类型:
1)alter table student change gender(列名) sex(新列名) varchar(10);
修改student表将gender列 更换为sex 并设置数据类型为varchar(10)
2)alter table student modify gender varchar(20);
修改student表将gender列的数据类型 更改为varchar(20)
增加列:alter table student add gender varchar(10);
删除列:alter table student drop gender;
4.查询:
1).show tables; 显示某个数据库中所有表名称
2)desc 表名; (describe描述)描述表结构
三.表数据(DML:增删改表数据)
1.增加:insert into student(id,name,scoer) values(1,'张三',97)
1) 列名和值要一一对应。
2) 如果表名后,不定义列名,则默认给所有列添加值
insert into 表名 values(值1,值2,...值n);
3) 除了数字类型,其他类型需要使用引号(单双都可以)引起来
2.删除:delete from student where id=1 删除id=1的数据如果是null
则不能用"=" where id is null
1)delete from student(即不加where)删除student表所有数据,不推荐
2)truncate table student 删除表然后创建一样结构的表,推荐(DDL级别)
3.修改:update student set name='张三',age=18 where id = 1;
注意:不加条件则修改全部数据
4.查询:(DQL查询语句)
select * from student;查询student表显示所有数据
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
* 如果该字段为null后的替换值。
4. 起别名:
* as:as也可以省略
3) 条件查询
1. where子句后跟条件
2. 运算符
* > 、< 、<= 、>= 、= 、<>
* BETWEEN...AND
* IN( 集合)
* LIKE:模糊查询
* 占位符:
* _:单个任意字符
* %:多个任意字符
* IS NULL
* and 或 &&
* or 或 ||
* not 或 !

4)排序查询
语法: order by 排序字段1 排序方式1(ASC 升序,默认的),
排序方式2 排序方式2(DESC 降序)...
注:多个排序条件,第一个条件值一样时,才会判断第二条件

5)聚合函数:将一列数据作为一个整体,进行纵向的计算
count 计算个数
一般选择非空的列:主键
count(*)
max 计算最大值
min 计算最小值
sum 计算和
avg 计算平均值

注意:聚合函数的计算,排除null值
解决方案:
1.选择不包含费控的列进行计算
2.ifnull函数
6)分组查询:
1.语法:group by 分组字段
2.注意:
* 分组后跟查询字段:分组字段, 聚合函数
* where 和 having区别?
where用在分组前,对数据条件在限定;
having用在分组后,显示限定.
7)分页查询:(MySQL方言:limit)
语法: limit 开始索引,显示页数;
公式:开始的索引 = (当前的页码 - 1) * 每页显示的条数
- - 例: 每页显示3条记录
SELECT * FROM student LIMIT 0,3; -- 第1页
SELECT * FROM student LIMIT 3,3; -- 第2页
SELECT * FROM student LIMIT 6,3; -- 第3页
-------------------------------------------------------------
5.综合查询例:
查询 查询受雇日期 早于 2007-05-23的 员工 ,并且按照部门分组,查询每个部门的薪水总和,且部门的总薪水大于25000,最终按照总薪水的大小进行降序排列
SELECT deptno,SUM(sal) --显示部门(deptno),薪水总和
FROM emp --从emp表查
WHERE hiredate < '2007-05-23' --筛选受雇日期< '2007-05-23'的数据
GROUP BY deptno --按照部门分组
HAVING SUM(sal)>25000 --从分组后的数据中筛选出薪水综合>2500的
ORDER BY SUM(sal) DESC; --按照薪水总和降序排序


Day03
约束
概念:对表中数据进行限定,保证数据的正确性,有效性,完整性
分类:
1.非空约束 not nul
2.主键约束 primary key
3.唯一约束 unique
4.外键约束 foreign key

* 非空约束:not null,某一列的值不能为null
1. 创建表时添加约束
[Java] [color=rgb(51, 102, 153) !important]纯文本查看 [color=rgb(51, 102, 153) !important]复制代码
[color=white !important]

[color=white !important]?

 

1
 
2
 
3
 
4
CREATE TABLE stu(
id int,
name VARCHAR(20) not null -- name为非空
);
 





2. 创建表完后,添加非空约束
alter table stu modify name varchar(20) not null;
3. 删除name的非空约束
lter table stu modify name varchaar(20)
* 唯一约束:unique,某一列的值不能重复
1. 注意:
* 唯一约束可以有NULL值,但是只能有一条记录为null
2. 在创建表时,添加唯一约束
CREATE TABLE stu(
id INT,
phone_number VARCHAR(20) unique -- 手机号
);
3. 删除唯一约束
alter table stu drop index phone_number;
4. 在表创建完后,添加唯一约束
atler table stu modify phone_number varchar(20) unique
* 主键约束:primary key。
1. 注意:
1. 含义:非空且唯一
2. 一张表只能有一个字段为主键
3. 主键就是表中记录的唯一标识

2. 在创建表时,添加主键约束
create table stu(
id int primary key,-- 给id添加主键约束
name varchar(20)
);

3. 删除主键
-- 错误 alter table stu modify id int ;
alter table stu drop primary key;

4. 创建完表后,添加主键
alter table stu modify id int primary key

5. 自动增长:
1. 概念:如果某一列是数值类型的,使用 auto_increment 可以来完成值的自动
增长
2. 在创建表时,添加主键约束,并且完成主键自增长
create table stu(
id int primary key auto_increment,-- 给id添加主键约束
name varchar(20)
);

3. 删除自动增长
alter table stu modify id int;

4. 添加自动增长
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 主表名(主表列名称)
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. 多表之间的关系
1. 分类:
1. 一对一(了解):
2. 一对多(多对一):
3. 多对多:
2. 数据库设计的范式

* 分类:
1. 第一范式(1NF):每一列都是不可分割的原子数据项
2. 第二范式(2NF):在1NF的基础上,非码属性必须完全依赖于码(在1NF基础上消除非主属性对主码的部分函数依赖)
* 几个概念:
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基础上消除传递依赖)
数据库的备份和还原
数据库的备份和还原
1. 命令行:
* 语法:
* 备份: mysqldump -u用户名 -p密码 数据库名称 > 保存的路径
* 还原:
1. 登录数据库
2. 创建数据库
3. 使用数据库
4. 执行文件。source 文件路径
2. 图形化工具:
Day04
1.        多表查询(掌握)
1.1概述:
多个表放在一起查询
笛卡尔积:
        * 有两个集合A,B .取这两个集合的所有组成情况。
        * 要完成多表查询,需要消除无用的数据(笛卡尔积)
通过主键 和 外键 关联(因为外键的值 来源于主键值)
1.2多表查询的分类:

内链接,只会把查询的表中符合连接条件的数据展示出来
左外链接,显示左表全部信息,若左表的某行在有表中没有匹配行,则右表对应的行为null.
1.-- 隐式内连接
SELECT
        t1.* ,t2.*
FROM
        emp t1, dept t2
WHERE
        t1.dept_id = t2.id;
2.-- 显式内连接
SELECT  t1.*,t2.* FROM  emp t1  [INNER]  JOIN  dept t2  ON  t1.dept_id = t2.id;
3.-- 左外链接(左表全部数据 以及 右表交集部分 --左表:t1,右表:t2 )
SELECT  t1.*,t2.* FROM  emp t1   LEFT   JOIN  dept t2  ON  t1.dept_id = t2.id;
4.-- 右外链接(右表所有数据 以及 左表交集部分  --左表:t1,右表:t2)
SELECT  t1.*,t2.* FROM  emp t1   RIGHT  JOIN  dept t2  ON  t1.dept_id = t2.id;
        
1.3子查询:查询中嵌套查询,称被嵌套的查询为子查询
子查询三种情况:
(1).子查询作为一个值(单行单列) 用于条件判断
Select max(salary) from emp;
Select * from emp where emp.salary=(Select max(salary) from emp

(2).:子查询作为一个数组(多行单列)

(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'


`

2.        事务
2.1事务的基本介绍
1)概念:如果一个包含多个步骤的业务操作,被事务管理,那么这些操作要么同时成                   功,要么同时失败.
2)操作:
1.开启事务: start transaction;
2.回滚: rollback;
3.提交: commit;
Day05
1.        JDBC
1.1 JDBC概念: Java DateBase Connectivity  
Java数据库连接,Java语言操作数据库
*JDBC本质:其实是官方(sun公司)定义的一套操作所有关系型数据库的规则,即接口. 各个数据库厂商去实现这套接口,提供数据库驱动jar包.我们可以使用这套接口(JDBC)编程,真正执行的代码是驱动jar包中的实现类.
Jdbc的一套接口:java.sql.*
不同的数据库厂商实现一套接口
//mysqlConnection.mysql数据库厂商提供的实现类
//Connection 就是sun官方提供的接口,去调用相关的实现类的方法,
//java.sqlConnection 接口,实现类:com.mysql.jdbc.MySqlConnection(mysql数据库提供的)
public mysqlConnection implement java.sql.Connection{...}
1.2快速入门:
步骤:
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. 释放资源1.3
1.3详解各个对象
1.        Java.sql.DriverManager(类)驱动管理对象
*功能:
1.注册驱动告诉程序该使用哪一个数据库驱动jar
        static void registerDriver(Driver driver) :注册与给定的                                        驱动程序 DriverManager 。
写代码使用:Class.forName("com.mysql.jdbc.Driver");
        通过查看源码发现:在com.mysql.jdbc.Driver类中存        在静态代码块
                           [Java] [color=rgb(51, 102, 153) !important]纯文本查看 [color=rgb(51, 102, 153) !important]复制代码
[color=white !important]

[color=white !important]?

 

1
 
2
 
3
 
4
 
5
 
6
 
7
static {
                                   try {
               java.sql.DriverManager.registerDriver(new Driver());
                                   } catch (SQLException E) {
                                  throw new RuntimeException("Can't register                                                         driver!");
                                   }
                                   }
 






                                注意:mysql5之后的驱动jar包可以省略注册驱动的步骤。
2.JDBC控制事务:

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


day06
1.数据库连接池
1.1 概念:
其实就是一个容器(集合),存放数据库连接的容器。当系统初始化好后,容器被创建,容器中会申请一些连接对象,当用户来访问数据库时,从容器中获取连接对象,用户访问完之后,会将连接对象归还给容器。
1.2        好处:
1. 节约资源: 没有数据库连接池时,使用connection以后,释放资源.
使用数据库连接池后, 使用完后归还connection到连接池中.
        2. 用户访问高效: 不用每次都创建连接对象,可以从数据库连接池取
1.3 实现:
1. 标准接口:DataSource   javax.sql包下的
1. 方法:
        * 获取连接:getConnection()
        * 归还连接:Connection.close()。如果连接对象Connection是从连接池中获取的,那么调用Connection.close()方法,则不会再关闭连接了。而是归还连接

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

1.4 C3P0:数据库连接池技术
* 步骤:
1. 导入jar包 (两个) c3p0-0.9.5.2.jar mchange-commons-java-0.2.12.jar ,
                * 不要忘记导入数据库驱动jar包
        2. 定义配置文件:(c3p0会自动读取配置文件 但必须如下定义)
                * 名称: c3p0.properties 或者 c3p0-config.xml
                * 路径:直接将文件放在src目录下即可。

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

发布了969 篇原创文章 · 获赞 11 · 访问量 3万+
展开阅读全文

没有更多推荐了,返回首页

©️2019 CSDN 皮肤主题: 大白 设计师: CSDN官方博客

分享到微信朋友圈

×

扫一扫,手机浏览