前端开发经常遇到一个词：路由，在Android APP开发中，路由还经常和组件化开发强关联在一起，那么到底什么是路由，一个路由框架到底应该具备什么功能，实现原理是什么样的？路由是否是APP的强需求呢？与组件化到底什么关系，本文就简单分析下如上几个问题。

路由（routing）就是通过互联的网络把信息从源地址传输到目的地址的活动。路由发生在OSI网络参考模型中的第三层即网络层。

import com.snail.activityforresultexample.test.SecondActivity;



public class MainActivity extends AppCompatActivity {



    void jumpSecondActivityUseClassName(){

    

        Intent intent =new Intent(MainActivity.this, SecondActivity.class);

        startActivity(intent);

    }

    

void jumpSecondActivityUseFilter() {

    Intent intent = new Intent();

    intent.setAction("com.snail.activityforresultexample.SecondActivity");

    startActivity(intent);

}

	@Route(path = "/test/activity2")

	public class Test2Activity extends AppCompatActivity {

		 ...

	}

        ARouter.getInstance()

                .build("/test/activity2")

                .navigation(this);

@Target({ElementType.TYPE})

@Retention(RetentionPolicy.CLASS)

public @interface Route {



    /**

     * Path of route

     */

    String path();

@Route(path = "/test/activity1", name = "测试用 Activity")

public class Test1Activity extends BaseActivity {

    @Autowired

