Fork me on GitHub

Docker的使用

一、docker的使用

1、docker添加镜像加速文件

1
2
3
4
5
6
7
8
9
cd /etc/docker
#如果没有daemon.json文件，需要新建一个
sudo touch daemon.json
sudo vim daemon.json
#daemon.json添加以下配置，然后保存
{"registry-mirrors":["https://registry.docker-cn.com"]}
#重启服务
sudo systemctl daemon-reload
sudo systemctl restart docker

2、查看docker的版本

1
2
3
4
5
6
7
docker version
#使用docker查找镜像
sudo docker search mysql
#查看本地下载的镜像
sudo docker images
#查看本地正在运行的镜像
sudo docker ps -a

3、使用docker拉取镜像

1
2
3
4
5
sudo docker pull redis:5.0.6
sudo docker pull nginx
sudo docker pull mysql:8.0.18
#删除拉取的镜像
sudo docker image rm mysql:8.0.18

4、使用docker安装并运行nginx

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
sudo docker search nginx
#pull的时候，后面不追加冒号和版本号，默认是最新的latest版本
sudo docker pull nginx
#运行nginx
sudo docker run --name victor-nginx-test -p 8081:80 -d nginx
#victor-nginx-test是容器名称
-d，设置容器在后台一直运行
-p，端口进行映射，将本地的8081端口映射到容器内部的80端口
#执行玩上面那条命令后，会生成一串字符串45faac1c8dcac4c356e4fd8f8dc0ee204385feca7e851cbe874805db7b811f89，这个表示容器的id，一般作为日志的文件名来查看启动信息等
sudo docker logs 45faac1c8dcac4c356e4fd8f8dc0ee204385feca7e851cbe874805db7b811f89
#停止nginx
sudo docker ps
#复制对应容器的id,然后停止镜像
sudo docker stop 45faac1c8dca
#删除镜像
sudo docker rm 45faac1c8dca

5、使用docker部署项目

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#首先创建一个文件夹，里面包含3个子文件夹
sudo mkdir -p ~/桌面/nginx/www ~/桌面/nginx/logs ~/桌面/nginx/conf
#首先你要直到容器的id，
sudo docker ps -a
#复制docker容器里的nginx默认配置文件信息，到你的本地刚创建的conf文件夹目录下
sudo docker cp76d9d74d071e:/etc/nginx/nginx.conf ~/桌面/nginx/conf
#部署项目，到docker里的nginx
sudo docker run -p 8082:80 --name victor-nginx-web -v ~/桌面/nginx/www:/usr/share/nginx/html -v ~/桌面/nginx/conf/nginx.conf:/etc/nginx/nginx.conf -v ~/桌面/nginx/logs:/var/log/nginx -d nginx

#命令说明
-p 8082:80  是把你容器里的nginx的80端口映射到你本地主机的8082端口
--name victor-nginx-web  是把容器重命名我们自己喜欢的名字
-v ~/桌面/nginx/www:/usr/share/nginx/html   是把我们本地创建的项目 的www目录挂在到容器的/usr/share/nginx/html
-v ~/桌面/nginx/conf/nginx.conf:/etc/nginx/nginx.conf 是吧我们创建的nginx.conf挂在到容器的/etc/nginx/nginx.conf
-v ~/桌面/nginx/logs:/var/log/nginx 是把我们自己创建的logs挂在到容器的/var/log/nginx
-d nginx :是设置容器一直后台运行

#执行完命令后，会生成一串字符串，用这个字符串表示日志id，可以使用
sudo docker logs 76d9d74d071e8b2d8499a56691587eef3e2f19d4fddeb5a3e26e5d9338856e10

6、使用docker安装mysql并运行

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#拉去mysql的镜像
sudo docker pull mysql:5.7
#本地创建一个文件夹，用来映射容器的mysql
sudo mkdir -p ~/桌面/mydata/mysql/log ~/桌面/mydata/mysql/conf ~/桌面/mydata/mysql/data
#给创建好的文件夹开权限
sudo chmod 777 -R ~/桌面/mydata/
#使用docker命令启动mysql
sudo docker run -p 3305:3306 --name mysql -v ~/桌面/mydata/mysql/log:/var/log/mysql -v ~/桌面/mydata/mysql/data:/var/lib/mysql -v ~/桌面/mydata/mysql/conf:/etc/mysql -e MYSQL_ROOT_PASSWORD=root -d mysql:5.7
#查看镜像，如果存在，或者端口被占用，则换为3305映射容器的端口
sudo docker ps -a
#先删除被占用名字的容器镜像id，然后重新执行启动命令
sudo docker rm3bf96e1f8a95
#进入运行mysql的docker容器
sudo docker exec -it mysql /bin/bash

########以下是mysql的命令操作
#使用mysql 命令打开客户端
mysql -uroot -proot --default-character-set=utf8
#查看数据库
show databases;
create database test character set utf8;
use test;
create table ();
#退出mysql命令操作
\q
#退出mysql运行的docker容器
exit

7、使用docker安装并运行redis

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#docker拉取redis
sudo docker pull redis:3.2
#本地创建一个redis文件夹存放数据
sudo mkdir -p ~/桌面/mydata/redis/data
#更改文件件执行权限
sudo chmod 777 -R ~/桌面/mydata/redis
#使用docker命令启动redis
sudo docker run -p 6379:6379 --name redis -v ~/桌面/mydata/redis/data:/data -d redis:3.2 redis-server --appendonly yes
#进入redis容器使用redis-cli命令进行连接
sudo docker exec -it redis redis-cli
#####以下为redis的命令
ping
set a 100
get a
#退出redis
exit

8、使用docker安装并运行rabbitmq

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#拉取docker镜像
sudo docker pull rabbitmq:3.7.15
#使用docker命令启动rabbitmq
sudo docker run --name rabbitmq --publish 5671:5671 --publish 5672:5672 --publish 4369:4369 --publish 25672:25672 --publish 15672:15672 --publish 15671:15671 -d rabbitmq:3.7.15
#Ubuntu的防火墙暴露端口15672
sudo ufw allow 15672
#开启防火墙
sudo ufw enable
#重新加载
sudo ufw reload
#查看防火墙状态
sudo ufw status
#进入到rabbitmq的连接
sudo docker exec -it rabbitmq /bin/bash
#然后输入如下命令，开启rabbitmq的管理后台
rabbitmq-plugins enable rabbitmq_management
#浏览器输入rabbitmq的管理后台页面
http://localhost:15672
用户名密码：guest guest
#退出
exit
#rabbitmq的下一次启动
#直接找到对应的Container ID
sudo docker ps -a
#然后启动命令
sudo docker start 213a1c20682e
#停止命令
sudo docker stop 213a1c20682e

展开全文 >>

HBase

一、引言

1、分布式结构化存储系统

​ 大数据中，除了直接以文件形式保存的数据外(HDFS)，还有大量结构化和半结构化的数据，这种数据一般需要支持更新操作，随机插入，删除。使得HDFS无法满足要求。为了方便用户存取海量结构化和半结构化数据，HBase诞生了。是一个分布式列存储系统，有很好的扩展性、容错性、易用的API。HBase是构建在HDFS之上的，支持随机插入和删除的列簇式存储系统，可以理解成一个具有持久化能力的分布式有序映射表。

​ 虽然HBase随机读写性能比较高，但是数据scan扫描速度较慢，难以适用于OLAP场景。后来Cloudera设计出了Kudu，很好的兼顾吞吐率和延迟。

二、背景

​ 由于关系型数据库用来解决数据存储和维护有关的问题。大数据出现后，大多公司实现处理大数据，并开始选择Hadoop的解决方案。Hadoop使用分布式文件系统HDFS，用来存储大数据，使用MapReduce来处理数据。

