Handler 的内存泄漏问题

在多线程操作中，handler会使用的非常多，但是每次使用handler你有没有考虑内存泄漏的问题。

如果你使用handler进行操作时，你会发现出现以下提示
This Handler class should be static or leaks might occur (anonymous android.os.Handler)这样的提示。翻译：
由于此Handler被声明为内部类，因此可能会阻止外部类被垃圾回收。 如果Handler使用Looper或MessageQueue作为主线程以外的线程，则没有问题。 如果Handler正在使用主线程的Looper或MessageQueue，则需要修复Handler声明，如下所示：将Handler声明为静态类; 在外部类中，实例化外部类的WeakReference，并在实例化Handler时将此对象传递给Handler; 使用WeakReference对象对外部类的成员进行所有引用。

警告原因：handler没有设置为静态类，声明内部类可能会阻止被GC回收，从而导致内存泄漏

那么为什么会造成内存泄漏呢。
首先来说下什么是内存泄漏
内存泄漏（Memory Leak)：指的是程序已经动态分配的堆内存由于某种原因程序未释放或者无法释放，造成系统资源浪费，会造成程序运行缓慢甚至系统崩溃等严重后果。
问题代码：

public class MainActivity extends AppCompatActivity {

    private Handler mHandler = new Handler();

    private TextView mTextView;

    @Override

    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        setContentView(R.layout.activity_main);

        mTextView = (TextView) findViewById(R.id.tv);

        //模拟内存泄漏

        mHandler.postDelayed(new Runnable() {

            @Override

            public void run() {

                mTextView.setText("yiyi");

            }

        }, 1000);

    }

内存泄漏原因

从上面问题代码，可以看出这里通过内部类方式创建handler，而在java中，非静态内部类会持有外部类的引用，这里的postDelayed是一个延迟处理消息，将一个handler装入到message中，将消息放进消息队列messageQueue由Looper进行取消息进行处理。如果此时activity要退出了，想要调用**destroy**销毁，但是此时Looper正在处理消息，**Looper**的生命周期明显比activity长，这将使得activity无法被**GC**回收，最终造成内存泄漏。并且此时handler还持有activity的引用，也是造成内存泄漏的一个原因(不是根本原因)。

但是我觉得真正handler造成内存泄漏的根本原因是生命周期比activity长，比如TextView也是内部类创建的，那么它怎么没有造成内存泄漏，它也持有外部类Activity的引用，根本原因是它的生命周期比Activity短，Activity销毁时候，它可以被GC回收

总结

当handler有没有处理的消息或者正在处理消息，此时Handler的生命周期明显比Activity长，GC持有Activity与handler两者的引用，导致Activity无法被GC回收，造成内存泄漏。而handler是不是内部类，并不是造成内存泄漏的根本原因。

解决方案

静态内部类+弱引用

将Handler的子类设置成 静态内部类，并且可加上 使用WeakReference弱引用持有Activity实例

原因：弱引用的对象拥有短暂的生命周期。而垃圾回收器不管内存是否充足都会回收弱引用对象。

public class HandlerActivity extends AppCompatActivity  {

    private static class MyHandler extends Handler {

    private final WeakReference<HandlerActivity> mActivity;

    public MyHandler(HandlerActivity activity) {

        mActivity = new WeakReference<HandlerActivity>(activity);

    }

 

    @Override

    public void handleMessage(Message msg) {

        HandlerActivity activity = mActivity.get();

        if (activity != null) {

        }

    }

 

    private final MyHandler mHandler = new MyHandler(this);

    private static final Runnable mRunnable = new Runnable() {

        @Override

        public void run() { }

    };

    @Override

    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        mHandler.postDelayed(mRunnable, 1000 * 60 * 1);

        finish();

    }

}

复制代码

Activity生命周期结束时，清空消息队列
只需在Activity的onDestroy()方法中调用mHandler.removeCallbacksAndMessages(null);就行了。

@Override

protected void onDestroy() {

    super.onDestroy();

    if(handler!=null){

        handler.removeCallbacksAndMessages(null);

        handler = null;

    }

}

先进 简洁 安全。

在语法表现上，Kotlin够简洁明了。不防看看：你应该切换到Kotlin开发，它包含了零默认值和不可变性的安全特性，使你的Android应用程序在默认情况下是安全的 并且性能是良好的。

代码更安全

编写更安全的代码，并在应用程序中避免 发生Nullpointerexception。

var output: String

output = null   // Compilation error==================================val name: String? = null    // Nullable type

println(name.length())      // Compilation error 

语法更易读和简洁

Data Classes

更加专注于表达你自己的代码创意设计，无需编写更多的样板代码。

// Create a POJO with getters, setters, equals(), hashCode(), toString(), and copy() with a single line:

data class User(val name: String, val email: String)         

Lambdas语法

使用lambda来简化你的代码。

button.setOnClickListener(new View.OnClickListener(){

   @Override

   public void onClick(View v){

       doSomething();

   }

});          

button.setOnClickListener { doSomething() }    

默认的命名参数

通过使用默认参数减少重载函数的数量。使用命名参数调用函数，使自己的代码更具有可读性。

fun format(str: String,

          normalizeCase: Boolean = true,

          upperCaseFirstLetter: Boolean = true,

          divideByCamelHumps: Boolean = false,

          wordSeparator: Char = ' ') {

       …

   }==================================// Call function with named arguments.

format(str, normalizeCase = true, upperCaseFirstLetter = true)         

和 findViewById 说再见

在你自己的代码中避免findViewById() 调用。专注于写你的逻辑，而不需要那么繁琐。

import kotlinx.android.synthetic.main.content_main.*class MainActivity : AppCompatActivity() {   override fun onCreate(savedInstanceState: Bundle?) {

       super.onCreate(savedInstanceState)

       setContentView(R.layout.activity_main)

       // No need to call findViewById(R.id.textView) as TextView

       textView.text = "Kotlin for Android rocks!"   }

}          

扩展功能, 而不是用继承

扩展函数和属性使你可以轻松地扩展类的功能，而无需继承它们。调用代码是可读和自然的。

// Extend ViewGroup class with inflate function

fun ViewGroup.inflate(layoutRes: Int): View {

   return LayoutInflater.from(context).inflate(layoutRes, this, false)

}==================================// Call inflate directly on the ViewGroup instance

override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): ViewHolder {

   val v = parent.inflate(R.layout.view_item)

   return ViewHolder(v)

}

100%的和Java可互操作性

在你非常不是想用Java的情况下，尽量多地使用Kotlin。Kotlin是一种与Java完全可互操作的JVM语言。

// Calling Java code from Kotlin

class KotlinClass {

   fun kotlinDoSomething() {

       val javaClass = JavaClass()

       javaClass.javaDoSomething()

       println(JavaClass().prop)

   }

}==================================// Calling Kotlin code from Java

public class JavaClass {

   public String getProp() { return "Hello"; }

   public void javaDoSomething() {

       new KotlinClass().kotlinDoSomething();

   }

}          

强大的开发工具支持

Android Studio 3.0 提供了不错的工具来帮助你开始使用Kotlin开发。在将Java代码粘贴到Kotlin文件时，可以转换整个Java文件或转换一段代码片段。很稳！

Kotlin 是开放的

与Android一样，Kotlin是Apache 2.0下的一个开源项目。Google对 Kotlin 的选择重申了Android对开发者 开放生态系统的承诺，随着 Google 的发展和 Android平台的发展，Google 希望 kotlin 语言的发展， 也很高兴看到 kotlin 语言的发展。

Tamic的一些话

Java 10 的 新特性也刚好（ Java 10 新特性解密）迎合kotlin的某些特性一样，以后即将用var 来定义变量和类。 因此我们发现Koltin将来必定是开发者所关注的一名语言趋势，假如有一天，Google像抛弃 Eclispe，投坏Android Studio一样，放弃对Java的支持，到时候，至少你还能掌握kotlin开发，不然，你是要转行吗？

相关视频

Android进阶开发：函数与方法有本质区别 你知道吗

Git 有很多客户端工具，不过感觉还是命令行操作最好用，方便又快捷，不过命令行操作需要小伙伴们对 Git 命令比较熟练，这可能对有的人来说会有一些难度，所以，客户端工具有时候也不能抛弃，如果非要推荐一个 Git 客户端工具，我觉得还是 IDEA 中的 Git 插件吧。其他的 Git 客户端工具松哥之前也有体验过一些，不过感觉还是 IDEA 中的用起来更加省事。

今天这篇文章算是我第二次教大家在开发工具中使用 Git 了，刚毕业的时候，松哥写过一篇文章，教大家在 Eclipse 中使用 Git，那时候在 Eclipse 中使用 Git 是真的麻烦，光是插件就要安装半天，刚刚翻了一下那篇文章，已经是七年前的事情了。

七年之后，Eclipse 也没了往日的风光，IDEA 逐渐成了开发的主流工具，咱们今天就来捋一捋 IDEA 中使用 Git。

1. 基本配置

首先你要安装 Git，这个就不需要我多说了，IDEA 上默认也是安装了 Git 插件，可以直接使用。

为了给小伙伴们演示方便，我这里使用 GitHub 作为远程仓库，如果还有人不清楚 GitHub 和 Git 的区别，可以在公众号江南一点雨底部菜单栏查看 Git 教程，看完了就明白了。

从 2021.08.13 号开始，IDEA 上配置 GitHub 有一个小小的变化，即不能使用用户名密码的方式登录了，如果你尝试用用户名/密码的方式登录 GitHub 提交代码，会收到如下提示：

Support for password authentication was removed on August 13, 2021. 

Please use a personal access token instead.

在 IDEA 上使用用户名/密码的方法登录 GitHub 也会报如下错误：

需要我们点击右上角的 Use Token，使用令牌的方式登录 GitHub，令牌的生成方式如下：

1. 网页上登录你的 GitHub 账号。


2. 点击右上角，选择 Settings：

3. 拉到最下方，选择左边的 Developer settings：

4. 选择左边的 Personal access tokens，然后点击右上角的 Generate new token：

5. 填一下基本信息，选一下权限即可（权限需要选择 repo 和 gist，其他根据自己的需求选择）：

6. 最后会生成一个令牌，拷贝到 IDEA 中即可，如下：

这就是基本配置。

小伙伴们在公司做开发，一般是不会将 GitHub 作为远程仓库的，那么这块根据自己实际情况来配置就行了。

2. clone

头一天上班，首先上来要先 clone 项目下来，IDEA 中有对应的 clone 工具，我们直接使用即可：

这块也可以直接选择下面的 GitHub，然后直接从自己的 GitHub 仓库上拉取新代码。

clone 完成之后，IDEA 会提示是否打开该项目，选择 yes 即可。

代码 clone 下来之后，就可以根据松哥前文介绍的 Git Flow 开始开发了。

3. 分支

假设我们先创建 develop 和 release 分支，创建方式如下，选中当前工程，右键单击，然后依次选择 Git->Repository->Branches...：

或者依次点击顶部的 VCS->Git->Branches...：

当然两个方式都比较麻烦，直接点击 IDEA 的右下角最为省事，也是最常用的办法，如下图：

选择 New Branch，然后创建新的分支，勾选上 Checkout 表示分支创建成功后，切换到该分支上，如下：

选择一个分支，然后点击 Checkout，可以切换到该分支上：

接下来我们把 develop 分支提交到远程仓库，如下：

我们没有修改代码，所以直接点击 Push 按钮提交即可。

提交完成后，develop 后面多了 origin 前缀，Remote Branches 中也多了 develop 分支，说明提交成功。

现在假设我们想从 develop 上拉一个名为 feature-login 的分支，来完成登录功能，如下：

从创建的日志中，我们能看到 feature-login 确实是来自 develop：

好啦，接下来我们就可以愉快的开启一天的工作啦～

feature-login 上的功能开发完成后，首先点击 IDEA 的右上角完成本地仓库的提交，如下图：

填入提交的 Message，下方也能看到不同版本的内容对比，点击右下角完成代码提交，注意这个只是提交到本地仓库。

由于我们并不会将 feature-login 提交到远程仓库，所以接下来我们要将 feature-login 合并到 develop 然后将最新的 develop push 到远程仓库，操作方式如下：

1. 切换回 develop 分支。


2. 选择 feature-login->Merge into Current 进行合并。

合并完成后，如需删除 feature-login 分支，也可以在 IDEA 日志中顺手删除：

不过上面介绍的合并是快速合并，即让 develop 的指针指向了 feature-login，很多时候我们可能需要加上 --no-ff 参数来合并，那么步骤如下：

从 feature-login 切换回 develop 分支，然后如下：

此时我们看一眼提交日志，如下：

从这日志中也可以看出，此时不是快速合并模式了！

最后，选择 develop->Push，将代码提交到远程仓库。

4. pull

在 IDEA 中，如需从远程仓库中更新代码，点击右上角的按钮即可，如下图：

好啦，这就是一个大致的流程。

当然 Git 博大精深，IDEA 中支持的功能也非常多，其他功能就需要小伙伴们自己来摸索了，有不明白的欢迎留言讨论。

断言

1. 断言是一个逻辑判断，用于检查不应该发生的情况


2. Assert 关键字在 JDK1.4 中引入，可通过 JVM 参数-enableassertions开启


3. SpringBoot 中提供了 Assert 断言工具类，通常用于数据合法性检查

// 要求参数 object 必须为非空（Not Null），否则抛出异常，不予放行  

// 参数 message 参数用于定制异常信息。  

void notNull(Object object, String message)  

// 要求参数必须空（Null），否则抛出异常，不予『放行』。  

// 和 notNull() 方法断言规则相反  

void isNull(Object object, String message)  

// 要求参数必须为真（True），否则抛出异常，不予『放行』。  

void isTrue(boolean expression, String message)  

// 要求参数（List/Set）必须非空（Not Empty），否则抛出异常，不予放行  

void notEmpty(Collection collection, String message)  

// 要求参数（String）必须有长度（即，Not Empty），否则抛出异常，不予放行  