    int age = 10;

@Override

public boolean process(Set annotations, RoundEnvironment roundEnv) {

    if (CollectionUtils.isNotEmpty(annotations)) {

    

        Set routeElements = roundEnv.getElementsAnnotatedWith(Route.class);

        

            this.parseRoutes(routeElements);

       ...

    return false;

}

 

 

private void parseRoutes(Set routeElements) throws IOException {

						...

                     // Generate groups

            String groupFileName = NAME_OF_GROUP + groupName;

            JavaFile.builder(PACKAGE_OF_GENERATE_FILE,

                    TypeSpec.classBuilder(groupFileName)

                            .addJavadoc(WARNING_TIPS)

                            .addSuperinterface(ClassName.get(type_IRouteGroup))

                            .addModifiers(PUBLIC)

                            .addMethod(loadIntoMethodOfGroupBuilder.build())

                            .build()

            ).build().writeTo(mFiler);

	public class RouterInitializer {

	

	    public static void init(boolean debug, Class webActivityClass, IRouterInterceptor... interceptors) {

	        ...

	        loadRouterTables();

	    }

		//自动注册代码    

	    public static void loadRouterTables() {

	    

	    }

}

 public static void loadRouterTables() {

 

    

    register("com.alibaba.android.arouter.routes.ARouter$$Root$$modulejava");

    register("com.alibaba.android.arouter.routes.ARouter$$Root$$modulekotlin");

    register("com.alibaba.android.arouter.routes.ARouter$$Root$$arouterapi");

    register("com.alibaba.android.arouter.routes.ARouter$$Interceptors$$modulejava");

    ...

}

public interface HelloService extends IProvider {

    void sayHello(String name);

}

@Route(path = "/yourservicegroupname/hello")

public class HelloServiceImpl implements HelloService {

    Context mContext;



    @Override

    public void sayHello(String name) {

        Toast.makeText(mContext, "Hello " + name, Toast.LENGTH_SHORT).show();

    }

  ((HelloService) ARouter.getInstance().build("/yourservicegroupname/hello").navigation()).sayHello("mike");

	public class HelloService {

		

		

    	@MethodRouter(url = {"arouter://sayhello"})

 	    public void sayHello(String name) {

	        Toast.makeText(mContext, "Hello " + name, Toast.LENGTH_SHORT).show();

	    }

 RouterCall.callMethod("arouter://sayhello?name=hello");

一、前言

    Room 是 Android Jetpack 的一部分。在 Android 中数据库是SQLite数据库，Room 就是在SQLite上面提供了一个抽象层，通过 Room 既能流畅地访问数据库，又能充分展示 SQLite 数据库的强大功能。Room 主要有以下几大优点：

• 在编译时校验 SQL 语句；


• 易用的注解减少重复和易错的模板代码；


• 简化的数据库迁移路径。

    正是 Room 有以上的优点，所以建议使用 Room 访问数据库。

二、Room 主要组件

    Room 主要组件有三个：

• 数据库类（RoomDatabase）：拥有数据库，并作为应用底层持久性数据的主要访问接入点。


• 数据实体类（Entity）：表示应用数据库中的表。


• 数据访问对象（DAO）：提供方法使得应用能够在数据库中查询、更新、插入以及删除数据。

    应用从数据库类获取一个与之相关联的数据访问对象（DAO）。应用可以通过这个数据访问对象（DAO）在数据库中检索数据，并以相关联的数据实体对象呈现结果；应用也可以使用对的数据实体类对象，更新数据库对应表中的行（或者插入新行）。应用对数据库的操作完全通过 Room 这个抽象层实现，无需直接操作 SQLite数据库。下图就是 Room 各个组件之间的关系图：

三、Room 基础入门

    大致了解了 Room 的工作原理之后，下面我们就来介绍一下 Room 的使用入门。

3.1 引入 Room 库到项目

引入 Room 库到项目，在项目程序模块下的 build.gradle 文件的 dependencies

// Kotlin 开发环境，需要引入 kotlin-kapt 插件

apply plugin: 'kotlin-kapt'



// .........



dependencies {

    // other dependecies 



    def room_version = "2.3.0"

    implementation("androidx.room:room-runtime:$room_version")

    // 使用 Kotlin 注解处理工具（kapt，如果项目使用Kotlin语言开发，这个必须引入，并且需要引入 kotlin-kapt 插件

    kapt("androidx.room:room-compiler:$room_version")

    // To use Kotlin Symbolic Processing (KSP)

    // ksp("androidx.room:room-compiler:$room_version")



    // 可选 - 为 Room 添加 Kotlin 扩展和协程支持

    implementation("androidx.room:room-ktx:$room_version")



    // 可选 - 为 Room 添加 RxJava2 支持

    implementation "androidx.room:room-rxjava2:$room_version"



    // 可选 - 为 Room 添加 RxJava3 支持

    implementation "androidx.room:room-rxjava3:$room_version"



    // optional - Guava support for Room, including Optional and ListenableFuture

    implementation "androidx.room:room-guava:$room_version"



    // optional - Test helpers

    testImplementation("androidx.room:room-testing:$room_version")

}

注意事项：如果项目是用 kotlin 语言开发，一定要引入 kotlin 注解处理工具，并且在 build.gradle 中添加 kitlin-kapt插件（apply plugin: 'kotlin-kapt'），否则应用运行会抛出 xx.AppDatabase. AppDatabase_Impl does not exist 异常。

3.2 Room 使用示例

    使用 Room 访问数据库，需要首先定义 Room 的三个组件，然后通过数据访问对象实例访问数据。

3.2.1 定义数据实体类

    数据实体类对应数据库中的表，实体类的字段对应表中的列。定义 Room 数据实体类，使用 data class 关键字，并使用 @Entity 注解标注。更多关于数据实体类相关注解（包括属性相关注解），请参考： Android Room 数据实体类详解。如下代码所示：

@Entity

class User(@PrimaryKey val uid: Int, @ColumnInfo() val name: String, @ColumnInfo val age: Int)

注意事项：默认情况下，Room 会根据实体类的类为表名（在数据库中表名其实不区分大小写），开发者也可以在 @Entity 注解通过 tableName 参数指定表名。

3.3.2 定义数据访问对象（DAO）

    数据访问对象是访问数据库的桥梁，通过 DAO 访问数据，查询或者更新数据库中的数据（数据实体类是媒介）。数据访问对象（DAO）是一个接口，定义时添加 @Dao 注解标注，接口中的每一个成员方法表示一个操作，成员方法使用注解标示操作类型。更多关于数据访问对象（DAO）和数据操作类型注解，请参考：Android Room 数据访问对象详解。以下是简单的 DAO 示例代码：

@Dao

interface UserDao {

    @Query("SELECT * FROM user")

    fun getAll(): List<User>



    @Query("SELECT * FROM user WHERE name LIKE :name")

    fun findByName(name: String): List<User>



    @Insert

    fun insertAll(vararg users: User)



    @Delete

    fun delete(user: User)

}

注意事项：
1. 数据访问对象是接口类型，成员方法是没有方法体的，成员方法必须使用注解标示操作类型；
2. 数据库实体类成员方法中的 SQL 语句，在编译是会检查语法是否正确。

3.3.3 定义数据库类

    数据库是存储数据的地方，使用 Room 定义数据库时，声明一个抽象类（abstract class），并用 @Database 注解标示，在 @Database 注解中使用 entities 参数指定数据库关联的数据实体类列表，使用 version 参数指定数据的版本。数据库类中包含获取数据访问实体类对象的抽象方法，更多关于数据库相关内容，请参考：Android Room 数据库详解，以下是简单的数据类定义。

@Database(entities = [User::class], version = 1)

abstract class AppDatabase: RoomDatabase() {

    abstract fun userDao(): UserDao

}

注意事项：
1. 数据库类是一个抽象类，他的成员方法是抽象方法；
2. 定义数据库类时必须指定关联的数据实体类列表，这样数据库类才知道需要创建那些表；
3. 数据的版本号，如果数据库的表构造有变动时，需要升级版本号，这样数据库才会更新表结构（如修改表字段、新增表等，跟直接使用 SQLite 接口使用 SQLiteDatabase 类一样），但是数据库的升级并不是修改版本号那么简单，还需要处理数据库升级过程中需要修改的地方，更多详情请参考：Android Room 数据库升级。

3.3.4 创建数据库实例

    定义好数据实体类、数据访问对象（DAO）和数据类之后，便可以创建数据库实例。使用 Room.databaseBuilder().build() 创建一个数据库实体类，Room 会根据定义的数据实体类、数据库访问对象和数据库类，以及他们定义时指定的对应关系，自动创建数据库和对应的表关系。如以下示例代码所示：

val db = Room.databaseBuilder(applicationContext, AppDatabase::class.java, "app_db").build()

注意事项：
1. 每一个 RoomDatabase 实例都是非常耗费资源的，如果你的应用是单个进程中运行，那么在实例 RoomDatabase 时请遵循单例设计模式，在单个进程中几乎不需要访问多个 RoomDatabase 实例。
2. 如果你的应用在多个进程中运行（比如：远程服务（RemoteService）），在构建 RoomDatabase 的构建器中调用 Room.databaseBuilder().enableMultiInstanceInvalidation() 方法，这样一来，在每个进程中都有一个 RoomDatabase 实例，如果在某个进程中将共享的数据库文件失效，将会自动将这个失效自动同步给其他进程中的 RoomDatabase 实例。

3.3.5 从数据库实例中获取数据访问对象（DAO）实例

    在定义数据库类时，将数据访问对象（DAO）类与之相关联，定义抽象方法返回对应的数据库访问对象（DAO）实例。在数据库实例化过程中，Room 会自动生成对应的数据访问对象（DAO），只需要调用定义数据库类时定义的抽象方法，即可获取对应的数据访问对象（DAO）实例。如下示例所示：

val userDao = db.userDao()

3.3.6 通过数据访问对象（DAO）实例操作数据库

    获取到数据访问对象（DAO）实例，就可以调用数据库访问对象（DAO）类中定义的方法操作数据库了。如下示例所示：

Thread {

    // 插入数据

    userDao.insertAll(

        User(1, "Student1", 18), 

        User(2, "Student2", 18),

        User(3, "Student3", 17), 

        User(4, "Student4", 19)

    )



    // 查询数据

    val result = userDao.getAll()



    result.forEach {

        println("Student: id = ${it.uid}, name = ${it.name}, age = ${it.age}")

    }

}.start()

注意事项：
1. 使用数据访问对象（DAO）实例操作数据库时，不能再 UI 主线程中调用 DAO 接口，否则会抛出异常（java.lang.IllegalStateException: Cannot access database on the main thread since it may potentially lock the UI for a long period of time.）

四、编后语

    Room 是非常强大易用的，可以减少数据库操作过程中的出错，因为所有的 SQL 语句都在编译是进行检查，如果存在错误，将会在编译时就显示错误信息。不仅如此，Room 还非常优秀地处理了多进程很多线程访问数据库的问题。

————————————————
版权声明：本文为CSDN博主「精装机械师」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/yingaizhu/article/details/117514630

Android数据库—SQLite

• 不适合存储大规模数据


• 用来存储每一个用户各自的信息

在线查看数据库方法

Android Studio查看SQLite数据库方法大全

从前我使用的是stetho方法来查看数据库，因为是外国网站，所以需要翻墙，比较麻烦。

如今最新版的Android Studio可以直接在里面查看数据库，无需别的了。

• stetho使用

  
  
  
  
  • 在build.gradle文件中引入依赖
  
  

    implementation 'com.facebook.stetho:stetho:1.5.1'
  
  

  
  
  
  
  • 在需要操作数据库的Activity中加入以下语句
  
  

  Stetho.initializeWithDefaults(this);
  
  

  
  
  
  
  • 谷歌调试
  
  

继承SQLiteOpenHelper的类，加载驱动

继承SQLiteOpenHelper类，实现三个方法。

• 构造函数


• 建表方法：onCreate方法


• 更新表方法：onUpgrade方法

• MySQLiteOpenHelper

package com.hnucm.androiddatabase;



import android.content.Context;

import android.database.sqlite.SQLiteDatabase;

import android.database.sqlite.SQLiteOpenHelper;

import androidx.annotation.Nullable;



//加载数据库驱动

//建立连接

public class MySQLiteOpenHelper extends SQLiteOpenHelper {

    //构造方法

    //name -> 数据库名字

    public MySQLiteOpenHelper(@Nullable Context context, @Nullable String name, @Nullable SQLiteDatabase.CursorFactory factory, int version) {

        super(context, name, factory, version);

    }



    //建表

    @Override

    public void onCreate(SQLiteDatabase sqLiteDatabase) {

        //建表语句   自增长  主键

        sqLiteDatabase.execSQL("create table products(id integer primary key autoincrement,name varchar(20),singleprice double,restnum integer) ");

    }



    //更新表

    @Override

    public void onUpgrade(SQLiteDatabase sqLiteDatabase, int i, int i1) {



    }

}

在Activity中进行增删改查

整个Activity都是用数据库，所以声明驱动和数据库为全局变量，方便使用。

//加载驱动

        mySQLiteOpenHelper = new MySQLiteOpenHelper(MainActivity.this,

                "product",null,1);

        //得到数据库

        sqLiteDatabase = mySQLiteOpenHelper.getWritableDatabase();

布局文件中设置四个按钮，进行增删改查操作。

• 布局-------activity_main.xml

<?xml version="1.0" encoding="utf-8"?>

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"

    xmlns:app="http://schemas.android.com/apk/res-auto"

    xmlns:tools="http://schemas.android.com/tools"

    android:layout_width="match_parent"

    android:layout_height="match_parent"

    android:orientation="vertical"

    android:gravity="center"

    tools:context=".MainActivity">



    <Button

        android:id="@+id/insert"

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"

        android:text="增加一条商品信息"

        android:textSize="25sp"

        />



    <Button

        android:id="@+id/delete"

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"

        android:text="删除一条商品信息"

        android:textSize="25sp"

        />



    <Button

        android:id="@+id/update"

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"

        android:text="修改一条商品信息"

        android:textSize="25sp"

        />



    <Button

        android:id="@+id/select"

        android:layout_width="wrap_content"

        android:layout_height="wrap_content"

        android:text="查询一条商品信息"

        android:textSize="25sp"

        />



</LinearLayout>

• 总体逻辑代码-------MainActivity

package com.hnucm.androiddatabase;



import androidx.appcompat.app.AppCompatActivity;



import android.content.ContentValues;

import android.database.Cursor;

import android.database.sqlite.SQLiteDatabase;

import android.os.Bundle;

import android.util.Log;

import android.view.View;

import android.widget.Button;



public class MainActivity extends AppCompatActivity implements View.OnClickListener{

    //声明增删改查四个按钮

    Button addBtn;

    Button delBtn;

    Button updateBtn;

    Button selectBtn;

    //声明驱动

    MySQLiteOpenHelper mySQLiteOpenHelper;

    //声明数据库

    SQLiteDatabase sqLiteDatabase;

    //数据对象

    ContentValues contentValues;

    //增删改查条件变量

    String id;

    String name;



    @Override

    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_main);



        //加载驱动

        mySQLiteOpenHelper = new MySQLiteOpenHelper(MainActivity.this,

                "product",null,1);

        //得到数据库

        sqLiteDatabase = mySQLiteOpenHelper.getWritableDatabase();



        //初始化四个按钮

        addBtn = findViewById(R.id.insert);

        delBtn = findViewById(R.id.delete);

        updateBtn = findViewById(R.id.update);

        selectBtn = findViewById(R.id.select);



        //点击四个按钮

        addBtn.setOnClickListener(this);

        delBtn.setOnClickListener(this);

        updateBtn.setOnClickListener(this);

        selectBtn.setOnClickListener(this);

    }



    //四个按钮的点击事件

    @Override

    public void onClick(View view) {

        switch (view.getId()){

            //增加数据

            case R.id.insert:

                //创建数据，使用ContentValues -> HashMap

                contentValues = new ContentValues();

                //自增长  主键  增加无需加入id

                //contentValues.put("id",1);

                contentValues.put("name","辣条");

                contentValues.put("singleprice",3.50);

                contentValues.put("restnum",12);

                //将创建好的数据对象加入数据库中的哪一个表

                sqLiteDatabase.insert("products",null,contentValues);

                break;

            //删除数据

            case R.id.delete:

                //删除条件

                id = "1";

                name = "辣条";

                //在哪张表里，根据条件删除

                sqLiteDatabase.delete("products","id = ? and name = ?",

                        new String[]{id,name});

                break;

            //修改数据

            case R.id.update:

                //修改条件

                id = "2";

                //将满足条件的数据修改

                contentValues = new ContentValues();

                contentValues.put("name","薯片");

                //在数据库中修改

                sqLiteDatabase.update("products",contentValues,"id=?",

                        new String[]{id});

                break;

            //查询所有数据

            case R.id.select:

                //采用cursor游标查询

                Cursor cursor = sqLiteDatabase.query("products",null,null,

                        null,null,null,null);

                //游标下一个存在，即没有到最后

                while(cursor.moveToNext()){

                    //每一条数据取出每一列

                    int id = cursor.getInt(cursor.getColumnIndex("id"));

                    name = cursor.getString(cursor.getColumnIndex("name"));

                    double singleprice = cursor.getDouble(cursor.getColumnIndex("singleprice"));

                    int restnum = cursor.getInt(cursor.getColumnIndex("restnum"));

                    //打印数据

                    Log.i("products","id:" + id + ",name:" + name + ",singleprice:"

                            + singleprice + ",restnum:" + restnum);

                }

                break;

        }

    }

}

增加数据

//创建数据，使用ContentValues -> HashMap

                contentValues = new ContentValues();

                //自增长  主键  增加无需加入id

                //contentValues.put("id",1);

                contentValues.put("name","辣条");

                contentValues.put("singleprice",3.50);

                contentValues.put("restnum",12);

                //将创建好的数据对象加入数据库中的哪一个表

                sqLiteDatabase.insert("products",null,contentValues);

删除数据

//删除条件

                id = "1";

                name = "辣条";

                //在哪张表里，根据条件删除

                sqLiteDatabase.delete("products","id = ? and name = ?",

                        new String[]{id,name});

修改数据

//修改条件

                id = "2";

                //将满足条件的数据修改

                contentValues = new ContentValues();

                contentValues.put("name","薯片");

                //在数据库中修改

                sqLiteDatabase.update("products",contentValues,"id=?",

                        new String[]{id});

查询数据

//采用cursor游标查询

                //没有查询条件，所以查询表中所有信息

                Cursor cursor = sqLiteDatabase.query("products",null,null,

                        null,null,null,null);

                //游标下一个存在，即没有到最后

                while(cursor.moveToNext()){

                    //每一条数据取出每一列

                    int id = cursor.getInt(cursor.getColumnIndex("id"));

                    name = cursor.getString(cursor.getColumnIndex("name"));

                    double singleprice = cursor.getDouble(cursor.getColumnIndex("singleprice"));

                    int restnum = cursor.getInt(cursor.getColumnIndex("restnum"));

                    //打印数据

                    Log.i("products","id:" + id + ",name:" + name + ",singleprice:"

                            + singleprice + ",restnum:" + restnum);

                }

Android技术迭代更新很快，各种新出的技术和名词也是层出不穷。不知从什么时候开始，总是会时不时听到AndroidX这个名词，这难道又是什么新出技术吗？相信有很多朋友也会存在这样的疑惑，那么今天我就来写一篇科普文章，向大家介绍AndroidX的前世今生。

Android系统在刚刚面世的时候，可能连它的设计者也没有想到它会如此成功，因此也不可能在一开始的时候就将它的API考虑的非常周全。随着Android系统版本不断地迭代更新，每个版本中都会加入很多新的API进去，但是新增的API在老版系统中并不存在，因此这就出现了一个向下兼容的问题。

举个例子，当Android系统发布到3.0版本的时候，突然意识到了平板电脑的重要性，因此为了让Android可以更好地兼容平板，Android团队在3.0系统（API 11）中加入了Fragment功能。但是Fragment的作用并不只局限于平板，以前的老系统中也想使用这个功能该怎么办？于是Android团队推出了一个鼎鼎大名的Android Support Library，用于提供向下兼容的功能。比如我们每个人都熟知的support-v4库，appcompat-v7库都是属于Android Support Library的，这两个库相信任何做过Android开发的人都使用过。

但是可能很多人并没有考虑过support-v4库的名字到底是什么意思，这里跟大家解释一下。4在这里指的是Android API版本号，对应的系统版本是1.6。那么support-v4的意思就是这个库中提供的API会向下兼容到Android 1.6系统。它对应的包名如下：

类似地，appcompat-v7指的是将库中提供的API向下兼容至API 7，也就是Android 2.1系统。它对应的包名如下：

可以发现，Android Support Library中提供的库，它们的包名都是以android.support.*开头的。

但是慢慢随着时间的推移，什么1.6、2.1系统早就已经被淘汰了，现在Android官方支持的最低系统版本已经是4.0.1，对应的API版本号是15。support-v4、appcompat-v7库也不再支持那么久远的系统了，但是它们的名字却一直保留了下来，虽然它们现在的实际作用已经对不上当初命名的原因了。

那么很明显，Android团队也意识到这种命名已经非常不合适了，于是对这些API的架构进行了一次重新的划分，推出了AndroidX。因此，AndroidX本质上其实就是对Android Support Library进行的一次升级，升级内容主要在于以下两个方面。

第一，包名。之前Android Support Library中的API，它们的包名都是在android.support.*下面的，而AndroidX库中所有API的包名都变成了在androidx.*下面。这是一个很大的变化，意味着以后凡是android.*包下面的API都是随着Android操作系统发布的，而androidx.*包下面的API都是随着扩展库发布的，这些API基本不会依赖于操作系统的具体版本。

第二，命名规则。吸取了之前命名规则的弊端，AndroidX所有库的命名规则里都不会再包含具体操作系统API的版本号了。比如，像appcompat-v7库，在AndroidX中就变成了appcompat库。

一个AndroidX完整的依赖库格式如下所示：

implementation 'androidx.appcompat:appcompat:1.0.2'

了解了AndroidX是什么之后，现在你应该放轻松了吧？它其实并不是什么全新的东西，而是对Android Support Library的一次升级。因此，AndroidX上手起来也没有任何困难的地方，比如之前你经常使用的RecyclerView、ViewPager等等库，在AndroidX中都会有一个对应的版本，只要改一下包名就可以完全无缝使用，用法方面基本上都没有任何的变化。

但是有一点需要注意，AndroidX和Android Support Library中的库是非常不建议混合在一起使用的，因为它们可能会产生很多不兼容的问题。最好的做法是，要么全部使用AndroidX中的库，要么全部使用Android Support Library中的库。

而现在Android团队官方的态度也很明确，未来都会为AndroidX为主，Android Support Library已经不再建议使用，并会慢慢停止维护。另外，从Android Studio 3.4.2开始，我发现新建的项目已经强制勾选使用AndroidX架构了。

那么对于老项目的迁移应该怎么办呢？由于涉及到了包名的改动，如果从Android Support Library升级到AndroidX需要手动去改每一个文件的包名，那可真得要改死了。为此，Android Studio提供了一个一键迁移的功能，只需要对着你的项目名右击 → Refactor → Migrate to AndroidX，就会弹出如下图所示的窗口。

这里点击Migrate，Android Studio就会自动检查你项目中所有使用Android Support Library的地方，并将它们全部改成AndroidX中对应的库。另外Android Studio还会将你原来的项目备份成一个zip文件，这样即使迁移之后的代码出现了问题你还可以随时还原回之前的代码。

版权声明：本文为CSDN博主「guolin」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/guolin_blog/article/details/97142065

这个问题在其他人整理的面试宝典中也有提及，一般来说都是问View的刷新，基本上从ViewRootImpl的scheduleTraversals()方法开始讲就可以了。之前看别人面试斗鱼的面经，被问到了Android屏幕刷新机制、双缓冲、三缓冲、黄油计划，然后我面网易云的时候也确实被问到了这个题目。

屏幕刷新这一整套，你把我这篇文章里的内容讲清楚了，肯定ok了。网易云还附加问了我CPU和GPU怎么交换绘制数据的，这个我个人认为完全是加分题了，我答不出来，感兴趣的小伙伴可以去看一看，你要是能说清楚，肯定能让面试官眼前一亮。

双缓冲

在讲双缓冲这个概念之前，先来了解一些基础知识。

显示系统基础

在一个典型的显示系统中，一般包括CPU、GPU、Display三个部分， CPU负责计算帧数据，把计算好的数据交给GPU， GPU会对图形数据进行渲染，渲染好后放到buffer(图像缓冲区)里存起来，然后Display(屏幕或显示器)负责把buffer里的数 据呈现到屏幕上。

• 画面撕裂

屏幕刷新频是固定的，比如每16.6ms从buffer取数据显示完一帧，理想情况下帧率和刷新频率保持一致，即每绘制完成一 帧，显示器显示一帧。但是CPU/GPU写数据是不可控的，所以会出现buffer里有些数据根本没显示出来就被重写了，即 buffer里的数据可能是来自不同的帧的。当屏幕刷新时，此时它并不知道buffer的状态，因此从buffer抓取的帧并不是完整的一帧画面，即出现画面撕裂。

简单说就是Display在显示的过程中，buffer内数据被CPU/GPU修改，导致画面撕裂。

那咋解决画面撕裂呢? 答案是使用双缓冲。

双缓冲

由于图像绘制和屏幕读取 使用的是同个buffer，所以屏幕刷新时可能读取到的是不完整的一帧画面。

双缓冲，让绘制和显示器拥有各自的buffer：GPU 始终将完成的一帧图像数据写入到 Back Buffer，而显示器使用 Frame Buffer，当屏幕刷新时，Frame Buffer 并不会发生变化，当Back buffer准备就绪后，它们才进行交换。

VSync

什么时候进行两个buffer的交换呢?

假如是 Back buffer准备完成一帧数据以后就进行，那么如果此时屏幕还没有完整显示上一帧内容的话，肯定是会出问题的。 看来只能是等到屏幕处理完一帧数据后，才可以执行这一操作了。

当扫描完一个屏幕后，设备需要重新回到第一行以进入下一次的循环，此时有一段时间空隙，称为VerticalBlanking Interval(VBI)。这个时间点就是我们进行缓冲区交换的最佳时间。因为此时屏幕没有在刷新，也就避免了交换过程中出现画面撕裂的状况。

VSync(垂直同步)是VerticalSynchronization的简写，它利用VBI时期出现的vertical sync pulse(垂直同步脉冲)来保证双缓冲在最佳时间点才进行交换。另外，交换是指各自的内存地址，可以认为该操作是瞬间完成。

所以说VSync这个概念并不是Google首创的，它在早年的PC机领域就已经出现了。

Android屏幕刷新机制

先总体概括一下，Android屏幕刷新使用的是“双缓存+VSync机制”，单纯的双缓冲模式容易造成jank（丢帧）现象，为了解决这个问题，Google在 Android4.1 提出了Project Butter(?油工程)，引入了 drawing with VSync 的概念。

jank（丢帧）

以时间的顺序来看下将会发生的过程:

1. Display显示第0帧数据，此时CPU和GPU渲染第1帧画面，且在Display显示下一帧前完成


2. 因为渲染及时，Display在第0帧显示完成后，也就是第1个VSync后，缓存进行交换，然后正常显示第1帧


3. 接着第2帧开始处理，是直到第2个VSync快来前才开始处理的。


4. 第2个VSync来时，由于第2帧数据还没有准备就绪，缓存没有交换，显示的还是第1帧。这种情况被Android开发组命名为“Jank”，即发生了丢帧。


5. 当第2帧数据准备完成后，它并不会?上被显示，而是要等待下一个VSync 进行缓存交换再显示。

所以总的来说，就是屏幕平白无故地多显示了一次第1帧。 原因是第2帧的CPU/GPU计算 没能在VSync信号到来前完成。

这里注意一下一个细节，jank（丢帧、掉帧），不是说这一帧丢弃了不显示，而是这一帧延迟显示了，因为缓存交换的时机只能等下一个VSync了。

黄油计划 —— drawing with VSync

为了优化显示性能，Google在Android 4.1系统中对Android Display系统进行了重构，实现了Project Butter(?油工程): 系统在收到VSync pulse后，将?上开始下一帧的渲染。即一旦收到VSync通知(16ms触发一次)，CPU和GPU 才立刻开 始计算然后把数据写入buffer。如下图:

CPU/GPU根据VSYNC信号同步处理数据，可以让CPU/GPU有完整的16ms时间来处理数据，减少了jank。 一句话总结，VSync同步使得CPU/GPU充分利用了16.6ms时间，减少jank。

问题又来了，如果界面比较复杂，CPU/GPU的处理时间较?，超过了16.6ms呢？如下图:

1. 在第二个时间段内，但却因 GPU 还在处理 B 帧，缓存没能交换，导致 A 帧被重复显示。


2. 而B完成后，又因为缺乏VSync pulse信号，它只能等待下一个signal的来临。于是在这一过程中，有一大段时间是被浪费的。


3. 当下一个VSync出现时，CPU/GPU?上执行操作(A帧)，且缓存交换，相应的显示屏对应的就是B。这时看起来就是正常的。只不过由于执行时间仍然超过16ms，导致下一次应该执行的缓冲区交换又被推迟了——如此循环反复，便出现了越来越多的“Jank”。

为什么 CPU 不能在第二个 16ms 处理绘制工作呢？ 因为只有两个 buffer，Back buffer正在被GPU用来处理B帧的数据， Frame buffer的内容用于Display的显示，这样两个 buffer都被占用，CPU 则无法准备下一帧的数据。 那么，如果再提供一个buffer，CPU、GPU 和显示设备都能使用各自的 buffer工作，互不影响。这就是三缓冲的来源了。

三缓冲

三缓存就是在双缓冲机制基础上增加了一个 Graphic Buffer 缓冲区，这样可以最大限度的利用空闲时间，带来的坏处是多使用的一个 Graphic Buffer 所占用的内存。

1. 第一个Jank，是不可避免的。但是在第二个 16ms 时间段，CPU/GPU 使用 第三个 Buffer 完成C帧的计算，虽然还是 会多显示一次 A 帧，但后续显示就比较顺畅了，有效避免 Jank 的进一步加剧。


2. 注意在第3段中，A帧的计算已完成，但是在第4个vsync来的时候才显示，如果是双缓冲，那在第三个vynsc就可以显示了。

三缓冲有效利用了等待VSync的时间，减少了jank，但是带来了延迟。是不是 Buffer 越多越好呢？这个是否定的， Buffer 正常还是两个，当出现 Jank 后三个足以。

Choreographer

上边讲的都是基础的刷新知识，那么在 Android 系统中，真正来实现绘制的类叫Choreographer。

Choreographer负责对CPU/GPU绘制的指导 —— 收到VSync信号才开始绘制，保证绘制拥有完整 16.6ms，避免绘制的随机性。

通常 应用层不会直接使用Choreographer，而是使用更高级的API，例如动画和View绘制相关的 ValueAnimator.start()、View.invalidate()等。

（这边补充说一个面试题，属性动画更新时会回调onDraw吗？不会，因为它内部是通过AnimationHandler中的Choreographer机制来实现的更新，具体的逻辑，如果以后有时间的话可以写篇文章来说一说。）

业界一般通过Choreographer来监控应用的帧率。

（这个东西也是个面试题，会问你如何检测应用的帧率？你可以提一下Choreographer里面的FrameCallback，然后结合一些第三方库的实现具体说一下。）

View刷新的入口

Activity启动，走完onResume方法后，会进行window的添加。window添加过程会调用ViewRootImpl的setView()方法， setView()方法会调用requestLayout()方法来请求绘制布局，requestLayout()方法内部又会走到scheduleTraversals()方法。最后会走到performTraversals()方法，接着到了我们熟知的测量、布局、绘制三大流程了。

当我们使用 ValueAnimator.start()、View.invalidate()时，最后也是走到ViewRootImpl的 scheduleTraversals()方法。(View.invalidate()内部会循环获取ViewParent直到ViewRootImpl的invalidateChildInParent()方法，然后走到scheduleTraversals()，可自行查看源码)

即所有UI的变化都是走到ViewRootImpl的scheduleTraversals()方法。

这里注意一个点：scheduleTraversals()之后不是立即就执行performTraversals()的，它们中间隔了一个Choreographer机制。简单来说就是scheduleTraversals()中，Choreographer会去请求native的VSync信号，VSync信号来了之后才会去调用performTraversals()方法进行View绘制的三大流程。

 //ViewRootImpl.java

void scheduleTraversals() {

    if (!mTraversalScheduled) {

        mTraversalScheduled = true;

        //添加同步屏障，屏蔽同步消息，保证VSync到来立即执行绘制

        mTraversalBarrier = mHandler.getLooper().getQueue().postSyncBarrier(); 

        //mTraversalRunnable是TraversalRunnable实例，最终走到run()，也即doTraversal();

        mChoreographer.postCallback(

                      Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null);

        if (!mUnbufferedInputDispatch) {

            scheduleConsumeBatchedInput();

        }

        notifyRendererOfFramePending();

        pokeDrawLockIfNeeded();

    }

}

final class TraversalRunnable implements Runnable {

    @Override

    public void run() {

         doTraversal();

    } 

}

final TraversalRunnable mTraversalRunnable = new TraversalRunnable();

void doTraversal() {

    if (mTraversalScheduled) {

        mTraversalScheduled = false;

        //移除同步屏障 

        mHandler.getLooper().getQueue().removeSyncBarrier(mTraversalBarrier); ...

        //开始三大绘制流程

        performTraversals();

        ...

    } 

}

1. postSyncBarrier 开启同步屏障，保证VSync到来后立即执行绘制


2. mChoreographer.postCallback()方法，发送一个会在下一帧执行的回调，即在下一个VSync到来时会执行 TraversalRunnable–>doTraversal()—>performTraversals()–>绘制流程。

Choreographer

初始化

mChoreographer，是在ViewRootImpl的构造方法内使用 Choreographer.getInstance()创建。

Choreographer和Looper一样是线程单例的，通过ThreadLocal机制来保证唯一性。因为Choreographer内部通过FrameHandler来发送消息，所以初始化的时候会先判断当前线程有无Looper，没有的话直接抛异常。

public static Choreographer getInstance() {

    return sThreadInstance.get();

}



private static final ThreadLocal<Choreographer> sThreadInstance =

              new ThreadLocal<Choreographer>() {

    @Override

    protected Choreographer initialValue() {

         Looper looper = Looper.myLooper();

         if (looper == null) {

         //当前线程要有looper，Choreographer实例需要传入

              throw new IllegalStateException("The current thread must have a looper!");

        }

        Choreographer choreographer = new Choreographer(looper, VSYNC_SOURCE_APP);

        if (looper == Looper.getMainLooper()) {

            mMainInstance = choreographer;

        }

        return choreographer;

   }

};

postCallback

mChoreographer.postCallback(Choreographer.CALLBACK_TRAVERSAL, mTraversalRunnable, null)方法，第一个参数是CALLBACK_TRAVERSAL，表示回调任务的类型，共有以下5种类型:

//输入事件，首先执行

public static final int CALLBACK_INPUT = 0; 

//动画，第二执行

public static final int CALLBACK_ANIMATION = 1; 

//插入更新的动画，第三执行

public static final int CALLBACK_INSETS_ANIMATION = 2; 

//绘制，第四执行

public static final int CALLBACK_TRAVERSAL = 3; 

//提交，最后执行，

public static final int CALLBACK_COMMIT = 4;

五种类型任务对应存入对应的CallbackQueue中，每当收到 VSYNC 信号时，Choreographer 将首先处理 INPUT 类型的任 务，然后是 ANIMATION 类型，最后才是 TRAVERSAL 类型。

postCallback()内部调用postCallbackDelayed()，接着又调用postCallbackDelayedInternal()，正常消息执行scheduleFrameLocked，延迟运行的消息会发送一个MSG_DO_SCHEDULE_CALLBACK类型的meessage:

private void postCallbackDelayedInternal(int callbackType,

      Object action, Object token, long delayMillis) {

    ...

    synchronized (mLock) {

        ...

        mCallbackQueues[callbackType].addCallbackLocked(dueTime, action, token);

        if (dueTime <= now) { //立即执行

             scheduleFrameLocked(now);

        } else {

            //延迟运行，最终也会走到scheduleFrameLocked()

            Message msg = mHandler.obtainMessage(MSG_DO_SCHEDULE_CALLBACK, action); 

            msg.arg1 = callbackType;

            msg.setAsynchronous(true);

            mHandler.sendMessageAtTime(msg, dueTime);

        } 

    }

}

FrameHandler这个类是内部专门用来处理消息的，可以看到延迟的MSG_DO_SCHEDULE_CALLBACK类型消息最终也是走到scheduleFrameLocked：

private final class FrameHandler extends Handler {

    public FrameHandler(Looper looper) {

        super(looper);

    }

    @Override

    public void handleMessage(Message msg) {

        switch (msg.what) {

            case MSG_DO_FRAME:

                // 执行doFrame,即绘制过程 

                doFrame(System.nanoTime(), 0);

                break;

            case MSG_DO_SCHEDULE_VSYNC: 

                //申请VSYNC信号，例如当前需要绘制任务时 

                doScheduleVsync();

                break;

            case MSG_DO_SCHEDULE_CALLBACK: 

                //需要延迟的任务，最终还是执行上述两个事件 

                doScheduleCallback(msg.arg1);

                break;

        } 

    }

}



void doScheduleCallback(int callbackType) {

    synchronized (mLock) {

        if (!mFrameScheduled) {

            final long now = SystemClock.uptimeMillis();

            if (mCallbackQueues[callbackType].hasDueCallbacksLocked(now)) {

                scheduleFrameLocked(now);

            }

        } 

    }

}

申请VSync信号

scheduleFrameLocked()方法里面就会去真正的申请 VSync 信号了。

private void scheduleFrameLocked(long now) {

    if (!mFrameScheduled) {

        mFrameScheduled = true; 

        if (USE_VSYNC) {

            //当前执行的线程，是否是mLooper所在线程

            if (isRunningOnLooperThreadLocked()) {

                //申请 VSYNC 信号

                scheduleVsyncLocked();

            } else {

                // 若不在，就用mHandler发送消息到原线程，最后还是调用scheduleVsyncLocked方法 

                Message msg = mHandler.obtainMessage(MSG_DO_SCHEDULE_VSYNC); 

                msg.setAsynchronous(true);//异步 

                mHandler.sendMessageAtFrontOfQueue(msg);

            }

        } else {

            // 如果未开启VSYNC则直接doFrame方法(4.1后默认开启) 

            final long nextFrameTime = Math.max(

            mLastFrameTimeNanos / TimeUtils.NANOS_PER_MS + sFrameDelay, now);

            Message msg = mHandler.obtainMessage(MSG_DO_FRAME); 

            msg.setAsynchronous(true);//异步 

            mHandler.sendMessageAtTime(msg, nextFrameTime);

        } 

    }

}

VSync信号的注册和监听是通过mDisplayEventReceiver实现的。mDisplayEventReceiver是在Choreographer的构造方法中创建的，是FrameDisplayEventReceiver的实例。 FrameDisplayEventReceiver是 DisplayEventReceiver 的子类，

private void scheduleVsyncLocked() {

    mDisplayEventReceiver.scheduleVsync();

}

public DisplayEventReceiver(Looper looper, int vsyncSource) {

    if (looper == null) {

        throw new IllegalArgumentException("looper must not be null");

    }

    mMessageQueue = looper.getQueue();

    // 注册native的VSYNC信号监听者

    mReceiverPtr = nativeInit(new WeakReference<DisplayEventReceiver>(this), mMessageQueue,vsyncSource);

    mCloseGuard.open("dispose");

}

VSync信号回调

native的VSync信号到来时，会走到onVsync()回调：

private final class FrameDisplayEventReceiver extends DisplayEventReceiver

        implements Runnable {

   

    @Override

    public void onVsync(long timestampNanos, long physicalDisplayId, int frame) {

        ...

        //将本身作为runnable传入msg， 发消息后 会走run()，即doFrame()，也是异步消息 

        Message msg = Message.obtain(mHandler, this);

        msg.setAsynchronous(true);

        mHandler.sendMessageAtTime(msg, timestampNanos / TimeUtils.NANOS_PER_MS);

    }

    

    @Override

    public void run() {

        mHavePendingVsync = false;

        doFrame(mTimestampNanos, mFrame);

    }

}

（这里补充一个面试题：页面UI没有刷新的时候onVsync()回调也会执行吗？不会，因为VSync是UI需要刷新的时候主动去申请的，而不是native层不停地往上面去推这个回调的，这边要注意。）

doFrame

doFrame()方法中会通过doCallbacks()方法去执行各种callbacks，主要内容就是取对应任务类型的队列，遍历队列执行所有任务，其中就包括了 ViewRootImpl 发起的绘制任务mTraversalRunnable了。mTraversalRunnable执行doTraversal()方法，移除同步屏障，调用performTraversals()开始三大绘制流程。

到这里整个流程就闭环了。

前言

备忘录模式能记录一个对象的内部状态，当用户后悔时能撤销当前操作，使数据恢复到它原先的状态。

定义

在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态，以便以后当需要时能将该对象恢复到原先保存的状态。该模式又叫快照模式。

优点

提供了一种可以恢复状态的机制。当用户需要时能够比较方便地将数据恢复到某个历史的状态。
实现了内部状态的封装。除了创建它的发起人之外，其他对象都不能够访问这些状态信息。
简化了发起人类。发起人不需要管理和保存其内部状态的各个备份，所有状态信息都保存在备忘录中，并由管理者进行管理，这符合单一职责原则。

缺点

资源消耗大。如果要保存的内部状态信息过多或者特别频繁，将会占用比较大的内存资源。

结构

• 发起人（Originator）角色：记录当前时刻的内部状态信息，提供创建备忘录和恢复备忘录数据的功能，实现其他业务功能，它可以访问备忘录里的所有信息。


• 备忘录（Memento）角色：负责存储发起人的内部状态，在需要的时候提供这些内部状态给发起人。


• 管理者（Caretaker）角色：对备忘录进行管理，提供保存与获取备忘录的功能，但其不能对备忘录的内容进行访问与修改。

实现

生活中最常用的计算器自己拥有备忘录的功能，用户计算完后软件会自动为用户记录最后几次的计算结果，我们可以模拟用户使用计算器的过程，以及打开备忘录查看记录。

package com.rabbit;



/**

 * 备忘录发起人,模拟计算器加法运算

 * Created by HASEE on 2018/4/29.

 */

public class Originator {



    private double num1;



    private double num2;



    //创建备忘录对象

    public Memento createMemento() {

        return new Memento(num1, num2);

    }



    public Originator(double num1, double num2) {

        this.num1 = num1;

        this.num2 = num2;

        System.out.println(num1 + " + " + num2 + " = " + (num1 + num2));

    }



}

package com.rabbit;



/**

 * 备忘录，要保存的属性

 * Created by HASEE on 2018/4/29.

 */

public class Memento {



    private double num1;//计算器第一个数字



    private double num2;//计算器第二个数字



    private double result;//计算结果



    public Memento(double num1, double num2) {

        this.num1 = num1;

        this.num2 = num2;

        this.result = num1 + num2;

    }



    public void show() {

        System.out.println(num1 + " + " + num2 + " = " + result);

    }



}

package com.rabbit;



import java.util.ArrayList;

import java.util.List;



/**

 * 备忘录管理者

 * Created by HASEE on 2018/4/29.

 */

public class Caretaker {



    private List<Memento> mementos;



    public boolean addMenento(Memento memento) {

        if (mementos == null) {

            mementos = new ArrayList<>();

        }

        return mementos.add(memento);

    }



    public List<Memento> getMementos() {

        return mementos;

    }



    public static Caretaker newInstance() {

        return new Caretaker();

    }

}

package com.rabbit;



import org.junit.Test;



import java.util.Random;



/**

 * Created by HASEE on 2018/4/29.

 */

public class Demo {



    @Test

    public void test() {

        Caretaker c = Caretaker.newInstance();

        //使用循环模拟用户使用计算器做加法运算

        Random ran = new Random(1000);

        for (int i = 0; i < 5; i++) {

            //用户计算

            Originator o = new Originator(ran.nextDouble(), ran.nextDouble());

            //计算器软件将用户的计算做备份，以便可以查看历史

            c.addMenento(o.createMemento());

        }

        System.out.println("---------------------用户浏览历史记录---------------------");

        for (Memento m : c.getMementos()) {

            m.show();

        }

        System.out.println("---------------------用户选择一条记录查看----------------------");

        c.getMementos().get(2).show();

    }



}

前言

访问者模式是一种将数据操作和数据结构分离的设计模式。

定义

将作用于某种数据结构中的各元素的操作分离出来封装成独立的类，使其在不改变数据结构的前提下可以添加作用于这些元素的新的操作，为数据结构中的每个元素提供多种访问方式。它将对数据的操作与数据结构进行分离，是行为类模式中最复杂的一种模式。

优点

1. 扩展性好。能够在不修改对象结构中的元素的情况下，为对象结构中的元素添加新的功能。


2. 复用性好。可以通过访问者来定义整个对象结构通用的功能，从而提高系统的复用程度。


3. 灵活性好。访问者模式将数据结构与作用于结构上的操作解耦，使得操作集合可相对自由地演化而不影响系统的数据结构。


4. 符合单一职责原则。访问者模式把相关的行为封装在一起，构成一个访问者，使每一个访问者的功能都比较单一。

缺点

1. 增加新的元素类很困难。在访问者模式中，每增加一个新的元素类，都要在每一个具体访问者类中增加相应的具体操作，这违背了“开闭原则”。


2. 破坏封装。访问者模式中具体元素对访问者公布细节，这破坏了对象的封装性。


3. 违反了依赖倒置原则。访问者模式依赖了具体类，而没有依赖抽象类。

结构

• 抽象访问者（Visitor）角色：定义一个访问具体元素的接口，为每个具体元素类对应一个访问操作 visit() ，该操作中的参数类型标识了被访问的具体元素。


• 具体访问者（ConcreteVisitor）角色：实现抽象访问者角色中声明的各个访问操作，确定访问者访问一个元素时该做什么。


• 抽象元素（Element）角色：声明一个包含接受操作 accept() 的接口，被接受的访问者对象作为 accept() 方法的参数。


• 具体元素（ConcreteElement）角色：实现抽象元素角色提供的 accept() 操作，其方法体通常都是 visitor.visit(this) ，另外具体元素中可能还包含本身业务逻辑的相关操作。


• 对象结构（Object Structure）角色：是一个包含元素角色的容器，提供让访问者对象遍历容器中的所有元素的方法，通常由 List、Set、Map 等聚合类实现。

示例

年底，CEO和CTO开始评定员工一年的工作绩效，员工分为工程师和经理，CTO关注工程师的代码量、经理的新产品数量；CEO关注的是工程师的KPI和经理的KPI以及新产品数量。
由于CEO和CTO对于不同员工的关注点是不一样的，这就需要对不同员工类型进行不同的处理。访问者模式此时可以派上用场了。

// 员工基类

public abstract class Staff {



    public String name;

    public int kpi;// 员工KPI



    public Staff(String name) {

        this.name = name;

        kpi = new Random().nextInt(10);

    }

    // 核心方法，接受Visitor的访问

    public abstract void accept(Visitor visitor);

}

Staff 类定义了员工基本信息及一个 accept 方法，accept 方法表示接受访问者的访问，由子类具体实现。Visitor 是个接口，传入不同的实现类，可访问不同的数据。下面看看工程师和经理的代码：

// 工程师

public class Engineer extends Staff {



    public Engineer(String name) {

        super(name);

    }



    @Override

    public void accept(Visitor visitor) {

        visitor.visit(this);

    }

    // 工程师一年的代码数量

    public int getCodeLines() {

        return new Random().nextInt(10 * 10000);

    }

}

// 经理

public class Manager extends Staff {



    public Manager(String name) {

        super(name);

    }



    @Override

    public void accept(Visitor visitor) {

        visitor.visit(this);

    }

    // 一年做的产品数量

    public int getProducts() {

        return new Random().nextInt(10);

    }

}

工程师是代码数量，经理是产品数量，他们的职责不一样，也就是因为差异性，才使得访问模式能够发挥它的作用。Staff、Engineer、Manager 3个类型就是对象结构，这些类型相对稳定，不会发生变化。
然后将这些员工添加到一个业务报表类中，公司高层可以通过该报表类的 showReport 方法查看所有员工的业绩，具体代码如下：

// 员工业务报表类

public class BusinessReport {



    private List<Staff> mStaffs = new LinkedList<>();



    public BusinessReport() {

        mStaffs.add(new Manager("经理-A"));

        mStaffs.add(new Engineer("工程师-A"));

        mStaffs.add(new Engineer("工程师-B"));

        mStaffs.add(new Engineer("工程师-C"));

        mStaffs.add(new Manager("经理-B"));

        mStaffs.add(new Engineer("工程师-D"));

    }



    /**

     * 为访问者展示报表

     * @param visitor 公司高层，如CEO、CTO

     */

    public void showReport(Visitor visitor) {

        for (Staff staff : mStaffs) {

            staff.accept(visitor);

        }

    }

}

下面看看 Visitor 类型的定义， Visitor 声明了两个 visit 方法，分别是对工程师和经理对访问函数，具体代码如下：

public interface Visitor {



    // 访问工程师类型

    void visit(Engineer engineer);



    // 访问经理类型

    void visit(Manager manager);

}

首先定义了一个 Visitor 接口，该接口有两个 visit 函数，参数分别是 Engineer、Manager，也就是说对于 Engineer、Manager 的访问会调用两个不同的方法，以此达成区别对待、差异化处理。具体实现类为 CEOVisitor、CTOVisitor类，具体代码如下：

// CEO访问者

public class CEOVisitor implements Visitor {

    @Override

    public void visit(Engineer engineer) {

        System.out.println("工程师: " + engineer.name + ", KPI: " + engineer.kpi);

    }



    @Override

    public void visit(Manager manager) {

        System.out.println("经理: " + manager.name + ", KPI: " + manager.kpi +

                ", 新产品数量: " + manager.getProducts());

    }

}

在CEO的访问者中，CEO关注工程师的 KPI，经理的 KPI 和新产品数量，通过两个 visitor 方法分别进行处理。如果不使用 Visitor 模式，只通过一个 visit 方法进行处理，那么就需要在这个 visit 方法中进行判断，然后分别处理，代码大致如下：

public class ReportUtil {

    public void visit(Staff staff) {

        if (staff instanceof Manager) {

            Manager manager = (Manager) staff;

            System.out.println("经理: " + manager.name + ", KPI: " + manager.kpi +

                    ", 新产品数量: " + manager.getProducts());

        } else if (staff instanceof Engineer) {

            Engineer engineer = (Engineer) staff;

            System.out.println("工程师: " + engineer.name + ", KPI: " + engineer.kpi);

        }

    }

}

这就导致了 if-else 逻辑的嵌套以及类型的强制转换，难以扩展和维护，当类型较多时，这个 ReportUtil 就会很复杂。而使用 Visitor 模式，通过同一个函数对不同对元素类型进行相应对处理，使结构更加清晰、灵活性更高。
再添加一个CTO的 Visitor 类：

public class CTOVisitor implements Visitor {

    @Override

    public void visit(Engineer engineer) {

        System.out.println("工程师: " + engineer.name + ", 代码行数: " + engineer.getCodeLines());

    }



    @Override

    public void visit(Manager manager) {

        System.out.println("经理: " + manager.name + ", 产品数量: " + manager.getProducts());

    }

}

重载的 visit 方法会对元素进行不同的操作，而通过注入不同的 Visitor 又可以替换掉访问者的具体实现，使得对元素的操作变得更灵活，可扩展性更高，同时也消除了类型转换、if-else 等“丑陋”的代码。
下面是客户端代码：

public class Client {



    public static void main(String[] args) {

        // 构建报表

        BusinessReport report = new BusinessReport();

        System.out.println("=========== CEO看报表 ===========");

        report.showReport(new CEOVisitor());

        System.out.println("=========== CTO看报表 ===========");

        report.showReport(new CTOVisitor());

    }

}

具体输出如下：

=========== CEO看报表 ===========

经理: 经理-A, KPI: 9, 新产品数量: 0

工程师: 工程师-A, KPI: 6

工程师: 工程师-B, KPI: 6

工程师: 工程师-C, KPI: 8

经理: 经理-B, KPI: 2, 新产品数量: 6

工程师: 工程师-D, KPI: 6

=========== CTO看报表 ===========

经理: 经理-A, 产品数量: 3

工程师: 工程师-A, 代码行数: 62558

工程师: 工程师-B, 代码行数: 92965

工程师: 工程师-C, 代码行数: 58839

经理: 经理-B, 产品数量: 6

工程师: 工程师-D, 代码行数: 53125

在上述示例中，Staff 扮演了 Element 角色，而 Engineer 和 Manager 都是 ConcreteElement；CEOVisitor 和 CTOVisitor 都是具体的 Visitor 对象；而 BusinessReport 就是 ObjectStructure；Client就是客户端代码。
访问者模式最大的优点就是增加访问者非常容易，我们从代码中可以看到，如果要增加一个访问者，只要新实现一个 Visitor 接口的类，从而达到数据对象与数据操作相分离的效果。如果不实用访问者模式，而又不想对不同的元素进行不同的操作，那么必定需要使用 if-else 和类型转换，这使得代码难以升级维护。

应用场景

当系统中存在类型数量稳定（固定）的一类数据结构时，可以使用访问者模式方便地实现对该类型所有数据结构的不同操作，而又不会对数据产生任何副作用（脏数据）。

简而言之，就是当对集合中的不同类型数据（类型数量稳定）进行多种操作时，使用访问者模式。

通常在以下情况可以考虑使用访问者模式。

1. 对象结构相对稳定，但其操作算法经常变化的程序。


2. 对象结构中的对象需要提供多种不同且不相关的操作，而且要避免让这些操作的变化影响对象的结构。


3. 对象结构包含很多类型的对象，希望对这些对象实施一些依赖于其具体类型的操作。  

很多面试官喜欢会就一个问题不断深入追问。

例如一个小小的 LiveData 的 postValue，就可能会问出一连串问题：

postValue 与 setValue

postValue 与 setValue 一样都是用来更新 LiveData 数据的方法：

• setValue 只能在主线程调用，同步更新数据


• postValue 可在后台线程调用，其内部会切换到主线程调用 setValue

liveData.postValue("a");

liveData.setValue("b");

上面代码，a 在 b 之后才被更新。

postValue 收不到通知

postValue 使用不当，可能发生接收到数据变更的通知：

If you called this method multiple times before a main thread executed a posted task, only the last value would be dispatched.

如上，源码的注释中明确记载了，当连续调用 postValue 时，有可能只会收到最后一次数据更新通知。

梳理源码可以了解其中原由：

protected void postValue(T value) {

    boolean postTask;

    synchronized (mDataLock) {

        postTask = mPendingData == NOT_SET;

        mPendingData = value;

    }

    if (!postTask) {

        return;

    }

    ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);

}

mPendingData 被成功赋值 value 后，post 了一个 Runnable

mPostValueRunnable 的实现如下：

private final Runnable mPostValueRunnable = new Runnable() {

    @SuppressWarnings("unchecked")

    @Override

    public void run() {

        Object newValue;

        synchronized (mDataLock) {

            newValue = mPendingData;

            mPendingData = NOT_SET;

        }

        setValue((T) newValue);

    }

};

• postValue 将数据存入 mPendingData，mPostValueRunnable 在UI线程消费mPendingData。




• 在 Runnable 中 mPendingData 值还没有被消费之前，即使连续 postValue ， 也不会 post 新的 Runnable




• mPendingData 的生产 (赋值) 和消费（赋 NOT_SET） 需要加锁

这也就是当连续 postValue 时只会收到最后一次通知的原因。

源码梳理过了，但是为什么要这样设计呢？

为什么 Runnable 只 post 一次？

当 mPenddingData 中有数据不断更新时，为什么 Runnable 不是每次都 post，而是等待到最后只 post 一次？

一种理解是为了兼顾性能，UI只需显示最终状态即可，省略中间态造成的频发刷新。这或许是设计目的之一，但是一个更为合理的解释是：即使 post 多次也没有意义，所以只 post 一次即可

我们知道，对于 setValue 来说，连续调用多次，数据会依次更新：

如下，订阅方一次收到 a b 的通知

liveData.setValue("a");

liveData.setValue("b");

通过源码可知，dispatchingValue() 中同步调用 Observer#onChanged()，依次通知订阅方：

//setValue源码



@MainThread

protected void setValue(T value) {

    assertMainThread("setValue");

    mVersion++;

    mData = value;

    dispatchingValue(null);

}

但对于 postValue，如果当 value 变化时，我们立即post，而不进行阻塞

protected void postValue(T value) {

    mPendingData = value;

    ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);

}



private final Runnable mPostValueRunnable = new Runnable() {

    public void run() {

        setValue((T) mPendingData);

    }

};

liveData.postValue("a")

liveData.postValue("b")

由于线程切换的开销，连续调用 postValue，收到通知只能是b、b，无法收到a。

因此，post 多次已无意义，一次即可。

为什么要加读写锁？

前面已经知道，是否 post 取决于对 mPendingData 的判断（是否为 NOT_SET）。因为要在多线程环境中访问 mPendingData ，不加读写锁无法保证其线程安全。

protected void postValue(T value) {

    boolean postTask = mPendingData == NOT_SET; // --1

    mPendingData = value; // --2

    if (!postTask) {

        return;

    }

    ArchTaskExecutor.getInstance().postToMainThread(mPostValueRunnable);

}



private final Runnable mPostValueRunnable = new Runnable() {

    public void run() {

        Object newValue = mPendingData;

        mPendingData = NOT_SET; // --3

        setValue((T) newValue);

    }

};

如上，如果在 1 和 2 之间，执行了 3，则 2 中设置的值将无法得到更新

使用RxJava替换LiveData

如何避免在多线程环境下不漏掉任何一个通知？ 比较好的思路是借助 RxJava 这样的流式框架，任何数据更新都以数据流的形式发射出来，这样就不会丢失了。

fun <T> Observable<T>.toLiveData(): LiveData<T> = RxLiveData(this)



class RxLiveData<T>(

    private val observable: Observable<T>

) : LiveData<T>() {

    private var disposable: Disposable? = null



    override fun onActive() {

        disposable = observable

            .observeOn(AndroidSchedulers.mainThread())

            .subscribe({

                setValue(it)

            }, {

                setValue(null)

            })

    }



    override fun onInactive() {

        disposable?.dispose()

    }

}

最后

想要保证事件在线程切换过程中的顺序性和完整性，需要使用RxJava这样的流式框架。

有时候面试官会使用追问的形式来挖掘候选人的技术深度，所以大家在准备面试时要多问自己几个问什么，知其然并知其所以然。

当然，我也不赞同这种刨根问底式的拷问方式，尤其是揪着一些没有实用价值的细枝末节不放。所以本文也是提醒广大面试官，挖掘深度的同时要注意分寸，不能以将候选人难倒为目标来问问题。

~~~格式优化整理~~~
1、下载FakerAndroid工具包
下载地址：https://github.com/Efaker/FakerAndroid/releases 
2、cmd切换到FakerAndroid.jar平级目录 
[工具包和要操作的Apk]

[工具包目录]

3、执行 java -jar FakerAndroid.jar fk <apkpath>生成AndroidStudio工程
[执行命令]

[等待命令执行完成]

4、查看Apk平级目录下面生成的AndroidStudio工程
[查看原安装包目录]

5、AndroidStudio直接打开生成的Android工程
[生成的Android项目工程目录结构]

6、等待加载完成直接运行项目(确认项目加载完成，部分Res或Manifest文件有问题的话需要手动修复一下，实测大部分的未做res混淆的Apk都是没有问题的)
[直接Run运行项目]

7、Java类调用之继承(意在演示Java层原有Java类调用)
[父类继承]

8、Java类调用之Api调用(意在演示Java层原有Java Api调用)
[父类Api调用]

9、Manifest入口Activity替换
[AndroidManifest入口Activity替换]

10、Java类替换(意在演示对原有Java类的直接替换)
[类替换之原类]

[类替换之自己编写的替换类]

11、定义Jni方法进行Hoook操作和il2cpp脚手架的调用
[Jni方法定义]

[HookApi和Il2cpp脚手架的使用]

12、对原il2cpp脚手架定义过的方法进行Hook替换
[Il2cpp脚手架中的UI回调函数替换以及Il2cpp脚手架中的Api调用]

[JniHook Btn]

13、最后上一下效果图，忘记说了，文章中所有图片的宽度都使用了1024px
[效果图]