​ Hadoop只能执行批量处理，而且是按顺序访问数据。也就是表明必须搜索整个数据集。如果想要处理结果在另一个庞大的数据，也是按照顺序处理一个巨大的数据集。为此，需要访问数据中的任何点的单元，也就是随机访问，出现新的解决方案。

​ Hadoop随机存取数据库的应用，HBase，Cassandra，CouchDB，Dynamo，MongoDB都是一些存储大量数据和随机访问访问的非关系型数据库。

  • 海量数据存储成为瓶颈，单机无法负载大量数据
  • 单机IO读写请求成为海量数据存储，高并发，大规模的瓶颈
  • 随着数据规模越来越大，大量业务场景开始考虑数据存储横向水平扩展，让存储服务可以增加/删除 ，而大部分关系型数据库更专注在一台机器。

三、HBase简介

​ HBase是BigTable的开源版本，使用Java编写的。是Apache Hadoop的数据库，建立在HDFS上，用来提供，高可靠，高性能，列存储，可伸缩，多版本的NoSQL的分布式数据库。可以实现对大型数据的实时、随机的读写访问。

  • HBase依赖HDFS做底层的数据存储，BigTable依赖Google GFS做数据存储
  • HBase依赖MapReduce进行数据计算，BigTable依赖Google MapReduce做数据计算
  • HBase依赖Zookeeper做服务协调，BigTable依赖Google Chubby做服务协调

1、非关系型和关系型数据库

  • NoSQL：HBase，Redis，MongoDB
  • RDBMS：MySQL，Oracle，SQL Server

2、HBase重点

  • HBase介于NoSQL和RDBMS之间，只能通过主键rowkey和主键的range来检索数据
  • HBase查询数据功能很简单，不支持join等关键查询复杂操作，可以通过Hive支持来实现多表join
  • HBase不支持复杂的事务，只支持行级事务
  • HBase中纯支持的数据类型，byte[]，底层所有数据的存储都是字节数组
  • HBase主要来存储结构化和半结构化的松散数据
    • 结构化数据：数据结构字段清晰，比如数据库的表结构
    • 半结构化：具有一定结构，语义不太确定，比如html网页的数据。

3、HBase的表

  • 数据量大：一张表可以有上十亿行，上百万列的数据
  • 面向列：列（族）的存储和权限控制，列簇独立检索
  • 稀疏数据：对于null的空列，并不会占用存储空间，在设计表的时候可以非常稀疏
  • 无模式：每行都有一个可以排序的主键rowkey和任意多的列，列可以根据需要动态的增加，同一张表中不同的行可以有截然不同的列
Rowkey ColumnFamily :CF1 ColumnFamily :CF2 TimeStamp
Column:Name Column:Alias Column:Age Column:Sex
rk001 zhangsan shanghai 22 M T1
rk002 lisi beijing 25 F T2

3.1、RowKey的含义

3.1.1、rowkey

​ HBase中的rowkey和MySQL中的主键是完全一样的，来唯一的区分某一行的数据。

3.1.2、HBase支持3种查询方式：
  • 基于Rowkey单行查询
  • 基于Rowkey的范围扫描
  • 全表扫描
3.1.3、rowkey分析

  • rowkey对HBase的性能影响很大，rowkey的设计也很重要，设计的时候需要考虑基于rowkey单行查询，还要考虑rowkey的范围查询。

  • rowkey行主键，可以是任意字符串，最大长度为64kb，实际中一般是10~100b，最好是16。HBase内部，rowkey保存为字节数组。HBase会对表中的数据按照rowkey进行字典序排序

3.2、Column的含义

  • 列，可以理解为MySQL的列

3.3、ColumnFamily的含义

  • 列族，HBase引入的定义
  • HBase通过列族划分数据的存储，列族下面可以包含若干个列，实现灵活的数据存取。就如同一个家族一样，列族是由一个个列组成。
  • HBase的表在创建的时候必须指定列族，就像你在MySQL创建表的时候必须指定具体的列一样。
  • HBase的列族并不是越多越好，一般列族最好是小于等于3个，一般常用1个列族

3.4、TimeStamp的含义

  • TimeStamp是实现HBase多版本的关键。HBase中使用不同的TimeStamp来标识相同rowkey行对应的不同版本的数据。类似Hive表中的时间分区字段。
  • HBase中通过rowkey和column确定一个存储单元为cell，每个cell保存同一份数据的多个版本。版本通过时间戳来索引。时间戳可以在HBase写入数据的时候自动赋值。为了避免数据版本冲突，必须自己生成具有唯一性的时间戳。一般每个cell中，不同版本的数据按照时间倒序，最新的数据在最前面。
  • 为了避免数据存太多版本造成存储和索引的负担，HBase还提供了2种版本回收方式
    • 保存数据的最后n个版本
    • 保存最近一段时间内的版本(可以设置数据的生命周期TTL)

3.5、单元格Cell

  • 由rowkey，column，version唯一确定的单元。Cell中的数据是没有类型的，全部是字节码byte[]形式存储。

展开全文 >>

Java并发编程

一、Java并发编程

  • 多线程程序包含两个或者多个可以同事运行的部分，每个部分可以同事处理不同的任务，从而能更好的利用可用资源，如果CPU是多核，多线程可以写入多个task，在同一个程序同时进行操作处理。

  • 多任务是多个进程共享，比如CPU处理公共资源

  • 多线程：将多任务的概念扩展到可以将单个应用程序中的特定操作细分为单个线程的应用程序 ，每个线程可以并行运行。

1、线程的生命周期

线程在生命周期中经历多个阶段：线程诞生，启动，运行，然后死亡。

  • 新线程New：新线程在新的状态下开始其生命周期，直到程序启动线程为止，保持在这种状态，也叫出生线程。
  • 可运行Runnable：新诞生的线程启动以后，start，该线层可以运行，状态的线程被认为正在执行其任务。
  • 等待Waiting：有时线程回转换到等待状态sleep,wait()，而线程等待另一个线程执行任务。只有当另一个线程发信号通知notify()/notifyAll()等待线程才能继续执行时，线程才转回到可运行状态。
  • 定时等待Timed Waiting：可运行的线程可以在指定的时间间隔内进入定时等待状态，当该时间间隔sleep(100)到期或者发生等待的事件的时候，此状态的线程将转换到可运行状态。
  • 终止dead：可执行线程在完成任务或者以其他方式终止的时候进入到终止状态。

2、线程优先级

每个java线程都有一个优先级，可以帮助操作系统安排线程的顺序。Java线程优先级在MIN_PRIORITY(1),和MAX_PRIORITY(10)之间的范围内，默认情况下的，每个线程优先级都是NORM_PRIORITY(5)

具有较高的优先级的线程相对于一个程序来说更重要，应该在低优先级线程之前分配处理器时间。然而，线程优先级并不能呢保证线程执行的顺序。

3、通过实现Runnable接口创建线程

  • 需要实现Runnable接口提供的run()方法。run()方法为线程提供一个入口，可以把完整的业务逻辑放到run()方法体。此方法是没有返回值的

    1
    2
    3
    public void run(){
        ...service....
    }

  • 然后在通过Thread构造函数，去创建一个对象

  • 对象调用start()方法来启动线程。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
package multi_thread;

/**
 * @Description:通过实现Runnable接口的方式创建线程
 * 1、首先是需要实现Runnable的接口的run方法，run()作为线程提供一个入口，完成的业务逻辑写在run()里
 * 2、通过Thread构造函数，去创建一个实例对象
 * 3、对象调用start()方法来启动线程
 * @Author: VictorDan
 * @Date: 19-8-12 下午3:58
 * @Version: 1.0
 */
public class TestRunnable implements Runnable {
    private Thread thread;
    private String threadName;

    public TestRunnable(String threadName) {
        this.threadName = threadName;
        System.out.println("创建线程："+threadName);
    }