void hasLength(String text, String message)  

// 要求参数（String）必须有内容（即，Not Blank），否则抛出异常，不予放行  

void hasText(String text, String message)  

// 要求参数是指定类型的实例，否则抛出异常，不予放行  

void isInstanceOf(Class type, Object obj, String message)  

// 要求参数 `subType` 必须是参数 superType 的子类或实现类，否则抛出异常，不予放行  

void isAssignable(Class superType, Class subType, String message)  

对象、数组、集合

ObjectUtils

1. 获取对象的基本信息

// 获取对象的类名。参数为 null 时，返回字符串："null"   

String nullSafeClassName(Object obj)  

// 参数为 null 时，返回 0  

int nullSafeHashCode(Object object)  

// 参数为 null 时，返回字符串："null"  

String nullSafeToString(boolean[] array)  

// 获取对象 HashCode（十六进制形式字符串）。参数为 null 时，返回 0   

String getIdentityHexString(Object obj)  

// 获取对象的类名和 HashCode。 参数为 null 时，返回字符串：""   

String identityToString(Object obj)  

// 相当于 toString()方法，但参数为 null 时，返回字符串：""  

String getDisplayString(Object obj)  

2. 判断工具

// 判断数组是否为空  

boolean isEmpty(Object[] array)  

// 判断参数对象是否是数组  

boolean isArray(Object obj)  

// 判断数组中是否包含指定元素  

boolean containsElement(Object[] array, Object element)  

// 相等，或同为 null时，返回 true  

boolean nullSafeEquals(Object o1, Object o2)  

/*  

判断参数对象是否为空，判断标准为：  

   Optional: Optional.empty()  

      Array: length == 0  

CharSequence: length == 0  

 Collection: Collection.isEmpty()  

        Map: Map.isEmpty()  

*/  

boolean isEmpty(Object obj)  

3. 其他工具方法

// 向参数数组的末尾追加新元素，并返回一个新数组  

<A, O extends A> A[] addObjectToArray(A[] array, O obj)  

// 原生基础类型数组 --> 包装类数组  

Object[] toObjectArray(Object source)  

StringUtils

1. 字符串判断工具

// 判断字符串是否为 null，或 ""。注意，包含空白符的字符串为非空  

boolean isEmpty(Object str)  

// 判断字符串是否是以指定内容结束。忽略大小写  

boolean endsWithIgnoreCase(String str, String suffix)  

// 判断字符串是否已指定内容开头。忽略大小写  

boolean startsWithIgnoreCase(String str, String prefix)   

// 是否包含空白符  

boolean containsWhitespace(String str)  

// 判断字符串非空且长度不为 0，即，Not Empty  

boolean hasLength(CharSequence str)  

// 判断字符串是否包含实际内容，即非仅包含空白符，也就是 Not Blank  

boolean hasText(CharSequence str)  

// 判断字符串指定索引处是否包含一个子串。  

boolean substringMatch(CharSequence str, int index, CharSequence substring)  

// 计算一个字符串中指定子串的出现次数  

int countOccurrencesOf(String str, String sub)  

2. 字符串操作工具

// 查找并替换指定子串  

String replace(String inString, String oldPattern, String newPattern)  

// 去除尾部的特定字符  

String trimTrailingCharacter(String str, char trailingCharacter)   

// 去除头部的特定字符  

String trimLeadingCharacter(String str, char leadingCharacter)  

// 去除头部的空白符  

String trimLeadingWhitespace(String str)  

// 去除头部的空白符  

String trimTrailingWhitespace(String str)  

// 去除头部和尾部的空白符  

String trimWhitespace(String str)  

// 删除开头、结尾和中间的空白符  

String trimAllWhitespace(String str)  

// 删除指定子串  

String delete(String inString, String pattern)  

// 删除指定字符（可以是多个）  

String deleteAny(String inString, String charsToDelete)  

// 对数组的每一项执行 trim() 方法  

String[] trimArrayElements(String[] array)  

// 将 URL 字符串进行解码  

String uriDecode(String source, Charset charset)  

3. 路径相关工具方法

// 解析路径字符串，优化其中的 “..”   

String cleanPath(String path)  

// 解析路径字符串，解析出文件名部分  

String getFilename(String path)  

// 解析路径字符串，解析出文件后缀名  

String getFilenameExtension(String path)  

// 比较两个两个字符串，判断是否是同一个路径。会自动处理路径中的 “..”   

boolean pathEquals(String path1, String path2)  

// 删除文件路径名中的后缀部分  

String stripFilenameExtension(String path)   

// 以 “. 作为分隔符，获取其最后一部分  

String unqualify(String qualifiedName)  

// 以指定字符作为分隔符，获取其最后一部分  

String unqualify(String qualifiedName, char separator)  

CollectionUtils

1. 集合判断工具

// 判断 List/Set 是否为空  

boolean isEmpty(Collection<?> collection)  

// 判断 Map 是否为空  

boolean isEmpty(Map<?,?> map)  

// 判断 List/Set 中是否包含某个对象  

boolean containsInstance(Collection<?> collection, Object element)  

// 以迭代器的方式，判断 List/Set 中是否包含某个对象  

boolean contains(Iterator<?> iterator, Object element)  

// 判断 List/Set 是否包含某些对象中的任意一个  

boolean containsAny(Collection<?> source, Collection<?> candidates)  

// 判断 List/Set 中的每个元素是否唯一。即 List/Set 中不存在重复元素  

boolean hasUniqueObject(Collection<?> collection)  

2. 集合操作工具

// 将 Array 中的元素都添加到 List/Set 中  

<E> void mergeArrayIntoCollection(Object array, Collection<E> collection)    

// 将 Properties 中的键值对都添加到 Map 中  

<K,V> void mergePropertiesIntoMap(Properties props, Map<K,V> map)  

// 返回 List 中最后一个元素  

<T> T lastElement(List<T> list)    

// 返回 Set 中最后一个元素  

<T> T lastElement(Set<T> set)   

// 返回参数 candidates 中第一个存在于参数 source 中的元素  

<E> E findFirstMatch(Collection<?> source, Collection<E> candidates)  

// 返回 List/Set 中指定类型的元素。  

<T> T findValueOfType(Collection<?> collection, Class<T> type)  

// 返回 List/Set 中指定类型的元素。如果第一种类型未找到，则查找第二种类型，以此类推  

Object findValueOfType(Collection<?> collection, Class<?>[] types)  

// 返回 List/Set 中元素的类型  

Class<?> findCommonElementType(Collection<?> collection)  

文件、资源、IO 流

FileCopyUtils

1. 输入

// 从文件中读入到字节数组中  

byte[] copyToByteArray(File in)  

// 从输入流中读入到字节数组中  

byte[] copyToByteArray(InputStream in)  

// 从输入流中读入到字符串中  

String copyToString(Reader in)  

2. 输出

// 从字节数组到文件  

void copy(byte[] in, File out)  

// 从文件到文件  

int copy(File in, File out)  

// 从字节数组到输出流  

void copy(byte[] in, OutputStream out)   

// 从输入流到输出流  

int copy(InputStream in, OutputStream out)   

// 从输入流到输出流  

int copy(Reader in, Writer out)  

// 从字符串到输出流  

void copy(String in, Writer out)  

ResourceUtils

1. 从资源路径获取文件

// 判断字符串是否是一个合法的 URL 字符串。  

static boolean isUrl(String resourceLocation)  

// 获取 URL  

static URL getURL(String resourceLocation)   

// 获取文件（在 JAR 包内无法正常使用，需要是一个独立的文件）  

static File getFile(String resourceLocation)  

2. Resource

// 文件系统资源 D:...  

FileSystemResource  

// URL 资源，如 file://... http://...  

UrlResource  

// 类路径下的资源，classpth:...  

ClassPathResource  

// Web 容器上下文中的资源（jar 包、war 包）  

ServletContextResource  

// 判断资源是否存在  

boolean exists()  

// 从资源中获得 File 对象  

File getFile()  

// 从资源中获得 URI 对象  

URI getURI()  

// 从资源中获得 URI 对象  

URL getURL()  

// 获得资源的 InputStream  

InputStream getInputStream()  

// 获得资源的描述信息  

String getDescription()  

StreamUtils

1. 输入

void copy(byte[] in, OutputStream out)  

int copy(InputStream in, OutputStream out)  

void copy(String in, Charset charset, OutputStream out)  

long copyRange(InputStream in, OutputStream out, long start, long end)  

2. 输出

byte[] copyToByteArray(InputStream in)  

String copyToString(InputStream in, Charset charset)  

// 舍弃输入流中的内容  

int drain(InputStream in)   

反射、AOP

ReflectionUtils

1. 获取方法

// 在类中查找指定方法  

Method findMethod(Class<?> clazz, String name)   

// 同上，额外提供方法参数类型作查找条件  

Method findMethod(Class<?> clazz, String name, Class<?>... paramTypes)   

// 获得类中所有方法，包括继承而来的  

Method[] getAllDeclaredMethods(Class<?> leafClass)   

// 在类中查找指定构造方法  

Constructor<T> accessibleConstructor(Class<T> clazz, Class<?>... parameterTypes)   

// 是否是 equals() 方法  

boolean isEqualsMethod(Method method)   

// 是否是 hashCode() 方法   

boolean isHashCodeMethod(Method method)   

// 是否是 toString() 方法  

boolean isToStringMethod(Method method)   

// 是否是从 Object 类继承而来的方法  

boolean isObjectMethod(Method method)   

// 检查一个方法是否声明抛出指定异常  

boolean declaresException(Method method, Class<?> exceptionType)   

2. 执行方法

// 执行方法  

Object invokeMethod(Method method, Object target)    

// 同上，提供方法参数  

Object invokeMethod(Method method, Object target, Object... args)   

// 取消 Java 权限检查。以便后续执行该私有方法  

void makeAccessible(Method method)   

// 取消 Java 权限检查。以便后续执行私有构造方法  

void makeAccessible(Constructor<?> ctor)   

3. 获取字段

// 在类中查找指定属性  

Field findField(Class<?> clazz, String name)   

// 同上，多提供了属性的类型  

Field findField(Class<?> clazz, String name, Class<?> type)   

// 是否为一个 "public static final" 属性  

boolean isPublicStaticFinal(Field field)   

4. 设置字段

// 获取 target 对象的 field 属性值  

Object getField(Field field, Object target)   

// 设置 target 对象的 field 属性值，值为 value  

void setField(Field field, Object target, Object value)   

// 同类对象属性对等赋值  

void shallowCopyFieldState(Object src, Object dest)  

// 取消 Java 的权限控制检查。以便后续读写该私有属性  

void makeAccessible(Field field)   

// 对类的每个属性执行 callback  

void doWithFields(Class<?> clazz, ReflectionUtils.FieldCallback fc)   

// 同上，多了个属性过滤功能。  

void doWithFields(Class<?> clazz, ReflectionUtils.FieldCallback fc,   

                 ReflectionUtils.FieldFilter ff)   

// 同上，但不包括继承而来的属性  

void doWithLocalFields(Class<?> clazz, ReflectionUtils.FieldCallback fc)   

AopUtils

1. 判断代理类型

// 判断是不是 Spring 代理对象  

boolean isAopProxy()  

// 判断是不是 jdk 动态代理对象  

isJdkDynamicProxy()  

// 判断是不是 CGLIB 代理对象  

boolean isCglibProxy()  

2. 获取被代理对象的 class

// 获取被代理的目标 class  

Class<?> getTargetClass()  

AopContext

1. 获取当前对象的代理对象

Object currentProxy()

场景

在后端服务开发时，现在很流行的框架组合就是SSM（SpringBoot + Spring + MyBatis），在我们进行一些业务系统开发时，会有很多的业务数据表，而表中的信息从新插入开始，整个生命周期过程中可能会进行很多次的操作。

比如，我们在某网站购买一件商品，会生成一条订单记录，在支付完金额后订单状态会变为已支付，等最后我们收到订单商品，这个订单状态会变成已完成等。

假设我们的订单表t_order结果如下：

当订单创建时，需要设置insert_by，insert_time，update_by，update_time的值；

在进行订单状态更新时，则只需要更新update_by，update_time的值。

那应该如何处理呢？

麻瓜做法

最简单的做法，也是最容易想到的做法，就是在每个业务处理的代码中，对相关的字段进行处理。

比如订单创建的方法中，如下处理：

public void create(Order order){

    // ...其他代码

    // 设置审计字段

    Date now = new Date();

    order.setInsertBy(appContext.getUser());

    order.setUpdateBy(appContext.getUser());

    order.setInsertTime(now);

    order.setUpdateTime(now);

    orderDao.insert(order);

}

订单更新方法则只设置updateBy和updateTime：

public void update(Order order){

    // ...其他代码



    // 设置审计字段

    Date now = new Date();

    order.setUpdateBy(appContext.getUser());

    order.setUpdateTime(now);

    orderDao.insert(order);

}

这种方式虽然可以完成功能，但是存在一些问题：

• 需要在每个方法中按照不同的业务逻辑决定设置哪些字段；


• 在业务模型变多后，每个模型的业务方法中都要进行设置，重复代码太多。

那我们知道这种方式存在问题以后，就得找找有什么好方法对不对，往下看！

优雅做法

因为我们持久层框架更多地使用MyBatis，那我们就借助于MyBatis的拦截器来完成我们的功能。

首先我们来了解一下，什么是拦截器？

什么是拦截器？

MyBatis的拦截器顾名思义，就是对某些操作进行拦截。通过拦截器可以对某些方法执行前后进行拦截，添加一些处理逻辑。

MyBatis的拦截器可以对Executor、StatementHandler、PameterHandler和ResultSetHandler 接口进行拦截，也就是说会对这4种对象进行代理。

拦截器设计的初衷就是为了让用户在MyBatis的处理流程中不必去修改MyBatis的源码，能够以插件的方式集成到整个执行流程中。

