渣渣白的java笔记

javaSE

Javac        编译命令

Javap        反编译命令

Javadoc  生产api命令

引用数据类型

字符串String

 

面对对象

面对对象的三大特征：封装  继承    多态

 

 

继承

 

接口

public interface 接口名称{           

         //接口内容

         //抽象方法

[public abstract] 返回值类型 方法名（参数列表）;

}

接口中可以包括：

1. 常量[public static final]用接口名称调用
2. 抽象方法

注意事项：接口中默认修饰符（public abstract）这两个修饰符可以省略

使用步骤：

1.接口不能直接使用，必须有一个“实现类”来“实现”接口

@Override

public class 实现类名称 implements 接口名称,接口名称{

                            //重写覆盖接口中的所有抽象方法

                            //可以实现多个接口

                            //重复的只需要重写覆盖一次

}

2.接口的实现类必须覆盖重写所有的抽象方法

3.创建实现类的对象开始使用。

注意：如果实现类没有覆盖重写所有的抽象方法，那么这个实现类必须是抽象类。

Java8以后还包括

1. 默认方法
   1. 默认方法可以解决接口的升级的问题
   2. 接口的默认方法可以通过接口的实现类对象，直接调用
   3. 接口的默认方法也可以被接口的实现类覆盖重写

public default 返回值类型 方法名称 （参数列表）{

                  //方法体

}

1. 静态方法

a)静态方法通过接口名称调用   接口名称.静态方法名

public static 返回值类型 方法名称（参数列表）{

         //方法体

}

Java9 还可以包括有

1. 私有方法
   1. 普通私有方法：解决多个默认方法之间重复代码问题

private 返回值类型 方法名称（参数列表）{

         方法体

}

1. 1. 静态私有方法：解决多个静态方法之间重复代码问题

private static 返回值类型 方法名称（参数列表）{ 方法体}

多态： extends继承或者implements实现是多态的提前

父类引用指向子类对象

父类名称 对象名 = new 子类名();

接口名称 对象名 = new 实现类名称();

1. 对象的向上转型(一定安全)
   1. 父类名称 对象名 = new 子类名称();
   2. 向上转型右侧创建一个子类对象，把他当做父类对待
2. 向下转型（有前提条件）
   1. 子类名称 对象名 = (子类名称)父类对象;

or   ((子类名称)父类对象名).子类方法

1. 1. 将父类对象[还原]为本来的子类对象

对象  instanceof  类名称     //判断对象是不是这个类的  返回boolean值

关键字

final（最终的，不可变的）

修饰 ：

1. 类：不能有任何的子类

public final class 类名称{……}

1. 方法：这方法就是最终方法不能重写public final 返回值类型 方法名（参数）{……}
2. 局部变量：

基本类型：数据不能更改值 只有唯一一次赋值

引用类型：内容可变地址值不变

 

final 数据类型 变量名 = 值；

1. 成员变量
   1. 由于成员变量具有默认值，所以用了final后必须手动赋值。
   2. 对于final的成员变量要么使用直接赋值，要么通过构造方法，二选一
   3. 必须保证类中所有重载的构造方法都最终会对final的成员赋值

注意：final 与 abstract 不能同时使用

权限修饰符

1. public 公共的
2. protect 受保护的
3. （default）不写
4. private 私有的

 

内部类

1. 成员内部类

修饰符     class         外部类名称{

          修饰符    class         内部类名称{……}

          ……

}

注意：内用外，随意访问；外用内，需要内部类对象

使用方法：

1. 1. 间接方式：在外部类方法中，调用内部类对象，通过外部类对象方法调用内部类
   2. 直接方式

外部类名称.内部类名称  对象名 = new 外部类名称（）. new 内部类名称（）;

         内部类调用外部类成员变量 ：外部类名. this . 变量名

1. 局部内部类（包含匿名内部类）：类定义在方法内部 只能被那方法使用

匿名内部类 只需要使用唯一的一次

接口名 对象名 = new 接口名（）{

         //覆盖重写所有的方法

};

object类：

根类，所有类的父类(Java.lang.object).

toString()   返回一个String

equals() 返回一个boolean

基本数据类型 :比较值

引用数据类型 :比较地址

Date日期类

System.currentTimeMillis()

获取当前系统从1970年1月1日0:0:0至今经历了多少毫秒(getTime())

DateFormat类

         格式化日期类按照指定的格式格式化 解析

 

创建对象构造方法中传入指定的格式

调用format(Date)方法按格式转化日期类为字符串