    /**
     * 实现Runnable接口，需要重写run方法
     * run方法里一般写的业务逻辑代码
     */
    @Override
    public void run() {
        System.out.println("创建线程："+threadName);
        try {
            for (int i = 0; i < 5; i++) {
                System.out.println("线程："+threadName+","+i);
                Thread.sleep(50);
            }
        }catch(InterruptedException e){
            System.out.println("线程："+threadName+"被打断");
        }
        System.out.println("线程:"+threadName+"执行完退出");
    }

    public void start(){
        System.out.println("开启线程："+threadName);
        if(thread==null){
            thread=new Thread(this,threadName);
            thread.start();
        }
    }

    public static void main(String[] args) {
        TestRunnable thread1 = new TestRunnable("Thread-1");
        thread1.start();
        TestRunnable thread2 = new TestRunnable("Thread-2");
        thread2.start();
    }
}

4、通过继承Thread类创建一个线程

5、线程池的使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
    public static void main(String[] args) {
        /**
         * 使用Executors可以创建线程池，但是你方便的同时，隐藏了复杂性，而埋下隐患，比如OOM，线程耗尽等。
         * 所以阿里开发规范，创建线程池要手动创建，而不允许Executors直接调用的方式。
         */
        //1、创建一个不限制线程数上限的线程池，任何提交的任务都立即执行，最大上限是Integer.MAX_VALUE,会使用
        Executors.newCachedThreadPool();
        //2、创建一个固定个数大小的线程池
        Executors.newFixedThreadPool(10);
        //3、创建一个只有1个线程的线程池
        Executors.newSingleThreadExecutor();
        //4、创建一个定时的线程池，工作队列是延迟队列。
        Executors.newScheduledThreadPool(20);
        //总结：小程序使用这些快捷方法创建线程池没问题，但是对于服务端长期运行的程序，需要如下通过利用ThreadPoolExecutor的构造函数创建线程池。
        /**
         * Executors.newXXXThreadPool(),这种方式创建线程池，会使用无界的任务队列，为了避免OOM，应该手动使用ThreadPoolExecutor的构造方法指定队列的最大长度。
         * 还要明确拒绝任务时的策略，行为。也就是任务对了沾满的时候，这里在submit()新的任务，
         * public interface RejectedExecutionHandler{
         *     void rejectedExecution(Runnable r,ThreadPoolExecutor executor);
         * }
         * 线程池提供了常见的拒绝策略。
         * 1、new ThreadPoolExecutor.DiscardOldestPolicy():丢弃执行队列中最老的任务，尝试为当前提交的任务腾出位置
         * 2、new ThreadPoolExecutor.DiscardPolicy()：什么都不做，直接忽略
         * 3、new ThreadPoolExecutor.AbortPolicy();抛出RejectedExecutionException
         * 4、new ThreadPoolExecutor.CallerRunsPolicy();直接由提交任务者执行这个任务
         * 线程池默认的拒绝行为是：AbortPolicy，也就是抛出RejectedExecutionException，
         * 如果不关心任务被拒绝，则可以使用DiscardPolicy，这样多余的任务可以悄悄的被忽略。
         */
        //Executors的方法也是使用ThreadPoolExecutor的构造方法创建的线程池。
        new ThreadPoolExecutor(2, 20, 0L, SECONDS, new ArrayBlockingQueue<>(512), new ThreadPoolExecutor.DiscardOldestPolicy());
        ExecutorService executorService = Executors.newCachedThreadPool();
        new ThreadPoolExecutor.DiscardPolicy();
        new ThreadPoolExecutor.AbortPolicy();
        new ThreadPoolExecutor.CallerRunsPolicy();
        new ThreadPoolExecutor.DiscardOldestPolicy();
        //executorService=Executors.newSingleThreadExecutor();
        for (int i = 0; i < 20; i++) {
            executorService.execute(new WorkTask());
        }
        Future<Object> future = executorService.submit(() -> {
            //这个异常会在调用Future.get()的时候传递给调用者
            throw new RuntimeException("exception in call");
        });
        try {
            Object result = future.get();
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (ExecutionException e) {
            //exception in Callable.call();
            e.printStackTrace();
        } finally {
            executorService.shutdown();
        }

        /**
         * 线程池的常用场景
         * 1、如何正确的构造线程池
         * 2、构造一个工作阻塞队列
         * 3、设置拒绝策略
         * 设置
         */
        int poolSize = Runtime.getRuntime().availableProcessors() * 2;
        /**
         * BlockingQueue只是一个接口，有好多实现类
         * 1、ArrayBlockingQueue:底层基于数组实现的阻塞队列
         * 2、LinkedBlockingQueue：底层基于链表实现的阻塞队列
         * 3、LinkedBlockingDeque：底层基于双端链表实现的阻塞队列
         * 4、DelayQueue：延迟队列
         * 5、PriorityBlockingQueue:基于优先队列，底层是堆实现的。
         * 6、SynchronousQueue:同步队列,队列内只存储一个元素。公平模式。
         */
        BlockingQueue<Object> queue = new ArrayBlockingQueue<>(512);
        RejectedExecutionHandler policy = new ThreadPoolExecutor.DiscardPolicy();
//        executorService = new ThreadPoolExecutor(poolSize, poolSize,
//                0, TimeUnit.SECONDS,
//                queue,
//                policy);
        System.out.println(poolSize);
    }

    class ThreadPoolExecutor1 {
        /**
         * 线程池长期维持的线程数，即使没有任务，也不会回收
         */
        int corePoolSize;
        /**
         * 线程数的上限，比如一般是Integer.MAX_VALUE
         */
        int maximumPoolSize;
        /**
         * 超过corePoolSize的线程，会有一个活跃时间，超过这个时间，多余线程会被回收
         */
        long keepAliveTime;
        TimeUnit unit;
        /**
         * 任务的排队队列，也就是排期队列。
         */
        BlockingQueue<Runnable> workQueue;
        /**
         * 创建线程的渠道
         */
        ThreadFactory threadFactory;
        /**
         * 拒绝策略，也就是任务队列也塞满了，新来的任务需要被拒绝。
         */
        RejectedExecutionHandler handler;
    }

6、ThreadLocal

​ 线程本地存储。ThreadLocal的作用是提供线程内的局部变量，这种变量在线程的生命周期内起作用，减少同一个线程内多个函数或者一个公共变量的传递复杂度。

6.1、ThreadLocalMap

  • 每个线程中都有一个自己的ThreadLocalMap类对象，可以将线程自己的对象保持到其中，各管各的，线程可以正确的访问到自己的对象。

  • 将一个公用的ThreadLocal静态实例作为key，将不同对象的引用保存到不同线程的ThreadLocalMap中，然后在线程执行的各处通过这个静态ThreadLocal实例的get()方法取的自己线程保存的对象，避免了将这个对象作为参数传递的麻烦。

  • ThreadLocalMap就是线程里的一个属性，在Thread类定义

    1
    ThreadLocal.ThreadLocalMap threadLocals=null;

  • 最常见的ThreadLocal使用场景，解决数据库连接，Session管理

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    private static final ThreadLocal local=new ThreadLocal();
        public static Session getSession(){
            Session s = (Session) local.get();
            try{
                if(s==null){
                    s= getSession()；
                    local.set(s);
                }
            }catch (HibernateException e){

            }
            return s;
        }

二、Dubbo的知识点

dubbo是一款高性能，轻量级的开源java RPC框架，提供3大核心功能：

  • 面向接口的远程方法调用
  • 智能容错和负载均衡
  • 服务自动注册和发现

dubbo是一个分布式服务框架，用来提供高性能和透明化的RPC远程服务调用方案，以及SOA服务治理。

1、什么是RPC？

RPC：Remote Procedure Call，一个远程过程调用，它是一种通过网络从远程计算机程序上请求服务，而不需要了解底层网络技术的协议。比如说两个不同的服务A，B部署在两台不同的机器上，那么服务A如果想要调用服务B中的某个方法怎么解决？使用HTTP请求当然可以，但是可能会比较慢，而且一些优化做的并不好，RPC的出现就是为了解决这个问题。

RPC的原理：

  • 服务消费方client调用以本地调用方式调用服务
  • client stub接收到调用后负责将方法、参数等组装成能够进行网络传输的消息体。
  • client stub找到服务地址，并将消息发送到服务端
  • server stub收到消息后进行解码
  • server stub根据解码结果调用本地的服务
  • 本地服务执行并结果返回给server stub
  • server stub将返回结果打包成消息并发送到消费方
  • client stub接收到消息，并进行解码
  • 服务消费方得到最终结果。

2、为什么要用dubbo？

dubbo和SOA分布式架构的流行有着关系。SOA面向服务的架构(Service Oriented Architecture)，就是把工程按照业务逻辑拆分成服务层，表现层两个工程。服务层中包含业务逻辑，只需要对外提供服务就行。表现层只需要处理和页面的交互，业务逻辑都是调用服务层的服务来实现。SOA架构中有两个主要角色：服务提供者Provieder和服务使用者Consumer

3、开发分布式及程序，可以直接基于HTTP接口进行通信，但是为什么要使用dubbo？

dubbo的四个特点：

  • 负载均衡：同一个服务部署在不同的机器时该调用哪一台机器上的服务
  • 服务调用链路生成：随着系统的发展，服务越来越多，服务间依赖关系变得错综复杂，甚至分不清哪个应用要在哪个应用之前启动，架构师都不能完整的描述应用的架构关系，dubbo可以为我们解决服务之间是如何互相调用的。
  • 服务访问压力以及时长统计，资源调度和治理：基于访问压力实时管理集群容量，提供集群利用率。
  • 服务降级：某个服务挂掉之后调用备用服务。

dubbo除了用在分布式系统中，也可以应用在微服务系统中，但是由于springboot cloud在微服务中更加广泛，所以一般提dubbo大部分在分布式系统的情况。

4、什么是分布式？

分布式或者说SOA分布式重要的就是面向服务，说简单的分布式就是我们把整个系统拆分成不同的服务然后将这些服务放在不同的服务器上减轻单体服务的压力提高并发量和性能。比如电商系统可以简单拆分成订单系统，商品系统，登录系统等，拆分之后的每个服务可以部署在不同的机器上，如果某一个服务的访问量比较大的话也可以将这个服务同时部署在多台机器上。

5、为什么要分布式？

从开发角度来讲单体应用的代码都集中在一起，而分布式系统的代码根据业务被拆分。所以每个团队可以负责一个服务的开发，这样提升了开发效率。另外，代码根据业务拆分之后更加便于维护和扩展。

另外，将系统拆分成分布式之后不光便于系统扩展和维护，更能提高整个系统的性能。把整个系统拆分成不同的服务、系统，然后每个服务，系统单独部署在一台服务器上，是不是很大成都提升了系统性能。

6、dubbo的架构

  • Provider：暴露服务的服务提供方
  • Consumer：调用远程服务的服务消费方
  • Registry：服务注册与发现的注册中心
  • Monitor：统计服务的调用次数和调用时间的监控中心
  • Container：服务运行容器

6.1、调用关系说明：

  • Container服务容器负责启动，加载，运行服务提供者Provider。

  • 服务提供者Provider在启动的是偶，向注册中心Registry注册自己提供的服务

  • 服务消费者Consumer在启动的时候，向注册中心Registry订阅自己所需要的服务

  • 注册中心Registry返回服务提供者Provider地址列表给消费者Consumer，如果有变更，注册中心Registry将基于长连接keep-alive推送变更数据给消费者Consumer

  • 服务消费者Consumer，从服务提供者Provider地址列表中，基于软负载均衡算法，选一台提供者进行调用，如果调用失败，再选另一台调用。

    • dubbo提供了4中负载均衡算法：
      • 权重随机算法：RandomLoadBalance
      • 最少活跃调用数算法：LeastActiveLoadBalance
      • 一致性哈希算法：ConsistentHashLoadBalance
      • 加权轮询算法：RoundRobinLoadBalance

  • 服务消费者Consumer和服务提供这Provider，在内存中累计调用次数和调用时间，定时每分钟发送一次统计数据到监控中心Monitor。

6.2、总结：

  • 注册中心负责服务地址的注册与查找，相当于目录服务，服务提供者Provider和服务消费者Consumer只在启动的时候与注册中心Registry交互，注册中心不转发请求，压力小。
  • 监控中心Monitor负责统计各个服务调动次数，调用时间等，统计现在内存汇总后每分钟一次发送到监控中心服务器，并以报表的形式显示。
  • 注册中心Registry，服务提供这Provider，服务消费者Consumer三者之间均为长连接Keep-alive，监控中心Monitor除外
  • 注册中心Registry通过长连接感知服务提供者Provider的存在，服务提供者挂了，注册中心立即将推送事件通知消费者Consumer。
  • 注册中心和监控中心全部挂了，不影响已经运行的服务提供者Provider和Consumer，消费者在本地缓存了提供者列表。
  • 注册中心和监控中心都是可选的，服务消费者Consumer可以直接连服务提供者Provider
  • 服务提供者Provider无状态，任意一台挂掉，不影响使用。
  • 服务提供者Provider全部挂了，服务消费者Consumer应用将无法使用，并无限次重连等待服务提供者恢复。

6.3、Zookeeper挂了与dubbo直连的情况

在实际生产中，如果zookeeper注册中心挂了，一段时间内服务消费者Consumer还是能够调用服务提供者Provider服务的，实际上Consumer使用了本地缓存进行通讯，Consumer本地缓存了提供者列表。

dubbo的健壮性:

  • 监控中心挂了不影响使用

展开全文 >>

Hadoop命令

1、文件操作

1
2
3
4
5
6
7
8
9
10
#在HDFS上创建目录
hadoop fs -mkdir <hdfs_path>
#查看文件
hadoop fs -ls <hdfs_path>
#显示文件的大小
hadoop fs -du <hdfs_path>
#只删除文件或者空目录
hadoop fs -rm <hdsf_path>
#递归删除目录，命令rm的递归版本，会递归删除目录下的各级目录以及文件
hadoop fs -rmr <hdfs_path>

2、查看文件内容

1
2
3
4
#显示文件内容
hadoop fs -cat <hdfs_path>
#将文件尾部1KB字节的内容输出到stdout
hadoop fs -tail [-f] URI

3、文件复制

1
2
3
4
5
6
7
8
9
10
11
12
#将文件源路径移动到目标路径
hadoop fs -mv <src1> <src2> <dest>
#将文件从源路径复制到目标路径
hadoop fs -cp <src1> <src2> <dest>       
#将本地文件放置在HDFS上
hadoop fs -copyFromLocal <local_path> <remote_path>     
#将HDFS上的文件复制到本地文件系统中
hadoop fs -copyToLocal <remote_path> <local_path>       
#复制文件到本地文件系统
hadoop fs -get <src> <localdst>    
#从本地文件系统中复制单个或多个源路径到目标文件系统中
hadoop fs -put <localsrc>... <dst>

4、高权限

1
2
3
scp victor@192.168.10.1:/home/victor/py/test.py /usr/opt/script/
#去前1000行记录到新文件
head -1000 basic.dat > test1.dat

展开全文 >>

双指针

算法中的双指针使用

双指针主要用来遍历数组，两个指针指向不同的元素，从而协同完成任务。

1、有序数组的Tow Sum

LeetCode的TowSum

题目描述：有序数组，找出两个数组，让和为target

算法思想：使用双指针，一个指针指向值较小的元素，一个指针指向值较大的元素，指向值较小元素的指针从头向后开始遍历，指向较大的指针从后向前开始遍历。

  • 如果两个指针指向元素的和sum==target，返回结果位置
  • 如果sum>target，则移动较大的指针
  • 如果sum<target，则移动较小的指针
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public int[] twoSum(int[] numbers,int target){
    int i=0,j=numbers.length-1;
    while(i<j){
        int sum=numbers[i]+numbers[j];
        if(sum==target){
            return new int[]{i+1,j+1};
        }else if(sum<target){
            i++;
        }else{
            j--;
        }
    }
    return null;
}

2、两数的平方和

LeetCode

题目描述：判断一个数是否为两个数的平方和

算法思想：还是使用两个指针，一个指针为0，一个指针为和的sqrt

  • 如果两个指针指向元素的和powSum==target，返回结果位置
  • 如果powSum>target，则移动较大的指针
  • 如果powSum<target，则移动较小的指针
1
2
3
4
5
6
7
8
9
10
11
12
13
14
public boolean judgeSquerSum(int target){
    int i=0,j=(int)Math.sqrt(target);
    while(i<=j){//此处有等号，不然target=2的时候，没有等号就返回false
        int sum=i*i+j*j;
        if(sum==target){
            return true;
        }else if(sum<target){
            i++;
        }else{
            j--;
        }
    }
    return false;
}

判断链表是否有环

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
public class Solution {
    public boolean hasCycle(ListNode head) {
        if(head==null){
            return false;
        }
        ListNode slow=head,fast=head;//声明两个临时指针，都指向head
        while(fast!=null&&fast.next!=null){
            slow=slow.next;
            fast=fast.next.next;
            if(slow==fast){
                return true;
            }
        }
        return false;
    }
}

展开全文 >>

Redis的使用

一、简介

Redis是速度非常快的非关系型(NoSQL)内存键值数据库。可以存储键和5种不同类型的值之间的映射。

key的类型只能为字符串，value支持6中类型：String,Hash,List,Set,zset,HyperLogLog

Redis支持很多特性，例如将内存中的数据持久化到硬盘中，使用复制来扩展读性能，使用分片来扩展写性能。

二、数据类型

数据类型 可以存储的值 操作
String 字符串，整数和浮点数 对整个字符串或者字符串的其中一部分执行操作，对整数和浮点数执行自增或者自减操作。
List 列表 从两端压入或者弹出元素，对单个或者多个元素进行修剪，只保留一个范围内的元素。
Set 无序集合 添加，获取，移除单个元素，检查一个元素是否存在于集合中，计算交集，并集，差集，从集合里面随机获取元素，去重。
Hash 包含键值对的无序散列表 添加，获取，移除单个键值对，获取素有键值对，检查某个键是否存在。
Zset 有序集合 添加，获取，删除元素，根据分值范围或者成员来获取元素计算一个键的排名

有点类似公司用的Wtable，每次用col key去获取数据。获取的数据里，有数据的，有字符串的，有对象的。

三、数据结构

1、字典

dictht是一个散列表结构，使用拉链法解决哈希冲突。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
typedef struct dictht{
    dictEntry **table;
    unsigned long size;
    unsigned long sizemask;
    unsigned long used;
}dictht;

typedef struct dictEntry{
    void *key;
    union{
        void *val;
        uint64_t u64;
        double d;
    }v;
    struct dictEntry *next;
}dictEntry;

Redis的字典dict中包含两个哈希表dictht，只是为了方便进行rehash操作。在扩容的时候，将其中一个dictht上的键值对rehash到另一个dictht上面，完成之后释放空间并交换两个dictht的角色。

rehash操作不是一次性完成，而是采用渐进方式，这是为了避免一次性执行过多的rehash操作给服务器带来过大的负担。

渐进式rehash通过记录dict的rehashidx完成，他从0开始，然后每执行一次rehash都会递增。

2、跳跃表

是有序集合的底层实现之一。

跳跃表是基于多指针有序链表实现的，可以看成多个有序链表。

在查找时候，从上层指针开始查找，找到对应的区间之后再到下一层去查找。

与红黑树等平衡树相比，跳跃表具有以下优点：

  • 插入速度非常快，因为不需要进行旋转等操作来维护平衡性。
  • 更容易实现
  • 支持无锁操作。

四、Redis使用场景

1、计数器

可以对String进行自增自减运算，从而实现计数器功能。

Redis这种内存型数据库的读写性能非常高，很适合存储频繁读写的及数量。

2、缓存

将热点数据存放到内存中，设置内存的最大使用量以及淘汰策略来保证缓存的命中率。

3、查找表

例如DNS的记录就很适合使用Redis进行存储。

查找表和缓存类似，也是利用Redis快速的查找特性。但是查找表的内容不能失效，而缓存的内容可以失效，因为缓存不作为可靠地数据来源。

4、消息队列

List是一个双向链表，可以通过lpush和rpop写入和读取消息

不过最好使用kafka，RabbitMQ等消息中间件。

5、Session缓存

可以使用Redis来同一个存储多台应用服务器的Session信息。

当应用服务器不在存储用户的会话信息，也就不再具有状态。一个用户可以请求任意一个应用服务器，从而更容易实现高可用性以及可伸缩性。

6、分布式锁实现

在分布式场景下，无法使用单机环境下的锁来对多个节点上的进程进行同步。

可以使用Redis子代的SETNX命令实现分布式锁，除此之外，还可以使用官方提供的RedLock分布式锁实现。

7、其他

Set可以实现交集，并集等操作，从而实现共同好友等功能 。

Zset可以shixi9an有序性操作，从而实现排行榜等功能。

五、Redis与Memcached

两个都是非关系型内存键值数据库。主要区别如下：

1、数据类型

Memcached只支持string类型，而Redis支持5种不同的数据类型，可更灵活的解决问题。

2、数据持久化

Redis支持3种持久化策略：RDB快照和AOF日志，RDB和AOF混合型，而Memcached不支持持久化。

3、分布式

Memcached不支持分布式，只能通过咋客户端使用一致性哈希来实现分布式存储，这种方式在存储和查询时都需要现在客户端计算一次数据所在的节点。

Redis Cluster实现了分布式的支持。

4、内存管理机制

  • 在Redis中，并不是所有数据都是一直存在内存里，可以将一些很久没用的value交换到磁盘，而Memcached的数据则会一直在内存中。
  • Memcached将内存分割成特定长度的块来存储数据，以完全解决内存碎片的问题，但是这种方式会使得内存的利用率不高。比如块代销为128b，只存储100b的数据，那么剩下的28b就浪费掉了。

六、Redis的key过期时间

Redis可以为每个key设置过期时间，当key过期时，会自动删除该key。

对于散列表这种容器，只能为整个key设置过期时间(整个散列表)，而不能为key里面的单个元素设置过期时间。

七、数据淘汰策略

Redis可以设置内存最大使用量，当内存使用量超出时，会施行数据淘汰策略。

Redis具有6种淘汰策略：

策略 描述
volatile-LRU 当内存使用量超出时，此种策略，从已经设置过期时间的数据集中选出最近最少使用的数据淘汰
volatile-TTL 当内存使用量超出时，此种策略，从已经设置过期时间的数据集中选出将要过期的数据淘汰
volatile-Random 当内存使用量超出时，此种策略，从已经设置过期时间的数据中任意选择数据淘汰
allkeys-LRU 当内存使用量超出时，此种策略，从所有数据中挑选最近最少使用的数据淘汰。
allkeys-Random 当内存使用量超出时，此种策略，从所有数据中选任意数据进行淘汰
noeviction 禁止驱逐数据

作为内存数据库，处于对性能和内存消耗的考虑，Redis的淘汰算法实际实现上并非针对素有key，而是抽样一小部分并且从中选出被淘汰的key。

使用Redis缓存数据时，为了提高缓存命中率，需要保证缓存数据都是热点数据。可以将内存最大使用量设置为热点数据占用的内存量，然后启用allkeys-LRU淘汰策略，将最近最少使用的数据淘汰。

Redis4.0引入了volatile-LFU,allkeys-LFU淘汰策略，LFU策略通过统计访问频率，将访问频率最少的键值对淘汰。

八、持久化

Redis是内存型数据库，为了保证数据在断电后不会丢失，需要将内存中的数据持久化到硬盘上。

1、RDB持久化

  • 将某个时间点的所有数据都存到硬盘上
  • 可以将快照复制到其他服务器从而创建具有相同数据的服务器副本。
  • 如果系统发生故障，将会丢失最后一次创建快照之后的数据。
  • 如果数据量很大，保存快照的时间会很长。

2、AOF持久化

将写命令添加到AOF文件(Append Only File)的末尾。

使用AOF持久化需要设置同步选项，从而确保写命令同步到磁盘文件上的时机。这是因为对文件进行写入并不会马上将内容同步到磁盘上，而是先存储到缓冲区，然后由操作系统决定什么时候同步到磁盘。有以下同步选项：

选项 同步频率
always 每个写命令都同步
everysec 每秒同步一次
no 让操作系统决定何时同步
  • always选项会严重降低服务器的性能。
  • everysec选项比较合适，可以保证系统崩溃时只会丢失一秒左右的数据，并且Redis每秒执行一次同步对服务器性能几乎没有任何影响。
  • no选项并不能给服务器性能带来多大的提升，而且也会增加系统崩溃时数据丢失的数量。

随着服务器写请求的增多，AOF文件也会越来越大。Redis提供了一种将AOF重写特性，能够去除AOF文件中的冗余写命令。

九、事务

一个事务包含了多个命令，服务器在执行事务期间，不会改去执行其他客户端的命令请求。也就是事务的ACID。

事务中的多个命令被一次性发给服务器，而不是一条一条的发送，这种方式叫流水线，它可以减少客户端和服务器之间的网络通信次数从而提升性能。

Redis最简单的事务实现方式是使用MULTI和EXEC命令来将事务操作包围起来。

十、事件

Redis服务器是一个事件驱动程序。

1、文件事件

展开全文 >>

Java编码规范

一、Java编码规范

1、命名风格

  1. 代码中的命名不能以_，$开始和结束

  2. 代码中的命名严禁使用拼音与英文混合，不允许使用中文的方式

  3. 常量命名全部大写，单词之间下划线隔开。

  4. POJO类中布尔类型，都不要加is，否则框架解析出现序列化错误。

  5. 对于Service和DAO类，基于SOA理念，暴露出服务一定是接口。

    内部的实现类用Impl。比如CacheServiceImpl是CacheService接口。

  6. 枚举类名要加上Enum后缀，枚举成员名称要全部大写，单词之间有下划线隔开。

    1
    2
    3
    public enum DealStatusEnum{
        SUCCESS,UNKOWN_REASON
    }

  7. 如果用到了设计模式，建议在类名中体现出具体设计模式

    1
    public class LoginProxy

2、代码风格

  1. 左右小括号和字符之间不能有空格

  2. 单行字符数限制不超过120个，超出需要换行。

    1
    2
    3
    sb.append("zi").append("xin")
        .append("victor")
        .append("victor")

  3. 方法体内的执行语句组、变量的定义语句组、不同的业务逻辑之前或者不同的语义之间插入一个空行。

    相同的业务逻辑和语义之间不需要插入一个空行

  4. if/for/while/switch/do等括号之间必须加空格

  5. 方法参数在定义和传入时，多个参数逗号后边必须加空格

    1
    method("a", "b", "c");

3、OOP规范

  1. 所有的重写方法，必须加上@Override注解；注：是为了让编译器帮你发现错误

  2. 相同参数类型，相同业务含义，才可以使用java的可变参数，避免使用Object可变参数。

  3. Object的equals方法容易抛出空指针异常，应使用常量或者确定有值得对象来调用equals

    1
    "test".equals(object);

  4. 所有的POJO类属性必须使用包装数据类型；RPC方法的返回值和参数必须使用包装数据类型

    注意：为了避免在POJO转换过程中失败。

  5. 定义DO/DTO/VO等POJO类时，不要设定任何属性默认值。

    注意：因为POJO原则转换过程中避免失败。

  6. 类内方法定义顺序依次是：public方法/protected方法>>private方法>>getter/setter方法

    注意：把最关注的方法放在前面

  7. getter/setter方法中，不要增加业务逻辑，增加排查问题的难度

  8. 慎用Object的clone方法来拷贝对象，深度复制需要自己实现。

  9. 循环体内，字符串的连接方式，使用StringBuilder的append方法进行扩展

  10. 拒绝巨型方法，把方法拆解到尽可能符合单一责任原则的粒度，方便维护及复用。

4、集合处理

  1. 只要重写equals，就必须重写hashCode()，Set，Map对象作为键的情况小重写hashCode,equals
  2. ArrayList的subList结果不可强转成ArrayList，否则会抛出ClassCastException强制类型转换异常。
  3. 使用工具类Arrays.asList()把数组转换为集合时，不能使用其修改集合相关的方法，它的add/remove/clear方法会抛出UnsupportedOperationException异常。

展开全文 >>

Spring Bean生命周期

一、Spring Bean生命周期

1、实例化

  • 实例化一个Bean，也就是我们常说的new

2、IOC依赖注入

  • 按照ApplicationContext上下文对实例化的Bean进行配置，也就是IOC注入

3、setBeanName实现

  • 如果这个Bean已经实现了BeanNameAware接口，会调用它实现的setBeanName(String id)方法，传递的就是Spring配置文件中的Bean的id值

4、BeanFactoryAware实现

  • 如果这个Bean已经实现了BeanFactoryAware接口，会调用它实现的setBeanFactory(BeanFactory)传递的是Spring工厂自身。可以用这个方式来获取其他Bean只需要在Spring配置文件中配置一个普通的Bean就可以。

5、ApplicationContextAware实现

  • 如果这个Bean已经实现了ApplicationContextAware接口，会调用setApplicationContext(ApplicationContext)方法，传入Spring上下文。比步骤4更好点，因为ApplicationContext是BeanFactory的子接口，有更多的实现方法。

6、postProcessBeforeInitialization接口实现-初始化预处理

  • 如果这个Bean关联了BeanPostProcessor接口，将会调用postProcessBeforeInitialization(Object obj,String s)方法，BeanPostProcessor经常被用来是Bean内容的更改，并且由于这个是在Bean初始化结束时调用的方法，可以被应用在内存或者缓存技术

7、init-method

  • 如果Bean在Spring配置文件中配置了init-method属性会自动调用其配置的初始化方法。对应的注解是@PostConstruct

8、postProcessAfterInitialization

  • 如果这个Bean关联了BeanPostProcessor接口，将会调用postProcessAfterInitialization(Object obj,String s)方法。以上工作完成以后，就可以应用这个Bean了，那这个Bean是一个Singleton单例的，所以一般情况下我们调用同一个id的Bean会是在内容地址相同的实例，当然可以在Spring配置文件中Bean的作用范围为ProtoType，GlobalSession等非Singleton。

9、Destroy过期自动清理阶段

  • 当Bean不在需要的时候，会经过清理阶段，如果Bean实现了DisposableBean这个接口，会调用destroy()方法。

10、destroy-method自配置清理

  • 如果这个Bean的Spring配置中配置了destroy-method属性，会自动调用它配置的销毁方法。对应的注解是@PreDestroy

11、总结

bean的配置文件中，bean标签有2个重要属性

1
<bean id="person" class="com.bean.Person" init-method="init" destroy-method="destroy"/>

  • init-method

    对应的注解为@PostConstruct

  • destroy-method

    对应的注解为@PreDestroy

二、Spring依赖注入4种方式

1、构造方法注入

1
2
3
public PersonServiceImpl(String name){
    this.name=name;
}
1
2
3
<bean id="personServiceImpl" class="com.service.impl.PersonServiceImpl">
	<constructor-arg value="name"></constructor-arg>
</bean>

2、setter方法注入

1
2
3
4
5
6
7
8
9
public class Person{
    private String name;
    public String getName(){
        return name;
    }
    public void setName(String name){
        this.name=name;
    }
}
1
2
3
<bean id="person" class="com.bean.Person">
	<property name="name" value="tom"></property>
</bean>

3、静态工厂注入

静态工厂，就是通过静态工厂的方法来获取自己需要的对象，为了让Spring管理所有对象，我们不能直接通过”类.静态方法()”的方式来获取对象，仍然是通过Spring注入的形式获取

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
//静态工厂
public class ServiceFactory{
    public static final PersonService getStaticServieFactoryImpl(){
        return new StaticFactoryServiceImpl();
    }
}

public class PersonController{
    //注入的对象
    private PersonService staticFactory;
    //注入对象的set方法
    public void setStaticFactoryService(ServiceFactory factory){
        this.staticFactory=factory;
    }
}
1
2
3
4
5
6
<bean name="personController" class="com.controller.PersonController">
    <!--使用静态工厂的方法注入对象，对应下面的配置文件-->
	<property name="staticFactory" ref="factory"></property>
</bean>
<!--用来获取对象的方式，从工厂类中获取静态方法,factory-method用来指定调用哪个工厂方法-->
<bean name="factory" class="com.service.ServiceFactory" factory-method="getStaticServiceFactoryImpl"></bean>

4、实例工厂

实例工厂就是获取对象的方法不是静态的，需要先new工厂类。再调用普通实例的方法

1
2
3
4
5
6
7
8
9
10
11
12
public class FactoryService{
    public FactoryDao getFactoryDaoImpl(){
        return new FactoryDaoImpl();
    }
}

public class PersonController{
    private FactoryDao factoryDao;
    public void setFactoryDao(FactoryDao dao){
        this.factoryDao=dao;
    }
}
1
2
3
4
5
6
<bean nam="personController" class="com.controller.PersonController">
    <!--使用实例工厂的方法注入对象，对应配置如下-->
	<property name="factoryDao" ref="factoryDao"></property>
</bean>
<!--获取对象的方式从工厂类中获取实例方法-->
<bean name="daoFactory" factory-bean="daoFactory" factory-method="getFactoryDaoImpl"></bean>

三、@Order注解使用

  • 使用@Order控制配置类的加载顺序

  • SpringBoot加载Bean的时候，有用到@Order注解

  • 通过@Order指定执行顺序，值越小，越先执行。

  • @Order注解常用来定义的AOP先于事务执行。

  • 如果@Order不标注数字，默认最低优先级，因为其默认值是int最大值。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
@Configuration
@Component("xxxConfig")
@Order(Ordered.HIGHEST_PRECEDENCE)
public class XXXConfig {

    @Value("${xxx.key.path}")
    private String xxxKey;

    @Value("${xxx.config.path}")
    private String xxxConfig;

    @PostConstruct
    public void init() {
        try {
            File file = ResourceUtils.getFile(xxxKey);
            xxxKey = file.getAbsolutePath();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
        .............
    }

}

展开全文 >>

Java的常识总结

一、Java的常识总结

1、final、finally、finalize的区别

  • final：修饰类、方法、变量

    • 修饰类：类不能被其他类继承
    • 修饰方法：方法锁定，防止其他继承类进行更改
    • 修饰变量：表示为常量，只能被赋值一次，不能更改，而且必须要初始化。

  • finally：只有与finally对应的try语句块得到执行的情况下，finally语句块才能执行。如果在执行try之前，方法发生异常，则finally不会执行。

  • finalize：是java.lang.Object定义的，每一个方法都有finalize方法

    方法是在gc启动的时候，被调用。凡是new出来的对象，gc都能搞定，一般情况下我们又不会用new以外的方式去创建对象，所以一般是不需要程序员去实现finalize。

2、HashMap与Hashtable

  • 线程是否安全：HashMap非线程安全，Hashtable线程安全。Hashtable的方法内部都是由synchronized修饰。保证线程安全建议使用ConcurrentHashMap
  • HashMap可以用null作为一个key键，但是只有一个，value为null可以有一个或者多个。Hashtable如果put进去的key为null就会报空指针。
  • HashMap默认的初始化为16，每次扩容会变为原来的2倍。JDK1.8以后的HashMap解决哈希冲突的时候，链表的长度默认值为8，如果超过8的时候，链表会转化为红黑树，用来减少搜索时间。

3、HashMap和HashSet

​ HashSet底层是基于HashMap实现。

HashMap HashSet
实现Map接口 实现Set接口
存key-value 存Object
调用put()添加 调用add()添加

HashSet检查重复：当add的时候，HashSet会先计算对象的hashcode值来判断对象加入的位置。

也即是先判断hashcode值，如果hashcode相同，则调用equals()方法，如果为true，则相同,HashsSet就不会加入操作成功。

  • HashMap多线程操作导致死循环问题，因为多线程并发情况下Rehash会造成元素之间形成一个循环链表。

4、ConcurrentHashMap

JDK1.8的ConcurrentHashMap取消了Segment分段锁，采用CAS和synchronized来保证并发安全。数据结构和1.8的HashMap类似，数组+链表/红黑二叉树。

当链表长度超过8，链表（查找复杂度O(N)）将转换为红黑树（查找复杂度O(longN)）

synchronized只锁定当前链表或者红黑二叉树的首节点，这样只要hash不冲突，就不会产生并发，效率又提升了N倍。

5、线程

线程是一个比进程更小的执行单位，一个进程在其执行的过程中可以产生多个线程。

与进程不同的是，类的多个线程共享进程的堆Heap和方法区Method Area资源。

每个线程都有自己的程序计数器PC，虚拟机栈Stack，本地方法栈Native Method Stack。

一个进程中可以有多个线程，多个线程共享进程的堆和方法区（JDK1.8以后的没有方法区，从JVM移到本地成为元空间MetaSpace）

  • 程序计数器PC：字节码解释器通过改变程序计数器来读取指令，主要是为了线程切换后能恢复到正确的执行位置。

  • 虚拟机栈和本地方法栈

    • 虚拟机栈：每个java方法在执行的同时会创建一个栈帧用来存储局部变量表，操作数栈，常量池引用的信息。
    • 本地方法栈：虚拟机栈是为Java方法也就是字节码服务，本地方法栈为虚拟机用到的Native方法服务。

  • 堆和方法区

    是所有线程共享的资源，堆是进程中最大的一块内存，主要用来存放新创建的对象，所有对象都在这里分配内存，用来存放新创建的对象。

    方法区：用来存放已被加载的类信息，常量，静态变量。

6、sleep()方法和wait()方法

wait()方法是java.lang.Object里的方法，用来线程间交互/通信

sleep()是thread的方法。sleep方法没有释放锁，wait会释放锁，导致其他进程占用锁。

wait()方法被调用后，线程不会自动苏醒，需要别的线程调用同一个对象上的notify()或者notifyAll()方法。

sleep()方法执行完后，线程会自动苏醒。

7、start()方法和run()方法

Thread thread=new Thread();线程就进入了新建装填，调用了start()方法，就会启动一个线程进入就绪状态。当分配到时间片就可以运行了。

start()：执行线程相应的准备工作，然后自动执行run()方法的内容。

直接执行run()，会把run()方法当成一个main主线程的普通方法去执行，并不会再某个线程中执行它。

run方法只是thread的一个普通方法调用，还是在主线程里执行。

8、synchronized关键字

synchronized关键字可以保证被修饰的方法、代码块在任何时刻都只有一个线程执行。

JDK1.6之前，synchronized属于重量锁，因为使用监视器monitor，它是依赖于操作系统Mutex lock。需要进行线程切换从用户态到和心态。

JDK1.6之后，引入了锁优化，自选锁，锁消除，锁粗化，偏向锁。等减少了锁操作的开销。

9、synchronized和ReentrantLock

都是可重入锁：自己可以再次获取自己的内部锁，比如一个线程获得了某个对象的锁，此时这个对象锁还没有释放，当再次想要获取这个对象的锁还是可以获取的，如果不可重入，就会死锁。

ReentrantLock是JDK层面实现的，需要用lock()和unlock()方法配合try/finally语句块。

ReentrantLock增加的高级功能：

  • 等待可中断：lock.lockInterruptibly();

  • 可实现公平锁：ReentrantLock(boolean fair)://值为true，则为公平锁。

  • 可实现选择性通知：需要借助Condition接口和newCondition()，来实现线程通信

    和wait()与notify()/notifyAll()原理类似。而Condition的singnalAll()方法会唤醒所有线程。

10、volatile关键字

Java的内存模型总是从主存（共享内存）读取变量，保证内存可见性CAS。

防止指令重排序。

二、HTTP请求头

http请求头，http客户程序（浏览器），向服务器发送请求的时候必须指明请求类型（GET或者POST），如果必要还可以选择发送其他的请求头。

  • Accept：浏览器可以接受的MIME类型
  • Accept-Charset：浏览器可接受的字符集
  • Accept-Encoding：浏览器能够进行解码的数据编码方式，比如gzip。Servlet能够向支持gzip的浏览器返回经过gzip编码的HTML页面，许多情形下可以减少5到10倍的下载时间
  • Accept-Language：浏览器所希望的语言种类，当服务器能够提供一种以上的语言版本时使用。
  • Authorization：授权信息，通常出现在服务器发送的token中
  • Connection：表示是否需要持久连接，如果Servlet看到这里的值为Keep-Alive，或者请求使用的是Http1.1（默认为持久连接）
  • Cookie：最重要的请求头信息之一
  • Host：初始URL中的主机和端口
  • Referer：包含一个URL，用户从该URL代表的页面出发访问当前请求的页面
  • User-Agent：浏览器类型，如果Servlet返回的内容与浏览器类型有关则该值非常有用。

展开全文 >>

AOP的使用

一、实际开发中AOP的使用

背景，为了打印controller的接口信息，以及传参等到log日志文件，方便后期查找问题。

1、首先定义一个注解类Log

首先在项目的结构下，创建一个package叫做annotation包

然后新建一个注解类@interface,在IDEA中的new->class中选Annotation项目

1
2
3
4
5
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Log {
    String value() default "";
}

2、指定@Log注解使用的切面

在项目的结构下，新建一个package叫做aop

然后新建一个类LogAspect

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
/**
 * @Description:日志切面
 * @Author: VictorDan
 * @Date: 19-7-30 上午10:07
 * @Version: 1.0
 */
@Component
@Aspect
public class LogAspect {
    public final static Logger logger = LoggerFactory.getLogger(LogAspect.class);

    /**
     * controller层切点
     */
    @Pointcut("@annotation(com.anjuke.ai.annotation.Log)")
    public void controllerAspect(){

    }

    /**
     * 前置通知，用于拦截controller层记录用户的操作
     * @param joinPoint 切点
     * @throws ClassNotFoundException
     */
    @Before("controllerAspect()")
    public void before(JoinPoint joinPoint) throws Exception {
        HttpServletRequest request = ((ServletRequestAttributes) RequestContextHolder.getRequestAttributes()).getRequest();
        logger.info("请求IP：{}",request.getRemoteAddr());
        logger.info("请求路径：{}",request.getRequestURL());
        logger.info("请求方式：{}",request.getMethod());
        logger.info("方法描述：{}",getMethodDescription(joinPoint));
    }

    /**
     * 环绕通知，用于方法执行结束，返回值的打印
     * @param joinPoint
     * @return
     * @throws Throwable
     */
    @Around("controllerAspect()")
    public Object around(ProceedingJoinPoint joinPoint) throws Throwable {
        long startTime=System.currentTimeMillis();
        Object[] args = joinPoint.getArgs();
        Object proceed = joinPoint.proceed(args);
        String result = "null";
        if (proceed != null) {
            result = proceed.toString();
            if (result.length() > 90) {
                result = result.substring(0, 90);
            }
        }
        long endTime=System.currentTimeMillis();
        logger.info("执行时间：{}ms",endTime-startTime);
        logger.info("返回值：{}\n\t", result);
        return proceed;
    }

    /**
     * 异常通知，用来拦截controller层的异常日志
     * @param ex
     */
    @AfterThrowing(throwing = "ex",pointcut = "controllerAspect()")
    public void afterThrowing(Throwable ex){
        logger.error("发生异常：{}",ex.toString());
    }

    /**
     * 获取注解中对方法的描述信息
     * @param point 切点
     * @return 方法描述
     * @throws ClassNotFoundException
     */
    private String getMethodDescription(JoinPoint point) throws ClassNotFoundException {
        String targetName = point.getTarget().getClass().getName();
        String methodName = point.getSignature().getName();
        Object[] args = point.getArgs();
        Class<?> targetClass = Class.forName(targetName);
        Method[] methods = targetClass.getMethods();

        String description="";
        for (Method method:methods) {
            if(method.getName().equals(methodName)){
                Class<?>[] clazz = method.getParameterTypes();
                if(clazz.length==args.length){
                    description=method.getAnnotation(Log.class).value();
                    break;
                }
            }
        }
        return description;
    }

    /**
     * @RequestBody的数据，只能通过流来读取，而controller读取过request的数据，流就会关闭，所以log打印不出。
     * @param httpServletRequest
     * @return
     */
    private String getRequestData(HttpServletRequest httpServletRequest){
        HttpServletRequestWrapper httpServletRequestWrapper = new HttpServletRequestWrapper(httpServletRequest);
        StringBuilder sb = new StringBuilder();
        BufferedReader reader = null;
        InputStreamReader inputStreamReader=null;
        ServletInputStream servletInputStream =null;
        try {
            servletInputStream =  httpServletRequestWrapper.getInputStream();
            inputStreamReader=new InputStreamReader (servletInputStream, Charset.forName("UTF-8"));
            reader = new BufferedReader(inputStreamReader);
            String line = "";
            while ((line = reader.readLine()) != null) {
                sb.append(line);
            }
        } catch (IOException e) {
            logger.error("IO异常：{}",e.getMessage());
        }finally {
            try {
                if(servletInputStream!=null){
                    servletInputStream.close();
                }
                if(inputStreamReader!=null){
                    inputStreamReader.close();
                }
                if(reader!=null){
                    reader.close();
                }
            } catch (IOException e) {
                logger.error("IO异常：{}",e.getMessage());
            }
        }
        return sb.toString ();
    }
}

3、在Controller中方法的注解使用就行

1
2
3
4
5
6
7
8
9
10
11
@PostMapping("/key-data")
    @Log(value = "关键数据")
    public ResponseEntity<Map<String, Object>> getKeyDataDaily(@RequestBody KeyDataDailyRequest request) {
        BrokerUserSession brokerUserSession = getBrokerUserSession();
        Long brokerId = brokerUserSession.getUserId();
        request.setBrokerId(brokerId);
        Map<String, Object> data = service.getKeyDataDaily(request);
        boolean flag = service.isThirtyDailyPmPropZero(request);
        data.put("isZero",flag);
        return resultOK(data);
    }

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia-plus根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

主要涉及技术：
Java后端开发、Hadoop、Spark、微服务、TensorFlow
AI、公众号开发、开源爱好者、Linux
大数据、DevOps、分布式中间件