比如MyBatis中的Executor有BatchExecutor、ReuseExecutor、SimpleExecutor和CachingExecutor，如果这几种实现的query方法都不能满足你的需求，我们可以不用去直接修改MyBatis的源码，而通过建立拦截器的方式，拦截Executor接口的query方法，在拦截之后，实现自己的query方法逻辑。

在MyBatis中的拦截器通过Interceptor接口表示，该接口中有三个方法。

public interface Interceptor {



  Object intercept(Invocation invocation) throws Throwable;



  Object plugin(Object target);



  void setProperties(Properties properties);



}

plugin方法是拦截器用于封装目标对象的，通过该方法我们可以返回目标对象本身，也可以返回一个它的代理。

当返回的是代理的时候我们可以对其中的方法进行拦截来调用intercept方法，当然也可以调用其他方法。

setProperties方法是用于在Mybatis配置文件中指定一些属性的。

使用拦截器更新审计字段

那么我们应该如何通过拦截器来实现我们对审计字段赋值的功能呢？

在我们进行订单创建和修改时，本质上是通过MyBatis执行insert、update语句，MyBatis是通过Executor来处理的。

我们可以通过拦截器拦截Executor，然后在拦截器中对要插入的数据对象根据执行的语句设置insert_by,insert_time,update_by,update_time等属性值就可以了。

自定义拦截器

自定义Interceptor最重要的是要实现plugin方法和intercept方法。

在plugin方法中我们可以决定是否要进行拦截进而决定要返回一个什么样的目标对象。

在intercept方法就是要进行拦截的时候要执行的方法。

对于plugin方法而言，其实Mybatis已经为我们提供了一个实现。Mybatis中有一个叫做Plugin的类，里面有一个静态方法wrap(Object target,Interceptor interceptor)，通过该方法可以决定要返回的对象是目标对象还是对应的代理。

但是这里还存在一个问题，就是我们如何在拦截器中知道要插入的表有审计字段需要处理呢？

因为我们的表中并不是所有的表都是业务表，可能有一些字典表或者定义表是没有审计字段的，这样的表我们不需要在拦截器中进行处理。

也就是说我们要能够区分出哪些对象需要更新审计字段。

这里我们可以定义一个接口，让需要更新审计字段的模型都统一实现该接口，这个接口起到一个标记的作用。

public interface BaseDO {

}



public class Order implements BaseDO{



    private Long orderId;



    private String orderNo;



    private Integer orderStatus;



    private String insertBy;



    private String updateBy;



    private Date insertTime;



    private Date updateTime;

    //... getter ,setter

}

接下来，我们就可以实现我们的自定义拦截器了。

@Component("ibatisAuditDataInterceptor")

@Intercepts({@Signature(method = "update", type = Executor.class, args = {MappedStatement.class, Object.class})})

public class IbatisAuditDataInterceptor implements Interceptor {



    private Logger logger = LoggerFactory.getLogger(IbatisAuditDataInterceptor.class);



    @Override

    public Object intercept(Invocation invocation) throws Throwable {

        // 从上下文中获取用户名

        String userName = AppContext.getUser();

        

        Object[] args = invocation.getArgs();

        SqlCommandType sqlCommandType = null;

        

        for (Object object : args) {

            // 从MappedStatement参数中获取到操作类型

            if (object instanceof MappedStatement) {

                MappedStatement ms = (MappedStatement) object;

                sqlCommandType = ms.getSqlCommandType();

                logger.debug("操作类型： {}", sqlCommandType);

                continue;

            }

            // 判断参数是否是BaseDO类型

            // 一个参数

            if (object instanceof BaseDO) {

                if (SqlCommandType.INSERT == sqlCommandType) {

                    Date insertTime = new Date();

                    BeanUtils.setProperty(object, "insertedBy", userName);

                    BeanUtils.setProperty(object, "insertTimestamp", insertTime);

                    BeanUtils.setProperty(object, "updatedBy", userName);

                    BeanUtils.setProperty(object, "updateTimestamp", insertTime);

                    continue;

                }

                if (SqlCommandType.UPDATE == sqlCommandType) {

                    Date updateTime = new Date();

                    BeanUtils.setProperty(object, "updatedBy", userName);

                    BeanUtils.setProperty(object, "updateTimestamp", updateTime);

                    continue;

                }

            }

            // 兼容MyBatis的updateByExampleSelective(record, example);

            if (object instanceof ParamMap) {

                logger.debug("mybatis arg: {}", object);

                @SuppressWarnings("unchecked")

                ParamMap<Object> parasMap = (ParamMap<Object>) object;

                String key = "record";

                if (!parasMap.containsKey(key)) {

                    continue;

                }

                Object paraObject = parasMap.get(key);

                if (paraObject instanceof BaseDO) {

                    if (SqlCommandType.UPDATE == sqlCommandType) {

                        Date updateTime = new Date();

                        BeanUtils.setProperty(paraObject, "updatedBy", userName);

                        BeanUtils.setProperty(paraObject, "updateTimestamp", updateTime);

                        continue;

                    }

                }

            }

            // 兼容批量插入

            if (object instanceof DefaultSqlSession.StrictMap) {

                logger.debug("mybatis arg: {}", object);

                @SuppressWarnings("unchecked")

                DefaultSqlSession.StrictMap<ArrayList<Object>> map = (DefaultSqlSession.StrictMap<ArrayList<Object>>) object;

                String key = "collection";

                if (!map.containsKey(key)) {

                    continue;

                }

                ArrayList<Object> objs = map.get(key);

                for (Object obj : objs) {

                    if (obj instanceof BaseDO) {

                        if (SqlCommandType.INSERT == sqlCommandType) {

                            Date insertTime = new Date();

                            BeanUtils.setProperty(obj, "insertedBy", userName);

                            BeanUtils.setProperty(obj, "insertTimestamp", insertTime);

                            BeanUtils.setProperty(obj, "updatedBy", userName);

                            BeanUtils.setProperty(obj, "updateTimestamp", insertTime);

                        }

                        if (SqlCommandType.UPDATE == sqlCommandType) {

                            Date updateTime = new Date();

                            BeanUtils.setProperty(obj, "updatedBy", userName);

                            BeanUtils.setProperty(obj, "updateTimestamp", updateTime);

                        }

                    }

                }

            }

        }

        return invocation.proceed();

    }



    @Override

    public Object plugin(Object target) {

        return Plugin.wrap(target, this);

    }



    @Override

    public void setProperties(Properties properties) {

    }

}

通过上面的代码可以看到，我们自定义的拦截器IbatisAuditDataInterceptor实现了Interceptor接口。

在我们拦截器上的@Intercepts注解，type参数指定了拦截的类是Executor接口的实现，method 参数指定拦截Executor中的update方法，因为数据库操作的增删改操作都是通过update方法执行。

配置拦截器插件

在定义好拦截器之后，需要将拦截器指定到SqlSessionFactoryBean的plugins中才能生效。所以要按照如下方式配置。