SimpleDateFormat   s  =   new SimpleDateFormat("yyyy年MM月dd日 HH时mm分ss");

用parse(String)方法把文本解析为指定格式的Date日期

String c  = "1998-10-2";

        try {

           Date a = s.parse(c);

        } catch (ParseException e) {

            e.printStackTrace();

        }

Calendar日历类

get方法:

Calendar c = Calendar.getInstance();

Date d = c.getTime();//获得日期

int year = c.get(Calendar.YEAR);//获取年      MONTH获取月(西方的月1-11)要加一

                                                                               DATE 天(DAY_OF_MONTH)

set方法

c.set(Calendar.YEAR,999);//设置年

c.set(888,8,8);//公式设置年月日

c.add(Calendar.YEAR,2);//把年增加2

System类(系统类)

long  time = System.currentTimeMillis();//获取一个毫秒值

 

arraycopy(Object src(原数组), int srcPos(起始索引), Object dest(目标数组), int destPos(目标数组的起始位置), int length(复制的个数))

将指定源数组中的数组从指定位置复制到目标数组的指定位置。

StringBuilder类

字符串缓冲区,可以提高字符串的操作效率.(可以看成是一个可以变化的数组)

底层是数组,但是没有被final修饰,

StringBuilder在内存中始终是一个数组,占用空间少效率高,会自动扩容

构造方法:

StringBuilder b = new StringBuilder();//构造创建空字符串,初始容量15字符

StringBuilder b1 = new StringBuilder("dasdas");//带字符串的构造

append //添加任意类型的数据

b.append("a").append(1).append(1).append(1);//链式编程

toString()把StringBuilder返回一个字符串

 

Collection集合(单列集合)

add(E e);添加元素

clear();清空集合中的元素

remove(E e);把给定的对象在当前集合中删除

contains(E e);判断集合中是否包含给定的对象

isEmply();判断当前集合是否为空

size();返回集合中元素的个数

toArray();把集合中的数据存储到数组中

 

List接口:

1.有序的集合

2.允许存储重复的元素

3.有索引可以使用普通的for循环遍历

ArrayList集合

1. 重写了toString()方法
2. 底层是数组,查询快,增删慢

LinkedList集合

1. 链表,查询快,增删慢.
2. 包含大量操作首尾元素的方法

 

addFirst()在开头插入一个元素(getFirst,removeLast)

addLast()在末尾插入(setLast、removeLast)

Vector集合(了解)

Set接口:

1. 不能存储重复值
2. 没有索引，不能用普通的for方法遍历

 

HashSet集合( LinkedHashSet集合)

         无序的集合，存储顺序和取出元素的顺序有可能不一致

         底层是一个hash表结果查询的速度非常快

         hash表 ：数组 + 链表/红黑树

 

LinkedHashSet集合

         底层是哈希表（数组+链表/红黑树） + 链表：多了一条链表，保证元素有序

TreeSet集合

Collections工具类

addall  在一个集合中添加多个元素Collections.addAll(li(集合名字),"a","b","c");

shufflc 打乱顺序Collections.shuffle(li);

sort    默认规则排序Collections.sort(li);

Iterator接口(迭代器)

对集合进行遍历

Boolean  hasNext()如果仍有元素可以迭代则返回ture

next() 返回迭代的下一个元素(取出)25

Iterator接口也是有泛型的,跟着集合走,

Collection c = new ArrayList();

Iterator it = c.iterator();

while(it.hasNext()){

String s = it.next();

System.out.println(s);

}

for(Iterator it = c.iterator();it.hasNext();){

String s = it.next();

System.out.println(s);}

Map集合

双列集合,由键和值组成,键是唯一的不可重复作为K的元素,对象必须重写code和equals方法

put(key,value)                  添加元素  键重复 会覆盖前面的

remove(key)   通过键删除元素

get(key) 获得该键的值

HashMap

底层哈希表,查询速度特别快 无序的

LinkedHashMap

有序的

Map遍历

1. 以键找值 :  获取所有的键的集合    keyset()方法
2. 键值对遍历  entrySet()方法获得键值对关系对象的集合Set> entrySet = map.entrySet();

增强for循环

for(数组/集合的数据类型 变量名：数组/集合名){

System.out.println(i);}

Propertise持久的属性集

         它自己具有写数据到文件的方法

         没有泛型的默认是String,String

         有map的所有方法

         特有方法

1. getProperty(String K) 根据键获取值
2. setProperty(String K,String value) 添加一对
3. stringPropertyNames();  获得key  返回一个键的Set集合
4. store(new FileWriter(“文件名.properties”), “空着” );保存数据到文件 在工程的根目录  后缀名用properties
5. load(new FileRead(“文件名.properties”) );从文件中加载数据

