shell复制代码2020-11-20 18:52:26.864 WARN  o.s.b.w.s.c.AnnotationConfigServletWebServerApplicationContext - Exception encountered during context initialization - cancelling refresh attempt: org.springframework.context.ApplicationContextException: Failed to start bean 'documentationPluginsBootstrapper'; nested exception is com.google.common.util.concurrent.ExecutionError: java.lang.NoSuchMethodError: com.google.common.collect.FluentIterable.concat(Ljava/lang/Iterable;Ljava/lang/Iterable;)Lcom/google/common/collect/FluentIterable;
2020-11-20 18:52:26.866 INFO  o.s.j.e.a.AnnotationMBeanExporter - Unregistering JMX-exposed beans on shutdown
2020-11-20 18:52:26.867 INFO  o.s.j.e.a.AnnotationMBeanExporter - Unregistering JMX-exposed beans
2020-11-20 18:52:26.886 WARN  c.n.c.sources.URLConfigurationSource - No URLs will be polled as dynamic configuration sources.
2020-11-20 18:52:26.886 INFO  c.n.c.sources.URLConfigurationSource - To enable URLs as dynamic configuration sources, define System property archaius.configurationSource.additionalUrls or make config.properties available on classpath.
2020-11-20 18:52:26.905 INFO  o.s.a.r.l.SimpleMessageListenerContainer - Shutdown ignored - container is not active already
2020-11-20 18:52:26.910 INFO  o.a.catalina.core.StandardService - Stopping service [Tomcat]
2020-11-20 18:52:26.927 WARN  o.a.c.loader.WebappClassLoaderBase - The web application [ROOT] appears to have started a thread named [Abandoned connection cleanup thread] but has failed to stop it. This is very likely to create a memory leak. Stack trace of thread:
 java.lang.Object.wait(Native Method)
 java.lang.ref.ReferenceQueue.remove(ReferenceQueue.java:144)
 com.mysql.cj.jdbc.AbandonedConnectionCleanupThread.run(AbandonedConnectionCleanupThread.java:43)

Process finished with exit code 1

shell复制代码but has failed to stop it. This is very likely to create a memory leak. Stack trace of thread

shell复制代码 Failed to start bean 'documentationPluginsBootstrapper' 
 nested exception is com.google.common.util.concurrent.ExecutionError: java.lang.NoSuchMethodError: com.google.common.collect.FluentIterable.concat(Ljava/lang/Iterable;Ljava/lang/Iterable;)Lcom/google/common/collect/FluentIterable;

xml复制代码   <!-- <dependency>
        <groupId>com.google.guava</groupId>
        <artifactId>guava</artifactId>
        <version>19.0</version>
    </dependency>-->

    <dependency>
        <groupId>com.google.guava</groupId>
        <artifactId>guava</artifactId>
        <version>20.0</version>
    </dependency>

xml复制代码<dependency>
    <groupId>org.apache.shiro</groupId>
    <artifactId>shiro-core</artifactId>
    <version>1.7.0</version>
</dependency>
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>jcl-over-slf4j</artifactId>
    <version>1.7.29</version>
</dependency>
<dependency>
    <groupId>org.slf4j</groupId>
    <artifactId>slf4j-log4j12</artifactId>
    <version>1.7.29</version>
</dependency>
<dependency>
    <groupId>log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>1.2.17</version>
</dependency>

ini复制代码# =============================================================================
# Tutorial INI configuration
#
# Usernames/passwords are based on the classic Mel Brooks' film "Spaceballs" :)
# =============================================================================

# -----------------------------------------------------------------------------
# Users and their (optional) assigned roles
# username = password, role1, role2, ..., roleN
# -----------------------------------------------------------------------------
[users]
root = secret, admin
guest = guest, guest
presidentskroob = 12345, president
darkhelmet = ludicrousspeed, darklord, schwartz
lonestarr = vespa, goodguy, schwartz

# -----------------------------------------------------------------------------
# Roles with assigned permissions
# roleName = perm1, perm2, ..., permN
# -----------------------------------------------------------------------------
[roles]
admin = *
schwartz = lightsaber:*
goodguy = winnebago:drive:eagle5

ini复制代码Factory<SecurityManager> factory = new IniSecurityManagerFactory("classpath:shiro.ini");
SecurityManager securityManager = factory.getInstance();
SecurityUtils.setSecurityManager(securityManager);

ini复制代码Environment environment = new BasicIniEnvironment("classpath:shiro.ini");
SecurityManager securityManager = environment.getSecurityManager();
SecurityUtils.setSecurityManager(securityManager);