<bean id="transSqlSessionFactory" class="org.mybatis.spring.SqlSessionFactoryBean">

    <property name="dataSource" ref="transDataSource" />

    <property name="mapperLocations">

        <array>

            <value>classpath:META-INF/mapper/*.xml</value>

        </array>

    </property>

    <property name="plugins">

        <array>

            <!-- 处理审计字段 -->

            <ref bean="ibatisAuditDataInterceptor" />

        </array>

    </property>

到这里，我们自定义的拦截器就生效了，通过测试你会发现，不用在业务代码中手动设置审计字段的值，会在事务提交之后，通过拦截器插件自动对审计字段进行赋值。

小结

你好呀，我是歪歪。

前几天在某技术平台上看到别人提的关于 Synchronized 的一个用法问题，我觉得挺有意思的，这个问题其实也是我三年前面试某公司的时候遇到的一个真题，当时不知道面试官想要考什么，没有回答的特别好，后来研究了一下就记住了。

所以看到这个问题的时候觉得特别亲切，准备分享给你一起看看：

首先为了方便你看文章的时候复现问题，我给你一份直接拿出来就能跑的代码，希望你有时间的话也把代码拿出来跑一下：

public class SynchronizedTest {



    public static void main(String[] args) {

        Thread why = new Thread(new TicketConsumer(10), "why");

        Thread mx = new Thread(new TicketConsumer(10), "mx");

        why.start();

        mx.start();

    }

}



class TicketConsumer implements Runnable {



    private volatile static Integer ticket;



    public TicketConsumer(int ticket) {

        this.ticket = ticket;

    }



    @Override

    public void run() {

        while (true) {

            System.out.println(Thread.currentThread().getName() + "开始抢第" + ticket + "张票，对象加锁之前：" + System.identityHashCode(ticket));

            synchronized (ticket) {

                System.out.println(Thread.currentThread().getName() + "抢到第" + ticket + "张票，成功锁到的对象：" + System.identityHashCode(ticket));

                if (ticket > 0) {

                    try {

                        //模拟抢票延迟

                        TimeUnit.SECONDS.sleep(1);

                    } catch (InterruptedException e) {

                        e.printStackTrace();

                    }

                    System.out.println(Thread.currentThread().getName() + "抢到了第" + ticket-- + "张票，票数减一");

                } else {

                    return;

                }

            }

        }

    }

}

程序逻辑也很简单，是一个模拟抢票的过程，一共 10 张票，开启两个线程去抢票。

票是共享资源，且有两个线程来消费，所以为了保证线程安全，TicketConsumer 的逻辑里面用了 synchronized 关键字。

这是应该是大家在初学 synchronized 的时候都会写到的例子，期望的结果是 10 张票，两个人抢，每张票只有一个人能抢到。

但是实际运行结果是这样的，我只截取开始部分的日志：

截图里面有三个框起来的部分。

最上面的部分，就是两个人都在抢第 10 张票，从日志输出上看也完全没有任何毛病，最终只有一个人抢到了票，然后进入到第 9 张票的争夺过程。

但是下面被框起来的第 9 张票的争夺部分就有点让人懵逼了：

why抢到第9张票，成功锁到的对象：288246497

mx抢到第9张票，成功锁到的对象：288246497

为什么两个人都抢到了第 9 张票，且成功锁到的对象都一样的？

这玩意，超出认知了啊。

这两个线程怎么可能拿到同一把锁，然后去执行业务逻辑呢？

所以，提问者的问题就浮现出来了。

• 1.为什么 synchronized 没有生效？


• 2.为什么锁对象 System.identityHashCode 的输出是一样的？

为什么没有生效？

我们先来看一个问题。

首先，我们从日志的输出上已经非常明确的知道，synchronized 在第二轮抢第 9 张票的时候失效了。

经过理论知识支撑，我们知道 synchronized 失效，肯定是锁出问题了。

如果只有一把锁，多个线程来竞争同一把锁，synchronized 绝对是不会有任何毛病的。

但是这里两个线程并没有达成互斥的条件，也就是说这里绝对存在的不止一把锁。

这是我们可以通过理论知识推导出来的结论。

先得出结论了，那么我怎么去证明“锁不止一把”呢？

能进入 synchronized 说明肯定获得了锁，所以我只要看各个线程持有的锁是什么就知道了。

那么怎么去看线程持有什么锁呢？

jstack 命令，打印线程堆栈功能，了解一下？

这些信息都藏在线程堆栈里面，我们拿出来一看便知。

在 idea 里面怎么拿到线程堆栈呢？

这就是一个在 idea 里面调试的小技巧了，我之前的文章里面应该也出现过多次。

首先为了方便获取线程堆栈信息，我把这里的睡眠时间调整到 10s：

跑起来之后点击这里的“照相机”图标：

点击几次就会有对应点击时间点的几个 Dump 信息：

由于我需要观察前两次锁的情况，而每次线程进入锁之后都会等待 10s 时间，所以我就在项目启动的第一个 10s 和第二个 10s 之间各点击一次就行。

为了更直观的观察数据，我选择点击下面这个图标，把 Dump 信息复制下来：

复制下来的信息很多，但是我们只需要关心 why 和 mx 这两个线程即可。

这是第一次 Dump 中的相关信息：

mx 线程是 BLOCKED 状态，它在等待地址为 0x000000076c07b058 的锁。

why 线程是 TIMED_WAITING 状态，它在 sleeping，说明它抢到了锁，在执行业务逻辑。而它抢到的锁，你说巧不巧，正是 mx 线程等待的 0x000000076c07b058。

从输出日志上来看，第一次抢票确实是 why 线程抢到了：

从 Dump 信息看，两个线程竞争的是同一把锁，所以第一次没毛病。

好，我们接着看第二次的 Dump 信息：

这一次，两个线程都在 TIMED_WAITING，都在 sleeping，说明都拿到了锁，进入了业务逻辑。

但是仔细一看，两个线程拿的锁是不相同的锁。

mx 锁的是 0x000000076c07b058。

why 锁的是 0x000000076c07b048。

由于不是同一把锁，所以并不存在竞争关系，因此都可以进入 synchronized 执行业务逻辑，所以两个线程都在 sleeping，也没毛病。

然后，我再把两次 Dump 的信息放在一起给你看一下，这样就更直观了：

如果我用“锁一”来代替 0x000000076c07b058，“锁二”来代替 0x000000076c07b048。

那么流程是这样的：

why 加锁一成功，执行业务逻辑，mx 进入锁一等待状态。

why 释放锁一，等待锁一的 mx 被唤醒，持有锁一，继续执行业务。

同时 why 加锁二成功，执行业务逻辑。

从线程堆栈中，我们确实证明了 synchronized 没有生效的原因是锁发生了变化。

同时，从线程堆栈中我们也能看出来为什么锁对象 System.identityHashCode 的输出是一样的。

第一次 Dump 的时候，ticket 都是 10，其中 mx 没有抢到锁，被 synchronized 锁住。

why 线程执行了 ticket-- 操作，ticket 变成了 9，但是此时 mx 线程被锁住的 monitor 还是 ticket=10 这个对象，它还在 monitor 的 _EntryList 里面等着的，并不会因为 ticket 的变化而变化。

所以，当 why 线程释放锁之后，mx 线程拿到锁继续执行，发现 ticket=9。

而 why 也搞到一把新锁，也可以进入 synchronized 的逻辑，也发现 ticket=9。

好家伙，ticket 都是 9， System.identityHashCode 能不一样吗？

按理来说，why 释放锁一后应该继续和 mx 竞争锁一，但是却不知道它在哪搞到一把新锁。

那么问题就来了：锁为什么发生了变化呢？

谁动了我的锁？

经过前面一顿分析，我们坐实了锁确实发生了变化，当你分析出这一点的时候勃然大怒，拍案而起，大喊一声：是哪个瓜娃子动了我的锁？这不是坑爹吗？

按照我的经验，这个时候不要急着甩锅，继续往下看，你会发现小丑竟是自己：

抢完票之后，执行了 ticket-- 的操作，而这个 ticket 不就是你的锁对象吗？

这个时候你把大腿一拍，恍然大悟，对着围观群众说：问题不大，手抖而已。

于是大手一挥，把加锁的地方改成这样：

synchronized (TicketConsumer.class)

利用 class 对象来作为锁对象，保证了锁的唯一性。

经过验证也确实没毛病，非常完美，打完收工。

但是，真的就收工了吗？

其实关于锁对象为什么发生了变化，还隔了一点点东西没有说出来。

它就藏在字节码里面。

我们通过 javap 命令，反查字节码，可以看到这样的信息：

Integer.valueOf 这是什么玩意？

让人熟悉的 Integer 从 -128 到 127 的缓存。

也就是说我们的程序里面，会涉及到拆箱和装箱的过程，这个过程中会调用到 Integer.valueOf 方法。具体其实就是 ticket-- 的这个操作。

对于 Integer，当值在缓存范围内的时候，会返回同一个对象。当超过缓存范围，每次都会 new 一个新对象出来。

这应该是一个必备的八股文知识点，我在这里给你强调这个是想表达什么意思呢？

很简单，改动一下代码就明白了。

我把初始化票数从 10 修改为 200，超过缓存范围，程序运行结果是这样的：

很明显，从第一次的日志输出来看，锁都不是同一把锁了。

这就是我前面说的：因为超过缓存范围，执行了两次 new Integer(200) 的操作，这是两个不同的对象，拿来作为锁，就是两把不一样的锁。

再修改回 10，运行一次，你感受一下：

从日志输出来看，这个时候只有一把锁，所以只有一个线程抢到了票。

因为 10 是在缓存范围内的数字，所以每次是从缓存中获取出来，是同一个对象。

我写这一小段的目的是为了体现 Integer 有缓存这个知识点，大家都知道。但是当它和其他东西揉在一起的时候因为这个缓存会带来什么问题，你得分析出来，这比直接记住干瘪的知识点有效一点。

但是...

我们的初始票是 10，ticket-- 之后票变成了 9，也是在缓存范围内的呀，怎么锁就变了呢？

如果你有这个疑问的话，那么我劝你再好好想想。

10 是 10，9 是 9。

虽然它们都在缓存范围内，但是本来就是两个不同的对象，构建缓存的时候也是 new 出来的：

为什么我要补充这一段看起来很傻的说明呢？

因为我在网上看到其他写类似问题的时候，有的文章写的不清楚，会让读者误认为“缓存范围内的值都是同一个对象”，这样会误导初学者。

总之一句话：请别用 Integer 作为锁对象，你把握不住。

但是...

stackoverflow

但是，我写文章的时候在 stackoverflow 上也看到了一个类似的问题。

这个哥们的问题在于：他知道 Integer 不能做为锁对象，但是他的需求又似乎必须把 Integer 作为锁对象。

stackoverflow.com/questions/6…

我给你描述一下他的问题。

首先看标号为 ① 的地方，他的程序其实就是先从缓存中获取，如果缓存中没有则从数据库获取，然后在放到缓存里面去。

非常简单清晰的逻辑。

但是他考虑到并发的场景下，如果有多个线程同一时刻都来获取同一个 id，但是这个 id 对应的数据并没有在缓存里面，那么这些线程都会去执行查询数据库并维护缓存的动作。

对应查询和存储的动作，他用的是 fairly expensive 来形容。

就是“相当昂贵”的意思，说白了就是这个动作非常的“重”，最好不要重复去做。

所以只需要让某一个线程来执行这个 fairly expensive 的操作就好了。

于是他想到了标号为 ② 的地方的代码。

用 synchronized 来把 id 锁一下，不幸的是，id 是 Integer 类型的。

在标号为 ③ 的地方他自己也说了：不同的 Integer 对象，它们并不会共享锁，那么 synchronized 也没啥卵用。

其实他这句话也不严谨，经过前面的分析，我们知道在缓存范围内的 Integer 对象，它们还是会共享同一把锁的，这里说的“共享”就是竞争的意思。

但是很明显，他的 id 范围肯定比 Integer 缓存范围大。

那么问题就来了：这玩意该咋搞啊？

我看到这个问题的时候想到的第一个问题是：上面这个需求我好像也经常做啊，我是怎么做的来着？

想了几秒恍然大悟，哦，现在都是分布式应用了，我特么直接用的是 Redis 做锁呀。

根本就没有考虑过这个问题。

如果现在不让用 Redis，就是单体应用，那么怎么解决呢？

在看高赞回答之前，我们先看看这个问题下面的一个评论：

开头三个字母：FYI。

看不懂没关系，因为这个不是重点。

但是你知道的，我的英语水平 very high，所以我也顺便教点英文。

FYI，是一个常用的英文缩写，全称是 for your information，供参考的意思。

所以你就知道，他后面肯定是给你附上一个资料了，翻译过来就是： Brian Goetz 在他的 Devoxx 2018 演讲中提到，我们不应该把 Integer 作为锁。

你可以通过这个链接直达这一部分的讲解，只有不到 30s秒的时间，随便练练听力：http://www.youtube.com/watch?v=4r2…

那么问题又来了？

Brian Goetz 是谁，凭什么他说的话看起来就很权威的样子？

Java Language Architect at Oracle，开发 Java 语言的，就问你怕不怕。

同时，他还是我多次推荐过的《Java并发编程实践》这本书的作者。

好了，现在也找到大佬背书了，接下来带你看看高赞回答是怎么说的。

前部分就不详说了，其实就是我们前面提到的那一些点，不能用 Integer ，涉及到缓存内、缓存外巴拉巴拉的...

关注划线的部分，我加上自己的理解给你翻译一下：

如果你真的必须用 Integer 作为锁，那么你需要搞一个 Map 或 Integer 的 Set，通过集合类做映射，你就可以保证映射出来的是你想要的明确的一个实例。而这个实例，就那可以拿来做锁。

然后他给出了这样的代码片段：

就是用 ConcurrentHashMap 然后用 putIfAbsent 方法来做一个映射。

比如多次调用 locks.putIfAbsent(200, 200)，在 map 里面也只有一个值为 200 的 Integer 对象，这是 map 的特性保证的，无需过多解释。

但是这个哥们很好，为了防止有人转不过这个弯，他又给大家解释了一下。

首先，他说你也可以这样的写：

但这样一来，你就会多产生一个很小成本，就是每次访问的时候，如果这个值没有被映射，你都会创建一个 Object 对象。

为了避免这一点，他只是把整数本身保存在 Map 中。这样做的目的是什么？这与直接使用整数本身有什么不同呢？

他是这样解释的，其实就是我前面说的“这是 map 的特性保证的”：

当你从 Map 中执行 get() 时，会用到 equals() 方法比较键值。

两个相同值的不同 Integer 实例，调用 equals() 方法是会判定为相同的 。

因此，你可以传递任何数量的 "new Integer(5)" 的不同 Integer 实例作为 getCacheSyncObject 的参数，但是你将永远只能得到传递进来的包含该值的第一个实例。

就是这个意思：

汇总一句话：就是通过 Map 做了映射，不管你 new 多少个 Integer 出来，这多个 Integer 都会被映射为同一个 Integer，从而保证即使超出 Integer 缓存范围时，也只有一把锁。

除了高赞回答之外，还有两个回答我也想说一下。

第一个是这个：

不用关心他说的内容是什么，只是我看到这句话翻译的时候虎躯一震：

skin this cat ？？？

太残忍了吧。

我当时就觉得这个翻译肯定不太对，这肯定是一个小俚语。于是考证了一下，原来是这个意思：

免费送你一个英语小知识，不用客气。

第二个应该关注的回答排在最后：

这个哥们叫你看看《Java并发编程实战》的第 5.6 节的内容，里面有你要寻找的答案。

巧了，我手边就有这本书，于是我翻开看了一眼。

第 5.6 节的名称叫做“构建高效且可伸缩的结果缓存”：

好家伙，我仔细一看这一节，发现这是宝贝呀。

你看书里面的示例代码：

不就和提问题的这个哥们的代码如出一辙吗？

都是从缓存中获取，拿不到再去构建。

不同的地方在于书上把 synchronize 加在了方法上。但是书上也说了，这是最差的解决方案，只是为了引出问题。

随后他借助了 ConcurrentHashMap、putIfAbsent 和 FutureTask 给出了一个相对较好的解决方案。

你可以看到完全是从另外一个角度去解决问题的，根本就没有在 synchronize 上纠缠，直接第二个方法就拿掉了 synchronize。

看完书上的方案后我才恍然大悟：好家伙，虽然前面给出的方案可以解决这个问题，但是总感觉怪怪的，又说不出来哪里怪。原来是死盯着 synchronize 不放，思路一开始就没打开啊。

书里面一共给出了四段代码，解决方案层层递进，具体是怎么写的，由于书上已经写的很清楚了，我就不赘述了，大家去翻翻书就行了。

没有书的直接在网上搜“构建高效且可伸缩的结果缓存”也能搜出原文。

我就指个路，看去吧。

作用

Bindings 主要配合 GetX 路由和依赖一起使用，作用是在路由跳转页面加载时注入当前页面所需的依赖关系。Bindings 的好处是能统一管理页面的依赖关系，当业务复杂时可能一个页面需要注入大量的依赖，此时使用 Bindings 能更方便的维护页面的依赖关系。

使用

前面说了 Bindings 需要结合 GetX 路由一起使用，而 GetX 路由分为普通路由和别名路由，接下来分别看看如何使用。

首选创建一个自定义 Bindings 继承自 Bindings，比如计数器界面，创建一个 CounterBindings 在 dependencies 方法中注入 CounterController， 代码如下：

class CounterBinding extends Bindings {

  @override

  void dependencies() {

    Get.lazyPut(() => CounterController());

  }

}

上面通过 lazyPut 懒加载方式注入的，也可以使用前面讲到的其他注入方式注入。

普通路由

普通路由使用 Bindings 很简单，在路由跳转时加上 binding 参数传入创建的自定义 Bindings 对象即可：

Get.to(CounterPage(), binding: CounterBinding());



Get.off(CounterPage(), binding: CounterBinding());



Get.offAll(CounterPage(), binding: CounterBinding());

这样通过路由进入 CounterPage 时就会自动调用 CounterBinding 的 dependencies 方法初始化注入对应的依赖，在 CounterPage 中就能正常使用 Get.find 获取到注入的 CounterController 对象。

别名路由

Flutter应用框架搭建(一)GetX集成及使用详解 一文中介绍了别名路由的使用，需要先创建 GetPage 确定别名与页面的关系并配置到 GetMaterialApp 的 getPages 中，使用时通过 Get.toNamed 进行路由跳转，而 Get.toNamed 方法并没有 binding 参数用于传入 Bindings。

使用别名路由时需要在创建 GetPage 时就传入 Bindings 对象，如下：

GetPage(name: "/counter", page: () => CounterPage(), binding: CounterBinding());

跳转时正常使用 Get.toNamed 就能达到同样的效果。

Get.toNamed("/counter");

别名路由与普通路由对于 Bindings 的使用上还有一个区别，普通路由只有一个 binding 参数，只能传入一个 Bindings 对象，而别名路由除了 binding 参数以外还有一个 bindings 参数，可传入 Bindings 数组。使用如下：

GetPage(

  name: "/counter",

  page: () => CounterPage(),

  binding: CounterBinding(),

  bindings: [PageABinding(), PageBBinding(), PageCBinding()]);

那 bindings 的作用是什么呢？为什么需要传入一个数组？

通常一个页面只需要一个 Bindings 用来管理页面的依赖，但是当使用到 ViewPager 等嵌套组件或者存在页面嵌套时，因为页面中嵌套的页面不是通过路由加载出来的所以无法自动调用 Bindings 的 dependencies 方法来初始化依赖关系，而嵌套的页面有可能也需要单独显示，为了提高页面的复用性也会为嵌套页面创建 Bindings ，这样当页面嵌套使用时就可以把嵌套页面的 Bindings 传入到主页面路由的 bindings 中，使用如下：

/// ViewPager 页面路由

GetPage(

  name: "/viewpager",

  page: () => ViewPagerPage(),

  binding: ViewPagerBinding(),

  bindings: [PageABinding(), PageBBinding(), PageCBinding()]);



/// 单独 PageA pageB pageC 路由

GetPage(

  name: "/pageA",

  page: () => PageAPage(),

  binding: PageABinding(),);

GetPage(

  name: "/pageB",

  page: () => PageBPage(),

  binding: PageBBinding(),);

GetPage(

  name: "/pageC",

  page: () => PageCPage(),

  binding: PageCBinding(),);



/// 使用

Get.toNamed("/viewpager");



Get.toNamed("/pageA");

Get.toNamed("/pageB");

Get.toNamed("/pageC");

这样就能实现，当在 ViewPager 中使用时也能初始化 ViewPager 中嵌套页面的依赖，单独使用某个 Page 时也能正常加载依赖。

原理

前面讲了 Bindings 的作用和使用方法，下面通过源码简单分析一下 Bindings 的原理。

Bindings 是一个抽象类，只有一个 dependencies 抽象方法，源码如下：

abstract class Bindings {

  void dependencies();

}

在页面路由中注册 Bindings 后，页面初始化时会调用 Bindings 的 dependencies 方法，初始化页面依赖，其调用是在 GetPageRoute 的 buildContent 中，而 GetPageRoute 是继承至 Flutter 的 PageRoute 即在路由跳转加载页面内容时调用， 核心源码如下：

Widget _getChild() {

  if (_child != null) return _child!;

  final middlewareRunner = MiddlewareRunner(middlewares);



  /// 获取 Bindings

  final localbindings = [

    if (bindings != null) ...bindings!,

    if (binding != null) ...[binding!]

  ];

  /// 调用中间件的 onBindingsStart 方法

  final bindingsToBind = middlewareRunner.runOnBindingsStart(localbindings);

  

  /// 调用 Bindings 的 dependencies 方法

  if (bindingsToBind != null) {

    for (final binding in bindingsToBind) {

      binding.dependencies();

    }

  }



  final pageToBuild = middlewareRunner.runOnPageBuildStart(page)!;

  _child = middlewareRunner.runOnPageBuilt(pageToBuild());

  return _child!;

}



@override

Widget buildContent(BuildContext context) {

  return _getChild();

}

源码核心代码就是在创建页面 Widget 时获取路由传入的 Bindings ，然后依次调用 Bindings 的 dependencies 方法。

其中：

  /// 获取 Bindings

  final localbindings = [

    if (bindings != null) ...bindings!,

    if (binding != null) ...[binding!]

  ];

  /// 调用中间件的 onBindingsStart 方法

  final bindingsToBind = middlewareRunner.runOnBindingsStart(localbindings);

  

  /// 调用 Bindings 的 dependencies 方法

  if (bindingsToBind != null) {

    for (final binding in bindingsToBind) {

      binding.dependencies();

    }

  }

就是将路由中传入的 bindings 和 binding 取出放入同一个数组。然后依次调用 dependencies 方法，其中 binding 就是路由或 GetPage 中传入的 binding 参数，而 bindings 就是使用别名路由时在 ``GetPage 中传入的 Bindings 数组。

总结

本文通过介绍在 GetX 依赖注入中 Bindings 的作用以及使用方法，再结合 GetX 的源码分析了 Bindings 的实现原理，更进一步了解了 Bindings 为什么能实现页面依赖注入的管理，希望通过源码让大家更好的理解 GetX 中的 Bindings ，从而在开发中灵活使用 Bindings 管理页面所需的依赖。

前言

初学 Flutter 的时候，一个很大的感受就是组件嵌套层级很深，写下来的代码找对应的括号都找不到。比如下面这种情况，从最外层的 Scaffold 到最里层的 Image.asset，一共有7层组件嵌套。这还不算多的，最夸张是见过一个表单页面写了10多层，代码的阅读体验非常糟糕，而且如果不小心删除了一个括号要找半天才对应得上。当然，通过 VSCode 彩虹括号（Rainbow Brackets）这个插件能够一定程度上解决括号对称查找得问题，但是代码的可维护性、阅读体验还是很差。自然而然，大家会想到拆分。拆分有两种方式，一种是使用返回Widget 的函数，另一种是使用 StatelessWidget，那这两种该如何选择呢？

拆分原则

在关于这个问题的讨论上，2年前 StackOverflow 有一个经典的回答：使用函数和使用类来构建可复用得组件有什么区别？，大家可以去看看。其中提到得一个关键因素是 Flutter 框架能够检测组件树的类对象，从而提高复用性。而对于私有的方法来说 Flutter 在更新的时候并不知道该如何处理。

答主也对比了使用类和函数的优劣势。使用类构建的方式：

• 支持性能优化，比如使用 const 构造方法，更细颗粒度的刷新；


• 两个不同的布局切换时，能够正确地销毁对应得资源。这个我们在上篇讲 StatefulWidget 的时候有介绍过。


• 保证正确的方式进行热重载，而使用函数可能破坏热重载。


• 在 Widget Inspector 中可以查看得到，从而可以方便我们定位和调试问题。


• 更友好的错误提示。当组件树出现错误时，框架会给出当前构建得组件名称，而如果使用函数的话则得不到清晰得名词。


• 可以使用 key 提高性能。


• 可以使用 context 提供的方法（函数式组件除非显示地传递 context）。

使用函数构建组件唯一的优势就是代码量会更少（这可以通过 functional_widget 插件解决，functional_widget 是一个通过注解将和函数式组件构建方式自动转换为类组件的代码生成插件）。

示例对比

下面我们看一段没有拆分的代码，这个仅仅是示例代码，没有任何实际意义。

class _MyStatefulWidgetState extends State<MyStatefulWidget> {

  int _counter = 0;



  @override

  Widget build(BuildContext context) {

    return Row(

      children: [

        Text('Counter: $_counter'),

        Container(

          child: Column(

            children: [

              Text('Hello'),

              Row(

                children: [

                  Text('there'),

                  Text('world!'),

                ],

              ),

            ],

          ),

        ),

      ],

    );

  }

}

括号有点多，对吧，一眼看过去都懵圈了 —— 这也是很多初次接触 Flutter 的人吐槽地方，可以说让不少人直接放弃了! 最直接的方式就是将部分代码抽离成为一个私有方法，比如像下面这样。

class _MyStatefulWidgetState extends State<MyStatefulWidget> {

  int _counter = 0;



  Widget _buildNonsenseWidget() {

    return Container(

      child: Column(

        children: [

          Text('Hello'),

          Row(

            children: [

              Text('there'),

              Text('world!'),

            ],

          ),

        ],

      ),

    );

  }



  @override

  Widget build(BuildContext context) {

    return Row(

      children: [

        Text('Counter: $_counter'),

        _buildNonsenseWidget(),

      ],

    );

  }

}

将深度嵌套的组件代码单独抽成了一个返回 Widget 的私有方法，看起来确实让代码简洁不少。
那么问题就解决了吗？我们来看一下当状态改变的时候会发生什么。
我们知道，当状态变量_counter改变后，Flutter 会调用 build 方法刷新组件。这会导致 _buildNonsenseWidget 这个方法在刷新的时候每次都会被调用，意味着每次都会创建新的组件来替换旧的组件，即便两个组件没有任何改变。而事实上，我们应该只重建那些变化的组件，从而提高性能。
现在再来看使用类组件的方式，实际上有代码模板的情况下，编写一个 StatelessWidget 非常简单。使用类组件后的代码如下所示。代码确实会比函数的方式多，但是实际上大部分不需要我们手敲。

class _MyStatefulWidgetState extends State<MyStatefulWidget> {

  int _counter = 0;



  @override

  Widget build(BuildContext context) {

    return Row(

      children: [

        Text('Counter: $_counter'),



        // The deeply nesting widget is now refactored into a

        // stateless const widget. No more needless rebuilding!

        const _NonsenseWidget(),

      ],

    );

  }

}



class _NonsenseWidget extends StatelessWidget {

  const _NonsenseWidget();



  @override

  Widget build(BuildContext context) {

    return Container(

      child: Column(

        children: [

          Text('Hello'),

          Row(

            children: [

              Text('there'),

              Text('world!'),

            ],

          ),

        ],

      ),

    );

  }

}

这里注意，以为这个_NonsenseWidget 在组件得声明周期不会改变，因此使用了 const 的构造方法。这样在刷新过程中，就不会重新构建了！关于 const 可以参考之前的两篇文章。

关于 StatefulWidget，你不得不知道的原理和要点！

解密 Flutter 的 const 关键字

总结

相比使用函数构建复用的组件代码，请尽可能地使用类组件的方式，而且尽可能地将组件拆分为小一点的单元。这样一方面可以提供精确的刷新，另一方面则是可以将组件复用到其他页面中。如果你不想改变自己得习惯，那么可以考虑使用 functional_widget 这个插件来自动生成类组件。

桶排序也叫箱排序，工作的原理是将数组分到有限数量的桶里。每个桶再进行排序排序，可能再使用别的排序算法或者是以递归的方式继续使用桶排序进行排序，桶排序是鸽巢排序的一种归纳结果。

当输入在一个范围内均匀分布时，桶排序非常好用。

例如：对范围从0.0到1.0且均匀分布在该范围内的大量浮点数进行排序。

创建桶算法的方法：

1. 创建n个空桶（列表）。


2. 对每个数组元素arr[i]插入bucket[n*array[i]]


3. 使用插入排序对各个桶进行排序


4. 连接所有的排序桶

Java示例：

import java.util.*;

import java.util.Collections;



class GFG {



	// 使用桶排序对大小为 n 的 arr[] 进行排序

	static void bucketSort(float arr[], int n)

	{

		if (n <= 0)

			return;



		// 1) 创建 n 个空桶

		@SuppressWarnings("unchecked")

		Vector<Float>[] buckets = new Vector[n];



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

			buckets[i] = new Vector<Float>();

		}



		// 2) 将数组元素放在不同的桶中

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

			float idx = arr[i] * n;

			buckets[(int)idx].add(arr[i]);

		}



		// 3) 对单个存储桶进行排序

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

			Collections.sort(buckets[i]);

		}



		// 4) 将所有桶连接到 arr[]

		int index = 0;

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

			for (int j = 0; j < buckets[i].size(); j++) {

				arr[index++] = buckets[i].get(j);

			}

		}

	}



	public static void main(String args[])

	{

		float arr[] = { (float)0.897, (float)0.565,

						(float)0.656, (float)0.1234,

						(float)0.665, (float)0.3434 };



		int n = arr.length;

		bucketSort(arr, n);



		System.out.println("排序后的数组为 ");

		for (float el : arr) {

			System.out.print(el + " ");

		}

	}

}

输出

排序后的数组为

0.1234 0.3434 0.565 0.656 0.665 0.897

性能

时间复杂度： 如果我们假设在桶中插入需要 O(1) 时间，那么上述算法的第 1 步和第 2 步显然需要 O(n) 时间。如果我们使用链表来表示桶，O(1) 很容易实现。第 4 步也需要 O(n) 时间，因为所有桶中都会有 n 个项目。 
分析的主要步骤是步骤 3。如果所有数字均匀分布，这一步平均也需要 O(n) 时间。

包含负数的情况

上面的例子是桶排序时在对大于零的数组进行排序，对于包含负数的情况需要用下述的方法解决。

1. 将数组拆分为两部分创建两个空向量 Neg[], Pos[]（分别存正数和负数）通过转换将所有负，元素存储在 Neg[]，变为正数（Neg[i] = -1 * Arr[i]），将所有 +ve 存储在 pos[] (pos[i] = Arr[i])


2. 调用函数bucketSortPositive(Pos, pos.size())，调用函数 bucketSortPositive(Neg, Neg.size())，bucketSortPositive(arr[], n)


3. 创建n个空桶（或列表）。


4. 将每个数组元素 arr[i] 插入 bucket[n*array[i]]


5. 使用插入排序对单个桶进行排序。


6. 连接所有排序的桶。

Java示例

import java.util.*;

class GFG

{



// 使用桶排序对大小为 n 的 arr[] 进行排序

static void bucketSort(Vector<Double> arr, int n)

{



	// 1) 创建 n 个空桶

	@SuppressWarnings("unchecked")

	Vector<Double> b[] = new Vector[n];

	for (int i = 0; i < b.length; i++)

	b[i] = new Vector<Double>();



	// 2) 将数组元素放在不同的桶中

	for (int i = 0; i < n; i++)

	{

	int bi = (int)(n*arr.get(i)); // 桶中索引

	b[bi].add(arr.get(i));

	}



	// 3) 对单个存储桶进行排序

	for (int i = 0; i < n; i++)

	Collections.sort(b[i]);



	// 4) 将所有桶连接到 arr[]

	int index = 0;

	arr.clear();

	for (int i = 0; i < n; i++)

	for (int j = 0; j < b[i].size(); j++)

		arr.add(b[i].get(j));

}



// 这个函数主要是把数组一分为二，然后对两个数组调用bucketSort()。 

static void sortMixed(double arr[], int n)

{

	Vector<Double>Neg = new Vector<>();

	Vector<Double>Pos = new Vector<>();



	// 遍历数组元素

	for (int i = 0; i < n; i++)

	{

	if (arr[i] < 0)



		// 通过转换为 +ve 元素来存储 -Ve 元素

		Neg.add (-1 * arr[i]) ;

	else



		// 存储 +ve 元素

		Pos.add (arr[i]) ;

	}

	bucketSort(Neg, (int)Neg.size());

	bucketSort(Pos, (int)Pos.size());



	// 首先通过转换为 -ve 存储 Neg[] 数组的元素

	for (int i = 0; i < Neg.size(); i++)

	arr[i] = -1 * Neg.get( Neg.size() -1 - i);



	// 排序

	for(int j = Neg.size(); j < n; j++)

	arr[j] = Pos.get(j - Neg.size());

}



public static void main(String[] args)

{

	double arr[] = {-0.897, 0.565, 0.656,

					-0.1234, 0, 0.3434};

	int n = arr.length;

	sortMixed(arr, n);



	System.out.print("排序后的数组： \n");

	for (int i = 0; i < n; i++)

	System.out.print(arr[i] + " ");

}0

}

**输出： **

排序后的数组：

-0.897 -0.1234 0 0.3434 0.565 0.656

前言

金三银四，又到了换工作的最佳时机，我幻想着只要跳个槽，就能离开这个”鸟地方“，拿着更多的钱，干着最爽的事...

然而现实总是残酷的，最近有个学妹在换工作，面试前什么手写Priomise、vue双向绑定原理,webpack优化方式,准备了一大堆，本以为成竹在胸，结果却在算法上吃了大亏，心仪的offer没有拿到，一度怀疑人生。到底是什么算法题能让面试官对妹子说出你都工作3年了，这个算法题都不会？这样的狠话？

有效的括号问题

这是一道leetcode上的原题，本意是在考察候选人对栈数据结构的掌握。来看看题目

给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串 s ，判断字符串是否有效。
有效字符串需满足：

1. 左括号必须用相同类型的右括号闭合。


2. 左括号必须以正确的顺序闭合。

示例

示例 1：

输入：s = "()"

输出：true



示例 2：

输入：s = "()[]{}"

输出：true



示例 3：

输入：s = "(]"

输出：false



示例 4：

输入：s = "([)]"

输出：false



示例 5：

输入：s = "{[]}"

输出：true

解题信息

如果咱们确实没有刷过算法，不知道那么多套路，通过题目和示例尽可能的获取到更多的信息就很重要了。

根据题目推断出：

1. 字符串s的长度一定是偶数，不可能是奇数(一对对匹配)。


2. 右括号前面一定跟着左括号，才符合匹配条件，具备对称性。


3. 右括号前面如果不是左括号，一定不是有效的括号。

暴力消除法

得到了以上这些信息后，胖头鱼想既然是[]、{}、()成对的出现，我能不能把他们都挨个消除掉，如果最后结果是空字符串，那不就意味着符合题意了吗？

举个例子

输入：s = "{[()]}"



第一步：可以消除()这一对，结果s还剩{[]}



第二步: 可以消除[]这一对，结果s还剩{}



第三步: 可以消除{}这一对，结果s还剩'' 所以符合题意返回true

代码实现

const isValid = (s) => {

  while (true) {

    let len = s.length

    // 将字符串按照匹配对，挨个替换为''

    s = s.replace('{}', '').replace('[]', '').replace('()', '')

    // 有两种情况s.length会等于len

    // 1. s匹配完了，变成了空字符串

    // 2. s无法继续匹配，导致其长度和一开始的len一样，比如({],一开始len是3，匹配完还是3，说明不用继续匹配了，结果就是false

    if (s.length === len) {

      return len === 0

    }

  }

}

暴力消除法最终还是可以通过leetcode的用例，就是性能差了点，哈哈

栈解题法

解题信息中的第2条强调对称性，而栈（后入先出）入栈和出栈恰好是反着来，形成了鲜明的对称性。

入栈：abc，出栈：cba

abc

cba

所以可以试试从栈的角度来解析：

输入：s = "{[()]}"



第一步：读取ch = {，属于左括号，入栈，此时栈内有{

第二步：读取ch = [，属于左括号，入栈，此时栈内有{[

第三步：读取ch = (，属于左括号，入栈，此时栈内有{[(

第四步：读取ch = )，属于右括号，尝试读取栈顶元素(和)正好匹配，将(出栈，此时栈内还剩{[

第五步：读取ch = ]，属于右括号，尝试读取栈顶元素[和]正好匹配，将[出栈，此时栈内还剩{

第六步：读取ch = }，属于右括号，尝试读取栈顶元素{和}正好匹配，将{出栈，此时栈内还剩''

第七步：栈内只能''，s = "{[()]}"符合有效的括号定义，返回true

代码实现

const isValid = (s) => {

  // 空字符串符合条件

  if (!s) {

    return true

  }



  const leftToRight = {

    '(': ')',

    '[': ']',

    '{': '}'

  }

  const stack = []



  for (let i = 0, len = s.length; i < len; i++) {

    const ch = s[i]

    // 左括号

    if (leftToRight[ch]) {

      stack.push(ch)

    } else {

      // 右括号开始匹配

      // 1. 如果栈内没有左括号，直接false

      // 2. 有数据但是栈顶元素不是当前的右括号

      if (!stack.length || leftToRight[ stack.pop() ] !== ch) {

        return false

      }

    }

  }



  // 最后检查栈内还有没有元素，有说明还有未匹配则不符合

  return !stack.length

}

暴力解法虽然符合我们日常的思维，但是果然还是栈结构解法好了不少。

结尾

面试中，算法到底该不该成为考核候选人的重要指标咱们不吐槽，但是近几年几乎每个大厂都将算法放进了前端面试的环节，为了获得心仪的offer，重温数据结构，刷刷题还是很有必要的，愿你我都被算法温柔以待。

前言

在开发flutter或android项目，选择用Android stuido是比较方便的，在git的可视化使用上，Android studio已经非常方便了，但是还是有很多的小伙伴，依旧用其他工具来管理git。那么今天我就来详细的介绍一下 Android stuido的git使用与操作。

一、基本认知

git是采用分布式版本库机制。

工作区

项目目录下的文件可以称之为工作区

暂存区

增加文件，执行add操作则是把文件添加到暂存区

基本操作

git add 是将文件放到暂缓区
git commit 则是把文件添加到本地仓库
git push 则是提交到远程仓库
git status 是查看现有版本库中的文件状态

head指针

head表示的是当前版本，并不是任何分支的最新版本

二、Android studio中的git

文件样式与对应关系

文件1是git忽略文件
文件2是与本地分支版本一致
文件3是咱为提交到本地分支，并做了修改

假如文件是红色的样子，表示并没提交到暂存区

界面与操作

1. commit 提交到本地分支 （基本操作，不做说明）


2. add 添加到暂存区 （基本操作，不做说明）


3. .git/info/exclude (添加到 忽略文件，是为了让文件脱离git管理，不会上传到git仓库)


4. Annotate with Git Blame (显示每行代码的作者，如下图)

5. show diff （故名思义differences 差别）
6. compare with reversion（与某个版本比较）
7. compare with branch（与某个分支比较）
8. show history （查看历史）
9. show current revision （显示当前行最新修订历史版本、提示）
10. Rollback.. 在没有提交到本地库之前，丢弃工作区内容。
11. push.. 推到线上分支
12. pull.. 线上拉到本地并合并
13. fetch 线上拉到本地
14. merge.. 选择分支进行合并
15. rebase.. 选择分支进行合并，如有有合并冲突，会提示整理为一条commit直线
16. branches.. 创建分支与查看分支（这块下面快捷操作具体介绍）
17. new branch 会按照当前本地提交版本，来创建新的分支
18. new tag 给某一次提交增加个可识别的名字
19. reset HEAD
注意：Git中，用HEAD表示当前版本

有三个选项
Mixed：参数为默认值，暂存区的内容和工作区的内容都在工作区，提交上的都会还原到工作区
Soft：工作区的内容依旧在工作区，暂存区的内容还在暂存区（不被git管理的文件会变为新增文件）
Hard：工作区和暂存区的内容全部丢失（需要谨慎操作，一步就啥也木有了）

to commit 选择你要还原的commit号
20. stash changes..
git中如果本地有文件改动未提交、且该文件和服务器最新版本有冲突，pull更新会提示错误，无法更新：要么先commit自己的改动然后再通过pull拉取代码，stash的好处是可以先将你的改动暂存到本地仓库中，随时可以取出来再用，但是不用担心下次push到服务器时，把不想提交的改动也push到服务器上，因为Stash Changes的内容不参与commit和push。
21. unstash changes

View：查看
Drop：删除
Clear：清理
pop stash：移除stash
reinstate index
22. manager remote
查看git remote内容

右下角快捷操作

merge into current 合并到当前分支
rebase current onto selected 合并到当前rebase模式
chechout and rebase onto current 切换分支，并将分支合并到当前切换的分支

git面板快捷操作

compact references view 简洁引用视图
简洁引用：

align references to left 将引用向左对齐
引用左右对齐配置：

Show tag names 显示标签名称
设置是否显示标签：

Show long Edges 显示长线

Turn Intellisort On 打开intelli 排序
incase of merge show incoming commits first (directly below merge commit)
在合并的情况下，首先显示传入的提交 直接合并在下边

关键词含义

n：数据规模

时间复杂度

算法运行过程中所耗费的时间。

空间复杂度

算法运行过程中临时占用存储空间的大小。例如：O(1)表示所需空间大小为常量，与数据量n无关。

稳定性含义

• 稳定：在排序之前，如果两个数相等，那么排序之后，这两个数的先后顺序不变。如排序前，a=b，a在b的前面；那么排序后，a依旧在b的前面。


• 不稳定：在排序之前，如果两个数相等，那么排序之后，这两个数的先后顺序改变。如排序前，a=b，a在b的前面；那么排序后，a在b的后面。

冒泡排序

原理步骤

1. 比较相邻的两个数，如果前面的数大于后面的数，就交换这两个数。


2. 相邻的最前一对数和最后一对数都要进行比较，这样最后一个数就是最大的数。


3. 每个元素重复以上步骤，除了最后一个数。


4. 重复1-3的步骤。

代码实现

private static int[] bubbleSort(int array[]) {

    if (array.length == 0) {      

       return array;    

    }

    // 第1个for循环相当于步骤4    

    for (int i = 0; i < array.length; i++) {

        // 第2个for循环相当于步骤3        

        // array.length -1 是因为后面有j+1，先-1是为了避免数组越界        

        // array.length -1 - i，之所以减i（已经排过1遍，就减1；如果已经排过i遍，就减i），是为了不比较排在最后且已经排好序的数，相当于步骤3的最后一句话        

        for (int j = 0; j < array.length - 1 - i; j++) {

            int temp;            

            // if判断语句相当于步骤1和步骤2            

            if (array[j] > array[j + 1]) {                

                temp = array[j];                

                array[j] = array[j + 1];                

                array[j + 1] = temp;            

            }        

        }    

     }

     return array;

    }

快速排序

原理步骤

1. 取数组中的一个数作为key。


2. 从后往前获取数组的数，并将其与key进行对比。


3. 如果其中一个数小于key，那么就将这个数和key交换位置。


4. 交换位置之后，从前往后获取数组的数，并将其与key对比。


5. 如果其中一个数大于key，那么就将这个数和key交换位置。


6. 重复2-5的过程，直到key前面的数都比key小，key后面的数都比key大，这样就完成一次排序。


7. 以key为中心，对key前面的数组和后面的数组执行1-6的过程，直到数组完全有序。

代码实现

private static void quickSort(int[] array, int left, int right) {

    if (left >= right) {      

        return;    

    }

    int i, j, x;    

    i = left;    

    j = right;    

    x = array[i];

    while (i < j) {        

        while (i < j && array[j] > x) {            

            j--;        

        }        

        if (i < j) {            

            array[i] = array[j];            

            i++;        

        }        

        while (i < j && array[i] < x) {            

            i++;        

        }        

        if (i < j) {            

            array[j] = array[i];            

            j--;        

        }    

    }    

    // j=i    

    array[j] = x;    

    quickSort(array, j + 1, right);    

    quickSort(array, left, j - 1);

    }

插入排序

原理

• 每一步将一个待排序的数插入到已经排好序的序列中，直到插完所有数据。

代码实现

private static int[] insertSort(int array[]) {          

        if (array.length == 0) {                

            return array;          

        }                

        int i, j, temp;          

        // 注释①          

        for (i = 1; i < array.length; i++) {              

            // 注释②                  

            temp = array[i];                  

            // 注释③                  

            for (j = i - 1; j >= 0 && array[j] > temp; j--) {                    

                // 注释④                        

                array[j+1] = array[j];                  

            }                  

            // 注释⑤                  

            array[j+1] = temp;           

        }                  

        return array;

}

注释①

• 默认数组第一个数（i=0的数）是有序的。

注释②

• array[i]为待排序的数据。

注释③

• array[i]前面的数与array[i]进行排序。

注释④

• arr[j]相当于前数，arr[j+1]相当于后数。


• 如果前数比后数大，交换位置，前数放到后数的位置。

注释⑤

• 如果for循环内前数和后数交换了位置（即前数挪到了后数的位置），那么注释⑤处的代码，就是将后数挪到前数的位置，实现交换。


• 如果缺少注释⑤处的代码，那么前数的位置就会“空缺”，或者说依旧是原来的数，并没有实现交换。


• 如果for循环内两数并没有交换（即跳出了for循环），此时j=i-1,j+1=i,与tmp=a[i]效果是一样的。

选择排序

原理步骤：

1. 从未排序的序列中取出最小（最大）的数，放入已排序序列的初始位置；


2. 继续从未排序序列剩余的数中取最小（最大）的数，放在已排序序列的末尾。


3. 持续执行②的步骤，直到整个序列有序。

代码实现

private static int[] selectionSort(int[] array) {    

    if (array.length == 0) {        

        return array;    

    }    

    for (int i = 0; i < array.length; i++) {        

        int min = i;        

        for (int j = i; j < array.length; j++) {            

            // 从未排序序列中获取最小值            

            if (array[j] < array[min]) {                

                min = j;            

            }        

        }        

        // 把获取的最小值放入已排序序列的末尾（此时i代表末尾的索引）        

        int temp = array[i];        

        array[i] = array[min];        

        array[min] = temp;    

    }    

    return array;

}

总结1：

• 插入排序和选择排序可以划为一类排序算法来理解和掌握。


• 它们都具有相同点——将数组划分为已排序、未排序两个部分，然后将未排序的部分逐个迁移到已排序的部分，最终使整个数组实现完全有序。


• 而不同点在于从未排序合入到已排序的方式。插入排序会将未排序的数据在已排序的数组中执行直接插入排序；而选择排序会先在未排序的数组中选出最小值，当这个值合入到已排序的数组中时，不需要再进行比较，直接放到已排序数组的末尾就可以了。

希尔排序

原理步骤

• 把一个数组按增量进行分组。（增量指分组数量）


• 每个分组采用直接插入排序进行排序。


• 然后减小增量，每个分组的元素数目增加，直到增量为1，整个文件变为一组，算法结束。

代码实现

private static int[] shellSort(int[] array) {    

    if (array.length == 0) {        

        return array;    

    }

    // gap为分组数目    

    for (int gap = array.length / 2; gap > 0; gap = gap / 2) {    

        // i为索引,对每组进行排序        

        for (int i = gap; i < array.length; i++) {        

        // j为临时变量            

        int j = i;            

        // 分组内元素的个数可能大于2个，因此使用while循环            

        while (j - gap >= 0 && array[j] < array[j - gap]) {            

            // 在同一个分组中，如果后面的数（j）比前面的（j-gap）大，就交换它们的位置                

            int temp = array[j];                

            array[j] = array[j - gap];                

            array[j - gap] = temp;

            j = j - gap;            

        }        

        }    

     }    

     return array;

}

归并排序

原理步骤

• 将一个数组分为左子数组和右子数组，两个子数组的长度为n/2（n为数组的总长度）。


• 在两个子数组间进行归并排序（即每个子数组划分为更小的左子数组和右子数组，直到无法再分时，对两个数组进行排序，详情见代码）。


• 将两个有序的子数组合并为一个最终的有序数组。

代码实现

private static int[] mergeSort(int[] array) {    

    // 数组只有一个元素或没有元素，直接返回。    

    // 脱离递归的条件    

    if (array.length < 2) {        

        return array;    

    }    

    // 将数组分为两半，分别进行排序    

    int[] left = Arrays.copyOfRange(array, 0, array.length / 2);    

    int[] right = Arrays.copyOfRange(array, array.length / 2, array.length);    

    return merge(mergeSort(left),mergeSort(right));

}



    /** 

      * 将左数组与右数组合并为一个有序数组 

      * 注意：此时左数组、右数组已经有序 

      * @param left 

      * @param right 

      * @return 

      */

    private static int[] merge(int[] left, int[] right) {    

        // 合并后的有序数组    

        int[] result = new int[left.length + right.length];    

        for (int index = 0, i = 0, j = 0; index < result.length; index++) {        

        if (i >= left.length) {            

            // 如果左数组已经遍历结束，就插入右数组的值            

            result[index] = right[j];            

            j++;        

        } else if (j >= right.length) {            

            // 如果右数组已经遍历结束，就插入左数组的值            

            result[index] = left[i];            

            i++;        

        } else if (left[i] > right[j]) {            

            // 左数组与右数组的值同时存在时，就对两数进行比较            

            // 如果右数组的值比较小，就插入右数组的值。            

            result[index] = right[j];            

            j++;        

        } else {            

            // 左数组与右数组的值同时存在时，就对两数进行比较            

            // 如果左数组的值比较小，就插入左数组的值。            

            result[index] = left[i];            

            i++;        

        }    

    }    

    return result;

}

