开源项目
2 小时 读完 (大约 18080 个字)

metric

介绍

Metrics Registries类似一个metrics容器，维护一个Map，可以是一个服务一个实例。支持五种metric类型：Gauges、Counters、Meters、Histograms和Timers。
git:https://github.com/dropwizard/metrics

Gauges

Gauges是一个最简单的计量，一般用来统计瞬时状态的数据信息，比如系统中处于pending状态的job

Meters

Meters用来度量某个时间段的平均处理次数（request per second），每1、5、15分钟的TPS。比如一个service的请求数，通过metrics.meter()实例化一个Meter之后，然后通过 meter.mark()方法就能将本次请求记录下来。统计结果有总的请求数，平均每秒的请求数，以及最近的1、5、15分钟的平均TPS。

Histograms

Histograms主要使用来统计数据的分布情况，最大值、最小值、平均值、中位数，百分比（75%、90%、95%、98%、99%和99.9%）。例如，需要统计某个页面的请求响应时间分布情况，可以使用该种类型的Metrics进行统计。

Timers

Timers主要是用来统计某一块代码段的执行时间以及其分布情况，具体是基于Histograms和Meters来实现的。

阅读更多
Tomcat
15 分钟 读完 (大约 2216 个字)

Tomcat（七）设计模式总结

前言

分析一下Tomcat中所涉及到设计模式，本文我们将主要来分析外观模式，观察者模式，责任链模式，模板方法模式,命令模式。
在开始本文之前，先说明一下对于设计模式的一点看法。曾经经常看到网上有人讨论设计模式，也偶尔会遇到有人非要严格按照GOF设计模式的类图以及其中的角色去套用别人的设计，只要类图不一样，或者角色多了或者少了就会觉得怎么和官方定义的模式不一样，我个人认为这是对设计模式的误解。设计模式其实不仅仅存在软件行业，各行各业其实都有模式，它是所在行业对一些通用问题解决方案的总结和抽象，是一种对常见问题的抽象的解决方案，不是一种具体的实现，所以我觉得在讨论设计模式的时候，千万别一个劲的套用GOF设计模式中的类图以及其中所涉及到的角色，而是要理解设计模式的思维，理解设计模式的使用场景，在代码层面上有无数种实现，无需照搬(或者copy)代码。

外观模式

在Tomcat中对于Request，Response，StandardSession，ApplicationContext，StandardWrapper都采用外观模式，它的类图如下。

通过上图，可以看到RequestFacade包装了Request，它们都实现了HttpServletRequest，当传递Request对象给应用的时候，其实是返回了RequestFacade对象，而RequestFacade内部可以根据是否自定义了安全管理器来进行相应的操作。
对于Response，StandardSession等处理是类似的，这里就不写了。

阅读更多
Tomcat
14 分钟 读完 (大约 2109 个字)

Tomcat（六）Session管理机制

Tomcat session相关的类图

通过上图，可以看出每一个StandardContext会关联一个Manager，默认情况下Manager的实现类是StandardManager，而StandardManager内部会聚合多个Session，其中StandardSession是Session的默认实现类，当我们调用Request#getSession()的时候，Tomcat通过StandardSessionFacade这个外观类将StandardSession包装以后返回。
org.apache.catalina.connector.Request#getSession()

1
2
3
4
5
6
7
8
9
10
11
12
13
/**
  * Return the session associated with this Request, creating one
  * if necessary.
  */
 @Override
 public HttpSession getSession() {
     Session session = doGetSession(true);
     if (session == null) {
         return null;
     }

     return session.getSession();
 }

从上面的代码，可以看出首先首先调用doGetSession()获取Session，然后再调用Session#getSession()返回HttpSession，那接下来再来看看doGetSession()。

阅读更多
Tomcat
28 分钟 读完 (大约 4258 个字)

Tomcat（五）类加载器机制