    debugCompile 'com.squareup.leakcanary:leakcanary-android:1.5'

    releaseCompile 'com.squareup.leakcanary:leakcanary-android-no-op:1.5'

    testCompile 'com.squareup.leakcanary:leakcanary-android-no-op:1.5'

可以看到，debugCompile跟releaseCompile 引入的是不同的包， 在 debug 版本上，集成 LeakCanary 库，并执行内存泄漏监测，而在 release 版本上，集成一个无操作的 wrapper ，这样对程序性能就不会有影响。

2）在Application类添加：

public class LCApplication extends Application {

    @Override

    public void onCreate() {

        super.onCreate();

        if (LeakCanary.isInAnalyzerProcess(this)) {

            // This process is dedicated to LeakCanary for heap analysis.

            // You should not init your app in this process.

            return;

        }

        LeakCanary.install(this);

        // Normal app init code...

    }

}

LeakCanary.install() 会返回一个预定义的 RefWatcher，同时也会启用一个 ActivityRefWatcher，用于自动监控调用 Activity.onDestroy() 之后泄露的 activity。

如果是简单的检测activity是否存在内存泄漏，上面两个步骤就可以了，是不是很简单。 那么当某个activity存在内存泄漏的时候，会有什么提示呢？LeakCanary会自动展示一个通知栏，点开提示框你会看到引起内存溢出的引用堆栈信息。

具体使用代码

1）Application 相关代码：

public class LCApplication extends Application {