数据结构

栈:            先进后出

队列:       先进先出

数组:       查询快增删慢

链表:       查询慢增删快

         单项链表:只有一条链子不能保证元素的顺序(存储和取出的顺序可能不一样)

         双向链表:两条链有一条专门记录元素的顺序有序列表

二分法查找O(logn)                                 所需执行指令数: a*logn

寻找数组中的最大/最小值O(n)           所需执行指令数: a*logn

归并排序算法O(nlogn)                           所需执行指令数:c*nlogn

选择排序 O(n^2)                                      所需执行指令数:d*n^2

可变参数

当方法参数的类型已经确定，但是参数的个数不确定，就可以使用可变参数

使用：

         修饰符 返回值类型 方法名（数据类型  变量名）{}

底层是一个数组 ，根据传递参数的个数不同，会创建不同长度的数组，来储存这些参数

         传递的参数个数可以0-n个

注意：1.一个方法的列表只能有一个可变参数

2.如果方法的参数有多个，可变参数必须写在参数末尾

终极写法：public static void method(Object ... obj){}

异常

1. try{}catch(){}捕获异常
   1. e.printStackTrace();
   2. finally 一般用于资源释放,无论是否出现异常都要释放资源
2. throws声明异常

lambda表达式

标准格式:  

1. 1. 1. 1. 一些参数
         2. 一个箭头
         3. 一段代码

(参数列表)  - > {  一些重写方法的代码  }

( ) 接口中抽象方法发的参数列表  没有参数就空着,有参数就写出参数,多个参数用都好分割

-> 传递的意思 把参数传递给方法体

{} 重写接口的抽象方法的方法体

特点 : 可推导可省略,凡是根据上下文推导出来的内容,都可以省略

                  可省略的内容:

                          1.(参数列表 ) 括号中参数列表的数据类型可以省略不写

                          2.(参数列表) 括号中的参数如果只有一个,那么类型和()都可以不写

                          3.{一些代码} 如果()中的代码只有一行,无论是否有返回值,都可以省略({} ,return ,分号)

                                   要省略 ({},return,分号)要一起省略

junit单元测试

测试分类:

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

Junit使用: 白盒

         1.定义一个测试类   测试类名:被测试的类后加Test               包名: xxx.xxx.xx.test   cn.tian.test

         2.定义测试方法 : 可以独立运行    方法名: text测试的方法名  textadd()   返回值  void  参数列表建议空参

         3.给方法加注解  @tests

判定结果:绿色为成功  红色为失败 一般为们会用断言的操作来处理结果 Assertions.assertEquals(期望的结果 , 运算的结果)

init()方法 初始化方法 :  用于资源的申请,所有的测试方法在执行钱都会先执行该方法

@BeforeAll

public void init(){

}

close()方法 释放资源方法 : 所有测试方法执行完后都会自动执行该方法

@AfterAll

public void close(){

}

 

多线程Thread

         进程 : 正在运行的程序叫进程

         线程 : 是进程中的一个小任务

         分时调度: 所有线程轮流使用cpu的使用权 平均分配

         抢占式调度:优先让优先级高的线程使用

1. 继承方式
2. 实现方式

反射(框架设计灵魂)

         框架 : 半成品软件,可以在框架的基础上进行软件开发,简化编码

         概念 : 将类的个个组成部分,封装为其他对象,这就是反射机制

                  好处: 1.可以在程序运行过程中,操作这些对象

2.可以解耦,提高程序的可扩展性

         获取成员变量方法

//1.获取person对象的Class对象

Class peClass = Person.class;

                  Field[]  getFields()   获取所有public修饰的成员变量  get/set

                  Field   getField("");  需要传入值  获取指定的成员变量          get/set

                  Field[] de = peClass.getDeclaredFields();获取所有的成员变量,不考虑修饰符          

Field name = peClass.getDeclaredField("name");获取指定的成员变量,不考虑修饰符

                  name.setAccessible(true);忽略访问修饰符的安全检查,暴力反射

获取构造方法的对象

 //获取person的构造方法

Constructor constructor = peClass.getConstructor(String.class, int.class);

constructor.setAccessible(true);//暴力反射

 //创建构造法的对象

Object person  = constructor.newInstance("张", 10);

//空参

Constructor constructor = peClass.getConstructor();

Object zhn = constructor.newInstance();

//空参简化

Object o = peClass.newInstance();

获取成方法

 //获取成员方法对象