当一个JVM启动时，至少有三个ClassLoader会被启动：

  • Bootstrap 类加载器：加载Java核心包，它们被置放在(<JAVA_HOME>/lib目录下，这部分是JVM的一部分，往往使用native code完成。
  • Extensions类加载器：加载Java扩展包，即位于<JAVA_HOME>/lib/ext下的包，这里要注意的是，有些JVM的这个加载器和Bootstrap类加载器是同一个加载器，而Sun是把二者分开的，其实现类为sun.misc.Launcher$ExtClassLoader。
  • System类加载器：这个类加载器加载CLASSPATH下的类，Sun的默认实现是sun.misc.Launcher$ExtClassLoader。

这三者之间的父子关系是：Bootstrap类加载器是Extensions类加载器的父类加载器，而Extensions类加载器是System类加载器的父类加载器。
Tomcat的Classloader机制，从Bootstrap开始。在BootStrap初始化的时候，调用org.apache.catalina.startup.Bootstrap#initClassLoaders()，这个方法里面创建3个ClassLoader，它们分别是commonLoader，catalinaLoader，sharedLoader，其中catalinaLoader，sharedLoader的父亲加载器是commonLoader，initClassLoaders执行的过程中会执行createClassLoader，而createClassLoader是根据conf/catalina.properties文件中common.loader，server.loader，shared.loader的值来初始化，它的代码如下。
org.apache.catalina.startup.Bootstrap#createClassLoader()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
private ClassLoader createClassLoader(String name, ClassLoader parent)
    throws Exception {

    String value = CatalinaProperties.getProperty(name + ".loader");
    // 1 
    if ((value == null) || (value.equals("")))
        return parent;
    // 2
    value = replace(value);

    List<Repository> repositories = new ArrayList<Repository>();

    StringTokenizer tokenizer = new StringTokenizer(value, ",");
    while (tokenizer.hasMoreElements()) {
        String repository = tokenizer.nextToken().trim();
        if (repository.length() == 0) {
            continue;
        }

        // Check for a JAR URL repository
        try {
            @SuppressWarnings("unused")
            URL url = new URL(repository);
            repositories.add(
                    new Repository(repository, RepositoryType.URL));
            continue;
        } catch (MalformedURLException e) {
            // Ignore
        }

        // Local repository
        if (repository.endsWith("*.jar")) {
            repository = repository.substring
                (0, repository.length() - "*.jar".length());
            repositories.add(
                    new Repository(repository, RepositoryType.GLOB));
        } else if (repository.endsWith(".jar")) {
            repositories.add(
                    new Repository(repository, RepositoryType.JAR));
        } else {
            repositories.add(
                    new Repository(repository, RepositoryType.DIR));
        }
    }
    // 3
    ClassLoader classLoader = ClassLoaderFactory.createClassLoader
        (repositories, parent);

    // Retrieving MBean server
    MBeanServer mBeanServer = null;
    if (MBeanServerFactory.findMBeanServer(null).size() > 0) {
        mBeanServer = MBeanServerFactory.findMBeanServer(null).get(0);
    } else {
        mBeanServer = ManagementFactory.getPlatformMBeanServer();
    }

    // Register the server classloader
    ObjectName objectName =
        new ObjectName("Catalina:type=ServerClassLoader,name=" + name);
    mBeanServer.registerMBean(classLoader, objectName);

    return classLoader;

}

  • 标注1的代码：判断如果catalina.properties中没有配置对应的loader属性的话，直接返回父加载器，而默认情况下，server.loader，shared.loader为空，那么此时的catalinaLoader，sharedLoader其实是同一个ClassLoader。
  • 标注2的代码：根据环境变量的配置替换字符串中的值，默认情况下，common.loader的值为common.loader=${catalina.base}/lib，${catalina.base}/lib/.jar，${catalina.home}/lib，${catalina.home}/lib/.jar，这里会将catalina.base和catalina.home用环境变量的值替换。
  • 标注3的代码：最终调用org.apache.catalina.startup.ClassLoaderFactory#createClassLoader()静态工厂方法创建URLClassloader的实例，而具体的URL其实就是*.loader属性配置的内容，此外如果parent = null的话，则直接用系统类加载器。
阅读更多
Tomcat
39 分钟 读完 (大约 5903 个字)

Tomcat（四）请求处理流程

前言


在开始本文之前，先来看看一个Http请求处理的过程，一般情况下是

1
2
3
4
5
浏览器发送http请求
->建立Socket连接
->通过Socket读取数据
->根据http协议解析数据
->调用后台服务完成响应

详细的流程图如上图所示。Tomcat既是一个HttpServer也是一个Servlet 容器，那么这里必然也涉及到如上过程，首先根据HTTP协议规范解析请求数据，然后将请求转发给Servlet进行处理，因此顺应这样的思路，本文也将从Http协议请求解析，请求如何转发给Servlet两个方面来进行分析。首先来看Http协议请求解析。

阅读更多
Tomcat
15 分钟 读完 (大约 2241 个字)

Tomcat（三）关闭过程

源码分析

已经知道Tomcat启动以后，会启动6条线程，它们分别如下
Tomcat threads

1
2
3
4
5
6
"ajp-bio-8009-AsyncTimeout" daemon prio=5 tid=7f8738afe000 nid=0x115ad6000 waiting on condition [115ad5000]
"ajp-bio-8009-Acceptor-0" daemon prio=5 tid=7f8738b05800 nid=0x1159d3000 runnable [1159d2000]
"http-bio-8080-AsyncTimeout" daemon prio=5 tid=7f8735acb800 nid=0x1158d0000 waiting on condition [1158cf000]
"http-bio-8080-Acceptor-0" daemon prio=5 tid=7f8735acd000 nid=0x1157cd000 runnable [1157cc000]
"ContainerBackgroundProcessor[StandardEngine[Catalina]]" daemon prio=5 tid=7f8732850800 nid=0x111203000 waiting on condition [111202000]
"main" prio=5 tid=7f8735000800 nid=0x10843e000 runnable [10843c000]

其中5条是Dameon线程，而对于Java程序来说，当所有非Dameon程序都终止的时候，JVM就会退出，因此要想终止Tomcat就只需要将main()这一条非Dameon线程终止即可。
Dameon线程又叫后台或者守护线程，它负责在程序运行期提供一种通用服务的线程，比如垃圾收集线程，非Dameon线程和Dameon线程的区别就在于当程序中所有的非Daemon线程都终止的时候，JVM会杀死余下的Dameon线程，然后退出。
接下来，一步步的分析如何来让main()线程终止，要想终止它，还是得从Tomcat的启动中来寻找答案，在分析Tomcat容器启动的时候，在Catalina#start()中有一段代码，接下来就来看看这段代码。

阅读更多
Tomcat
1 小时 读完 (大约 9284 个字)

Tomcat（二）启动过程

Tomcat组件生命周期管理

Tomcat中Server，Service，Connector，Engine，Host，Context的继承关系图，你会发现它们都实现org.apache.catalina.Lifecycle接口，而org.apache.catalina.util.LifecycleBase采用模板方法模式来对所有支持生命周期管理的组件的生命周期各个阶段进行总体管理，每个需要生命周期管理的组件只需要继承这个基类，然后覆盖对应的钩子方法即可完成相应的生命周期阶段性的管理工作。
下面我们首先来看看org.apache.catalina.Lifecycle接口的定义，它的类图如下图所示。

从上图我们可以清楚的看到LifeCycle中主要有四个生命周期阶段，它们分别是init()初始化，start()启动，stop()停止，destory()销毁。知道这四个生命周期阶段以后，看看org.apache.catalina.util.LifecycleBase是如何实现模板方法模式的。
那接下来我们就来看看org.apache.catalina.util.LifecycleBase类的定义，它的类图如下所示。

上图中用红色标注的四个方法就是模板方法模式中的钩子方法，子类可以通过实现钩子方法来纳入到基类已经流程化好的生命周期管理中。
上面我们对LifeCycle和LifeCycleBase有一个总体的认识，接下来，我们通过查看org.apache.catalina.util.LifecycleBase的源代码来具体的分析一下。

阅读更多
Tomcat
13 分钟 读完 (大约 1904 个字)

Tomcat（一）总体结构

前言

本章以Tomcat7为主。

Tomcat的总体结构

Tomcat即是一个Http服务器也是一个Servlet容器，它的总体结构我们可以用下图来描述。

通过上图我们可以看出Tomcat中主要涉及Server，Service，Engine，Connector，Host，Context组件。在Tomcat二进制分发包解压后，在conf目录中有一个server.xml文件，server.xml文件中已经包含上述的几个名称。Tomcat7.0.42分发包中的server.xml来具体分析一下，它的内容如下。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
<?xml version='1.0' encoding='utf-8'?>
<!--
  Licensed to the Apache Software Foundation (ASF) under one or more
  contributor license agreements.  See the NOTICE file distributed with
  this work for additional information regarding copyright ownership.
  The ASF licenses this file to You under the Apache License, Version 2.0
  (the "License"); you may not use this file except in compliance with
  the License.  You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0

  Unless required by applicable law or agreed to in writing, software
  distributed under the License is distributed on an "AS IS" BASIS,
  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  See the License for the specific language governing permissions and
  limitations under the License.
-->
<!-- Note:  A "Server" is not itself a "Container", so you may not
     define subcomponents such as "Valves" at this level.
     Documentation at /docs/config/server.html
 -->
<Server port="8005" shutdown="SHUTDOWN">
  <!-- Security listener. Documentation at /docs/config/listeners.html
  <Listener className="org.apache.catalina.security.SecurityListener" />
  -->
  <!--APR library loader. Documentation at /docs/apr.html -->
  <Listener className="org.apache.catalina.core.AprLifecycleListener" SSLEngine="on" />
  <!--Initialize Jasper prior to webapps are loaded. Documentation at /docs/jasper-howto.html -->
  <Listener className="org.apache.catalina.core.JasperListener" />
  <!-- Prevent memory leaks due to use of particular java/javax APIs-->
  <Listener className="org.apache.catalina.core.JreMemoryLeakPreventionListener" />
  <Listener className="org.apache.catalina.mbeans.GlobalResourcesLifecycleListener" />
  <Listener className="org.apache.catalina.core.ThreadLocalLeakPreventionListener" />

  <!-- Global JNDI resources
       Documentation at /docs/jndi-resources-howto.html
  -->
  <GlobalNamingResources>
    <!-- Editable user database that can also be used by
         UserDatabaseRealm to authenticate users
    -->
    <Resource name="UserDatabase" auth="Container"
              type="org.apache.catalina.UserDatabase"
              description="User database that can be updated and saved"
              factory="org.apache.catalina.users.MemoryUserDatabaseFactory"
              pathname="conf/tomcat-users.xml" />
  </GlobalNamingResources>

  <!-- A "Service" is a collection of one or more "Connectors" that share
       a single "Container" Note:  A "Service" is not itself a "Container",
       so you may not define subcomponents such as "Valves" at this level.
       Documentation at /docs/config/service.html
   -->
  <Service name="Catalina">

    <!--The connectors can use a shared executor, you can define one or more named thread pools-->
    <!--
    <Executor name="tomcatThreadPool" namePrefix="catalina-exec-"
        maxThreads="150" minSpareThreads="4"/>
    -->


    <!-- A "Connector" represents an endpoint by which requests are received
         and responses are returned. Documentation at :
         Java HTTP Connector: /docs/config/http.html (blocking & non-blocking)
         Java AJP  Connector: /docs/config/ajp.html
         APR (HTTP/AJP) Connector: /docs/apr.html
         Define a non-SSL HTTP/1.1 Connector on port 8080
    -->
    <Connector port="8080" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="8443" />
    <!-- A "Connector" using the shared thread pool-->
    <!--
    <Connector executor="tomcatThreadPool"
               port="8080" protocol="HTTP/1.1"
               connectionTimeout="20000"
               redirectPort="8443" />
    -->
    <!-- Define a SSL HTTP/1.1 Connector on port 8443
         This connector uses the JSSE configuration, when using APR, the
         connector should be using the OpenSSL style configuration
         described in the APR documentation -->
    <!--
    <Connector port="8443" protocol="HTTP/1.1" SSLEnabled="true"
               maxThreads="150" scheme="https" secure="true"
               clientAuth="false" sslProtocol="TLS" />
    -->

    <!-- Define an AJP 1.3 Connector on port 8009 -->
    <Connector port="8009" protocol="AJP/1.3" redirectPort="8443" />


    <!-- An Engine represents the entry point (within Catalina) that processes
         every request.  The Engine implementation for Tomcat stand alone
         analyzes the HTTP headers included with the request, and passes them
         on to the appropriate Host (virtual host).
         Documentation at /docs/config/engine.html -->

    <!-- You should set jvmRoute to support load-balancing via AJP ie :
    <Engine name="Catalina" defaultHost="localhost" jvmRoute="jvm1">
    -->
    <Engine name="Catalina" defaultHost="localhost">

      <!--For clustering, please take a look at documentation at:
          /docs/cluster-howto.html  (simple how to)
          /docs/config/cluster.html (reference documentation) -->
      <!--
      <Cluster className="org.apache.catalina.ha.tcp.SimpleTcpCluster"/>
      -->

      <!-- Use the LockOutRealm to prevent attempts to guess user passwords
           via a brute-force attack -->
      <Realm className="org.apache.catalina.realm.LockOutRealm">
        <!-- This Realm uses the UserDatabase configured in the global JNDI
             resources under the key "UserDatabase".  Any edits
             that are performed against this UserDatabase are immediately
             available for use by the Realm.  -->
        <Realm className="org.apache.catalina.realm.UserDatabaseRealm"
               resourceName="UserDatabase"/>
      </Realm>

      <Host name="localhost"  appBase="webapps"
            unpackWARs="true" autoDeploy="true">

        <!-- SingleSignOn valve, share authentication between web applications
             Documentation at: /docs/config/valve.html -->
        <!--
        <Valve className="org.apache.catalina.authenticator.SingleSignOn" />
        -->

        <!-- Access log processes all example.
             Documentation at: /docs/config/valve.html
             Note: The pattern used is equivalent to using pattern="common" -->
        <Valve className="org.apache.catalina.valves.AccessLogValve" directory="logs"
               prefix="localhost_access_log." suffix=".txt"
               pattern="%h %l %u %t &quot;%r&quot; %s %b" />

      </Host>
    </Engine>
  </Service>
</Server>

Server

Server是Tomcat中最顶层的组件，它可以包含多个Service组件。在Tomcat源代码中Server组件对应源码中的org.apache.catalina.core.StandardServer类。
StandardServer的继承关系图如下图所示。

阅读更多
MyBatis
1 分钟 读完 (大约 125 个字)

MyBatis SQL日志源码分析

源码

BaseJdbcLogger

打印日志的抽象类。

PreparedStatementLogger

PreparedStatement的日志。

ResultSetLogger

ResultSet的日志。

打印debug的日志

1
2
3
4
5
protected void debug(String text, boolean input) {
    if (statementLog.isDebugEnabled()) {
      statementLog.debug(prefix(input) + text);
    }
}

字符串前缀

1
2
3
4
5
6
7
8
9
10
11
private String prefix(boolean isInput) {
   char[] buffer = new char[queryStack * 2 + 2];
   Arrays.fill(buffer, '=');
   buffer[queryStack * 2 + 1] = ' ';
   if (isInput) {
     buffer[queryStack * 2] = '>';
   } else {
     buffer[0] = '<';
   }
   return new String(buffer);
 }
开源项目
1 小时 读完 (大约 8027 个字)

Kryo

介绍

Kryo是一个快速有效的对象图序列化Java库。它的目标是快速、高效、易使用。该项目适用于对象持久化到文件或数据库中或通过网络传输。Kryo还可以自动实现深浅的拷贝/克隆。 就是直接复制一个对象对象到另一个对象，而不是对象转换为字节然后转化为对象。
Kryo如果设置References=true，序列化的时候会从缓存中获取之前序列化过的对象，从而提高效率。

特点

  1. 序列化、反序列化速度快。
  2. 序列化和反序列化，第1次加载类的全部信息，如果使用代码里reference=true。默认会生成和对象相对应的id值。但第2次、第N次加载类时，会根据id值去缓存中查找相对应的对象。

    示例

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    Kryo kryo = new Kryo(); 
    //是否使用引用,默认开启，使用引用对象会和id进行关联 
    kryo.setReferences(false);
    //注册对象，使用java的原生序列化对象
    kryo.register(obj.getClass(), new JavaSerializer()); 
    // 序列化 
    Output output = new Output(new FileOutputStream("file.bin")); 
    SomeClass someObject = ... 
    kryo.writeObject(output, someObject); 
    output.close(); 
    // 反序列化 
    Input input = new Input(new FileInputStream("file.bin")); 
    SomeClass someObject = kryo.readObject(input, SomeClass.class); 
    input.close();
阅读更多
关注我

链接

分类

标签云

Android Centos Effect Java JDK6 源码 JDK7 源码 JDK8 源码 JMM JVM Java Linux MongoDB Mongodb MyBatis MySQL Redis Spring Think In Java Tomcat Ubuntu 一致性哈希算法 书 倒排索引 内存泄漏 分支限界算法 分治法 分治算法 分词算法 动态规划 动态规划算法 华为 回溯算法 多线程 工具 并发 开源项目 手机游戏 排序算法 推荐 散列表 数学 数据库 数据结构 日语 最优路径算法 机器学习 源码 算法 线程安全 编程珠玑 计算机基础 设计模式 贪心算法 跳表 面试

最新文章

归档

标签

Android 1
Centos 3
Effect Java 2
JDK6 源码 18
JDK7 源码 6
JDK8 源码 1
JMM 7
JVM 10
Java 40
Linux 4
MongoDB 1
Mongodb 1
MyBatis 3
MySQL 2
Redis 1
Spring 4
Think In Java 1
Tomcat 7
Ubuntu 1
一致性哈希算法 1
书 3
倒排索引 1
内存泄漏 1
分支限界算法 2
分治法 1
分治算法 1
分词算法 2
动态规划 1
动态规划算法 2
华为 1
回溯算法 4
多线程 2
工具 1
并发 5
开源项目 17
手机游戏 1
排序算法 1
推荐 1
散列表 1
数学 1
数据库 2
数据结构 5
日语 1
最优路径算法 1
机器学习 1
源码 3
算法 26
线程安全 2
编程珠玑 3
计算机基础 1
设计模式 4
贪心算法 3
跳表 1
面试 1

最新文章

归档

标签

Android 1
Centos 3
Effect Java 2
JDK6 源码 18
JDK7 源码 6
JDK8 源码 1
JMM 7
JVM 10
Java 40
Linux 4
MongoDB 1
Mongodb 1
MyBatis 3
MySQL 2
Redis 1
Spring 4
Think In Java 1
Tomcat 7
Ubuntu 1
一致性哈希算法 1
书 3
倒排索引 1
内存泄漏 1
分支限界算法 2
分治法 1
分治算法 1
分词算法 2
动态规划 1
动态规划算法 2
华为 1
回溯算法 4
多线程 2
工具 1
并发 5
开源项目 17
手机游戏 1
排序算法 1
推荐 1
散列表 1
数学 1
数据库 2
数据结构 5
日语 1
最优路径算法 1
机器学习 1
源码 3
算法 26
线程安全 2
编程珠玑 3
计算机基础 1
设计模式 4
贪心算法 3
跳表 1
面试 1
Your browser is out-of-date!

Update your browser to view this website correctly. Update my browser now

×