总结2：

• 希尔排序和归并排序可以划为一类排序算法来理解和掌握。


• 它们都具有相同点——先将整个大的数组分为不同的小组，然后对小组的数据进行排序，最终将所有小组合并为一个有序数组。


• 而不同点在于分组后的排序方式不同。希尔排序会针对一个小组内的数据执行直接插入排序，而归并排序会直接将两个小组合并为一个有序数组。

排序算法进阶

• 以上冒泡、快排、插入、选择、希尔、归并这六种排序算法都是基础的排序算法，很多中等、困难难度的算法题一般都是基于上述算法进行解决。（比如《合并两个有序数组》其实就是归并算法的某一部分）


• 推荐《最小K个数》、《数组中的第K个最大元素》作为进阶学习。（它们都是基于快排实现，类似的变形有最大K个数等）

Android小萌新今天在做项目的时候遇到一个小问题，来记录一下~

在做一个登录界面的时候，想使用DataBinding+ViewModel+LiveData

但是怎样让ViewModel拿到EditText控件的实例呢？一开始想到把DataBinding对象从Activity传入ViewModel，后来发现不可行，因为DataBinding在初始化的时候需要传入owner参数，而这个owner参数传的是Activity本身，也就是说DataBinding持有了Activity的引用，这时候如果把DataBinding传给ViewModel不就成了ViewModel持有Activity的引用了吗？内存泄漏！不行！