Method eat = peClass.getMethod("eat");

eat.setAccessible(true);

//执行方法

eat.invoke(eat);//需要传入方法的名字和参数列表

//获得所有public修饰的方法

Method[] methods = peClass.getMethods();

//获取方法名

String name = eat.getName();

获取类名

String className = peClass.getName();

 

注解

概念：说明程序的，给计算机看的

定义：注解（Annotation）,也叫元数据。一种代码级别的说明，他是jdk1.5以后版本引入的一个新特性，与类、接口、枚举是在同一个层次，他可以声明在包、类、字段、方法、局部变量、方法参数等的前面，用来对这些元素进行说明，注释。

 

作用分类：

①编写文档：通过代码里标识的注解生成文档（生成文档doc文档）

②代码分析：通过代码里标识的注解对代码进行分析【使用反射】

③编译检查：通过代码里标识的注解让编译器能够实现基本的编译检查【Override】

JDK中预定义的一些注解

@Override                        检测被该注解标注的方法是否是继承父类的

@Deprecated                   该注解标注的内容已过时

@SuppressWarnings       压制警告                 参数为all @SuppressWarnings("all")一般用在类上，所有的警告都不在出现

 

自定义注解

①格式

元注解

Public @interfa 名字{}

②本质：注解本质上是一个接口，该接口默认继承Annotation接口

Public interface 注解名 extends Java.lang.annotation{}

③属性：接口中可以定义的成员方法，就是接口中定义的抽象方法

1. 属性的返回值类型其他都不行，基本数据类型、String、枚举、注解、以上类型的数组（不能为void）
2. 定义了属性在使用时需要给属性赋值，多个值用逗号隔开，也可以
   1. 在定义时设置default默认值，在使用时可以不赋值
   2. 如果只有一个属性需要赋值，且属性的名称是value，value可以省略
   3. 数组赋值时，使用{}包裹。如果数组中只有一个值，大括号可以省略

④元注解：用于描述注解的注解

1. @target:描述注解能够作用的位置
   1. ElementType参数：
      1. 1. 1. TYPE              可以用于类上
            2. METHOD          可以作用于方法上
            3. FIELD                可以作用于成员变量上
2. @Retention:描述注解被保留的一个阶段
   1. @Retention(RetentionPolicy.RUNTIME) ：当前被描述的注解，会保留到class字节码文件中，并被jvm读取到
3. @documented:描述注解是否被抽取到api文档中
4. @Inherited:描述注解是否被子类继承

 

在程序使用（解析）注解：获取注释中定义的属性值

注解设置配置文件

 

JDBC

Java Databases Connectivity Java 数据库链接,java语言操作数据库

官方定义的一套操作所有关系型数据库的规则,即接口,个个数据库厂商去实现这个接口,提供数据库的驱动jar包

使用 :

1. 导包
2. 注册驱动Class.forName("com.mysql.cj.jdbc.Driver");
3. 获取数据库连接对象   Connection con = DriverManager.getConnection(url);
4. 定义sql
5. 获取执行sql的   Statement Statement st = con.createStatement();
6. 执行sql接受返回的结果 int count = st.executeUpdate(sql);
7. 处理结果
8. 关闭链接 close()

PreparStatement :执行sql的对象  解决sql注入问题  预编译的SQL 参数使用?作为占位符

public class Demo {

    public static void main(String[] args) throws ClassNotFoundException {

         Connection conn = null;

         String sql;

            // MySQL的JDBC URL编写方式：jdbc:mysql://主机名称：连接端口/数据库的名称?参数=值

            // 避免中文乱码要指定useUnicode和characterEncoding

            String url = "jdbc:mysql://127.0.0.1:3306/text?useUnicode=true&characterEncoding=UTF8&serverTimezone=UTC&"

                    + "user=root&password=kanglimin";

           

 

            try {

                Class.forName("com.mysql.cj.jdbc.Driver");// 动态加载mysql驱动 

                System.out.println("成功加载MySQL驱动程序");

                // 一个Connection代表一个数据库连接

                conn = DriverManager.getConnection(url);

                // Statement里面带有很多方法，比如executeUpdate可以实现插入，更新和删除等

                Statement stmt = conn.createStatement();

                sql = "create table student(NO char(20),name varchar(20),primary key(NO))";

// executeUpdate语句会返回一个受影响的行数，如果返回-1就没有成功

int result = stmt.executeUpdate(sql);

                if (result != -1) {

                    System.out.println("创建数据表成功");

                    sql = "insert into student(NO,name) values('2016001','刘大')";

                    result = stmt.executeUpdate(sql);

                    sql = "insert into student(NO,name) values('2016002','陈二')";

                    result = stmt.executeUpdate(sql);

                    sql = "select * from student";

                    ResultSet rs = stmt.executeQuery(sql);// executeQuery会返回结果的集合，否则返回空值

                    System.out.println("学号\t姓名");

                    while (rs.next()) {

                        System.out.println(rs.getString(1)+ "\t" + rs.getString(2));

// 入如果返回的是int类型可以用getInt()

                    }

                }

            } catch(SQLException e) {

                System.out.println("MySQL操作错误");

                e.printStackTrace();

     

            } catch (Exception e) {

                e.printStackTrace();

            } finally {

                try {

                   conn.close();

                } catch (SQLException e) {

                   // TODO Auto-generated catch block

                   e.printStackTrace();

                }

            }

     

        }

 

}

 