    @Override

    public void onCreate() {

        super.onCreate();

        if (LeakCanary.isInAnalyzerProcess(this)) {

            // This process is dedicated to LeakCanary for heap analysis.

            // You should not init your app in this process.

            return;

        }

        LeakCanary.install(this);

        // Normal app init code...

    }



}

2）泄漏的activity类代码：

public class MainActivity extends Activity {



    private Button next;



    @Override

    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_main);



        next = (Button) findViewById(R.id.next);

        next.setOnClickListener(new View.OnClickListener() {

            @Override

            public void onClick(View v) {

                Intent intent = new Intent(MainActivity.this, SecondActivity.class);

                startActivity(intent);

                finish();

            }

        });

        new Thread(new Runnable() {

            @Override

            public void run() {

                while (true) {

                    System.out.println("=================");

                }

            }

        }).start();

    }

}

当点击next跳到第二个界面后，LeakCanary会自动展示一个通知栏，点开提示框你会看到引起内存溢出的引用堆栈信息，如上图所示，这样你就很容易定位到原来是线程引用住当前activity，导致activity无法释放。

1）Application 中获取到refWatcher对象。

public class LCApplication extends Application {



    public static RefWatcher refWatcher;



    @Override

    public void onCreate() {

        super.onCreate();

        if (LeakCanary.isInAnalyzerProcess(this)) {

            // This process is dedicated to LeakCanary for heap analysis.

            // You should not init your app in this process.

            return;

        }

        refWatcher  = LeakCanary.install(this);

        // Normal app init code...

    }

}

2）使用 RefWatcher 监控 Fragment：

public abstract class BaseFragment extends Fragment {