解决办法是通过DataBinding双向绑定（View可以操作数据，数据变化时通知View），让EditText的内容直接对应到ViewModel中的LiveData上，这样的话在输入框输入的同时LiveData也在随时变化。

一些收获的经验：

1. @={}和@{}

我发现EditText的text属性要使用@={...}而不是像TextView直接使用@{...}来和Livedata绑定，多出来的这个"="我个人认为是TextView和LiveData绑定仅仅只是get数据，而EditText和数据绑定需要get和实时set数据，所以"="可以理解为赋值

<EditText

        ...

        android:text="@={viewModel.inputAccount}"

        ... />

        

<EditText

        ...

        android:text="@={viewModel.inputVerify}"

        ... />



<Button

        ...

        android:onClick="@{(v)->viewModel.onLogin()}"

        ... />

2. 为什么在账号EditText输入一个数，getInputAccount()会被调用两次呢？

public class TemporaryLoginViewModel extends ViewModel {



    private static final String TAG = "TemporaryLoginViewModel";

    MutableLiveData<String> mInputAccount;

    MutableLiveData<String> mInputVerify;



    public MutableLiveData<String> getInputAccount() {

        // TODO:为什么EditText输入一个数，getInputAccount()会调用两次？

        Log.d(TAG, "getInputAccount: Entrance");

        //双检锁

        if (mInputAccount == null)

            synchronized (TemporaryLoginViewModel.class) {

                if (mInputAccount == null)

                    mInputAccount = new MutableLiveData<>();

            }

        //只是TextView展示的话可以返回不可变的LiveData，这里因为是EditText所以只能返回可变的MutableLivedata

        return mInputAccount;

    }



