java学习~线程、注解反射、Swagger

这几天一直在学习java基础，所以跟着老师一起学习做的总结。
项目地址：StudyJava项目地址

一：线程学习

这是代码的布局以及对各个类的描述和总结。可以借鉴。
线程代码地址：thread

No1_thread——
            线程的五大状态：
            Thread.state
            NEW创建状态，就绪状态，RUNNABLE运行状态，(BLOCKED,WAITING,TIME_WAITING)阻塞状态，TERMINATED死亡状态
            1.创建线程（启动线程）就绪状态（获取CPU调度）运行状态（释放CPU调度）就绪状态
            2.运行状态（用户输入线程停止，线程自然停止外部干预）死亡状态
            3.运行状态（线程阻塞）阻塞状态（阻塞解除）就绪状态
            |——thread1——线程创建
                        |——TestThread1：创建线程方式一，继承Thread
                        |——TestThread1_test1:利用多线程下载图片
                        |——TestThread2：创建线程方式二，实现Runnable接口
                        |——TestThread2——test1：龟兔赛跑问题
                        |——TestThread2——test2：抢票问题（线程不安全）
                        |——TestThread3：创建线程方式三：实现Callable接口(线程池)
            |——thread2——线程基础
                        |——Lambda:lambda表达式的简化的过程详解(外部类-静态内部类-局部内部类-匿名内部类-Lambda表达式)
                        |——Lambda2：带有参数的Lambda表达式简化的过程
                        |——StaticProxy：静态代理（举例说明代理模式：Company代理You，Thread代理Runnable接口）
            |——thread3——线程方法
                        |——DaemonThread：线程分为守护线程+用户线程，后台记录操作，监控内存，垃圾回收等守护线程。
                                         GC守护线程，虚拟机确保用户线程执行完毕，不用等待守护线程执行完毕
                        |——JoinThread：Join合并线程，待此线程完成后，在执行其他线程，其他线程阻塞
                        |——SleepThread:睡眠让线程从阻塞状态转为就绪状态。实例：1.模拟网络延迟 2.模拟倒计时  3.模拟打印当前时间
                                       每个对象都有一把锁，但是sleep不会释放锁
                        |——StopThread：停止线程，推荐手动停止，设置标志位flag（设置修改标志位的方法stop）
                        |——ThreadPriority：优先级高的线程不一定先执行，要看CPU的心情
                        |——ThreadState:测试线程的状态，线程五大状态：NEW,RUNNABLE,TERMINATED,TERMINATED(注意：测试时记得加slepp延迟，否则运行太快观察不到变化)
                                       线程终止或者结束，一旦进入死亡线程后，就不能再次启动
                        |——YieldThread：礼让将线程从运行状态转为就绪状态。
                                        礼让线程，让当前正在执行的线程暂停，但不阻塞，yield礼让不一定成功，看CPU心情
            |——thread4——线程同步：多个资源操作同一资源；并发：同一个对象被多个线程同时操作（多个线程，同时买票，同时取钱）
                        解决线程同步的方法：队列+锁，加入锁机制synchronized
                        每个对象都有一把锁，但是sleep不会释放锁，wait会释放锁。
                        带来的问题：1.一个线程持有锁会导致其他需要该锁的线程挂起
                                  2.在多个线程竞争下加锁释放锁会引起过多的上下文切换以及性能问题
                                  3.如果一个优先级低的线程等待优先级高的线程，会导致线程的优先级倒置，引起性能问题。
                        三大不全的案例：1.不安全的买票+2.不安全的取钱+3.不安全的集合ArrayList（注：每个线程都在自己的工作内存交互，内存控制不当会导致数据不一致）
                        |——UnsafeBuyTicket:不安全的买票
                        |——UnsafeList:不安全的集合ArrayList
                        |——UnsafeBank:不安全的取钱
                        线程的同步方法：加入synchronized关键字(synchronized块和synchronized方法)，必须获得对象的锁，否则线程会阻塞。
                                原理：方法一旦执行就独占该锁，直到方法执行结束，释放锁，后面被阻塞的线程才会获得该锁，继续执行。
                                缺点：若将一个大的方法声明为synchronized将会影响效率（只有修改的代码需要同步，只读代码大家看到的都一样，锁的太多会浪费资源）
                        同步块：synchronized(obj){}：obj是同步监视器：
                              obj可以是任何对象但是推荐使用共享资源作为同步监视器
                              同步方法中无需指定同步监视器，因为同步方法中的同步监视器就是this，就是对象本身或者说是class。
                              同步监视器的执行过程：1.线程一访问，锁定同步监视器，执行其中的代码
                                                2.线程二访问，发现同步监视器被占用，无法访问
                                                3.线程一执行完毕解锁同步监视器
                                                4.线程二访问，发现同步监视器没有锁，锁定然后访问
                        在以上三个不安全的案例中分别加上synchroized即可解除不安全的状态；注意：锁的对象是变化的量，需要增删改的对象
                        |——JUCThread:CopyOnWriteArrayList<String>是安全类型的集合，在import java.util.concurrent包下
                        |——DeadLock：死锁
                        |——Lock:显示的定义同步锁，ReentrantLock（可重入锁）实现了Lock，它拥有和synchronized相同的并发性和内存语义：可以显示加锁，释放锁
                           Lock和synchronized区别：1.Lock是显示的锁，手动加锁和释放锁(别忘记关锁)，synchronized是隐士的锁，除了区域自动释放锁
                                                  2.Lock只有代码块，synchronized既有代码块锁也有方法锁
                                                  3.使用Lock锁，JVM会花费较少的时间来调用线程，性能更好
                                                  4.使用顺序：Lock>同步代码块（方法体内）>同步方法（方法体外）
            ——thread5——综合类(生产者消费者问题)
                       Object类：
                               wait方法：线程一直等待，直到其他线程通知，会释放锁。
                               wait(long timeout)：指定等待的毫秒数
                               notify方法：唤醒一个处于等待的线程
                               notifyAll()：唤醒同一个对象上所有调用wait方法的线程，优先级别高的线程优先调度
                       |——TestPC：解决方式1，管程法(利用缓存区解决):生产者，消费者，产品，缓冲区
                       |——TestPC：解决方式2，信号灯法
                       |——TestPool:线程池,避免重复创建销毁，重复利用。1.创建服务，创建线程池。2.丢入线程，service.execute执行。3.关闭链接