数据库连接池,

就是一个容器,(集合),存放数据库链接的容器

         当系统初始化后,容器被创建,,容器中会申请一些链接对象,当用户访问数据库时,从容器中获取链接对象,用户访问玩之后,会将连接对象归还给容器.

         节约资源,用户访问高效\

         实现:

1. 标准接口: DataSource  javax.sql包下 
   1. 获取链接 getConnection()  
   2. 归还链接 如果链接对象Connection是从连接池中获取的,那么调用Connection.close()方法,则不会再关闭链接了,而是归还链接
2. 一般我们不去实现它,有数据库厂商来实现\
   1. c3p0 数据库连接池技术
      1. 导入jar包c3p0-0.9.5.2  依赖于mchange-commons-java-0.2.11
      2. 定义配置文件  名字为 : c3p0.properties  or  c3p0-config.xml
      3. 路径默认src下,
      4. 创建核心对象,数据库连接池对象ComboPooledDataSource

• • • v. //1.创建数据库连接池对象 DataSource ds = new ComboPooledDataSource(); //2.获取链接对象 Connection conn = ds.getConnection();
  • Druid 数据库链接池实现技术,由啊里巴巴提供(略)

Spring JDBC

spring框架对JDBC的简单封装,提供了一个JDBCTemplate对象简化JDBC的开发

javaEE

         java语言在企业级开发中使用的技术规范的总和,一共规定了13项大的规范

         java动态项目的目录结构:

                  --项目根目录

                          --WEB-INF

                                   --web.xml      web项目的核心配置文件

--classes目录        放置字节码文件的目录

--lib目录                  放置依赖jar包的

aop面向切面编程

纵向重复代码,横向抽取

xml

概念:Extensible Markup Language 可拓展标记语言

         可扩展:标签都是自定义的,

功能:存储数据(配置文件)  在网络中传输

与html: 都是W3C(万维网联盟)    xml语法非常严格

语法:

         基本语法

1. 后缀名  .xml
2. xml第一行必须为文档声明,空行也不行
3. xml文档中有且只有一个根标签
4. 属性值必须用引号引起来单双都可以
5. 标签必须正确关闭

快速入门:

        

        

        

                  zhangs

                  10

                  male

        

        

                  lisi

                  14

                  female

        

         组成部分:

1. 文档声明
   1. 属性列表

version : 版本号  必须的属性

ebcoding : 编码方式,告知解析引擎当前文档使用的编码方式  默认iso-8859-1

standalone : 是否独立  yes (不依赖其他文件)  no(依赖其他文件)(了解)

1. 指令(了解):结合css的
2. 标签
3. 属性:id值唯一
4. 文本内容

CDATA区:

         约束文档 :规定xml文档的书写规则

1. 能够在xml中引入约束文档
2. 能够读懂约束文档

约束文档:

1. DTD:一种简单的约束技术

引入:

          内部dtd : 将约束规则定义在xml文档中

                  

                            约束内容

]>

          内部dtd : 将约束规则定义在外部dtd文件中

                   本地 :

                   网络

1. Schema:一种复杂的,后缀名.xsd

解析:操作xml文档,将文档中的数据读取到内存中

         操作xml文档

1. 解析(读取) : 将文档中的数据读取到内存中
2. 写入 : 将内存中的数据保存到xml文档中,持久化的存储

解析xml的方式:

1. Dom:将标记语言文档一次性加载进内存,在内存中形成一颗dom树
   1. 优点:操作方便
   2. 缺点:占内存
2. SAX:逐行读取,基于事件驱动的
   1. 优点:不占内存
   2. 缺点:只能读取,不能增删改查