    public MutableLiveData<String> getInputVerify() {

        ...

    }



    public void onLogin() {

        Log.d(TAG, "onLogin: 账号：" + mInputAccount.getValue() + "  验证码：" + mInputVerify.getValue());

    }

}

这就要进入源码去看一眼了，在getInputAccount()上选择findUsages
发现有两处地方调用了它

第一处在一个回调方法的onChange()中，我们打个断点查看虚拟机栈的栈帧，在第一次执行到断点的时候，虚拟机栈是这样的：

onChange()内部是这样的：

也就是说你在输入框里打字使得EditText数据改变的时候，首先回调到onChange()中，在这个onChange()中通过getInputAccount()得到LiveData再给它set一个字符串值

第二处是在executeBindings()中，这个方法是什么时候执行呢？我们让程序继续执行，在下一次执行到断点的时候，虚拟机栈是这样的：

可以看到在第二次执行到断点的时候，程序从executeBindings()方法中企图调用getInputAccount()

继续向下追踪，就可以看到这样的一个描述

意思是当View所绑定的数据发生变更的时候，执行此方法

总结

走到这里就很清晰了，整个流程是首先在输入框中输入，当监听到输入后先回调onChange()，在onChange()中通过getInputAccount()得到LiveData，然后修改了LiveData的值；LiveData一但修改，就会重新执行executeBindings()，所以又会调用一次getInputAccount()

到现在就明白了为什么ViewModel中的getInputAccount()会被执行两次啦~

3. getInputAccount()只能返回MutableLiveData

第三个问题也很好理解，为了安全嘛，我一开始试图让getInputAccount()返回一个不可修改的LiveData，然后报错了！

从第二个问题的分析不难看出，人家内部还要给get到的LiveData执行setValue()呢，所以返回的LiveData一定是可变的MutableLiveData啦~

4. 程序启动时会额外执行一次getInputAccount()

当我查看Activity中的setLifecycleOwner(this)方法时发现它设置了一个LifecycleObserver

进入这个Observer

它观察到Activity处于onStart状态的时候会调用executePendingBindings()

进入executePendingBindings()瞅瞅

又要去调用executeBindingsInternal()，这不就是我们上面在虚拟机栈中看到的调用步骤吗？也就是说在Activity在onStart状态时会执行一次getInputAccount()

卡顿优化思路

• 卡顿原理分析


• 卡顿流程flow


• 卡顿概貌分析


• 卡顿实际数据收集


• 卡顿优化细节

卡顿原因

屏幕刷新频率高于帧率,帧率低于30

每帧执行流程

Choreographer中维护着四个队列callbacks

• 输入事件队列


• 动画队列


• 绘制队列


• app添加的frameCallback队列

vysnc信号由SurfaceFlinger中创建HWC触发，通过bitTube技术发送到目标进程，目标进程vsync信号到来时，执行Choreographer中的onVsync回调，最终触发doFrame顺序执行这四条队列中的消息。

bitTube

在linux/unix中，bitTube技术成为socketPair，它通过dup技术复制socket的句柄，传递到目标进程，开启socket的全双工通信。

句柄

在内核中，每一个进程都有一个私有的“打开文件表”，这个表是一个指针数组，每一个元素都指向一个内核的打开文件对象。而fd，就是这个表的下标。当用户打开一个文件时，内核会在内部生成一个打开文件对象，并在这个表里找到一个空项，让这一项指向生成的打开文件对象，并返回这一项的下标作为fd.

ui优化

• 多余Bg移除


• ui重叠区域优化 cancas.clipRect


• 减少ui层级


• 耗时方法分析与优化


• 多样式布局采用单一rv处理

webview优化

webview的加载流程

webiew初始化

• 目的是初始化并启动浏览器内核。


• 提前初始化webview并隐藏 优化126ms

webview 单独进程

• 单独进程 activity配置


• 单独进程的交互 webview.addJavascriptInterface(),webview.evalute()

安全性

• addJavaScriptInterface添加的java对象的方法，需要添加@addJavascriptInterface注解，避免xss攻击

卡顿收集策略

开发卡顿检测StrictMode

private void initStrictMode() {

    if (isDebug()) {

        StrictMode.setThreadPolicy(new StrictMode.ThreadPolicy.Builder()

                .detectCustomSlowCalls() //API等级11，使用StrictMode.noteSlowCode

                .detectDiskReads()

                .detectDiskWrites()

                .detectNetwork() // or .detectAll() for all detectable problems

                .penaltyDialog() //弹出违规提示对话框

                .penaltyLog() //在Logcat 中打印违规异常信息

                .penaltyFlashScreen() //API等级11

                .build());

        StrictMode.setVmPolicy(new StrictMode.VmPolicy.Builder()

                .detectLeakedSqlLiteObjects()

                .detectLeakedClosableObjects() //API等级11

                .penaltyLog()

                .penaltyDeath()

                .build());

    }

}

线下卡顿检测

• adb shell dumpsys gfxinfo [packagename]

Applications Graphics Acceleration Info:

Uptime: 205237819 Realtime: 436545102



** Graphics info for pid 5842 [xxxx] **



Stats since: 198741999784549ns

Total frames rendered: 653

Janky frames: 157 (24.04%)

50th percentile: 9ms

90th percentile: 34ms

95th percentile: 53ms

99th percentile: 200ms

Number Missed Vsync: 46

Number High input latency: 268

Number Slow UI thread: 76

Number Slow bitmap uploads: 3

Number Slow issue draw commands: 8

Number Frame deadline missed: 92

• 通过gpu绘制条形柱分析

条形柱共分为8种颜色，绿色和蓝色部分是异步应用能够优化的部分。包括其他处理 - 输入 - 动画 - travel

BlockCanary检测卡顿

在ActivityThread.main中的Looper大循环中，Looper.looponce会不断从消息队列中取出消息派发出去,并在前后通过logging打印了两个日志，我们通过设置自定义的logger，在两部分日志的时间差与30ms做对比，如果超过30ms，认为是卡顿。

logging.println(">>>>> Dispatching to " + msg.target + " "

                    + msg.callback + ": " + msg.what);

msg.target.dispatchMessage(msg);

logging.println("<<<<< Finished to " + msg.target + " " + msg.callback);

卡顿分析信息收集

• Debug.startMethodTracing 收集具体的卡顿方法


• 查看trace文件 根据bottomup分析具体的耗时方法


• 火焰图，横轴是调用方法耗时，纵轴是调用深度


• 调用图，调用链以及方法耗时

线上卡顿分析与收集

在ActivityThread.main中的Looper大循环中，Looper.looponce会不断从消息队列中取出消息派发出去,并在前后通过logging打印了两个日志，我们通过设置自定义的logger，在两部分日志的时间差与30ms做对比，如果超过30ms，认为是卡顿。将主线程堆栈信息写入到缓存文件并异步发送到日志后台。

常见的卡顿问题

sharepreference

• 首次读取写入会loadxml到内存


• sp文件修改是全量读写的


• commit异步写入，通过CountdownLatch阻塞等待结果


• apply延迟100ms写入，无返回结果


• 主线程ANR，sp的修改会先体现在内存中，然后往QueueWorker中加入磁盘异步写数据的任务，但是会在Activity.onResume以及Service.onstartCommand等方法中增加waitToFinish等待磁盘写入完成的代码。


• 解决方案使用MMKV


• 尽量拆分小的xml

主线程操作文件

主线程网络操作

写在前面

首先祝大家新年快乐，开工大吉。

最新刚换了工作，大部分精力还是放到新工作上面，所以这次还是先给大家带来一个小而实用的库：Silhouette。另外，考虑到Kotlin越来越普及，作者在开发过程中也切实感受到Kotlin相较于Java带来的便利，后续的IM系列文章及项目考虑用Kotlin重写，而且考虑到由于工作业务需求过多可能出现断更的情况，所以打算一次性写完再放出来，避免大家学习不方便。

废话不多说，直接开始吧。

Silhouette是什么？

Silhouette意为“剪影”，取名并没有特别的含义，只是单纯地觉得意境较美。例如上一篇文章Shine——更简单的Android网络请求库封装的网络请求库：Shine即意为“闪耀”，也没有特别的含义，只是作者认为开源库起名较难，特意找一些比较优美的单词。

Silhouette是一系列基于GradientDrawable及StateListDrawable封装的组件集合，主要用于实现在Android Layout XML中直接支持Shape/Selector等功能。

我们都知道在Android开发中，不同的TextView及Button各种样式（形状、背景色、描边、圆角、渐变等）的传统实现方式是在drawable文件夹中编写各种shape/selector等文件，这种方式至少会存在以下几种弊端：

1. shape/selector文件过多，项目体积增大；


2. shape/selector文件命名困难，命名规范时往往会存在功能重复的文件；


3. 功能存在局限性：例如gradient渐变色。传统shape方式只支持三种颜色过渡(startColor/centerColor/endColor)，如果设计稿存在四种以上颜色渐变，shape gradient无能为力。再比如TextView在常态和按下态需要同时改变背景色及文字颜色时，传统方式只能在代码中动态设置等。