  @Override public void onDestroy() {

    super.onDestroy();

    RefWatcher refWatcher = LCApplication.refWatcher;

    refWatcher.watch(this);

  }

}

这样则像监听activity一样监听fragment。其实这种方式一样适用于任何对象，比如图片，自定义类等等，非常方便。

public static RefWatcher install(Application application) {

        return ((AndroidRefWatcherBuilder)refWatcher(application).listenerServiceClass(DisplayLeakService.class).excludedRefs(AndroidExcludedRefs.createAppDefaults().build())).buildAndInstall();

    }

listenerServiceClass(DisplayLeakService.class)：用于分析内存泄漏结果信息，然后发送通知给用户。 excludedRefs(AndroidExcludedRefs.createAppDefaults().build())：设置需要忽略的对象，比如某些系统漏洞不需要统计。 buildAndInstall()：真正检测内存泄漏的方法，下面将展开分析该方法。

public RefWatcher buildAndInstall() {

        RefWatcher refWatcher = this.build();

        if(refWatcher != RefWatcher.DISABLED) {

            LeakCanary.enableDisplayLeakActivity(this.context);

            ActivityRefWatcher.installOnIcsPlus((Application)this.context, refWatcher);

        }



        return refWatcher;

    }

可以看到，上面方法主要做了三件事情： 1.实例化RefWatcher对象，该对象主要作用是检测是否有对象未被回收导致内存泄漏； 2.设置APP图标可见； 3.检测内存

public static void enableDisplayLeakActivity(Context context) {

        LeakCanaryInternals.setEnabled(context, DisplayLeakActivity.class, true);

    }

public static void setEnabled(Context context, final Class<?> componentClass, final boolean enabled) {

        final Context appContext = context.getApplicationContext();

        executeOnFileIoThread(new Runnable() {

            public void run() {

                LeakCanaryInternals.setEnabledBlocking(appContext, componentClass, enabled);

            }

        });

    }

public static void setEnabledBlocking(Context appContext, Class<?> componentClass, boolean enabled) {

        ComponentName component = new ComponentName(appContext, componentClass);

        PackageManager packageManager = appContext.getPackageManager();

        int newState = enabled?1:2;

        packageManager.setComponentEnabledSetting(component, newState, 1);

    }

可见，最后调用packageManager.setComponentEnabledSetting（）方法，实现应用图标的隐藏和显示。

public static void installOnIcsPlus(Application application, RefWatcher refWatcher) {

        if(VERSION.SDK_INT >= 14) {

            ActivityRefWatcher activityRefWatcher = new ActivityRefWatcher(application, refWatcher);

            activityRefWatcher.watchActivities();

        }

    }

该方法实例化出ActivityRefWatcher 对象，该对象用来监听activity的生命周期，具体实现如下所示：

public void watchActivities() {

        this.stopWatchingActivities();

        this.application.registerActivityLifecycleCallbacks(this.lifecycleCallbacks);

    }

private final ActivityLifecycleCallbacks lifecycleCallbacks = new ActivityLifecycleCallbacks() {

        public void onActivityCreated(Activity activity, Bundle savedInstanceState) {

        }



        public void onActivityStarted(Activity activity) {

        }



        public void onActivityResumed(Activity activity) {

        }



        public void onActivityPaused(Activity activity) {

        }



        public void onActivityStopped(Activity activity) {

        }



        public void onActivitySaveInstanceState(Activity activity, Bundle outState) {

        }



        public void onActivityDestroyed(Activity activity) {

            ActivityRefWatcher.this.onActivityDestroyed(activity);

        }

    };

public void watch(Object watchedReference) {

        this.watch(watchedReference, "");

    }