二.注解反射学习

可以练习代码帮助理解和掌握。
Annotation_Reflection代码地址：Annotation

-No2_annotation——
                 |——Test01:测试注解+自定义注解
                 |——Test02:1.反射测试，2.获取Class类的方法
                 |——Test03:获取所有类型的Class
                 |——Test04：测试类的主动引用和被动引用
                 |——Test05：引导类加载器(java平台核心库rt.jar包)，扩展类加载器(jre/lib/ext目录下)，系统类加载器
                 |——Test06:获得类的属性
                 |——Test07：动态创建对象,利用反射
                 |——Test08:反射操作注解。ORM：对象关系映射


A.注解：Annotation,不是程序本身，可以对程序作出解释，可以被其他程序读取
          1.内置注解：
          @Override:重写注解,java.lang.Override
          @Deprecated:表示程序不鼓励程序员使用这样的元素
          @SuppressWarnings:抑制警告
          2.元注解：
          @Target():描述注解的使用范围
          @Retention():在什么级别保存该注解有效 SOURCE<CLASS<RUNTIME
          @Inherited:子类可以继承父类的该注解

B.反射：
1.动态语言：运行时可以改变其结构的语言，javascript,Object-C,PHP,Python,C#
2.静态语言：java，C，C++。java不是动态语言，但是java可以称之为准静态语言。利用反射机制获得类似动态语言的特性。
          正常方式：引入需要包类的名称->new实例化->取得实例化对象
          反射方式：实例化对象->getClass()->获得完整的包类的名称

C.类的加载过程：
    1.类的加载:将类的Class文件读入内存；
              并为之创建一个java.lang.Class对象
    2.类的链接：将类的二进制数据合并到JRE中；
              为类变量（static）分配内存并设置类变量默认初始阶段，初始化为0。
    3.类的初始化：JVM负责对类进行初始化；
              执行类构造器的<clinit>()方法，自动加载和合并代码中的语句

D.类加载器的作用：
    源程序(*.java文件)->Java编译器->字节码(.class文件)->类加载器->字节码校验器->解释器->操作系统平台