xml常见的解析器

1. JAXP :sun公司提供的解析器
2. DOM4J : 一款非常优秀的解析器
3. Jsop : ??????
4. PULL:Android内置的解析器sax方式的

Jsop

1. Jsop : 工具类,可以解析html和xml文档,返回Document

parse解析html或xml文档,返回Document

parse(File in,String charsetName)  : 解析xml或html文件的

parse(string html) : 解析xml或html字符串

parse(URL url , int timemeoutMillis) : 通过网络路径获取指定的html或xml的文档对象

1. Document : 文档对象,代表内存中的dom树

获取Element对象

         getElementsById(String id ) : 根据ID属性值获取唯一的element对象

         getElementsByTag(string tagName) : 根据标签名获取元素对象集合

         getElementsByAttribute(String Key) : 根据属性名称获取元素对象集合

         getElementsByAttributevalue(string key,string value)根据对应得属性名和属性值获取元素对象集合

1. Elements:元素Element对象的集合可以当做ArrayList来使用
2. Element:元素对象

1. 获取子元素对象
2. 获取属性值     attr(String  Key)根据属性名称获取属性值
3. 获取文本  String text() 获取文本内容   String  html()  获取标签体的所有内容(包括标签的字符串内容)

1. Node : 节点对象   是Document和Element的父类
2. 查询

Selector:选择器  Elements   select(String  cssQuery)

XPath: 查询xml的语法路径语言   需要额外导入jar包

Tomcat

服务器:安装了服务器软件的计算机

web服务器软件: 接受用户的请求 ,处理请求,做出响应  在web服务软件中,可以部署web项目,让用户通过浏览器来访问这

                                   些项目

与Java相关的服务器软件:

         WebLogic:    oracle公司,大型的javaEE服务器,支持所有的javaEE规范,收费的

         WebSphere:  IBM公司,大型的javaEE服务器,支持所有的javaEE规范,收费的

         JBoss:  JBoss公司,大型的javaEE服务器, 支持所有的javaEE规范,收费的

         Tomcat:  Apache基金组织,中小型的javaEE服务器,仅仅支持少量的javaEE规范,开源的,免费的

Tomcat:web服务器软件

1. 下载:http://tomcat.apache.org/
2. 安装:解压压缩包(目录不要有中文)
3. 卸载(删除目录)
4. 启动:在bin下startup.bat文件 访问:  http://localhost:8080
5. 关闭:执行bin下的shutdown.bat 或者  ctrl+c
6. 配置

部署项目的方式:

1. 直接将项目放到webapps下

简化部署:将项目打包为一个war包放到webapps下,war包会自动解压缩

1. 修改conf/server.xml文件在path是虚拟目录(不安全)
2. 在conf\Catalina\localhost目录下创建任意名称的xml文件,添加文件名称为虚拟目录(热部署)

Servlet

概念:运行在服务端的小程序,servlet就是一个接口,定义了java类被浏览器访问到(被Tomcat识别的规则)的规则

         将来我们复写一个类实现servlet接口,就可以被浏览器(Tomcat)访问到

体系结构

       两个实现类servlet -à GenericServlet(抽象类) ---à  HttpServlet(抽象类)

       GenericServlet将servlet中的方法做了空实现,只将Service()方法作为抽象方法   

HttpServlet:对http协议的一种封装

复写doGet/doPost方法

创建

1.创建一个继承Servlet的类,实现方法

public class ServletDemo1 implements Servlet{

/* *

 *执行时机:当Servlet的对象销毁时被调用,做一些收尾,清理的工作

 *

 */

@Override

public void destroy() {

          System.out.println("Servlet销毁了");

         

}

/**

 * 获得当前ServletConfig的配置对象

 */

@Override

public ServletConfig getServletConfig() {

          // TODO Auto-generated method stub

          return null;

}

/**

 * 获得当前Servlet的属性信息 , 返回一些作者,(了解)

 */

@Override

public String getServletInfo() {

          // TODO Auto-generated method stub

          return null;

}

 

 

    /*执行时机,当servlet创建的时候被调用,做初始化工作(初始化方法)

*ServletConfig:Serlet      :Servlet的配置对象,初始化的时候可以进行配置

*/

@Override

public void init(ServletConfig arg0) throws ServletException {

          System.out.println("Servlet被创建了(init方法)");

}

/*

 *当一个请求,请求当前Servlet的时候被调用

 *处理当前Servlet的业务逻辑并把相应的 返回给浏览器

 *ServletRequest请求对象

 *ServletResponse响应对象

 */

@Override

public void service(ServletRequest request, ServletResponse response) throws ServletException, IOException {

          response.getOutputStream().write("hello Servlet".getBytes());

         

}

 

}