java复制代码public class Tutorial {

   private static final transient Logger log = LoggerFactory.getLogger(Tutorial.class);

   public static void main(String[] args) {
       log.info("My First Apache Shiro Application");

       // 1.初始化环境，主要是加载shiro.ini配置文件的信息
       Environment environment = new BasicIniEnvironment("classpath:shiro.ini");
      // 2.获取SecurityManager安全管理器
      SecurityManager securityManager = environment.getSecurityManager();
      SecurityUtils.setSecurityManager(securityManager);

      // 3.获取当前主体（用户）
      Subject currentUser = SecurityUtils.getSubject();

      // 4.获取当前主体的会话
      Session session = currentUser.getSession();
      // 5.向会话中存储一些内容（不需要web容器或EJB容器）
      session.setAttribute("someKey", "aValue");
      // 6.再次从会话中获取存储的内容，并比较与存储值是否一致。
      String value = (String) session.getAttribute("someKey");
      if ("aValue".equals(value)) {
         log.info("Retrieved the correct value! [" + value + "]");
      }

      // 当前用户进行登录操作，进而可以检验用户的角色和权限。    
      // 7.判断当前用户是否认证（此时很显然未认证）
      if (!currentUser.isAuthenticated()) {
         // 8.将账号和密码封装到UsernamePasswordToken中
         UsernamePasswordToken token = new UsernamePasswordToken("lonestarr", "vespa");
         // 9.记住我
         token.setRememberMe(true);
         try {
            // 10.进行登录操作
            currentUser.login(token);
         } catch (UnknownAccountException uae) {
            log.info("There is no user with username of " + token.getPrincipal());
         } catch (IncorrectCredentialsException ice) {
            log.info("Password for account " + token.getPrincipal() + " was incorrect!");
         } catch (LockedAccountException lae) {
            log.info("The account for username " + token.getPrincipal() + " is locked.  " +
                  "Please contact your administrator to unlock it.");
         }
         // ... 更多其他异常，包括应用程序异常
         catch (AuthenticationException ae) {
            // 其他意外异常、error处理
         }
      }

      // 打印当前用户的主体信息
      log.info("User [" + currentUser.getPrincipal() + "] logged in successfully.");

      // 10.检查是否有指定角色权限（前面已经通过Environment加载了权限和角色信息）
      if (currentUser.hasRole("schwartz")) {
         log.info("May the Schwartz be with you!");
      } else {
         log.info("Hello, mere mortal.");
      }

      // 判断是否有资源操作权限
      if (currentUser.isPermitted("lightsaber:wield")) {
         log.info("You may use a lightsaber ring.  Use it wisely.");
      } else {
         log.info("Sorry, lightsaber rings are for schwartz masters only.");
      }

      // 更强级别的权限验证
      if (currentUser.isPermitted("winnebago:drive:eagle5")) {
         log.info("You are permitted to 'drive' the winnebago with license plate (id) 'eagle5'.  " +
               "Here are the keys - have fun!");
      } else {
         log.info("Sorry, you aren't allowed to drive the 'eagle5' winnebago!");
      }

      // 11.登出
      currentUser.logout();
      System.exit(0);
   }
}

kotlin复制代码INFO - My First Apache Shiro Application
INFO - Enabling session validation scheduler...
INFO - Retrieved the correct value! [aValue]
INFO - User [lonestarr] logged in successfully.
INFO - May the Schwartz be with you!
INFO - You may use a lightsaber ring.  Use it wisely.
INFO - You are permitted to 'drive' the winnebago with license plate (id) 'eagle5'.  Here are the keys - have fun!

ini复制代码// 1.初始化环境，主要是加载shiro.ini配置文件的信息
Environment environment = new BasicIniEnvironment("classpath:shiro.ini");
// 2.获取SecurityManager安全管理器
SecurityManager securityManager = environment.getSecurityManager();
SecurityUtils.setSecurityManager(securityManager);

java复制代码// 获取当前主体（用户）
Subject currentUser = SecurityUtils.getSubject();
// 判断当前用户是否认证
currentUser.isAuthenticated()
// 将账号和密码封装到UsernamePasswordToken中
UsernamePasswordToken token = new UsernamePasswordToken("lonestarr", "vespa");
// 记住我
token.setRememberMe(true);
// 登录操作
currentUser.login(token);

ini复制代码//currentUser类型为Subject，在构造了SecurityManager之后，提交认证，token封装了用户信息
currentUser.login(token);

//DelegatingSubject类中，调用SecurityManager执行认证
Subject subject = this.securityManager.login(this, token);

//DefaultSecurityManager类中，SecurityManager委托给Authenticator执行认证逻辑
AuthenticationInfo info = this.authenticate(token);

// AuthenticatingSecurityManager类中，进行认证
this.authenticator.authenticate(token);

//AbstractAuthenticator类中，进行认证
AuthenticationInfo info = this.doAuthenticate(token);

//ModularRealmAuthenticator类中，获取多Realm进行身份认证
Collection<Realm> realms = this.getRealms();
doSingleRealmAuthentication(realm, token);

//ModularRealmAuthenticator类中，针对具体的Realm进行身份认证
AuthenticationInfo info = realm.getAuthenticationInfo(token);

//AuthenticatingRealm类中，调用对应的Realm进行校验，认证成功则返回用户属性
AuthenticationInfo info = realm.doGetAuthenticationInfo(token);

//SimpleAccountRealm类中，根据token获取账户信息
UsernamePasswordToken upToken = (UsernamePasswordToken) token;
SimpleAccount account = getUser(upToken.getUsername());

//AuthenticatingRealm类中，比对传入的token和根据token获取到的账户信息
assertCredentialsMatch(token, info);
->getCredentialsMatcher().doCredentialsMatch(token, info);

//SimpleCredentialsMatcher类中，进行具体对比
byte[] tokenBytes = toBytes(tokenCredentials);
byte[] accountBytes = toBytes(accountCredentials);
MessageDigest.isEqual(tokenBytes, accountBytes);
//或
accountCredentials.equals(tokenCredentials);

arduino复制代码// 检查是否有相应角色权限
currentUser.hasRole("schwartz")
// 判断是否有资源操作权限
currentUser.isPermitted("lightsaber:wield")
// 判断是否有（更细粒度的）资源操作权限
currentUser.isPermitted("winnebago:drive:eagle5")

kotlin复制代码// 检查是否有相应角色权限
currentUser.hasRole("schwartz");

// DelegatingSubject类中，委托给SecurityManager判断角色与既定角色是否匹配
this.securityManager.hasRole(this.getPrincipals(), roleIdentifier);

// AuthorizingSecurityManager类中，SecurityManager委托Authorizer进行角色检验
this.authorizer.hasRole(principals, roleIdentifier);

// ModularRealmAuthorizer类中，获取所有Realm，并遍历检查角色
for (Realm realm : getRealms());
((Authorizer) realm).hasRole(principals, roleIdentifier)

// AuthorizingRealm中，Authorizer判断Realm中的角色/权限是否和传入的匹配
AuthorizationInfo info = getAuthorizationInfo(principal);

// AuthorizingRealm中，执行Realm进行授权操作
AuthorizationInfo info = this.doGetAuthorizationInfo(principals);