E：分析性能问题：
    1.普通方式调用方法：快捷，9ms
    2.反射调用方法：耗时，5.7s
    3.反射调用方法，关闭检测：稍好，1.9s

三.Swagger学习

一个Swagger的简单项目。
Swagger代码地址：Swagger
附上学习中的总结

项目在StudyJava同一级下
一.Swagger简介
    1.后端时代：前端只是管理静态页面；html->后端负责，模板引擎JSP
    2.前后端分离：Vue+SpringBoot
        （1）后端：控制层，服务层，数据访问层【后端团队】
        （2）前端：控制层，视图层【前端团队】
                 伪造后端数据，json，不需要后端，前端依然可以运行。
        （3）前后端交互：Api接口
        （4）前后端相对独立：松耦合
        （5）前后端可以建立在不同的服务器上
    3.前端测试接口：postman；后端需要实时更新接口和信息。
    4.引入->Swagger：（1）号称世界上最流行的Api框架
                    （2）RestFul Api文档在线自动生成工具->Api文档与Api定义同步更新
                    （3）直接运行，可以在线测试Api接口
                    （4）支持多种语言：java,php……

二.项目中使用Swagger需要Springfox：swagger2+ui（在maven官网下载这两个包或者直接在maven中配置）
三.SpringBoot集成Swagger
    (1)新建一个Springboot-web项目
    (2)导入依赖包
        <!-- https://mvnrepository.com/artifact/io.springfox/springfox-swagger-ui -->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.9.2</version>
        </dependency>
        <!-- https://mvnrepository.com/artifact/io.springfox/springfox-swagger2 -->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.9.2</version>
        </dependency>
    (3)编写一个Hello工程
    (4)配置Swagger
        @Configuration
        @EnableSwagger2  //开启Swagger2
        public class SwaggerConfig {
        }
    (5)测试运行：localhost:8080/swagger-ui.html
四.配置Swagger
    (1)Swagger的bean实例Docket
        @Configuration
        @EnableSwagger2/*开启Swagger2*/
        /*配置Swagger的Docket的bean实例*/
        @Bean
        public Docket docket() {
            return new Docket(DocumentationType.SWAGGER_2).apiInfo(apiInfo());
        }
       /*配置Swagger信息*/
       private ApiInfo apiInfo();
    (2)配置是否启动Swagger
    问题：我只希望我的Swagger在生产环境中启动，在发布的时候不启动？
五.总结
    1.可以通过Swagger给一些比较难理解的属性或者接口增加注释
    2.接口文档实时更新
    3.可以在线测试
    注意：在发布的时候一定要关闭Swagger，出于安全考虑。

四.项目疫情地图

day1：简单的小项目
地址：Mapday1

day1：任务：验证码发送，通过java程序，向用户输入的手机号码发送验证码
      任务线索：1.网址组成分析
              2.URL类使用
              3.编码表
              4.智能聊天机器人实现
              5.短信发送API
1.网址的组成分析
网址组成：协议：//域名：端口号/虚拟路径？参数列表#锚点
        协议：是计算机与计算机之间的协议，用于控制传输速率以及传输编码，出错控制
        域名：ip地址的别名，公网ip(网线),ip地址是计算机的唯一标识
             域名服务商。DNS解析商。www.baidu.com
        端口号：范围：0-65535
        虚拟路径：像文件夹一样，对网站资源分类
        参数列表：向服务器发送的数据，组成方式：由多个键值对组成，多个键值对之间哟个&间隔

2.URL类的使用
目标：访问网络资源
    （1）准备一个URL对象,url:URL url=new URL("网址");
    （2）连接服务器:URLConnection conn = url.openConnection();
    （3）加载网络资源:InputStream is = conn.getInputStream();
    （4）将is装饰为能一次读取一行的字符缓冲输入流:BufferedReader br = new BufferedReader(new InputStreamReader(is))
    （4）读取一行资源：String text = br.readLine();
    （5）显示：System.out.println(text);
    （6）关闭连接：br.close();

3.编码表
文字与数字对应的字典表格;BK,unicode,UTF-8

4.如何与服务器沟通
（1）与机器人交互
地址：https://api.jisuapi.com/iqa/query
示例：https://api.jisuapi.com/iqa/query?appkey=62958a3a6ef3c56d&question=河南天气
参数列表：appkey：秘钥，值为：62958a3a6ef3c56d
        question：与智能机器人的聊天内容 ，例如：北京天气