2.配置

  

<servlet>

    

    <servlet-name>demoservlet-name>

    

    <servlet-class>cn.tian.servlet.ServletDemo1servlet-class>

servlet>

<servlet-mapping>

    

    <servlet-name>demoservlet-name>

    

    <url-pattern>/demourl-pattern>

servlet-mapping>

注解配置

1. 创建javaEE项目选择servlet3.0以上版本,可以不创建web.xml
2. 定义一个类实现servlet接口
3. 复写方法
4. 在类上使用@WebServlet注解,进行配置

@WebServlet(urlPatterns = "/demo")

public class ServletDemo2 implements Servlet {

               简写: @WebServlet("/demo")

 

执行原理

1. 当服务器接收到客户端浏览器请求后,会解析请求url路径,获取访问的servlet的资源路径
2. 查找web.xml文件是否有对应得标签体内容
3. 如果有则再查找对应的全类名
4. Tomcat会将字节码文件加载到内存,并创建其对象
5. 调用其方法

生命周期

1. 被创建:执行init方法,只执行一次(加载资源)

servlet的init方法只执行一次说明servlet在内存中只存在一个对象,servlet是单例的

          多个用户同时访问时,容易出现线程安全问题;尽量不要在servlet中定义成员变量

          即使定义的成员变量,也不要对其赋值修改值

什么时候被创建? 

1.默认情况下第一次访问,servlet被创建,值为负数的时候(默认值负数)

2.在服务器启动时创建,方法 把值配成0或正整数

1. 提供服务:执行servies方法,执行多次
2. 被销毁:执行destroy方法,只执行一次

servlet被销毁 前 执行,服务器被关闭时,servlet被销毁

只有服务器正常关闭时才会被执行

一般用于释放资源

 

报错版本不对应

           Tomcat、jdk、web.xml 对应关系：

版本对应错误，更换便可。（版本往下兼容）

web.xml——version2.2——JDK1.1——Tomcat3.3

web.xml——version2.3——JDK1.3——Tomcat4.1

web.xml——version2.4——JDK1.4——Tomcat5.5

web.xml——version2.5——JDK5.0——Tomcat6.0

web.xml——version3.0——JDK6.0——Tomcat7.0

web.xml——versio3n3.1——JDK7.0——Tomcat8.0,Tomcat8.5

web.xml——version4.0——JDK8.0——Tomcat9.0

定义类继承HttpServlet

request

获取请求消息数据

1. 获取请求行数据

GET   /day/demo?name = zhang  HTTP/1.1

1. 1. 获取请求方式        GET    getMethod()
   2. 获取虚拟目录        /day   getContextPath()
   3. 获取Servlet的路径      /demo              getServletPath()
   4. 获取get方式的请求参数    name = zhang          getQueryString()
   5. 获取url  /day/demo     getRequestURI()                     /day/demo

getRequestURL()              http://localhost/day/demo

                  获取客户机的ip地址:  getRemoteAddr()

                  获取协议及版本 : getProtocol()

1. 获取请求头数据(防盗链)
   1. getHeader    通过请求头的名称获取请求头的值
   2. getHeaderNames 获取所有的请求头的名称
2. 获取请求体数据

Response

功能：设置响应消息

1. 设置响应行
   • • 格式：HTTP/1.1 200 OK
     • 设置状态码：setStatus(int sc)
2. 设置响应头
   • • setHeader(String  name,String value)
3. 设置响应体
   • • 使用步骤
       1. 获取输出流
          1. 字符输出流 ： PrintWriter  getWriter()
          2. 字节输出流 ： servletOutputStream  getOutputStream()
       2. 使用输出流，输出到客户端浏览器
4. 案例
   • • 完成重定向：资源跳转的方式
       1. 告诉浏览器重定向：状态码 302
          1.  response.setStatus(302);
       2. 告诉浏览器要重定向的页面：响应头location：页面的路径
          1.  response.setHeader("location","/response1");

简单的重定向方法

 response.sendRedirect("/response1");

1. 重定向的特点：redirect
   1. 地址栏发生变化
   2. 重定向可以访问其他站点服务器的资源
   3. 重定向是两次请求，不能使用request对象来共享数据
2. 转发的特点 ：forword
   1. 转发地址栏路径不变
   2. 转发只能访问当前服务器下的资源
   3. 转发只是一次请求，可以使用resquest对象来共享数据

5）forword 和 redirect 的区别

• • • 服务器输出字符数据到客户端浏览器
    • 服务器输出字节数据
    • 验证码

HTTP

Hyper Text Transfer Protocol 超文本传输协议