// SimpleAccountRealm类中，获得用户SimpleAccount（实现了AuthorizationInfo）,
// users类型为Map，以用户名为key，对应shiro.ini中配置的初始化用户信息
return this.users.get(username);

// AuthorizingRealm类中,判断传入的用户和初始化配置的是否匹配
return hasRole(roleIdentifier, info);

// AuthorizingRealm类中，最终的授权判断
return info != null && info.getRoles() != null && info.getRoles().contains(roleIdentifier);

java复制代码public class AuthenticationTest {

    SimpleAccountRealm simpleAccountRealm = new SimpleAccountRealm();

    @Before
    public void addUser() {
        // 在方法开始前添加一个用户
        simpleAccountRealm.addAccount("wmyskxz", "123456");
    }

    @Test
    public void testAuthentication() {
        // 1.构建SecurityManager环境
        DefaultSecurityManager defaultSecurityManager = new DefaultSecurityManager();
        defaultSecurityManager.setRealm(simpleAccountRealm);

        // 2.主体提交认证请求
        // 设置SecurityManager环境
        SecurityUtils.setSecurityManager(defaultSecurityManager);
        // 获取当前主体
        Subject subject = SecurityUtils.getSubject();
        UsernamePasswordToken token = new UsernamePasswordToken("wmyskxz", "123456");
        // 登录
        subject.login(token);
        // subject.isAuthenticated()方法返回一个boolean值,用于判断用户是否认证成功
        System.out.println("isAuthenticated:" + subject.isAuthenticated());
    }
}

shell复制代码#进入容器
docker exec -it redis-7001 /bin/bash
#建立集群，如果不指定master，会自己随机指定
redis-cli --cluster create 192.168.83.133:7001 192.168.83.133:7002 192.168.83.133:7003 192.168.83.133:7004 192.168.83.133:7005 192.168.83.133:7006 --cluster-replicas 1

bash复制代码#集群模式下，比单机多一个 -c
redis-cli -c  -h 192.168.83.133 -p 7001

set hello 1
set a aaa
set bb aa

复制代码cluster info

复制代码cluster nodes

bash复制代码docker stop redis-7001
#进入7002容器
docker exec -it redis-7002 /bin/bash
#连接redis客户端
redis-cli -c  -h 192.168.83.133 -p 7002
#获取之前存在redis7001 上的 hello的值，这时会发现，7001的副本（从机）会替代宕机的7001主机
#7005被集群提升为主节点
get hello
#查看节点信息
cluster nodes

bash复制代码#重启redis-7001容器
docker restart redis-7001
#查看节点信息
cluster nodes

bash复制代码GET /_cluster/health

bash复制代码PUT /blogs{
	"settings":{
		"number_of_shards": 3,
		"number_of_replicas": 1
	}
}

bash复制代码PUT /blogs/_settings
{
	"number_of_replicas": 2
}

ini复制代码#master节点上
node.master=true
node.data=false
discovery.zen.minimum_master_nodes=2

#data节点上
node.master=falsse
node.data=true

ini复制代码#防止JVM报错
#临时修改
sysctl -w vm.max_map_count=262144
#永久修改
echo vm.max_map_count=262144>>/etc/sysctl.conf
sysctl -p

ini复制代码#创建mynet
docker network create --driver bridge --subnet=172.18.12.0/16 --gateway=172.18.1.1 mynet
#查看网络信息
docker network inspect mynet

shell复制代码#discovery.zen.minimum_master_nodes:2 
#设置这个参数来保证集群中的节点可以知道其他N个有master资格的节点；官方推荐 （N/2）+ 1
for port in $(seq 1 3); \
do \
mkdir -p /var/mall/elasticsearch/master-${port}/config
mkdir -p /var/mall/elasticsearch/master-${port}/data
chmod -R 777 //var/mall/elasticsearch/master-${port}
cat<<EOF> /var/mall/elasticsearch/master-${port}/config/jvm.options
-Xms128m
-Xmx128m
EOF
cat<<EOF> /var/mall/elasticsearch/master-${port}/config/elasticsearch.yml
cluster.name: my-es #集群的名称，同一个集群值必须设置成一样的
node.name: es-master-${port} #该节点的名字
node.master: true #该节点有机会成为master节点
node.data: false #该节点可以存储数据
network.host: 0.0.0.0
http.host: 0.0.0.0 #所有http均可访问
http.port: 920${port}
transport.tcp.port: 930${port}
discovery.zen.ping_timeout: 10s #设置集群中自动发现其他节点时ping的超时时间
#设置集群中的Master节点的初始化列表，可以通过这些节点来自动发现其他新加入集群的节点，es7的新增配置
discovery.seed_hosts: ["172.18.12.21:9301","172.18.12.22:9302","172.18.12.23:9303"]
cluster.initial_master_nodes: ["172.18.12.21"] #新集群初始时的候选主节点，es7新增
EOF
docker run -d --name=es-node-${port} \
-p 920${port}:920${port} -p 930${port}:930${port} --network mynet --ip 172.18.12.2${port} \
-v /var/mall/elasticsearch/master-${port}/config/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml \
-v /var/mall/elasticsearch/master-${port}/config/jvm.options:/usr/share/elasticsearch/config/jvm.options \
-v /var/mall/elasticsearch/master-${port}/data:/usr/share/elasticsearch/data \
-v /var/mall/elasticsearch/master-${port}/plugins:/usr/share/elasticsearch/plugins \
elasticsearch:7.6.1;\
done

perl复制代码#停止全部es容器
docker stop $(docker ps -a |grep es-node-*|awk '{print $1}')
#删除全部es容器
docker rm -f $(docker ps -a |grep es-node-*|awk '{print $1}')