（2）短信发送：
地址：https://itdage.com/kkb/kkbsms
示例：https://itdage.com/kkb/kkbsms?key=xzk&number=13253357452&code=666123
参数列表：key：密钥，值为xzk
        number：接收验证码的手机号
        code:A-Za-z0-9的验证码内容

五JavaWeb学习

这里是关于javaweb的一些基础内容了解和掌握javaweb的前提基础（非代码部分）

JavaWeb
    1.web开发：
        1.1 静态web：html,css，提供给所有人的数据不会发生改变，都一样
        1.2 动态web：淘宝，几乎所有的网站提供给用户的网站会随着用户的不同时间和地点看到的信息不同
                   技术栈：serlvlet/jsp,ASP,PHP
        在java中，动态web资源开发的技术统称为Javaweb
    2.web应用：可以提供给浏览器访问的程序
        2.1 一个web应用由多部分组成（静态web，动态web）：html，css，js，jsp，servlet，java程序，jar包，配置文件
        2.2 web应用程序编写完毕后要给外界访问，需要一个服务器来统一管理。
    3.静态web：
        3.1 *.html,htm这些都是网页的后缀，如果服务器上一直存在这些东西，我们就可以一直访问。
        3.2 客户端->一次请求request->WebService->服务器->index.html
            客户端<-一次响应<-WebService<-服务器<-index.html
        3.3 静态web的缺点：无法与数据库交互，伪动态，javaScript实际开发中应用的多
    4.动态web：
        4.1 客户端->一次请求request->WebService Plugin->动态资源
              |                        静态|资源         |
              |<------一次响应<--------WebService <- 动态web资源(JSP/Servlet)
                                      File|System       |
                                                      JD|BC
                                                      数据库
        4.2 缺点：加入服务器的动态web资源出现了错误，需要重新编写后台程序：停机维护
        4.3 优点：程序可以动态更新，所有用户看到的不是同一个页面，可以与数据库交互。
    5.web服务器技术：
        5.1 ASP：微软，国内最早流行的ASP
                在html中嵌入了VB脚本，ASP+COM
                维护成本高！C#语言
                IIS服务器
        5.2 PHP:开发速度快，功能强大，跨平台，代码很简单
                无法承载大访问量的情况（局限性）
        5.3 JSP/Servlet:
                sun公司主推的B/S框架，可以承载三高带来的问题（高并发，高性能，高维护）
                B/S：浏览器服务器；C/S：客户端服务器
    6.web服务器：服务器是一种被动操作，用来处理用户的一些请求和给用户一些响应信息
        6.1 IIS：微软的ASP……Windows自带的
        6.2 tomcat：实际运行jsp和servlet
                    /bin：启动关闭的脚本文件
                    /config：配置
                    /lib：插件，依赖的jar包
                    /log日志
                    /webapps：访问网站的文件夹
                    启动关闭tomcat：shutup，shutdown
             6.2.1可以配置启动端口号/config/server修改tomcat默认端口号8080
             6.2.2可以修改localhost,system32/drivers/etc/可以修改localhost->www.syr.com
             6.2.3可以添加网页，默认访问的是webapps下的网页
             6.2.4 tomcat：8080，mysql：3306，http:80，https：443
        6.3 网站时如何访问的？
            （1）输入一个URL回车
            （2）检查本机中的sysytem32/drivers/etc是否有对应的域名映射
            （3）有->直接返回对应的ip地址，这个ip地址中有我们需要访问的web程序
                没有->去DNS服务器去查找
        6.4 发布一个网站：将自己的网站放到tomcat中指定的webapps下就可以了
            默认访问的是ROOT，编写自己的syr，访问自己编写的localhost：8080/syr
    7.http协议：
        7.1 http请求：客户端-发送请求-服务器
            （1）请求行：get：请求携带的参数少，大小有限制，在URL中显示，高效但不安全
                       post：请求携带的参数不限，URL不显示，安全
            （2）消息头
        7.2 http响应：服务器-响应-客户端
            （1）响应体
            （2）状态码：200-OK，4**：页面找不到（404），3**：重定向（303），5**:服务器代码消息（500,502网关错误）
    8.在浏览器中地址输入地址回车访问的一瞬间到页面展示，经历了什么？