         请求消息:客户端发送给服务端的数据

         响应消息:服务端发送给客户端的消息

 

 

         传输协议:定义了客户端,服务器端发送数据的格式

         特点:1.基于TCP/IP的高级协议

                   2.默认端口号80

                   3.基于请求/响应模型的:一次请求对应一次响应

                   4.无状态的,每次请求时间相互独立,不能相互交互数据

        版本:

                  1.0:每一次请求响应都会建立新的链接

                  1.1:复用链接

         请求消息数据格式

1. 请求行

请求方式:       请求url                           请求的版本/协议

GET                   Host: localhost:8080       HTTP/1.1        

请求方式:HTTP协议有七种请求方式

          GET:请求参数在url后 , 请求长度有限制(不太安全)                        

          post:请求参数在请求体中,请求长度没有限制(相对安全)

1. 请求头(键值对)

请求头名称:请求头值

User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:66.0) Gecko/20100101 Firefox/66.0浏览器告诉服务器,浏览器的版本信息

解决兼容性问题

Referer:                告诉服务器我(当前请求)从哪里来        1.防盗链2.统计工作

1. 请求空行

空行          用于分割post请求头和请求体的

1. 请求体

封装post请求消息的请求体的

Host: localhost:8080

User-Agent: Mozilla/5.0 (Windows NT 10.0; WOW64; rv:66.0) Gecko/20100101 Firefox/66.0

Accept: text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8

Accept-Language: zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2

Accept-Encoding: gzip, deflate

Upgrade-Insecure-Requests: 1

         响应消息数据格式

框架

提高开发效率

Ant

在项目的运行编译打包过程都需要依赖于ant构建工具

Maven项目构建工具

基于Ant的,Ant有的功能Maven都有,额外添加了其他功能

mvc

         他不是java独有,所有B/S架构的项目都在使用它!

M  - -  model 模型(自己写代码)

V   - -  view 视图(jsp)

C      - - Cotroller 控制器(servlet)

hibernate

在dao层操作数据库数据的(可以以面向对象的方式来完成,不需要书写SQL语句)

        

         在dao层操作数据库数据的技术

1. jdbc+连接池(c3p0  dbcp)
2. apache组织:dbutils工具类  封装了jdbc和连接池

QueryRunner qr = new QueryRnner(连接池);

1. hibernate 完成单表数据的crud(增删改查)操作

ORM框架 : 对象关系映射框架,将对象和表建立映射关系,,想操作对象就相当于操作数据库的表了

hibernate环境搭建

        

持久化类的编写和一级缓存

hibernate的关联关系( 一对多|多对多的关系)

hibernat的jpa

 

 

 

 

 

 

 

主配置

struts2

创建

1. 搭建环境(导包)
2. 书写action(动作)类
3. 配置xml    struts.xml 
   1. 在library下下  下 的struts-2.3.dtd 复制出来
   2. 打开

  搜索cata 

然后第一个是本地路径(文件是复制过来的,不能直接复制),第二个是struts-2.3.dtd里面的路径

然后把这个也放入到xml

1. 将Struts核心过滤器配置到web.xml

struts.xml配置详解

struts2常量配置

struts2默认常量配置位置:

修改默认常量配置:方式先后也是加载顺序,后加载的会覆盖先加载的

1. 在src下创建Struts.properties文件修改
2. 在struts.xml下配置
3. 在web.xml中配置

 

常量配置

         struts.i18n.encoding=UTF-8     i18n  :  国际化     解决post提交乱码

         struts.action.extension=action,,   指定反问action时的后缀名struts.action.extension=”do”访问时后缀名.do

         struts.devMode = false                     指定struts2是否以开发模式运行

1. 1. 1. 热加载主配置(不需要重启即可生效)
      2. 提供更多错误信息输出,方便开发时的调试

spring框架

ssh  :  hibernate  +  struts2  +  spring

ssm  :  mybatis  + springMVC + spring7

spring是分层的ee的full-stack(一站式)开源框架

ee分了三层: web层  service层 dao层(spring对ee 的每一层都提供了解决的技术)

                  web层             :        struts2   springmvc

                  service层        :        spring

                  dao层              :        hibernate   spring jdbcTemplate  (dbutils)

IOC思想 : 工厂+反射+ 配置文件      解耦合    控制反转

1. 1. beans
   2. core
   3. context
   4. expression