shell复制代码for port in $(seq 4 6); \
do \
mkdir -p /var/mall/elasticsearch/node-${port}/config
mkdir -p /var/mall/elasticsearch/node-${port}/data
chmod -R 777 //var/mall/elasticsearch/node-${port}
cat<<EOF> /var/mall/elasticsearch/node-${port}/config/jvm.options
-Xms128m
-Xmx128m
EOF
cat<<EOF> /var/mall/elasticsearch/node-${port}/config/elasticsearch.yml
cluster.name: my-es #集群的名称，同一个集群值必须设置成一样的
node.name: es-node-${port} #该节点的名字
node.master: false #该节点有机会成为master节点
node.data: true #该节点可以存储数据
network.host: 0.0.0.0
http.host: 0.0.0.0 #所有http均可访问
http.port: 920${port}
transport.tcp.port: 930${port}
discovery.zen.ping_timeout: 10s #设置集群中自动发现其他节点时ping的超时时间
#设置集群中的Master节点的初始化列表，可以通过这些节点来自动发现其他新加入集群的节点，es7的新增配置
discovery.seed_hosts: ["172.18.12.21:9301","172.18.12.22:9302","172.18.12.23:9303"]
cluster.initial_master_nodes: ["172.18.12.21"] #新集群初始时的候选主节点，es7新增
EOF
docker run -d --name=es-node-${port} \
-p 920${port}:920${port} -p 930${port}:930${port} --network mynet --ip 172.18.12.2${port} \
-v /var/mall/elasticsearch/node-${port}/config/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml \
-v /var/mall/elasticsearch/node-${port}/config/jvm.options:/usr/share/elasticsearch/config/jvm.options \
-v /var/mall/elasticsearch/node-${port}/data:/usr/share/elasticsearch/data \
-v /var/mall/elasticsearch/node-${port}/plugins:/usr/share/elasticsearch/plugins \
elasticsearch:7.6.1;\
done

bash复制代码#查看es容器日志信息
#主节点
docker logs es-node-1
#数据节点
docker logs es-node-4

bash复制代码mkdir -p /var/mall/rabbitmq/rabbitmq01
mkdir -p /var/mall/rabbitmq/rabbitmq02
mkdir -p /var/mall/rabbitmq/rabbitmq03

shell复制代码#rabbitmq01
docker run -d --hostname rabbitmq01 --name rabbitmq01 -v /var/mall/rabbitmq/rabbitmq01:/var/lib/rabbitmq  -p 15671:15672 -p 5671:5672 -e RABBITMQ_ERLANG_COOKIE='mall' rabbitmq:management

#rabbitmq02
docker run -d --hostname rabbitmq02 --name rabbitmq02 -v /var/mall/rabbitmq/rabbitmq02:/var/lib/rabbitmq  -p 15672:15672 -p 5672:5672 -e RABBITMQ_ERLANG_COOKIE='mall' --link rabbitmq01:rabbitmq01  rabbitmq:management

#rabbitmq03
docker run -d --hostname rabbitmq03 --name rabbitmq03 -v /var/mall/rabbitmq/rabbitmq03:/var/lib/rabbitmq  -p 15673:15672 -p 5673:5672 -e RABBITMQ_ERLANG_COOKIE='mall' --link rabbitmq01:rabbitmq01  --link rabbitmq02:rabbitmq02 rabbitmq:management

# --hostname 设置容器的主机名
RABBITMQ_ERLANG_COOKIE 节点认证作用，部署集群时，需要同步该值

bash复制代码docker exec -it rabbitmq01 /bin/bash

#清空、初始化mq
rabbitmqctl stop_app
rabbitmqctl reset
rabbitmqctl start_app
exit

perl复制代码docker exec -it rabbitmq02 /bin/bash

#清空、初始化mq，并加入集群
rabbitmqctl stop_app
rabbitmqctl reset
rabbitmqctl join_cluster --ram rabbit@rabbitmq01
rabbitmqctl start_app
exit

perl复制代码docker exec -it rabbitmq03 /bin/bash

#清空、初始化mq，并加入集群
rabbitmqctl stop_app
rabbitmqctl reset
rabbitmqctl join_cluster --ram rabbit@rabbitmq01
rabbitmqctl start_app
exit

makefile复制代码docker exec -it rabbitmq01 /bin/bash
#可以使用 rabbitmqctl list_policies -p /; 查看vhost/下面所有policy
#设置策略（所有队列都是高可用模式并且自动同步）
rabbitmqctl set_policy -p / ha "^" '{"ha-mode":"all","ha-sync-mode":"automatic"}'

css复制代码#在cluster中任意节点启用策略，策略会自动同步到集群节点
rabbitmqctl set_policy -p / ha-all "^" '{"ha-mode":"all"}'
#策略模式all即复制到所有节点，包含新增节点，策略正则表达式为"^",表示匹配所有

arduino复制代码dependencies {
  // debugImplementation because LeakCanary should only run in debug builds.
  debugImplementation 'com.squareup.leakcanary:leakcanary-android:2.5'
}

kotlin复制代码internal sealed class AppWatcherInstaller : ContentProvider() {
 
  /**
   * [MainProcess] automatically sets up the LeakCanary code that runs in the main app process.
   */
  internal class MainProcess : AppWatcherInstaller()
 
  /**
   * When using the `leakcanary-android-process` artifact instead of `leakcanary-android`,
   * [LeakCanaryProcess] automatically sets up the LeakCanary code
   */
  internal class LeakCanaryProcess : AppWatcherInstaller()
 
  override fun onCreate(): Boolean {
    val application = context!!.applicationContext as Application
    AppWatcher.manualInstall(application)
    return true
  }
  //....
}

arduino复制代码AppWatcher.objectWatcher.watch(myDetachedView, "View was detached")

scss复制代码//InternalAppWatcher初始化
fun install(application: Application) {
     
    ......
     
    val configProvider = { AppWatcher.config }
    ActivityDestroyWatcher.install(application, objectWatcher, configProvider)
    FragmentDestroyWatcher.install(application, objectWatcher, configProvider)
    onAppWatcherInstalled(application)
  }
 