    public void watch(Object watchedReference, String referenceName) {

        if(this != DISABLED) {

            Preconditions.checkNotNull(watchedReference, "watchedReference");

            Preconditions.checkNotNull(referenceName, "referenceName");

            long watchStartNanoTime = System.nanoTime();

            String key = UUID.randomUUID().toString();

            this.retainedKeys.add(key);

            KeyedWeakReference reference = new KeyedWeakReference(watchedReference, key, referenceName, this.queue);

            this.ensureGoneAsync(watchStartNanoTime, reference);

        }

    }

可以看到，上面方法主要做了三件事情： 1.生成一个随机数key存放在retainedKeys集合中，用来判断对象是否被回收； 2.把当前Activity放到KeyedWeakReference（WeakReference的子类）中； 3.通过查找ReferenceQueue，看该Acitivity是否存在，存在则证明可以被正常回收，不存在则证明可能存在内存泄漏。 前两件事很简单，这边主要看第三件事情的处理过程，及ensureGoneAsync方法的源码：

private void ensureGoneAsync(final long watchStartNanoTime, final KeyedWeakReference reference) {

        this.watchExecutor.execute(new Retryable() {

            public Result run() {

                return RefWatcher.this.ensureGone(reference, watchStartNanoTime);

            }

        });

    }

    

  Result ensureGone(KeyedWeakReference reference, long watchStartNanoTime) {

        long gcStartNanoTime = System.nanoTime();

        long watchDurationMs = TimeUnit.NANOSECONDS.toMillis(gcStartNanoTime - watchStartNanoTime);

        this.removeWeaklyReachableReferences();

        if(this.debuggerControl.isDebuggerAttached()) {

            return Result.RETRY;

        } else if(this.gone(reference)) {

            return Result.DONE;

        } else {

            this.gcTrigger.runGc();

            this.removeWeaklyReachableReferences();

            if(!this.gone(reference)) {

                long startDumpHeap = System.nanoTime();

                long gcDurationMs = TimeUnit.NANOSECONDS.toMillis(startDumpHeap - gcStartNanoTime);

                File heapDumpFile = this.heapDumper.dumpHeap();

                if(heapDumpFile == HeapDumper.RETRY_LATER) {

                    return Result.RETRY;

                }



                long heapDumpDurationMs = TimeUnit.NANOSECONDS.toMillis(System.nanoTime() - startDumpHeap);

                this.heapdumpListener.analyze(new HeapDump(heapDumpFile, reference.key, reference.name, this.excludedRefs, watchDurationMs, gcDurationMs, heapDumpDurationMs));

            }



            return Result.DONE;

        }

    }

该方法中首先执行removeWeaklyReachableReferences()，从ReferenceQueue队列中查询是否存在该弱引用对象，如果不为空，则说明已经被系统回收了，则将对应的随机数key从retainedKeys集合中删除。

 private void removeWeaklyReachableReferences() {

        KeyedWeakReference ref;

        while((ref = (KeyedWeakReference)this.queue.poll()) != null) {

            this.retainedKeys.remove(ref.key);

        }

    }

然后通过判断retainedKeys集合中是否存在对应的key判断该对象是否被回收。

private boolean gone(KeyedWeakReference reference) {

        return !this.retainedKeys.contains(reference.key);

    }

如果没有被系统回收，则手动调用gcTrigger.runGc();后再调用removeWeaklyReachableReferences方法判断该对象是否被回收。

GcTrigger DEFAULT = new GcTrigger() {

        public void runGc() {

            Runtime.getRuntime().gc();

            this.enqueueReferences();

            System.runFinalization();

        }



        private void enqueueReferences() {

            try {

                Thread.sleep(100L);

            } catch (InterruptedException var2) {

                throw new AssertionError();

            }

        }

    };

第三行代码为手动触发GC，紧接着线程睡100毫秒，给系统回收的时间，随后通过System.runFinalization()手动调用已经失去引用对象的finalize方法。 通过手动GC该对象还不能被回收的话，则存在内存泄漏，调用heapDumper.dumpHeap()生成.hprof文件目录，并通过heapdumpListener回调到analyze()方法，后面关于dump文件的分析这边就不介绍了，感兴趣的可以自行去看。

JAVA开发MQTT总结

MQTT 介绍

• 它是一种 机器之间通讯 machine-to-machine (M2M)、物联网 Internet of Things （IoT）常用的一种轻量级消息传输协议
• 适用于网络带宽较低的场合
• 包含发布、订阅模式，通过一个代理服务器（broker），任何一个客户端（client）都可以订阅或者发布某个主题的消息，然后订阅了该主题的客户端则会收到该消息

mqtt还是之前公司有需求所以写的一个demo，在这里记录下来，方便有人使用的时候查阅，不涉及mqtt的具体讲解，只是贴代码和运行过程。

MQTT的入门，以及特性，协议，结构的讲解，请看下面这篇文章

www.runoob.com/w3cnote/mqt…

什么是MQTT，它能干什么，它的应用场景在哪里？请参考下面这篇文章

www.ibm.com/developerwo…

本文中采用的MQTT服务器Apache-Apollo的下载配置搭建过程，请参考下面这篇文章

blog.csdn.net/qq_29350001…

下面就开始创建broker，

RaindeMacBook-Pro:bin rain$ ./apollo create mybroker

Creating apollo instance at: mybroker

Generating ssl keystore...



Warning:

JKS 密钥库使用专用格式。建议使用 "keytool -importkeystore -srckeystore keystore -destkeystore keystore -deststoretype pkcs12" 迁移到行业标准格式 PKCS12。



You can now start the broker by executing:



