搜索到
629
篇与
的结果
-
Java基础知识之内部类 Java四种内部类。实例内部类：没有static修饰的内部类。静态内部类：使用static修饰的内部类。局部内部类：在方法中定义的内部类。匿名内部类：没有名称的局部内部类。package com.company.innerclasspackage; public class Outer { private String classDesc = "实例内部类访问"; private static String staticClassDesc = "静态内部类访问"; /** * 实例内部类 */ public class Inner1 { public void desc() { System.out.println(classDesc); } } /** * 静态内部类 */ public static class Inner2 { public void Desc() { System.out.println(staticClassDesc); } } public void desc() { String localClassDesc = "局部内部类"; class Inner3{ public void desc(){ System.out.println(localClassDesc); } } } } -
Effective Java (高效 Java) 第三版-单例模式 Java中单例(Singleton)模式是一种广泛使用的设计模式。单例模式的主要作用是保证在Java程序中，某个类只有一个实例存在。一些管理器和控制器常被设计成单例模式。单例模式有很多好处，它能够避免实例对象的重复创建，不仅可以减少每次创建对象的时间开销，还可以节约内存空间；能够避免由于操作多个实例导致的逻辑错误。如果一个对象有可能贯穿整个应用程序，而且起到了全局统一管理控制的作用，那么单例模式也许是一个值得考虑的选择。饿汉模式public class Singleton{ private static Singleton instance = new Singleton(); private Singleton(){} public static Singleton newInstance(){ return instance; } }类的构造函数定义为private的，保证其他类不能实例化此类，然后提供了一个静态实例并返回给调用者。饿汉模式是最简单的一种实现方式，饿汉模式在类加载的时候就对实例进行创建，实例在整个程序周期都存在。它的好处是只在类加载的时候创建一次实例，不会存在多个线程创建多个实例的情况，避免了多线程同步的问题。它的缺点也很明显，即使这个单例没有用到也会被创建，而且在类加载之后就被创建，内存就被浪费了。这种实现方式适合单例占用内存比较小，在初始化时就会被用到的情况。但是，如果单例占用的内存比较大，或单例只是在某个特定场景下才会用到，使用饿汉模式就不合适了，这时候就需要用到懒汉模式进行延迟加载。懒汉模式public class Singleton{ private static Singleton instance = null; private Singleton(){} public static Singleton newInstance(){ if(null == instance){ instance = new Singleton(); } return instance; } }懒汉模式中单例是在需要的时候才去创建的，如果单例已经创建，再次调用获取接口将不会重新创建新的对象，而是直接返回之前创建的对象。如果某个单例使用的次数少，并且创建单例消耗的资源较多，那么就需要实现单例的按需创建，这个时候使用懒汉模式就是一个不错的选择。但是这里的懒汉模式并没有考虑线程安全问题，在多个线程可能会并发调用它的getInstance()方法，导致创建多个实例，因此需要加锁解决线程同步问题，实现如下。public class Singleton{ private static Singleton instance = null; private Singleton(){} public static synchronized Singleton newInstance(){ if(null == instance){ instance = new Singleton(); } return instance; } }synchronized修饰静态方法，可以锁定这个类的所有对象。双重校验锁加锁的懒汉模式看起来即解决了线程并发问题，又实现了延迟加载，然而它存在着性能问题，依然不够完美。synchronized修饰的同步方法比一般方法要慢很多，如果多次调用getInstance()，累积的性能损耗就比较大了。因此就有了双重校验锁，先看下它的实现代码。public class Singleton { private static Singleton instance = null; private Singleton(){} public static Singleton getInstance() { if (instance == null) { synchronized (Singleton.class) { if (instance == null) {//2 instance = new Singleton(); } } } return instance; } }可以看到上面在同步代码块外多了一层instance为空的判断。由于单例对象只需要创建一次，如果后面再次调用getInstance()只需要直接返回单例对象。因此，大部分情况下，调用getInstance()都不会执行到同步代码块，从而提高了程序性能。不过还需要考虑一种情况，假如两个线程A、B，A执行了if (instance == null)语句，它会认为单例对象没有创建，此时线程切到B也执行了同样的语句，B也认为单例对象没有创建，然后两个线程依次执行同步代码块，并分别创建了一个单例对象。为了解决这个问题，还需要在同步代码块中增加if (instance == null)语句，也就是上面看到的代码2。我们看到双重校验锁即实现了延迟加载，又解决了线程并发问题，同时还解决了执行效率问题，是否真的就万无一失了呢？这里要提到Java中的指令重排优化。所谓指令重排优化是指在不改变原语义的情况下，通过调整指令的执行顺序让程序运行的更快。JVM中并没有规定编译器优化相关的内容，也就是说JVM可以自由的进行指令重排序的优化。这个问题的关键就在于由于指令重排优化的存在，导致初始化Singleton和将对象地址赋给instance字段的顺序是不确定的。在某个线程创建单例对象时，在构造方法被调用之前，就为该对象分配了内存空间并将对象的字段设置为默认值。此时就可以将分配的内存地址赋值给instance字段了，然而该对象可能还没有初始化。若紧接着另外一个线程来调用getInstance，取到的就是状态不正确的对象，程序就会出错。以上就是双重校验锁会失效的原因，不过还好在JDK1.5及之后版本增加了volatile关键字。volatile的一个语义是禁止指令重排序优化，也就保证了instance变量被赋值的时候对象已经是初始化过的，从而避免了上面说到的问题。代码如下：public class Singleton { private static volatile Singleton instance = null; private Singleton(){} public static Singleton getInstance() { if (instance == null) { synchronized (Singleton.class) { if (instance == null) { instance = new Singleton(); } } } return instance; } }静态内部类除了上面的三种方式，还有另外一种实现单例的方式，通过静态内部类来实现。首先看一下它的实现代码：public class Singleton{ private static class SingletonHolder{ public static Singleton instance = new Singleton(); } private Singleton(){} public static Singleton newInstance(){ return SingletonHolder.instance; } }这种方式同样利用了类加载机制来保证只创建一个instance实例。它与饿汉模式一样，也是利用了类加载机制，因此不存在多线程并发的问题。不一样的是，它是在内部类里面去创建对象实例。这样的话，只要应用中不使用内部类，JVM就不会去加载这个单例类，也就不会创建单例对象，从而实现懒汉式的延迟加载。也就是说这种方式可以同时保证延迟加载和线程安全。枚举public enum Singleton{ instance; public void whateverMethod(){} }上面提到的四种实现单例的方式都有共同的缺点：1）需要额外的工作来实现序列化，否则每次反序列化一个序列化的对象时都会创建一个新的实例。2）可以使用反射强行调用私有构造器（如果要避免这种情况，可以修改构造器，让它在创建第二个实例的时候抛异常）。而枚举类很好的解决了这两个问题，使用枚举除了线程安全和防止反射调用构造器之外，还提供了自动序列化机制，防止反序列化的时候创建新的对象。因此，《Effective Java》作者推荐使用的方法。不过，在实际工作中，很少看见有人这么写。
-
Effective Java (高效 Java) 第三版-构造方法参数过多时使用 builder 模式 静态工厂和构造方法都有一个限制：它们不能很好地扩展到很多可选参数的情景。考虑我们有一个人员的类，如果只有姓名是必填的，年龄可选的，也许我们可以提供两个构造函数，但是试想一下，如果有两个类型一样的参数，是不是就没法重载了。或者可选的参数比较多，就比较麻烦了。这个时候，我们就可以考虑builder模式了。 public class Person { private String name; private int age; public static class Builder { private String name; private int age; public Builder(String name) { this.name = name; } public Builder withName(String name) { this.name = name; return this; } public Builder withAge(int age) { this.age = age; return this; } public Person build() { return new Person(this); } } public Person(Builder builder) { this.name = builder.name; this.age = builder.age; } public void desc() { System.out.println("姓名：" + name + ",年龄：" + age); } }调用Person person = new Person.Builder("张三").withAge(30).build(); person.desc();
-
Effective Java (高效 Java) 第三版-考虑使用静态工厂方法替代构造方法 public static Boolean valueOf(boolean b) { return b ? Boolean.TRUE : Boolean.FALSE; }静态工厂方法的优点构造方法没有名字，但是静态工厂方法是有名字的如果构造方法的参数本身并不描述被返回的对象，则具有精心选择名称的静态工厂更易于使用，并且生成的客户端代码更易于阅读。不需要每次调用时都创建一个新对象可以返回其返回类型的任何子类型的对象这种灵活性的一个应用是 API 可以返回对象而不需要公开它的类。 以这种方式隐藏实现类会使 API 非常紧凑。返回对象的类可以根据输入参数的不同而不同声明的返回类型的任何子类都是允许的。 返回对象的类也可以随每次发布而不同。在编写包含该方法的类时，返回的对象的类不需要存在这种灵活的静态工厂方法构成了服务提供者框架的基础，比如 Java 数据库连接 AP（JDBC）。服务提供者框架是提供者实现服务的系统，并且系统使得实现对客户端可用，从而将客户端从实现中分离出来。静态工厂方法的缺点没有公共或受保护构造方法的类不能被子类化要想将Collections框架中任何遍历的实现类进行子类化，是不可能的。程序员很难找到它们它们不像构造方法那样在 API 文档中明确的标注出来。因此，对于提供了静态方法而不是构造器的类来说，想要查明如何实例化一个类是十分困难的。
-
Java中Synchronized的用法 Synchronized是Java中的关键字，是一种同步锁。他修饰的对象有以下几种。修饰一个代码块被修饰的代码块称为同步语句块，其作用的范围是大括号{}括起来的代码，作用的对象是调用这个代码块的对象。修饰一个方法被修饰的方法称为同步方法，其作用的范围是整个方法，作用的对象是调用这个方法的对象。修饰一个静态方法其作用的范围是整个静态方法，作用的对象是这个类的所有对象。修饰一个类其作用的范围是synchronized后面括号括起来的部分，作用主的对象是这个类的所有对象。修饰一个代码块当修饰一个代码块时，我们一定要记住，作用的对象是调用这个代码块的对象。我们下面通过一段代码看一下。public class SynchronizedThread implements Runnable { /** * 计数 */ private static int count; @Override public void run() { synchronized (this) { for (int i = 0; i < 5; i++) { count++; System.out.println(Thread.currentThread().getName() + ":" + count); } } } }这段代码很简单，就是对对类的一个静态变量进行计数。接下来我们看一下调用这段代码的地方。SynchronizedThread synchronizedThread = new SynchronizedThread(); Thread thread1 = new Thread(synchronizedThread,"Thread1"); Thread thread2 = new Thread(synchronizedThread,"Thread2"); thread1.start(); thread2.start();运行上面的代码，查看控制台的输出信息不论我们怎么运行，Thead1与Thread2都是顺序执行的，这正是我们期望的。接下来，我们对上面的代码稍微做一下改动，改动后如下Thread thread3 = new Thread(new SynchronizedThread(),"Thread3"); Thread thread4 = new Thread(new SynchronizedThread(),"Thread4"); thread3.start(); thread4.start();再次运行，查看控制台输出信息可以看到Thead3与Thread4不再是顺序执行。why?Synchronized修饰一个代码块时，作用的对象是调用这个代码块的对象，我们可以看到Thead3与Thread4中是new了一个新的对象，不再是同一个对象，所以Synchronized不再起作用。修饰一个方法修饰一个方法跟修饰一个代码块类似，只是作用域不同。我们继续修改SynchronizedThread，修改后如下：public class SynchronizedThread implements Runnable { /** * 计数 */ private static int count; @Override public void run() { increment(); } public synchronized void increment(){ for (int i = 0; i < 15; i++) { count++; System.out.println(Thread.currentThread().getName() + ":" + count); } } }再次调用上面的两次代码，会发现结果是一样的。修饰静态方法由于静态方法是属于类而不是属于对象，因此synchronized修饰的静态方法锁定的是这个类的所有对象。我们再次对上面的SynchronizedThread进行修改，将increment()方法改成静态方法public class SynchronizedThread implements Runnable { /** * 计数 */ private static int count; @Override public void run() { increment(); } public synchronized static void increment(){ for (int i = 0; i < 15; i++) { count++; System.out.println(Thread.currentThread().getName() + ":" + count); } } }我们再次通过以下代码进行调用Thread thread3 = new Thread(new SynchronizedThread(),"Thread3"); Thread thread4 = new Thread(new SynchronizedThread(),"Thread4"); thread3.start(); thread4.start();查看控制台，可以看到之前不是顺序执行的方法，现在也是按照线程顺序执行了修饰一个类我们再次对上面的SynchronizedThread进行修改public class SynchronizedThread implements Runnable { /** * 计数 */ private static int count; @Override public void run() { increment(); } public static void increment() { synchronized (SynchronizedThread.class) { for (int i = 0; i < 15; i++) { count++; System.out.println(Thread.currentThread().getName() + ":" + count); } } } }我们再次通过以下代码进行调用Thread thread3 = new Thread(new SynchronizedThread(),"Thread3"); Thread thread4 = new Thread(new SynchronizedThread(),"Thread4"); thread3.start(); thread4.start();查看控制台，现在也是按照线程顺序执行的。
-
支持私有化部署的在线知识管理系统-觅思文档 为什么我们需要私有化部署知识库最近HVV行动搞的轰轰烈烈，你的腾讯文档、金山文档还好吗？数据在自己手里，更安全，更安心。觅思文档介绍 MrDoc 是基于Python开发的在线文档系统。 MrDoc 适合作为个人和中小型团队的私有云文档、云笔记和知识管理工具，致力于成为优秀的私有化在线文档部署方案。{message type="success" content="觅思文档有收费版也有免费版，个人感觉免费版其实完全就够用了"/}觅思文档安装 个人不擅长Python，使用Linux一键安装脚本也没有安装上，因此推荐大家使用Docker安装，避免乱七八糟的依赖报错。创建Docker创建本地挂载文件夹docker run -d --name mrdoc -p 12345:10086 -v /home/software/mrdoc:/app/MrDoc/config -v /home/software/mrdoc/media:/app/MrDoc/media jonnyan404/mrdoc-alpine:0.8.0运行镜像docker start mrdoc获取密码docker logs mrdoc 2>&1|grep pwd通过IP:12345即可访问常见问题获取的默认密码无法登录方式一:创建新管理员 docker exec -it mrdoc python manage.py createsuperuser根据提示输入 账号/邮箱/密码 即可方式二:修改管理员密码 docker exec -it mrdoc python manage.py changepassword admin按提示输入新密码即可,英文大小写混合+数字大于8位
-
centos7 yum命令安装软件报错One of the configured repositories failed (未知) [root@localhost yum.repos.d]# yum install ansible 已加载插件：fastestmirror One of the configured repositories failed (未知), and yum doesn't have enough cached data to continue. At this point the only safe thing yum can do is fail. There are a few ways to work "fix" this: 1. Contact the upstream for the repository and get them to fix the problem. 2. Reconfigure the baseurl/etc. for the repository, to point to a working upstream. This is most often useful if you are using a newer distribution release than is supported by the repository (and the packages for the previous distribution release still work). 3. Disable the repository, so yum won't use it by default. Yum will then just ignore the repository until you permanently enable it again or use --enablerepo for temporary usage: yum-config-manager --disable <repoid> 4. Configure the failing repository to be skipped, if it is unavailable. Note that yum will try to contact the repo. when it runs most commands, so will have to try and fail each time (and thus. yum will be be much slower). If it is a very temporary problem though, this is often a nice compromise: yum-config-manager --save --setopt=<repoid>.skip_if_unavailable=true Cannot retrieve metalink for repository: epel/x86_64. Please verify its path and try again解决办法yum remove epel-release -y yum update yum install epel-release -y
-
SpringBoot事务提交后执行异步代码 一般情况下，我们在使用事务时，都是在方法上添加一个@Transactional注解 @Transactional(rollbackFor = Exception.class) public void test1() { }但是有些时候，除了主要核心业务外，我们可能还需要推送消息，但是推送消息我们又需要使用我们核心业务的数据，比如我在核心业务代码中执行了插入，之后需要异步获取插入的数据，推送消息或者发送给异构系统，这个时候，我们可以使用Spring Boot提供的TransactionSynchronization接口，并实现afterCommit方法package com.example.demo.service; import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; import org.springframework.transaction.support.TransactionSynchronizationAdapter; import org.springframework.transaction.support.TransactionSynchronizationManager; import javax.annotation.Resource; @Service public class Test123Service { @Resource Test2Service test2Service; @Transactional(rollbackFor = Exception.class) public void test1() { boolean synchronizationActive = TransactionSynchronizationManager.isSynchronizationActive(); if (synchronizationActive) { TransactionSynchronizationManager.registerSynchronization( new TransactionSynchronizationAdapter() { @Override public void afterCommit() { test2Service.test2(); } } ); } else { test2Service.test2(); } } } package com.example.demo.service; import org.springframework.scheduling.annotation.Async; import org.springframework.stereotype.Service; @Service public class Test2Service { @Async public void test2(){ System.out.println("test2"); } }方法test1()不能调用同一给类中使用了@Async注解的方法test2()（此时@Async会失效）
-
Vue 2.X过渡系统 Vue2.X过渡系统过渡系统是Vue.js为DOM动画效果提供的一个特性，它能在元素从DOM中插入或移除时触发你的CSS过渡（transition）和动画（animation），也就是说在DOM元素发生变化时为其添加特尔顶的class类名，从而产生过渡效果。一、Vue2.X定义过渡动画的方法不同于Vue1.X，Vue2.x过渡系统取消了v-transion指令，新增了<transition/>内置标签，用法如下<transition name="hello"> <h1 v-if="show">你好</h1> </transition>transition标签为一个抽象标签，并不会额外渲染一个DOM元素，仅仅时用于包裹过渡元素及触发过渡行为。v-if、v-show等指令仍旧标记在内容元素上。二、transition参数2.1、nameVue根据name自动生成对应的对应的类名。name-enter、name-enter-active、name-enter-to、name-leave、name-leave-active、name-leave-to六种状态类名说明name-enter：定义进入过渡的开始状态。在元素被插入之前生效，在元素被插入之后的下一帧移除。name-enter-active：定义进入过渡生效时的状态。在整个进入过渡的阶段中应用，在元素被插入之前生效，在过渡/动画完成之后移除。这个类可以被用来定义进入过渡的过程时间，延迟和曲线函数。name-enter-to: 2.1.8版及以上 定义进入过渡的结束状态。在元素被插入之后下一帧生效 (与此同时 name-enter 被移除)，在过渡/动画完成之后移除。name-leave: 定义离开过渡的开始状态。在离开过渡被触发时立刻生效，下一帧被移除。name-leave-active：定义离开过渡生效时的状态。在整个离开过渡的阶段中应用，在离开过渡被触发时立刻生效，在过渡/动画完成之后移除。这个类可以被用来定义离开过渡的过程时间，延迟和曲线函数。name-leave-to: 2.1.8版及以上 定义离开过渡的结束状态。在离开过渡被触发之后下一帧生效 (与此同时 name-leave 被删除)，在过渡/动画完成之后移除。2.2、appear元素首次渲染的时候是否启用transition，默认为false。即v-if绑定值初始为true时，是否渲染时调用transition效果。2.3、css如果设置为true，则只监听钩子函数的调用。2.4、type设置监听CSS动画结束事件的类型。2.5、mode控制过渡插入/移除的先后顺序，主要用于元素切换时。可选择的值有out-in、in-out，如果不设置则同时调用。三、钩子函数与类名类似，也可以使用对应的钩子函数，包括@before-enter、@enter、@after-enter、@before-leave、@leave、@after-leave、四、transition-grouptransition-group主要用于将过渡动画应用到多个DOM元素上。五、Demo<style rel="stylesheet" type="text/css"> /* 动画退出类名 */ .hello-leave-active { animation: amt1 0.5s linear reverse; } /* 定义动画 */ @keyframes amt1 { from { transform: translateX(-100%); } to { transform: translateX(0px); } } /* 进入的起点、离开的终点 */ .hello-enter, .hello-leave-to { transform: translateX(-100%); } /* 进入的过程 */ .hello-enter-active, .hello-leave-active { transition: 0.5s linear; } /* 进入的终点、离开的起点 */ .hello-enter-to, .hello-leave { transform: translateX(0); } </style> <!-- <link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/animate.css/4.1.1/animate.min.css" /> --> </head> <script src="https://cdn.staticfile.org/vue/2.2.2/vue.min.js" type="text/javascript"></script> <body> <div id='app'> <button v-on:click="show = !show"> Toggle </button> <transition name="hello" @before-enter="beforeEnter"> <h1 v-if="show">你好</h1> </transition> <!-- <transition-group appear name="animate__animated animate__bounce" enter-active-class="animate__swing" leave-active-class="animate__backOutUp"> <h1 v-show="!show" key="1">你好啊！</h1> <h1 v-show="show" key="2">迪丽热巴！</h1> </transition-group> --> </div> <script> let vm = new Vue({ el: '#app', data: { show: false }, methods: { beforeEnter: function () { console.log('beforeEnter'); } } }) </script>
-
Typora 1.2.4破解版 简介 Typora是一款免费的轻量级Markdown编辑器，它没有Mou，Haroopad等Markdown编辑器那么大名鼎鼎，算是较为小众的一款产品。使用方法安装主程序打开下载的压缩包，双击typora-setup-x64-1.2.4.exe安装。覆盖资源文件安装完成后，将压缩包的app.asar覆盖到安装目录的resources文件夹内。破解打开Typora，点击输入序列号，邮箱随便填，序列号输入E8Q9Y5-KXMTL5-7578SL-4S5XKS下载地址{cloud title="Typora 1.2.4" type="bd" url="https://pan.baidu.com/s/1nze61I5ARtaDQf4Y4REcWg?pwd=g4j6" password="g4j6"/}{alert type="warning"}如果链接失效，可以留言回复{/alert}
-
Typora配置七牛云图床 {message type="warning" content="Typora 1.0.0之后已经开始收费"/}前置条件安装Typora 0.9.96及以上版本（0.9.96以上版本才支持第三方平台图床配置）注册七牛云账号并完成实名认证准备一个备案的域名七牛云配置创建七牛云空间打开七牛云，选择对象存储，并创建空间输入空间信息存储空间名称：自己随意命名；存储区域：尽量选择 华东、华北、华南中的一个(这里需要记住区域对应编号，后面配置会用到华东-z0；华北-z1;华南-z2);访问控制： 公开；绑定域名空间创建后，绑定域名使用自己的已备案域名并完成cname解析，这里不再赘述。获取密钥找到个人中心，打开密钥管理，里面会看到AK和SK参数Typora配置勾选自动上传图片进入Typora，进入偏好设置，找到[图像]选项，并按照如下勾选下载插件点击下载或更新，下载插件配置文件点击[打开配置文件]，参考以下内容{ "picBed": { "uploader": "qiniu", "qiniu": { "accessKey": "",//七牛对应的key "secretKey": "",//七牛对应的sk "bucket": "", // 存储空间名 "url": "", // 自定义域名 "area": "z0", // 存储区域编号 "options": "", // 网址后缀，比如？imgslim "path": "typora/" // 自定义存储路径，比如 img/ } }, "picgoPlugins": {} }
-
Vue自定义指令 Vue除了内置的v-bind、v-model、v-once、v-pre等内置指令外，我们还可以注册自定义指令，以便封装对DOM元素的重复处理行为，提高代码的复用率。指令的注册自定义指令分为两种，全局自定义指令及组件（局部）自定义指令。全局自定义指令在所有组件中都可以使用，组件（局部）自定义指令顾名思义，只能在当前组件中使用。全局自定义指令全局自定义指令通过Vue.directive(id,definition)进行注册。如下，我们定义一个自动获取焦点的自定义组件。实现功能，当页面打开时，让<input>控件自动获取焦点。<html> <head> <title></title> </head> <script src="https://cdn.staticfile.org/vue/2.2.2/vue.min.js" type="text/javascript"></script> <body> <div id='app'> <input type="text" v-g-focus="'1111'"/> </div> <script> Vue.directive('gFocus', { inserted: function (el,binding) { el.focus(); } }) let vm = new Vue({ el: '#app' }) </script> </body> </html> 组件（局部）自定义指令组件（局部）自定义指令通过组件的directives进行注册，如下let comp = Vue.extend({ directives: { 'localDirective': {} } })该指令只能在当前组件内调用，其他组件无法使用。指令的定义对象我们在注册指令的同时，可以传入definition定义对象，对指令赋予一些特殊的功能。这些对象主要包括五个钩子函数。bind:只被调用一次，在指令第一次绑定到元素上时调用。inserted:指令所绑定的元素插入到DOM中时调用update:指令在绑定之后以初始值作为参数进行第一次调用，之后每次当绑定值发生变化时调用。描述的是组件更新前的状态。componentUpdated:被绑定元素所在模板完成一次更新周期时调用。描述的是组件更新后的状态unbind:只被调用一次，当指令与元素解绑时调用。我们可以通过以下代码简单看一下使用方法<div id='app'> <input type="text" v-g-focus="param" v-if="exist" /> </div> <script> Vue.directive('gFocus', { bind:function(el, binding){ console.log('bind:' + binding.value) }, inserted: function (el, binding) { el.focus(); console.log('inserted:' + binding.value) }, update: function (el, binding) { console.log('update:' + binding.value) }, unbind:function(el, binding){ console.log('unbind:' + binding.value) }, componentUpdated:function(el, binding){ console.log('componentUpdated:' + binding.value) }, }) let vm = new Vue({ el: '#app', data: { param: 'first', exist: true } }) </script>当我们第一次打开页面时，查看控制台，会看到如下输出我们在控制台输入vm.param='second'，可以看到如下输出我们在控制台输入vm.exist=false，可以看到如下输出钩子函数参数钩子函数参数 (即 el、binding、vnode 和 oldVnode)指令钩子函数会被传入以下参数：el：指令所绑定的元素，可以用来直接操作DOM。binding：一个对象，包含以下属性：name：指令名，不包括v-前缀。value：指令的绑定值，例如：我们上面代码传递的param。oldValue：指令绑定的前一个值，仅在update和componentUpdated钩子中可用。无论值是否改变都可用。expression：字符串形式的指令表达式。例如v-my-directive="1 + 1"中，表达式为1 + 1。arg：传给指令的参数，可选。例如v-my-directive:foo中，参数为foo。modifiers：一个包含修饰符的对象。例如：v-my-directive.foo.bar 中，修饰符对象为 { foo: true, bar: true }。vnode：Vue 编译生成的虚拟节点。oldVnode：上一个虚拟节点，仅在update和componentUpdated钩子中可用。