//InternalleakCanary初始化
override fun invoke(application: Application) {
    _application = application
    checkRunningInDebuggableBuild()
 
    AppWatcher.objectWatcher.addOnObjectRetainedListener(this)
 
    val heapDumper = AndroidHeapDumper(application, createLeakDirectoryProvider(application))
 
    val gcTrigger = GcTrigger.Default
 
    val configProvider = { LeakCanary.config }
    //异步线程执行耗时操作
    val handlerThread = HandlerThread(LEAK_CANARY_THREAD_NAME)
    handlerThread.start()
    val backgroundHandler = Handler(handlerThread.looper)
 
    heapDumpTrigger = HeapDumpTrigger(
        application, backgroundHandler, AppWatcher.objectWatcher, gcTrigger, heapDumper,
        configProvider
    )
    //Application 可见性监听
    application.registerVisibilityListener { applicationVisible ->
      this.applicationVisible = applicationVisible
      heapDumpTrigger.onApplicationVisibilityChanged(applicationVisible)
    }
    registerResumedActivityListener(application)
    addDynamicShortcut(application)
 
    disableDumpHeapInTests()
  }

kotlin复制代码@Synchronized fun watch(
    watchedObject: Any,
    description: String
  ) {
    if (!isEnabled()) {
      return
    }
    removeWeaklyReachableObjects()
    val key = UUID.randomUUID()
        .toString()
    val watchUptimeMillis = clock.uptimeMillis()
    val reference =
      KeyedWeakReference(watchedObject, key, description, watchUptimeMillis, queue)
    SharkLog.d {
      "Watching " +
          (if (watchedObject is Class<*>) watchedObject.toString() else "instance of ${watchedObject.javaClass.name}") +
          (if (description.isNotEmpty()) " ($description)" else "") +
          " with key $key"
    }
 
    watchedObjects[key] = reference
    checkRetainedExecutor.execute {
      moveToRetained(key)
    }
  }

kotlin复制代码private fun checkRetainedObjects(reason: String) {
    val config = configProvider()
    // A tick will be rescheduled when this is turned back on.
    if (!config.dumpHeap) {
      SharkLog.d { "Ignoring check for retained objects scheduled because $reason: LeakCanary.Config.dumpHeap is false" }
      return
    }
 
    //第一次移除不可达对象
    var retainedReferenceCount = objectWatcher.retainedObjectCount
 
    if (retainedReferenceCount > 0) {
        //主动出发GC
      gcTrigger.runGc()
        //第二次移除不可达对象
      retainedReferenceCount = objectWatcher.retainedObjectCount
    }
 
    //判断是否还有剩余的监听对象存活，且存活的个数是否超过阈值
    if (checkRetainedCount(retainedReferenceCount, config.retainedVisibleThreshold)) return
 
    ....
 
    SharkLog.d { "Check for retained objects found $retainedReferenceCount objects, dumping the heap" }
    dismissRetainedCountNotification()
    dumpHeap(retainedReferenceCount, retry = true)
  }

kotlin复制代码//HeapAnalyzerService
private fun analyzeHeap(
    heapDumpFile: File,
    config: Config
  ): HeapAnalysis {
    val heapAnalyzer = HeapAnalyzer(this)
 
    val proguardMappingReader = try {
        //解析混淆文件
      ProguardMappingReader(assets.open(PROGUARD_MAPPING_FILE_NAME))
    } catch (e: IOException) {
      null
    }
    //分析hprof文件
    return heapAnalyzer.analyze(
        heapDumpFile = heapDumpFile,
        leakingObjectFinder = config.leakingObjectFinder,
        referenceMatchers = config.referenceMatchers,
        computeRetainedHeapSize = config.computeRetainedHeapSize,
        objectInspectors = config.objectInspectors,
        metadataExtractor = config.metadataExtractor,
        proguardMapping = proguardMappingReader?.readProguardMapping()
    )
  }

kotlin复制代码fun analyze(
   heapDumpFile: File,
   leakingObjectFinder: LeakingObjectFinder,
   referenceMatchers: List<ReferenceMatcher> = emptyList(),
   computeRetainedHeapSize: Boolean = false,
   objectInspectors: List<ObjectInspector> = emptyList(),
   metadataExtractor: MetadataExtractor = MetadataExtractor.NO_OP,
   proguardMapping: ProguardMapping? = null
 ): HeapAnalysis {
   val analysisStartNanoTime = System.nanoTime()
 
   if (!heapDumpFile.exists()) {
     val exception = IllegalArgumentException("File does not exist: $heapDumpFile")
     return HeapAnalysisFailure(
         heapDumpFile, System.currentTimeMillis(), since(analysisStartNanoTime),
         HeapAnalysisException(exception)
     )
   }
 
   return try {
     listener.onAnalysisProgress(PARSING_HEAP_DUMP)
     Hprof.open(heapDumpFile)
         .use { hprof ->
           val graph = HprofHeapGraph.indexHprof(hprof, proguardMapping)//建立gragh
           val helpers =
             FindLeakInput(graph, referenceMatchers, computeRetainedHeapSize, objectInspectors)
           helpers.analyzeGraph(//分析graph
               metadataExtractor, leakingObjectFinder, heapDumpFile, analysisStartNanoTime
           )
         }
   } catch (exception: Throwable) {
     HeapAnalysisFailure(
         heapDumpFile, System.currentTimeMillis(), since(analysisStartNanoTime),
         HeapAnalysisException(exception)
     )
   }
 }