4. 开发效率低；


5. 难以维护等；

综上所述，我们迫切需要一个库来解决以上问题，Silhouette正具备这些能力。接下来，我们来具体看看Silhouette能做什么吧。

Silhouette能做什么？

上面说到Silhouette是一系列组件集合，具体包含以下组件：

• 
  

  SleTextButton
  
  基于AppCompatTextView封装；
  
  具备定义各种样式（形状、背景色、描边、圆角、渐变等）的能力 ；
  
  具备不同状态（常态、按下态、不可点击态）下文字颜色指定等。

  
  


• 
  

  SleImageButton
  
  基于ShapeableImageView封装；
  
  通过指定sle_ib_type属性使ImageView支持按下态遮罩层、透明度改变、自定义图片，同时支持CheckBox功能；
  
  通过指定sle_ib_style属性使ImageView支持Normal、圆角、圆形等形状。

  
  


• 
  

  SleConstraintLayout
  
  基于ConstraintLayout封装；
  
  具备定义各种样式（形状、背景色、描边、圆角、渐变等）的功能。

  
  


• 
  

  SleRelativeLayout
  
  基于RelativeLayout封装；
  
  具备定义各种样式（形状、背景色、描边、圆角、渐变等）的功能。

  
  


• 
  

  SleLinearLayout
  
  基于LinearLayout封装；
  
  具备定义各种样式（形状、背景色、描边、圆角、渐变等）的功能。

  
  


• 
  

  SleFrameLayout
  
  基于FrameLayout封装；
  
  具备定义各种样式（形状、背景色、描边、圆角、渐变等）的功能。

  
  

设计、封装思路及原理

• 
  

  项目结构
  
  com.freddy.silhouette

  
  
  
  
  • config（配置相关，存放全局注解及公共常量、默认值等）
  
  
  • ext（kotlin扩展相关，可选择用或不用）
  
  
  • utils（工具类相关，可选择用或不用）
  
  
  • widget（控件相关）
    
    
    
    • button
    
    
    • layout
    
    
    
    
  
  
  
  

  由此可见，项目结构非常简单，所以Silhouette也是一个比较轻量级的库。

  
  


• 
  

  封装思路及原理
  
  由于该库非常简单，实际上就是根据Shape/Selector进行自定义属性，从而利用GradientDrawable及StateListDrawable提供的API进行封装，不存在什么难度，在此就不展开讲了。

  
  

  下面贴一下代码片段，基本上几个组件的实现原理都大同小异，都是利用GradientDrawable及StateListDrawable实现组件的Shape及Selector功能：

  
  

private fun init() {

    val normalDrawable =

        getDrawable(normalBackgroundColor, normalStrokeColor, normalGradientColors)

    var pressedDrawable: GradientDrawable? = null

    var disabledDrawable: GradientDrawable? = null

    var selectedDrawable: GradientDrawable? = null

    when (type) {

        TYPE_MASK -> {

            pressedDrawable = getDrawable(

                normalBackgroundColor,

                normalStrokeColor,

                normalGradientColors

            ).apply {

                colorFilter =

                    PorterDuffColorFilter(maskBackgroundColor, PorterDuff.Mode.SRC_ATOP)

            }

            disabledDrawable =

                getDrawable(disabledBackgroundColor, disabledBackgroundColor)

        }

        TYPE_SELECTOR -> {

            pressedDrawable =

                getDrawable(pressedBackgroundColor, pressedStrokeColor, pressedGradientColors)

            disabledDrawable = getDrawable(

                disabledBackgroundColor,

                disabledStrokeColor,

                disabledGradientColors

            )

        }

    }

    selectedDrawable = getDrawable(

        selectedBackgroundColor,

        selectedStrokeColor,

        selectedGradientColors

    )

    setTextColor(normalTextColor)

    background = StateListDrawable().apply {

        if (type != TYPE_NONE) {

            addState(intArrayOf(android.R.attr.state_pressed), pressedDrawable)

        }

        addState(intArrayOf(-android.R.attr.state_enabled), disabledDrawable)

        addState(intArrayOf(android.R.attr.state_selected), selectedDrawable)

        addState(intArrayOf(), normalDrawable)

    }

  

    setOnTouchListener(this)

}

  

private fun getDrawable(

    backgroundColor: Int,

    strokeColor: Int,

    gradientColors: IntArray? = null

): GradientDrawable {

    // 背景色相关

    val drawable = GradientDrawable()

    setupColor(drawable, backgroundColor)

  

    // 形状相关

    (drawable.mutate() as GradientDrawable).shape = shape

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {

        drawable.innerRadius = innerRadius

        if (innerRadiusRatio > 0f) {

            drawable.innerRadiusRatio = innerRadiusRatio

        }

        drawable.thickness = thickness

        if (thicknessRatio > 0f) {

            drawable.thicknessRatio = thicknessRatio

        }

    }

  

    // 描边相关

    if (strokeColor != 0) {

        (drawable.mutate() as GradientDrawable).setStroke(

            strokeWidth,

            strokeColor,

            dashWidth,

            dashGap

        )

    }

  

    // 圆角相关

    setupCornersRadius(

        drawable,

        cornersRadius,

        cornersTopLeftRadius,

        cornersTopRightRadius,

        cornersBottomRightRadius,

        cornersBottomLeftRadius

    )

  

    // 渐变相关

    (drawable.mutate() as GradientDrawable).gradientType = gradientType

    if (gradientCenterX != 0.0f || gradientCenterY != 0.0f) {

        (drawable.mutate() as GradientDrawable).setGradientCenter(

            gradientCenterX,

            gradientCenterY

        )

    }

    gradientColors?.let { colors ->

        (drawable.mutate() as GradientDrawable).colors = colors

    }

    var orientation: GradientDrawable.Orientation? = null

    when (gradientOrientation) {

        GRADIENT_ORIENTATION_TOP_BOTTOM -> {

            orientation = GradientDrawable.Orientation.TOP_BOTTOM

        }

        GRADIENT_ORIENTATION_TR_BL -> {

            orientation = GradientDrawable.Orientation.TR_BL

        }

        GRADIENT_ORIENTATION_RIGHT_LEFT -> {

            orientation = GradientDrawable.Orientation.RIGHT_LEFT

        }

        GRADIENT_ORIENTATION_BR_TL -> {

            orientation = GradientDrawable.Orientation.BR_TL

        }

        GRADIENT_ORIENTATION_BOTTOM_TOP -> {

            orientation = GradientDrawable.Orientation.BOTTOM_TOP

        }

        GRADIENT_ORIENTATION_BL_TR -> {

            orientation = GradientDrawable.Orientation.BL_TR

        }

        GRADIENT_ORIENTATION_LEFT_RIGHT -> {

            orientation = GradientDrawable.Orientation.LEFT_RIGHT

        }

        GRADIENT_ORIENTATION_TL_BR -> {

            drawable.orientation = GradientDrawable.Orientation.TL_BR

        }

    }

    orientation?.apply {

        (drawable.mutate() as GradientDrawable).orientation = this

    }

    return drawable

}

感兴趣的同学可以到官方文档了解GradientDrawable及StateListDrawable的原理。

自定义属性列表

自定义属性分为通用属性和特有属性。

• 
  

  通用属性

  
  
  
  
  • 类型
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  

  属性名称	类型	说明	备注
  sle_type	enum	类型 mask：遮罩 selector：自定义样式 none：无	默认值：mask 默认的mask为90%透明度黑色，可通过sle_maskBackgroundColors属性设置 若不指定为selector，则自定义样式无效

  
  
  
  
  • 形状相关
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  

  属性名称	类型	说明	备注
  sle_shape	enum	形状 rectangle：矩形 oval：椭圆形 line：线性形状 ring：环形	默认值：rectangle
  sle_innerRadius	dimension|reference	尺寸，内环的半径	shape="ring"可用
  sle_innerRadiusRatio	float	以环的宽度比率来表示内环的半径	shape="ring"可用
  sle_thickness	dimension|reference	尺寸，环的厚度	shape="ring"可用
  sle_thicknessRatio	float	以环的宽度比率来表示环的厚度	shape="ring"可用

  
  
  
  
  • 背景色相关
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  

  属性名称	类型	说明	备注
  sle_normalBackgroundColor	color|reference	常态背景颜色	/
  sle_pressedBackgroundColor	color|reference	按下态背景颜色	/
  sle_disabledBackgroundColor	color|reference	不可点击态背景颜色	默认值：#CCCCCC
  sle_selectedBackgroundColor	color|reference	选中态背景颜色	/

  
  
  
  
  • 描边相关
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  

  属性名称	类型	说明	备注
  sle_normalStrokeColor	color|reference	常态描边颜色	/
  sle_pressedStrokeColor	color|reference	按下态描边颜色	/
  sle_disabledStrokeColor	color|reference	不可点击态描边颜色	/
  sle_selectedStrokeColor	color|reference	选中态描边颜色	/
  sle_strokeWidth	dimension|reference	描边宽度	/
  sle_dashWidth	dimension|reference	虚线宽度	/
  sle_dashGap	dimension|reference	虚线间隔	/

  
  
  
  
  • 圆角相关
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  

  属性名称	类型	说明	备注
  sle_cornersRadius	dimension|reference	总圆角半径	/
  sle_cornersTopLeftRadius	dimension|reference	左上角圆角半径	/
  sle_cornersTopRightRadius	dimension|reference	右上角圆角半径	/
  sle_cornersBottomLeftRadius	dimension|reference	左下角圆角半径	/
  sle_cornersBottomRightRadius	dimension|reference	右下角圆角半径	/

  
  
  
  
  • 渐变相关
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  

  属性名称	类型	说明	备注
  sle_normalGradientColors	reference	常态渐变背景色	支持在res/array下定义数组实现多个颜色渐变
  sle_pressedGradientColors	reference	按下态渐变背景色	支持在res/array下定义数组实现多个颜色渐变
  sle_disabledGradientColors	reference	不可点击态渐变背景色	支持在res/array下定义数组实现多个颜色渐变
  sle_selectedGradientColors	reference	选中态渐变背景色	支持在res/array下定义数组实现多个颜色渐变
  sle_gradientOrientation	enum	渐变方向 TOP_BOTTOM：从上到下 TR_BL：从右上到左下 RIGHT_LEFT：从右到左 BR_TL：从右下到左上 BOTTOM_TOP：从下到上 BL_TR：从左下到右上 LEFT_RIGHT：从左到右 TL_BR：从左上到右下	/
  sle_gradientType	enum	渐变类型 linear：线性渐变 radial：圆形渐变，起始颜色从gradientCenterX、gradientCenterY点开始 sweep：A sweeping line gradient	/
  sle_gradientCenterX	float	渐变中心放射点x坐标	注意，这里的坐标是整个背景的百分比的点，并不是确切点，0.2就是20%的点
  sle_gradientCenterY	float	渐变中心放射点y坐标	注意，这里的坐标是整个背景的百分比的点，并不是确切点，0.2就是20%的点
  sle_gradientRadius	dimension|reference	渐变半径	需要配合gradientType=radial使用，如果设置gradientType=radial而没有设置gradientRadius，将会报错

  
  
  
  
  • 其它
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  

  属性名称	类型	说明	备注
  sle_maskBackgroundColor	color|reference	当sle_type=mask时，按钮按下状态的遮罩颜色	默认值：90%透明度黑色(#1A000000)
  sle_cancelOffset	dimension|reference	用于解决手指移出控件区域判断为cancel的偏移量	默认值：8dp

  
  


• 
  

  特有属性

  
  
  
  
  • SleConstraintLayout/SleRelativeLayout/SleFrameLayout/SleLinearLayout
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  

  属性名称	类型	说明	备注
  sle_interceptType	enum	事件拦截类型 intercept_super：return super intercept_true：return true intercept_false：return false	Layout组件设置此值，可实现是否拦截事件，如果设置为intercept_true，事件将不传递到子控件，在某些场景比较实用

  
  
  
  
  • SleTextButton
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  

  属性名称	类型	说明	备注
  sle_normalTextColor	color|reference	常态文字颜色	/
  sle_pressedTextColor	color|reference	按下态文字颜色	/
  sle_disabledTextColor	color|reference	不可点击态文字颜色	/
  sle_selectedTextColor	color|reference	选中态文字颜色	/

  
  
  
  
  • SleImageButton
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  
  

  属性名称	类型	说明	备注
  sle_ib_type	enum	类型 mask：图片遮罩 alpha：图片透明度改变 selector：自定义图片 checkBox：CheckBox场景 none：无	1.指定为mask时，自定义图片资源无效； 2.指定为alpha时，sle_pressedAlpha/sle_disabledAlpha生效； 3.指定为selector时，sle_normalResId/sle_pressedResId/sle_disabledResId生效； 4.指定为checkBox时，sle_checkedResId/sle_uncheckedResId/sle_isChecked生效； 5.指定为none时，图片资源均不生效，圆角相关配置有效
  sle_ib_style	enum	ImageView形状 normal：普通形状 rounded：圆角 oval：圆形	默认值：normal
  sle_normalResId	color|reference	常态图片资源	/
  sle_pressedResId	color|reference	按下态图片资源	/
  sle_disabledResId	color|reference	不可点击态图片资源	/
  sle_checkedResId	color|reference	选中态checkBox图片资源	/
  sle_uncheckedResId	color|reference	非选中态checkBox图片资源	/
  sle_isChecked	boolean	CheckBox是否选中	默认值：false
  sle_pressedAlpha	float	按下态图片透明度	默认值：70%
  sle_disabledAlpha	float	不可点击态图片透明度	默认值：30%

  
  

使用方式

1. 添加依赖

implementation "io.github.freddychen:silhouette:$lastest_version"

Note：最新版本可在maven central silhouette中找到。

2. 使用

由于自定义属性太多，在此就不一一列举了。下面给出几种常见的场景示例，大家可以根据自定义属性表自行编写：

• 常态