   "/Users/rain/Documents/Soft/apache-apollo-1.7.1/bin/mybroker/bin/apollo-broker" run



Or you can run the broker in the background using:



   "/Users/rain/Documents/Soft/apache-apollo-1.7.1/bin/mybroker/bin/apollo-broker-service" start

进入新生成的broker中

RaindeMacBook-Pro:bin rain$ ls

apollo		apollo.cmd	mybroker	testbroker

RaindeMacBook-Pro:bin rain$ cd mybroker/

RaindeMacBook-Pro:mybroker rain$ ls

bin	data	etc	log	tmp

RaindeMacBook-Pro:mybroker rain$ cd bin

RaindeMacBook-Pro:bin rain$ ls

apollo-broker		apollo-broker-service

可以看到有两个文件，启动apollo-broker

启动成功以后，就可以在浏览器中访问了，默认用户名和密码是admin，password

刚进去是，Topics选项卡是空的，我是在运行程序后截图的，所以有一个topic列表

配置Maven

在pom.xml中添加以下配置

<dependency>

            <groupId>org.eclipse.paho</groupId>

            <artifactId>org.eclipse.paho.client.mqttv3</artifactId>

            <version>1.2.0</version>

        </dependency>

再创建下面的类

MqttServer

import org.eclipse.paho.client.mqttv3.*;

import org.eclipse.paho.client.mqttv3.persist.MemoryPersistence;



public class MqttServer2 {

    /**

     * 代理服务器ip地址

     */

    public static final String MQTT_BROKER_HOST = "tcp://127.0.0.1:61613";



    /**

     * 订阅标识

     */

    public static final String MQTT_TOPIC = "test2";



    private static String userName = "admin";

    private static String password = "password";



    /**

     * 客户端唯一标识

     */

    public static final String MQTT_CLIENT_ID = "android_server_xiasuhuei32";

    private static MqttTopic topic;

    private static MqttClient client;



    public static void main(String... args) {

        // 推送消息

        MqttMessage message = new MqttMessage();

        try {

            client = new MqttClient(MQTT_BROKER_HOST, MQTT_CLIENT_ID, new MemoryPersistence());

            MqttConnectOptions options = new MqttConnectOptions();

            options.setCleanSession(true);

            options.setUserName(userName);

            options.setPassword(password.toCharArray());

            options.setConnectionTimeout(10);

            options.setKeepAliveInterval(20);



            topic = client.getTopic(MQTT_TOPIC);



            message.setQos(1);

            message.setRetained(false);

            message.setPayload("message from server222222".getBytes());

            client.connect(options);



            while (true) {

                MqttDeliveryToken token = topic.publish(message);

                token.waitForCompletion();

                System.out.println("已经发送222");

                Thread.sleep(10000);

            }



        } catch (Exception e) {

            e.printStackTrace();

        }

    }

}

MqttClient

import org.eclipse.paho.client.mqttv3.*;

import org.eclipse.paho.client.mqttv3.persist.MemoryPersistence;



public class MyMqttClient {

    /**

     * 代理服务器ip地址

     */

    public static final String MQTT_BROKER_HOST = "tcp://127.0.0.1:61613";



    /**

     * 客户端唯一标识

     */

    public static final String MQTT_CLIENT_ID = "android_xiasuhuei321";



    /**

     * 订阅标识

     */

//    public static final String MQTT_TOPIC = "xiasuhuei321";



    /**

     *

     */

    public static final String USERNAME = "admin";

    /**

     * 密码

     */

    public static final String PASSWORD = "password";

    public static final String TOPIC_FILTER = "test2";



    private volatile static MqttClient mqttClient;

    private static MqttConnectOptions options;



    public static void main(String... args) {

        try {

            // host为主机名，clientid即连接MQTT的客户端ID，一般以客户端唯一标识符表示，

            // MemoryPersistence设置clientid的保存形式，默认为以内存保存



            mqttClient = new MqttClient(MQTT_BROKER_HOST, MQTT_CLIENT_ID, new MemoryPersistence());

            // 配置参数信息

            options = new MqttConnectOptions();

            // 设置是否清空session,这里如果设置为false表示服务器会保留客户端的连接记录，

            // 这里设置为true表示每次连接到服务器都以新的身份连接

            options.setCleanSession(true);

            // 设置用户名

            options.setUserName(USERNAME);

            // 设置密码

            options.setPassword(PASSWORD.toCharArray());

            // 设置超时时间 单位为秒

            options.setConnectionTimeout(10);

            // 设置会话心跳时间 单位为秒 服务器会每隔1.5*20秒的时间向客户端发送个消息判断客户端是否在线，但这个方法并没有重连的机制

            options.setKeepAliveInterval(20);

            // 连接

            mqttClient.connect(options);

            // 订阅

            mqttClient.subscribe(TOPIC_FILTER);

            // 设置回调

            mqttClient.setCallback(new MqttCallback() {

                @Override

                public void connectionLost(Throwable throwable) {

                    System.out.println("connectionLost");

                }



                @Override

                public void messageArrived(String s, MqttMessage mqttMessage) throws Exception {

                    System.out.println("Topic: " + s + " Message: " + mqttMessage.toString());

                }



                @Override

                public void deliveryComplete(IMqttDeliveryToken iMqttDeliveryToken) {



                }

            });

        } catch (Exception e) {

            e.printStackTrace();

        }



    }



}

PublishSample

import org.eclipse.paho.client.mqttv3.MqttClient;

import org.eclipse.paho.client.mqttv3.MqttConnectOptions;

import org.eclipse.paho.client.mqttv3.MqttException;

import org.eclipse.paho.client.mqttv3.MqttMessage;

import org.eclipse.paho.client.mqttv3.persist.MemoryPersistence;



/**

 *发布端

 */

public class PublishSample {

    public static void main(String[] args) {



        String topic = "test2";

        String content = "hello 哈哈";

        int qos = 1;

        String broker = "tcp://127.0.0.1:61613";

        String userName = "admin";

        String password = "password";

        String clientId = "pubClient";

        // 内存存储

        MemoryPersistence persistence = new MemoryPersistence();



        try {

            // 创建客户端

            MqttClient sampleClient = new MqttClient(broker, clientId, persistence);

            // 创建链接参数

            MqttConnectOptions connOpts = new MqttConnectOptions();

            // 在重新启动和重新连接时记住状态

            connOpts.setCleanSession(false);

            // 设置连接的用户名

            connOpts.setUserName(userName);

            connOpts.setPassword(password.toCharArray());

            // 建立连接

            sampleClient.connect(connOpts);

            // 创建消息

            MqttMessage message = new MqttMessage(content.getBytes());

            // 设置消息的服务质量

            message.setQos(qos);

            // 发布消息

            sampleClient.publish(topic, message);

            // 断开连接

            sampleClient.disconnect();

            // 关闭客户端

            sampleClient.close();

        } catch (MqttException me) {

            System.out.println("reason " + me.getReasonCode());

            System.out.println("msg " + me.getMessage());

            System.out.println("loc " + me.getLocalizedMessage());

            System.out.println("cause " + me.getCause());

            System.out.println("excep " + me);

            me.printStackTrace();

        }

    }

}

SubscribeSample

import org.eclipse.paho.client.mqttv3.*;

import org.eclipse.paho.client.mqttv3.persist.MemoryPersistence;



/**

 *订阅端

 */

public class SubscribeSample {



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

        String HOST = "tcp://127.0.0.1:61613";

        String TOPIC = "test2";

        int qos = 1;

        String clientid = "subClient";

        String userName = "admin";

        String passWord = "password";

        try {

            // host为主机名，test为clientid即连接MQTT的客户端ID，一般以客户端唯一标识符表示，MemoryPersistence设置clientid的保存形式，默认为以内存保存

            MqttClient client = new MqttClient(HOST, clientid, new MemoryPersistence());

            // MQTT的连接设置

            MqttConnectOptions options = new MqttConnectOptions();

            // 设置是否清空session,这里如果设置为false表示服务器会保留客户端的连接记录，这里设置为true表示每次连接到服务器都以新的身份连接

            options.setCleanSession(true);

            // 设置连接的用户名

            options.setUserName(userName);

            // 设置连接的密码

            options.setPassword(passWord.toCharArray());

            // 设置超时时间 单位为秒

            options.setConnectionTimeout(10);

            // 设置会话心跳时间 单位为秒 服务器会每隔1.5*20秒的时间向客户端发送个消息判断客户端是否在线，但这个方法并没有重连的机制

            options.setKeepAliveInterval(20);

            // 设置回调函数

            client.setCallback(new MqttCallback() {



                public void connectionLost(Throwable cause) {

                    System.out.println("connectionLost");

                }



                public void messageArrived(String topic, MqttMessage message) throws Exception {

                    System.out.println("topic:"+topic);

                    System.out.println("Qos:"+message.getQos());

                    System.out.println("message content:"+new String(message.getPayload()));



                }



                public void deliveryComplete(IMqttDeliveryToken token) {

                    System.out.println("deliveryComplete---------"+ token.isComplete());

                }



            });

            client.connect(options);

            //订阅消息

            client.subscribe(TOPIC, qos);

        } catch (Exception e) {

            e.printStackTrace();

        }

    }

}

启动程序

1.启动MqttServer2以后，开始循环发送消息。

2.启动MyMqttClient开始接收消息。

到这里，整个程序基本可以运行。

3.启动PublishSample，发布一条消息，在启动SubscribeSample来订阅发布的消息。

4.发布的消息在MyMqttClient中也会显示出来

作者：魏小雨
链接：https://juejin.cn/post/6844904071367753735
来源：掘金
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

前言

最近的项目中使用了MQTT来接收后端推送过来的一些数据，这篇文章来介绍下Android端如何集成使用，关于MQTT相关介绍将不再阐述。

由于光写代码不实践的接收下数据很难验证我们写的是否正确，所以我将简单介绍下如何配置个MQTT服务端，并使用工具来发送数据到服务端，使得手机端能接收到数据。话不多说直接看。

1. MQTT服务器配置

1.1 下载EMQX

下载地址

1.2 启动EMQX

在解压后的bin目录下打开cmd命令，输入emqx.cmd start即可启动。

如果你在启动时遇到could't load module...，那就是因为你的路径中包含中文名导致启动不了，将该文件夹放到纯英文目录下即可启动。 

完事后在浏览器内输入http://127.0.0.1:18083即可打开web管理界面，帐号为admin,密码为public

按如图方式将语言改为中文 

1.3 界面说明

左侧的Clients标签下可以看到当前连接的客户端  左侧的Topics标签下可以看到当前订阅的主题 

1.4 个人理解

到这服务端就算是配置完成了，你可能会问，服务端就是这，那我手机客户端怎么接收消息呢，服务端从哪里发送消息呢？其实EMQX服务是消息中间件服务，有点像是转发。一个客户端发送消息并指定主题，该消息发送到服务端，那么连接了服务端并且订阅了该主题的所有客户端就都能接收到该消息，所以我们手机客户端想要接收到消息，还需要有一端来给EMQX服务端来发送消息才行。

2. MQTT客户端软件 Paho

2.1 下载MQTT客户端软件

下载地址 

下载勾选中的那个文件即可，下载完后解压得到paho.exe，即我们需要的客户端软件。

2.2 MQTT客户端使用

2.2.1 连接服务器

按如图所示步骤进行点击，1、新增一个连接，2、填写服务器地址和客户标识，这里的标识为自己定义的，服务器地址可在该地址那查看，可以看到是本地地址，端口号是1883或者11883 点击连接后可以看到连接状态变为已连接，就代表我们客户端已经连接到了EMQX。 

2.2.2 发送消息

在1处填写主题名，2处填写消息然后3处点击发布，然后可以看到4处显示已发布，代表我们已经发送到服务端了。

2.2.3 订阅主题

订阅我们刚才发送消息的那个主题

点击1处来新增订阅，点击2处输入我们要订阅的主题，这里我们设置为刚才发布消息的那个主题，然后点击3处的订阅，可以看到历史记录那里显示已订阅。