kotlin复制代码interface HeapGraph {
  val identifierByteSize: Int
  /**
   * In memory store that can be used to store objects this [HeapGraph] instance.
   */
  val context: GraphContext
  /**
   * All GC roots which type matches types known to this heap graph and which point to non null
   * references. You can retrieve the object that a GC Root points to by calling [findObjectById]
   * with [GcRoot.id], however you need to first check that [objectExists] returns true because
   * GC roots can point to objects that don't exist in the heap dump.
   */
  val gcRoots: List<GcRoot>
  /**
   * Sequence of all objects in the heap dump.
   *
   * This sequence does not trigger any IO reads.
   */
  val objects: Sequence<HeapObject>  //所有对象的序列，包括类对象、实例对象、对象数组、原始类型数组
 
  val classes: Sequence<HeapClass>   //类对象序列
 
  val instances: Sequence<HeapInstance>   //实例对象数组
 
  val objectArrays: Sequence<HeapObjectArray>  //对象数组序列
   
  val primitiveArrays: Sequence<HeapPrimitiveArray>   //原始类型数组序列
}

kotlin复制代码//PathFinder
private fun State.findPathsFromGcRoots(): PathFindingResults {
    enqueueGcRoots()//1
 
    val shortestPathsToLeakingObjects = mutableListOf<ReferencePathNode>()
    visitingQueue@ while (queuesNotEmpty) {
      val node = poll()//2
 
      if (checkSeen(node)) {//2
        throw IllegalStateException(
            "Node $node objectId=${node.objectId} should not be enqueued when already visited or enqueued"
        )
      }
 
      if (node.objectId in leakingObjectIds) {//3
        shortestPathsToLeakingObjects.add(node)
        // Found all refs, stop searching (unless computing retained size)
        if (shortestPathsToLeakingObjects.size == leakingObjectIds.size) {//4
          if (computeRetainedHeapSize) {
            listener.onAnalysisProgress(FINDING_DOMINATORS)
          } else {
            break@visitingQueue
          }
        }
      }
 
      when (val heapObject = graph.findObjectById(node.objectId)) {//5
        is HeapClass -> visitClassRecord(heapObject, node)
        is HeapInstance -> visitInstance(heapObject, node)
        is HeapObjectArray -> visitObjectArray(heapObject, node)
      }
    }
    return PathFindingResults(shortestPathsToLeakingObjects, dominatedObjectIds)
  }

css复制代码example/
   |--calc.go
   |--calc_test.go

go复制代码package example

func Add(a, b int) int {
    return a + b
}

go复制代码package example

import "testing"

func TestAdd(t *testing.T) {
    if ans := Add(1, 2); ans != 3 {
        t.Errorf("1 + 2 expected be 3, but %d got", ans)
    }

    if ans := Add(-1, -2); ans != -3 {
        t.Errorf("-1 + -2 expected be -3, but %d got", ans)
    }
}

shell复制代码$ go test helloworld_test.go
ok          command-line-arguments        0.003s
$ go test -v helloworld_test.go
=== RUN   TestHelloWorld
--- PASS: TestHelloWorld (0.00s)
        helloworld_test.go:8: hello world
PASS
ok          command-line-arguments        0.004s

go复制代码type Abser interface {
	Abs() float64
}
type Vertex struct {
	X, Y float64
}

func (v *Vertex) Abs() float64 {
	return math.Sqrt(v.X*v.X + v.Y*v.Y)
}

func main() {
	var a Abser
	v := Vertex{3, 4}
	a = &v // a *Vertex 实现了 Abser
	// 下面一行，v 是一个 Vertex（而不是 *Vertex）
	//v.Abs()调用时实际被转成了(&v).Abs()
	// 所以没有实现 Abser
	// 下面为错误代码
	a = v

	fmt.Println(a.Abs())
}

go复制代码func main() {
	var i interface{}
	i = 1
	i = 1.1
	i = "1"
	i = map[string]interface{}{}
	i = []int{}
	i = true
}

go复制代码type interface struct{
	data interface{}
	type Type
}

go复制代码var i interface{}
i = true
fmt.Printf("%v %T",i,i) // true bool

go复制代码func main() {

	var i interface{}
	if i == nil {
		log.Println("is nil") 		// is nil
	}
	var ipeople *IPeople
	i = ipeople
	log.Printf("%v %T", i, i)		// nil nil
	var people *People
	i = people
	if people == nil {
		log.Println("people is nil")  // people is nil
	}
	if i == nil {
		log.Println("i is nil")
	} else {
		log.Println("i is not nil")   // i is not nil
		log.Printf("%v %T", i, i)     // nil *main.People
	}
	var people2 People

	log.Printf("%v %T", people2, people2) //{} main.People
}

type People struct {
}

type IPeople interface{}

go复制代码func main() {
	var i interface{}
	i = 1

	v, ok := i.(int)
	log.Println(v, ok) // 1 true

	var people *People
	i = people
	people, ok = i.(*People)
	log.Println(people, ok) // <nil> true

	var ipeople *IPeople
	i = ipeople
	ipeople, ok = i.(*IPeople)
	log.Println(ipeople, ok) // <nil> true

	var people1 People
	var ipeople1 IPeople
	i = people1
	people1, ok = i.(People)
	log.Println(ipeople, ok) // <nil> true
	i = ipeople1
	ipeople1, ok = i.(IPeople)
	log.Println(ipeople1, ok) // <nil> false
	if ok && ipeople==nil{
        // do...
    }
}
type People struct{}
type IPeople interface{}

shell复制代码go get gopkg.in/ini.v1

ini复制代码[server]
HTTP_PORT = :8888

[database]
TYPE = mysql
USER = root
PASSWORD =
#127.0.0.1:3306  数据库IP:数据库端口号
HOST = 127.0.0.1:3306
NAME = blog

go复制代码package ConfigService

import (
	"fmt"
	"gopkg.in/ini.v1"
	"os"
)

type DbInfo struct {
	TYPE         string
	USER         string
	PASSWORD     string
	HOST         string
	NAME         string
	HTTP_PORT    string
}

func GetAppConfig(key string) *DbInfo {
	cfg, err := ini.Load("Config/app.ini")
	if err != nil {
		fmt.Printf("Fail to read file: %v", err)
		os.Exit(1)
	}
	d := new(DbInfo)
	_ = cfg.Section(key).MapTo(d)
	return d
}

func GetServerConfig() *DbInfo {
	return GetAppConfig("server")
}

func GetDbConfig() *DbInfo {
	return GetAppConfig("database")
}

go复制代码package DbService

import (
	"fmt"
	"golang-blog/Model/Entity"
	"golang-blog/Service/ConfigService"
	"gorm.io/driver/mysql"
	"gorm.io/gorm"
)

var Db *gorm.DB

func ConnectDb() {
	var (
		err error
	)
	dbConfig := ConfigService.GetAppConfig("database")
	connectStr := fmt.Sprintf("%s:%s@tcp(%s)/%s?charset=utf8&parseTime=True&loc=Local", dbConfig.USER,
		dbConfig.PASSWORD,
		dbConfig.HOST, dbConfig.NAME)
	Db, err = gorm.Open(mysql.Open(connectStr), &gorm.Config{})
	if err != nil {
		panic(err)
	}

	// 自动生成表结构
	dbErr := Db.AutoMigrate(&Entity.UserEntity{})
	if dbErr != nil {
		println(err)
	}
}

go复制代码package Routers

import (
	"github.com/gin-gonic/gin"
	"golang-blog/Controller/HomeControoler"
	"golang-blog/Service/ConfigService"
)

func Init(router *gin.Engine) {
	home := router.Group("Home")

	// 1.首位多余元素会被删除(../ or //);
	//2.然后路由会对新的路径进行不区分大小写的查找;
	//3.如果能正常找到对应的handler，路由就会重定向到正确的handler上并返回301或者307.(比如: 用户访问/FOO 和 /..//Foo可能会被重定向到/foo这个路由上)
	router.RedirectFixedPath = true

	{
		home.GET("/", HomeControoler.Index)
		home.GET("/Hi", HomeControoler.Hi)
	}

	serverConfig := ConfigService.GetServerConfig()
	router.Run(serverConfig.HTTP_PORT) // 监听并在 127.0.0.1:8888 上启动服务
}

kotlin复制代码class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        // 注册成为订阅者
        EventBus.getDefault().register(this)
    }

    override fun onDestroy() {
        super.onDestroy()
        // 解除注册 不再接收事件
        EventBus.getDefault().unregister(this)
    }
}

kotlin复制代码/**
 * 自定义的事件类
 *
 * @property message String 消息
 *
 * @author Qu Yunshuo
 * @since 3/29/21 8:05 PM
 */
data class SimpleEvent(val message: String)

/**
 * 发布一个事件
 */
fun postEvent() {
    EventBus.getDefault().post(SimpleEvent("Hello EventBus!"))
}

kotlin复制代码/**
 * 通过[Subscribe]注解进行注册，并且可以指定[ThreadMode]该方法执行的线程类型
 */
@Subscribe(threadMode = ThreadMode.MAIN)
fun onEvent(event: SimpleEvent) {
    Log.d("qqq", "onEvent: ${event.message}")
}

kotlin复制代码/**
 * 最常见的方式就是写在基类中，在[onCreate]方法中进行注册，在[onDestroy]方法中进行解除注册
 * 这样实现类就可以自动的完成注册与解除注册，完全不用考虑忘记解除注册这种低级错误🙅
 */
open class BaseActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        EventBus.getDefault().register(this)
    }

    override fun onDestroy() {
        super.onDestroy()
        EventBus.getDefault().unregister(this)
    }
}

kotlin复制代码open class BaseActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // 判断子类是否需要进行注册和解除注册
        if (isRegisterEventBus()) EventBus.getDefault().register(this)
    }

    override fun onDestroy() {
        super.onDestroy()
        // 判断子类是否需要进行注册和解除注册
        if (isRegisterEventBus()) EventBus.getDefault().unregister(this)
    }

    /**
     * 是否注册EventBus
     * @return Boolean
     */
    open fun isRegisterEventBus(): Boolean = false
}

kotlin复制代码/**
 * 进行标记需要进行注册EventBus
 *
 * @author Qu Yunshuo
 * @since 3/29/21 8:33 PM
 */
@Target(AnnotationTarget.CLASS)
@kotlin.annotation.Retention(AnnotationRetention.RUNTIME)
annotation class EventBusRegister


/**
 * Activity基类
 * 
 * @author Qu Yunshuo
 * @since 3/29/21 8:36 PM
 */
open class BaseActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // 获取到Class对象判断是否有EventBusRegister注解
        if (javaClass.isAnnotationPresent(EventBusRegister::class.java)) {
            EventBus.getDefault().register(this)
        }
    }

    override fun onDestroy() {
        super.onDestroy()
        // 获取到Class对象判断是否有EventBusRegister注解
        if (javaClass.isAnnotationPresent(EventBusRegister::class.java)) {
            EventBus.getDefault().unregister(this)
        }
    }
}

kotlin复制代码@EventBusRegister
class MainActivity : BaseActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {...}
}

kotlin复制代码/**
 * EventBus工具类
 * 
 * @author Qu Yunshuo
 * @since 3/29/21 8:42 PM
 */
object EventBusUtils {

    /**
     * 订阅
     * @param subscriber 订阅者
     */
    fun register(subscriber: Any) = EventBus.getDefault().register(subscriber)

    /**
     * 解除注册
     * @param subscriber 订阅者
     */
    fun unRegister(subscriber: Any) = EventBus.getDefault().unregister(subscriber)

    /**
     * 发送普通事件
     * @param event 事件
     */
    fun postEvent(event: Any) = EventBus.getDefault().post(event)

    /**
     * 发送粘性事件
     * @param stickyEvent 粘性事件
     */
    fun postStickyEvent(stickyEvent: Any) = EventBus.getDefault().postSticky(stickyEvent)

    /**
     * 手动获取粘性事件
     * @param stickyEventType 粘性事件
     * @param <T>             事件泛型
     * @return 返回给定事件类型的最近粘性事件
     */
    fun <T> getStickyEvent(stickyEventType: Class<T>): T = EventBus.getDefault().getStickyEvent(stickyEventType)