接下来我们再发送一次该主题消息，观察历史记录

可以看到，当我们发布后，由于我们订阅了该主题，所以就接收到了该主题消息。

在MQTT服务端配置完成以及MQTT客户端软件测试可行后，现在来看我们的安卓端如何订阅并接收消息。

3. Andoird端集成使用

3.1 添加依赖、权限等配置

//MQTT

implementation 'org.eclipse.paho:org.eclipse.paho.client.mqttv3:1.1.0'

implementation 'org.eclipse.paho:org.eclipse.paho.android.service:1.1.1'

implementation 'androidx.localbroadcastmanager:localbroadcastmanager:1.0.0'

AndroidManifest文件配置

<manifest xmlns:android="http://schemas.android.com/apk/res/android"

    package="com.myfittinglife.mqttdemo">



<!--必要的三个权限-->

<uses-permission android:name="android.permission.INTERNET"/>

<uses-permission android:name="android.permission.WAKE_LOCK"/>

<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>



<application

	...>

	...

	<!--添加该Service-->

	<service android:name="org.eclipse.paho.android.service.MqttService"/>

</application>

3.2 使用

3.2.1 创建MqttAndroidClient对象

var mClient: MqttAndroidClient? = null



private fun createClient() {



    //1、创建接口回调

    //以下回调都在主线程中(如果使用MqttClient,使用此回调里面的都是非主线程)

    val mqttCallback: MqttCallbackExtended = object : MqttCallbackExtended {

        override fun connectComplete(reconnect: Boolean, serverURI: String) {

            //连接成功

            Log.i(TAG, "connectComplete: ")

            showToast("连接成功")

        }



        override fun connectionLost(cause: Throwable) {

            //断开连接

            Log.i(TAG, "connectionLost: ")

            showToast("断开连接")



        }



        @Throws(Exception::class)

        override fun messageArrived(topic: String, message: MqttMessage) {

            //得到的消息

            var msg = message.payload

            var str = String(msg)

            Log.i(TAG, "messageArrived: $str")

            showToast("接收到的消息为：$str")



        }



        override fun deliveryComplete(token: IMqttDeliveryToken) {

            //发送消息成功后的回调

            Log.i(TAG, "deliveryComplete: ")

            showToast("发送成功")



        }

    }



    //2、创建Client对象

    try {

        mClient = MqttAndroidClient(this, "tcp://192.168.14.57:1883", "客户端名称，可随意")

        mClient?.setCallback(mqttCallback) //设置回调函数

    } catch (e: MqttException) {

        Log.e(TAG, "createClient: ", e)

    }

}

3.2.2 设置MQTT连接的配置信息

val mOptions = MqttConnectOptions()

mOptions.isAutomaticReconnect = false //断开后，是否自动连接

mOptions.isCleanSession = true //是否清空客户端的连接记录。若为true，则断开后，broker将自动清除该客户端连接信息

mOptions.connectionTimeout = 60 //设置超时时间，单位为秒

//mOptions.userName = "Admin" //设置用户名。跟Client ID不同。用户名可以看做权限等级

//mOptions.setPassword("Admin") //设置登录密码

mOptions.keepAliveInterval = 60 //心跳时间，单位为秒。即多长时间确认一次Client端是否在线

mOptions.maxInflight = 10 //允许同时发送几条消息（未收到broker确认信息）

mOptions.mqttVersion = MqttConnectOptions.MQTT_VERSION_3_1_1 //选择MQTT版本

3.2.3 建立连接

try {

    mClient?.connect(mOptions, this, object : IMqttActionListener {

        override fun onSuccess(asyncActionToken: IMqttToken?) {

            Log.i(TAG, "onSuccess:连接成功 ")

        }



        override fun onFailure(asyncActionToken: IMqttToken?, exception: Throwable?) {

            Log.i(TAG, "onFailure: " + exception?.message)

        }



    })

} catch (e: MqttException) {

    Log.e(TAG, "onCreate: ", e)

}

3.2.4 订阅主题

//设置监听的topic

try {

    mClient?.subscribe("topicName", 0)

} catch (e: MqttException) {

    Log.e(TAG, "onCreate: ", e)

}

3.2.5 发送消息

try {

    var str = "要发送的消息"

    var msg = MqttMessage()

    msg.payload =str.toByteArray()

    mClient?.publish(Const.Subscribe.mTopic,msg)

} catch (e: MqttException) {

    Log.e(TAG, "onCreate: ",e )

}

3.3 最终效果

在我们的Paho MQTT Utility软件发送消息后，我们的手机端由于订阅了该主题，所以就可以接收到该消息。 

4. 注意事项

• 别忘记在manifest中添加service，否则在connect()的时候会报mClient为空。

  <service android:name="org.eclipse.paho.android.service.MqttService"/>
  
  

• 别忘记添加localbroadcastmanager依赖，否则会报Failed resolution of: Landroidx/localbroadcastmanager/content/LocalBroadcastManager错误。

  implementation 'androidx.localbroadcastmanager:localbroadcastmanager:1.0.0'
  
  

• 启动emqx服务时，一定要将该文件目录放到纯英文的目录下，不能包含中文，否则会出现could't load module的错误。

5. 总结

按以上步骤即可完成最基本的功能，以上只是简单的使用，其实还可以设置用户登录名和密码、设置服务质量、重连的操作等。关于MQTT的相关内容可以看这篇文章MQTT。

项目Github地址

如果本文对你有帮助，请别忘记三连，如果有不恰当的地方也请提出来，下篇文章见。

作者：重拾丢却的梦

链接：https://juejin.cn/post/6939153370267516941

来源：掘金

著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

概述

MQTT是IBM开发的一个即时通讯协议，有可能成为物联网的重要组成部分。该协议支持所有平台，几乎可以把所有联网物品和外部连接起来，被用来当做传感器和制动器之间通信的桥梁。

MQTT协议是为大量计算能力有限，且工作在低带宽、不可靠的网络的远程传感器和控制设备通讯而设计的协议。有以下特点：

• 使用发布/订阅消息模式，提供一对多的消息发布


• 使用TCP/IP提供网络连接


• 小型传输，开销很小（固定长度的头部是 2 字节），协议交换最小化，以降低网络流量，传输的内容最大为256MB。


• 使用 Last Will 和 Testament 特性通知有关各方客户端异常中断的机制。

1.MQTT协议实现方式

---

MQTT系统由与服务器通信的客户端组成，通常称服务器为“代理Broker”。客户可以是信息发布者Publish或订阅者Subscribe。每个客户端都可以连接到代理。

信息按主题层次结构组织。当发布者具有要分发的新数据时，它会将包含数据的控制消息发送到连接的代理。然后，代理将信息分发给已订阅该主题的任何客户端。发布者不需要有关于订阅者数量或位置的任何数据，而订阅者又不必配置有关发布者的任何数据。

MQTT传输的消息分为：主题（Topic）和负载（payload）两部分： （1）Topic，可以理解为消息的类型，订阅者订阅（Subscribe）后，就会收到该主题的消息内容（payload）； （2）payload，可以理解为消息的内容，是指订阅者具体要使用的内容。

2. MQTT协议中的术语

---

2.1订阅（Subscription）

订阅包含主题筛选器（Topic Filter）和最大服务质量（QoS）。订阅会与一个会话（Session）关联。一个会话可以包含多个订阅。每一个会话中的每个订阅都有一个不同的主题筛选器。

2.2会话（Session）

每个客户端与服务器建立连接后就是一个会话，客户端和服务器之间有状态交互。会话存在于一个网络之间，也可能在客户端和服务器之间跨越多个连续的网络连接。

2.3主题名（Topic Name）

连接到一个应用程序消息的标签，该标签与服务器的订阅相匹配。服务器会将消息发送给订阅所匹配标签的每个客户端。 系统主题：通过定义$SYS开头的主题可以查看一些系统信息，如客户端连接数量等， 详细介绍：github.com/mqtt/mqtt.g…

2.4主题筛选器（Topic Filter）

一个对主题名通配符筛选器，在订阅表达式中使用，表示订阅所匹配到的多个主题。 多级匹配符 # 单级匹配符 + 更多主题讨论，请移步github wiki github.com/mqtt/mqtt.g…

2.5负载（Payload）

消息订阅者所具体接收的内容。

3.保留消息和最后遗嘱

---

保留消息 Retained Messages

MQTT中，无论是发布还是订阅都不会有任何触发事件。 1个Topic只有唯一的retain消息，Broker会保存每个Topic的最后一条retain消息。 发布消息时把retain设置为true，即为保留信息。每个Client订阅Topic后会立即读取到retain消息。如果需要删除retain消息，可以发布一个空的retain消息，因为每个新的retain消息都会覆盖最后一个retain消息。

最后遗嘱 Last Will & Testament

MQTT本身就是为信号不稳定的网络设计的，所以难免一些客户端会无故的和Broker断开连接。 当客户端连接到Broker时，可以指定LWT，Broker会定期检测客户端是否有异常。 当客户端异常掉线时，Broker就往连接时指定的topic里推送当时指定的LWT消息。

4.消息服务质量

---

有三种消息发布服务质量qos(Quality of Service)：

4.1“至多一次”

消息发布完全依赖底层TCP/IP网络。会发生消息丢失或重复。这一级别可用于如下情况，环境传感器数据，丢失一次读记录无所谓，因为不久后还会有第二次发送。

4.2“至少一次”

PUBACK消息是对QoS级别为1的PUBLISH消息的响应.PUBACK消息由服务器发送以响应来自发布端的PUBLISH消息，订阅端也会响应来自服务器的PUBLISH消息。当发布端收到PUBACK消息时，它会丢弃原始消息，因为它也被服务器接收（并记录）。

如果一定时间内，发布端或服务器没有收到PUBACK消息，则会进行重发。这种方式虽然确保了消息到达，但消息重复可能会发生。

4.3“只有一次”

PUBREC消息是对QoS级别为2的PUBLISH消息的响应。它是QoS级别2协议流的第二个消息。 PUBREC消息由服务器响应来自发布端的PUBLISH消息，或订阅端响应来自服务器的PUBLISH消息。发布端或服务器收到PUBREC消息时，会响应PUBREL消息。

PUBREL消息是从发布端对PUBREC的响应，或从服务器对订阅端PUBREC消息的响应。 这是QoS 2协议流中第三个消息。当服务器从发布者收到PUBREL消息时，服务器会将PUBLISH消息发送到订阅端，并发送PUBCOMP消息到发布端。 当订阅端收到来自服务器的消息PUBREL时，使得消息可用于应用程序并将PUBCOMP消息发送到服务器。

PUBCOMP消息是服务器对来自发布端的PUBREL消息的响应，或订阅者对来自服务器的PUBREL消息的响应。 它是QoS 2协议流程中的第四个也是最后一个消息。当发布端收到PUBCOMP消息时，它会丢弃原始消息，因为它已经将消息发给了服务器。

在一些要求比较严格的计费系统中，可以使用此级别。在计费系统中，消息重复或丢失会导致不正确的结果。这种最高质量的消息发布服务还可以用于即时通讯类的APP的推送，确保用户收到且只会收到一次。

---

附录：各编程语言对MQTT客户端/服务器的实现

Name	Language	Type	Last release	License
Adafruit IO	Ruby on Rails, Node.js	Client	2.0.0	?
flespi	C	Broker	?	Proprietary License
M2Mqtt	C#	Client	4.3.0.0	Eclipse Public License 1.0
Machine Head	Clojure	Client	1.0.0	Creative Commons Attribution 3.0 Unported License
moquette	Java	Broker	0.10	Apache License 2.0
Mosquitto	C, Python	Broker and client	1.4.15	Eclipse Public License 1.0, Eclipse Distribution License 1.0 (BSD)
Paho MQTT	C, C++, Java, Javascript, Python, Go	Client	1.3.0	Eclipse Public License 1.0, Eclipse Distribution License 1.0 (BSD)
SharkMQTT	C	Client	1.5	Proprietary License
VerneMQ	Erlang/OTP	Broker	1.4.1	Apache License 2.0
wolfMQTT	C	Client	0.14	GNU Public License, version 2
MQTTRoute	C, Python	Broker	1.0	Proprietary License
HiveMQ	Java	Broker	3.4.0	Proprietary License
SwiftMQ	Java	Broker	11.1.0	Proprietary License
JoramMQ	Java	Broker	11.1.0	Proprietary License

作者：brandonbai
链接：https://juejin.cn/post/6844903829096382471
来源：掘金
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。