    /**
     * 手动删除粘性事件
     * @param stickyEventType 粘性事件
     * @param <T>             事件泛型
     * @return 返回给定事件类型的最近粘性事件
     */
    fun <T> removeStickyEvent(stickyEventType: Class<T>): T = EventBus.getDefault().removeStickyEvent(stickyEventType)
}

java复制代码/**
 * 商品秒杀
 */
@Service
public class GoodsOrderServiceImpl implements OrderService {

    @Autowired
    private GoodsDao goodsDao;

    @Autowired
    private OrderDao orderDao;

    /**
     * 下单
     *
     * @param goodsId 商品ID
     * @param userId  用户ID
     * @return
     */
    @Override
    public boolean grab(int goodsId, int userId) {
        // 查询库存
        int stock = goodsDao.selectStock(goodsId);
        try {
            // 这里睡2秒是为了模拟等并发都来到这，模拟真实大量请求涌入
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        // 库存大于0，扣件库存，保存订单
        if (stock > 0) {
            goodsDao.updateStock(goodsId, stock - 1);
            orderDao.insert(goodsId, userId);
            return true;
        }
        return false;
    }
}

java复制代码@Service("grabNoLockService")
public class GrabNoLockServiceImpl implements GrabService {

    @Autowired
    OrderService orderService;

    /**
     * 无锁的抢购逻辑
     *
     * @param goodsId
     * @param userId
     * @return
     */
    @Override
    public String grabOrder(int goodsId, int userId) {
        try {
            System.out.println("用户:" + userId + " 执行抢购逻辑");
            boolean b = orderService.grab(goodsId, userId);
            if (b) {
                System.out.println("用户:" + userId + " 抢购成功");
            } else {
                System.out.println("用户:" + userId + " 抢购失败");
            }
        } finally {

        }
        return null;
    }
}

java复制代码@Service("grabJvmLockService")
public class GrabJvmLockServiceImpl implements GrabService {

    @Autowired
    OrderService orderService;

    /**
     * JVM锁的抢购逻辑
     *
     * @param goodsId
     * @param userId
     * @return
     */
    @Override
    public String grabOrder(int goodsId, int userId) {
        String lock = (goodsId + "");

        synchronized (lock.intern()) {
            try {
                System.out.println("用户:" + userId + " 执行抢购逻辑");
                boolean b = orderService.grab(goodsId, userId);
                if (b) {
                    System.out.println("用户:" + userId + " 抢购成功");
                } else {
                    System.out.println("用户:" + userId + " 抢购失败");
                }
            } finally {

            }
        }
        return null;
    }
}

java复制代码/**
 * MySQL写的分布式锁
 */
@Service
@Data
public class MysqlLock implements Lock {

    @Autowired
    private GoodsLockDao goodsLockDao;

    private ThreadLocal<GoodsLock> goodsLockThreadLocal;

    @Override
    public void lock() {
        // 1、尝试加锁
        if (tryLock()) {
            System.out.println("尝试加锁");
            return;
        }
        // 2.休眠
        try {
            Thread.sleep(10);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        // 3.递归再次调用
        lock();
    }

    /**
     * 非阻塞式加锁，成功，就成功，失败就失败。直接返回
     */
    @Override
    public boolean tryLock() {
        try {
            GoodsLock goodsLock = goodsLockThreadLocal.get();
            goodsLockDao.insert(goodsLock);
            System.out.println("加锁对象：" + goodsLockThreadLocal.get());
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    @Override
    public void unlock() {
        goodsLockDao.delete(goodsLockThreadLocal.get().getGoodsId());
        System.out.println("解锁对象：" + goodsLockThreadLocal.get());
        goodsLockThreadLocal.remove();
    }

    @Override
    public void lockInterruptibly() throws InterruptedException {
        // TODO Auto-generated method stub

    }

    @Override
    public boolean tryLock(long time, TimeUnit unit) throws InterruptedException {
        // TODO Auto-generated method stub
        return false;
    }
    
    @Override
    public Condition newCondition() {
        // TODO Auto-generated method stub
        return null;
    }
}

java复制代码@Service("grabMysqlLockService")
public class GrabMysqlLockServiceImpl implements GrabService {

    @Autowired
    private MysqlLock lock;
    
    @Autowired
    OrderService orderService;

    ThreadLocal<GoodsLock> goodsLock = new ThreadLocal<>();

    @Override
    public String grabOrder(int goodsId, int userId) {
        // 生成key
        GoodsLock gl = new GoodsLock();
        gl.setGoodsId(goodsId);
        gl.setUserId(userId);
        goodsLock.set(gl);
        lock.setGoodsLockThreadLocal(goodsLock);

        // lock
        lock.lock();

        // 执行业务
        try {
            System.out.println("用户:"+userId+" 执行抢购逻辑");

            boolean b = orderService.grab(goodsId, userId);
            if(b) {
                System.out.println("用户:"+userId+" 抢购成功");
            }else {
                System.out.println("用户:"+userId+" 抢购失败");
            }
        } finally {
            // 释放锁
            lock.unlock();
        }
        return null;
    }
}

sh复制代码setnx key value;
expire key time_in_second;

sh复制代码set key value nx ex time_in_second;

java复制代码@Service
public class RenewGrabLockServiceImpl implements RenewGrabLockService {

    @Autowired
    private RedisTemplate<String, String> redisTemplate;

    @Override
    @Async
    public void renewLock(String key, String value, int time) {
        System.out.println("续命"+key+"  "+value);
        String v = redisTemplate.opsForValue().get(key);
        // 写成死循环，加判断
        if (StringUtils.isNotBlank(v) && v.equals(value)){
            int sleepTime = time / 3;
            try {
                Thread.sleep(sleepTime * 1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
            redisTemplate.expire(key,time,TimeUnit.SECONDS);
            renewLock(key,value,time);
        }
    }