快乐12必中5码的方法:ImportNew - Co. Ltd.四川快乐12 //www.zk5bt.cn Thu, 09 Aug 2018 22:00:26 +0000 zh-CN hourly 1 //wordpress.org/?v=3.4.2 JDK源码阅读:ByteBuffer - Co. Ltd.四川快乐12 //www.zk5bt.cn/29473.html //www.zk5bt.cn/29473.html#comments Thu, 09 Aug 2018 22:00:26 +0000 唐尤华 //www.zk5bt.cn/?p=29473 Buffer是Java NIO中对于缓冲区的封装。在Java BIO中,所有的读写API,都是直接使用byte数组作为缓冲区的,简单直接。但是在Java NIO中,缓冲区这一概念变得复杂,可能是对应Java堆中的一块内存,也可能是对应本地内存中的一块内存。而byte数组只能用来指定Java堆中的一块内存,所以Java NIO中设计了一个新的缓冲区抽象,涵盖了不同类型缓冲区,这个抽象就是Buffer。

Buffer

Buffer是Java NIO中对于缓冲区的抽象。是一个用于存储特定基本数据类型的容器。Buffer是特定基本数据类型的线性有限序列。

Java有8中基本类型:byte,short,int,long,float,double,char,boolean,除了boolean类型外,其他的类型都有对应的Buffer具体实现:

Buffer抽象类定义了所有类型的Buffer都有的属性和操作,属性如下:

  • capacity:缓冲区的容量,在缓冲区建立后就不能改变
  • limit:表示第一个不能读写的元素位置,limit不会大于capacity
  • position:表示下一个要读写的元素位置,position不会大于limit
  • mark:用于暂存一个元素位置,和书签一样,用于后续操作

所有的Buffer操作都围绕这些属性进行。这些属性满足一个不变式:0<=mark<=position<=limit<=capacity。

新建的Buffer这些属性的取值为:

  • position=0
  • limit=capacity=用户设置的容量
  • mark=-1

直接看定义比较抽象,可以看一下示意图,下图是一个容量为10的Buffer:

ByteBuffer的具体实现

所有Buffer实现中,最重要的实现是ByteBuffer,因为操作系统中所有的IO操作都是对字节的操作。当我们需要从字节缓冲区中读取别的数据类型才需要使用其他具体类型的Buffer实现。

ByteBuffer也是一个抽象类,具体的实现有HeapByteBuffer和DirectByteBuffer。分别对应Java堆缓冲区与堆外内存缓冲区。Java堆缓冲区本质上就是byte数组,所以实现会比较简单。而堆外内存涉及到JNI代码实现,较为复杂,本次我们以HeapByteBuffer为例来分析Buffer的相关操作,后续专门分析DirectByteBuffer。

ByteBuffer的类图如下:

读写Buffer

Buffer作为缓冲区,最主要的作用是用于传递数据。Buffer提供了一系列的读取与写入操作。因为不同类型的Buffer读写的类型不同,所以具体的方法定义是定义在Buffer实现类中的。与读写相关的API如下:

byte get()
byte get(int index)
ByteBuffer get(byte[] dst, int offset, int length)
ByteBuffer get(byte[] dst)

ByteBuffer put(byte b)
ByteBuffer put(int index, byte b)
ByteBuffer put(ByteBuffer src) 
ByteBuffer put(byte[] src, int offset, int length)

Buffer的读写操作可以按照两种维度分类:

  • 单个/批量:
    • 单个:一次读写一个字节
    • 批量:一次读写多个字节
  • 相对/绝对:
    • 相对:从Buffer维护的position位置开始读写,读写时position会随之变化
    • 绝对:直接指定读写的位置。指定index的API就是绝对API

接着我们来看看这些函数在HeapByteBuffer中是如何实现的:

final byte[] hb;    // 作为缓冲区的byte数组              
final int offset;   // 指定缓冲区的起始位置

public byte get() {
    // get操作就是直接从数组中获取数据
    return hb[ix(nextGetIndex())];
}

public byte get(int i) {
    // 从指定位置获取数据,是绝对操作,只需检查下标是否合法
    return hb[ix(checkIndex(i))];
}

// 获取下一个要读取的元素的下标
// position的定义就是下一个要读写的元素位置,
// 所以这里是返回position的当前值,然后再对position进行加一操作
final int nextGetIndex() {                          // package-private
    if (position >= limit)
        throw new BufferUnderflowException();
    return position++;
}

// 因为支持偏移量,所以算出来的下标还需要加上偏移量
protected int ix(int i) {
    return i + offset;
}

单字节put与get逻辑一样??匆幌屡縢et是如何实现的:

public ByteBuffer get(byte[] dst) {
    return get(dst, 0, dst.length);
}

public ByteBuffer get(byte[] dst, int offset, int length) {
    // 检查参数是否越界
    checkBounds(offset, length, dst.length);
    // 检查要获取的长度是否大于Buffer中剩余的数据长度
    if (length > remaining())
        throw new BufferUnderflowException();
    // 调用System.arraycopy进行数组内容拷贝
    System.arraycopy(hb, ix(position()), dst, offset, length);
    // 更新position
    position(position() + length);
    return this;
}

可以看出,HeapByteBuffer是封装了对byte数组的简单操作。对缓冲区的写入和读取本质上是对数组的写入和读取。使用HeapByteBuffer的好处是我们不用做各种参数校验,也不需要另外维护数组当前读写位置的变量了。

同时我们可以看到,Buffer中对于position的操作没有使用锁进行?;?,所以Buffer不是线程安全的。

Buffer的模式

虽然JDK的Java Doc并没有提到Buffer有模式,但是Buffer提供了flip等操作用于切换Buffer的工作模式。在正确使用Buffer时,一定要注意Buffer的当前工作模式。否则会导致数据读写不符合你的预期。

Buffer有两种工作模式,一种是接收数据模式,一种是输出数据模式。

新建的Buffer处于接收数据的模式,可以向Buffer放入数据,放入一个对应基本类型的数据后,position加一,如果position已经等于limit了还进行put操作,则会抛出BufferOverflowException异常。

这种模式的Buffer可以用于Channel的read操作缓冲区,或者是用于相对put操作。

比如向一个接受数据模式的Buffer put5个byte后的示例图:

因为Buffer的设计是读写的位置变量都使用position这个变量,所以如果要从Buffer中读取数据,要切换Buffer到输出数据模式。Buffer提供了flip方法用于这种切换。

public final Buffer flip() {
    limit = position;
    position = 0;
    mark = -1;
    return this;
}

切换后的效果图:

然后就可以从Buffer中读取数据了。每次读取一个元素,position就会加一,如果position已经等于limit还进行读取,会抛出BufferUnderflowException异常。

可以看出Buffer本身没有一个用于存储模式的变量,模式的切换只是position和limit的变换而已。

flip方法只会把Buffer从接收模式切换到输出模式,如果要从输出模式切换到接收模式,可以使用compact或者clear方法,如果数据已经读取完毕或者数据不要了,使用clear方法,如果已读的数据需要保留,同时需要切换到接收数据模式,使用compat方法。

// 压缩Buffer,去掉已经被读取的数据
// 压缩后的Buffer处于接收数据模式
public ByteBuffer compact() {
    System.arraycopy(hb, ix(position()), hb, ix(0), remaining());
    position(remaining());
    limit(capacity());
    discardMark();
    return this;
}

// 清空Buffer,去掉所有数据(没有做清理工作,是指修改位置变量)
// 清空后的Buffer处于接收数据模式
public final Buffer clear() {
    position = 0;
    limit = capacity;
    mark = -1;
    return this;
}

总结

  • Buffer是Java NIO对缓冲区的抽象
  • 除了boolean类型,其他的基本类型都有对应的Buffer实现
  • 最常用的Buffer实现是ByteBuffer,具体的实现有HeapByteBuffer和DirectByteBuffer,分别对应Java堆缓冲区与对外内存缓冲区
  • HeapByteBuffer是对byte数组的封装,方便使用
  • Buffer不是线程安全的
  • Buffer有两种模式一种是接收数据模式,一种是输出数据模式。新建的Buffer处于接收数据模式,使用flip方法可以切换Buffer到输出数据模式。使用compact或者clear方法可以切换到接收数据模式。

参考资料

相关文章

]]>
//www.zk5bt.cn/29473.html/feed 0
高效遍历Java容器 - Co. Ltd.四川快乐12 //www.zk5bt.cn/29465.html //www.zk5bt.cn/29465.html#comments Thu, 09 Aug 2018 22:00:20 +0000 yizhe //www.zk5bt.cn/?p=29465 通过本文,你可以更深入的学习 Java 语言中 forEach 语法的知识,以及它和 C 语言形式的 for 循环、 Steam API 的对比。

简介

Java 程序员经常使用容器,比如 ArrayList 和 HashSet。Java 8 中的 lambda 语法和 steaming API 可以让我们更方便的使用容器。大部分情况下,我们仅仅处理几千个元素,也不会去考虑性能问题。但是,在一些极端场景下,如果我们需要遍历上百万个元素,性能问题就凸显出来了。

本文将采用?JMH?计算每块代码的运行时间。

forEach vs. C Style vs. Stream API

遍历是一个基本的功能。所有编程语言都提供了简单的语法,让程序员去遍历容器。Steam API 以一种非常直接的形式来遍历容器。

    public List<Integer> streamSingleThread(BenchMarkState state){
        List<Integer> result = new ArrayList<>(state.testData.size());
        state.testData.stream().forEach(item -> {
            result.add(item);
        });
        return result;
    }
    public List<Integer> streamMultiThread(BenchMarkState state){
        List<Integer> result = new ArrayList<>(state.testData.size());
        state.testData.stream().parallel().forEach(item -> {
            result.add(item);
        });
        return result;
    }

forEach 循环也很简单:

    public List<Integer> forEach(BenchMarkState state){
      List<Integer> result = new ArrayList<>(state.testData.size());
      for(Integer item : state.testData){
        result.add(item);
      }
      return result;
    }

C 语言形式的 for 循环啰嗦一些,不过依然很紧凑:

    public List<Integer> forCStyle(BenchMarkState state){
      int size = state.testData.size();
      List<Integer> result = new ArrayList<>(size);
      for(int j = 0; j < size; j ++){
        result.add(state.testData.get(j));
      }
      return result;
    }

以下是性能报告:

Benchmark                               Mode  Cnt   Score   Error  Units
TestLoopPerformance.forCStyle           avgt  200  18.068 ± 0.074  ms/op
TestLoopPerformance.forEach             avgt  200  30.566 ± 0.165  ms/op
TestLoopPerformance.streamMultiThread   avgt  200  79.433 ± 0.747  ms/op
TestLoopPerformance.streamSingleThread  avgt  200  37.779 ± 0.485  ms/op

使用 C 语言形式的 for 循环,JVM 每次仅仅增加一个数字,然后直接从内存里读出数据。这使得它非常迅速。但是 forEach 就大不一样,根据?StackOverFlow 的这篇回答,和?Oracle 的文章,JVM 需要把 forEach 转换成一个 iterator,然后每个元素都调用一次 hasNext() 方法。这就是 forEach 比 C 语言的形式慢一些的原因。

哪一个是遍历 Set 最高效的方法呢?

我们先定义测试数据集:

    @State(Scope.Benchmark)
    public static class BenchMarkState {
        @Setup(Level.Trial)
        public void doSetup() {
            for(int i = 0; i < 500000; i++){
                testData.add(Integer.valueOf(i));
            }
        }
        @TearDown(Level.Trial)
        public void doTearDown() {
            testData = new HashSet<>(500000);
        }
        public Set<Integer> testData = new HashSet<>(500000);
    }

Java 中的 Set 也支持 Steam API 和 forEach 循环。参考之前的测试,如果我们把 Set 转换成 ArrayList,然后遍历 ArrayList,或许性能会好一些?

    public List<Integer> forCStyle(BenchMarkState state){
        int size = state.testData.size();
        List<Integer> result = new ArrayList<>(size);
        Integer[] temp = (Integer[]) state.testData.toArray(new Integer[size]);
        for(int j = 0; j < size; j ++){
            result.add(temp[j]);
        }
        return result;
    }

如果把 iterator 和 C 语言形式结合起来呢?

    public List<Integer> forCStyleWithIteration(BenchMarkState state){
        int size = state.testData.size();
        List<Integer> result = new ArrayList<>(size);
        Iterator<Integer> iteration = state.testData.iterator();
            for(int j = 0; j < size; j ++){
            	result.add(iteration.next());
            }
        return result;
    }

或者,简单的遍历怎么样?

    public List<Integer> forEach(BenchMarkState state){
        List<Integer> result = new ArrayList<>(state.testData.size());
        for(Integer item : state.testData) {
            result.add(item);
        }
        return result;
    }

这个主意不错,不过它的效率也不高,因为初始化一个新的 ArrayList 同样需要消耗资源。

Benchmark                                   Mode  Cnt  Score   Error  Units
TestLoopPerformance.forCStyle               avgt  200  6.013 ± 0.108  ms/op
TestLoopPerformance.forCStyleWithIteration  avgt  200  4.281 ± 0.049  ms/op
TestLoopPerformance.forEach                 avgt  200  4.498 ± 0.026  ms/op

HashMap (使用 HashMap<E,Object> 的 HashSet) 不是为遍历所有元素设计的。遍历一个 HashMap 最快的方法是把 Iterator 和 C 语言形式结合起来,这样 JVM 就不会去调用 hasNext()。

结论

Foreach 和 Steam API 用来处理集合是很方便的。你可以更快的写代码。不过,如果你的系统很稳定,性能是一个主要的考量,你应该考虑一下重写你的循环。

 

相关文章

]]>
//www.zk5bt.cn/29465.html/feed 0
Java结合keytool实现非对称签名与验证 - Co. Ltd.四川快乐12 //www.zk5bt.cn/29455.html //www.zk5bt.cn/29455.html#comments Thu, 09 Aug 2018 01:20:14 +0000 唐尤华 //www.zk5bt.cn/?p=29455

参考”Oracle–The Java Tutorials: Generate Keys”
还有姊妹篇:Java结合keytool实现非对称加密和解密

keytool的使用

keytool 是 JDK 自带的一个密钥库管理工具。这里只用到了 keytool 的部分功能,包括生成密钥对、导出公钥等。keytool 生成的公钥/私钥对存放到一个到了一个文件中,这个文件有密码?;?,通称为 keystore。

生成密钥对

$ keytool -genkey -alias signLegal -keystore examplestanstore -validity 1800

生成别名为 signLegal 的密钥对,存放在密钥库 examplestanstore 中,证书的有效期是1800天(默认是90天)。
输入一系列的参数。输入的参数遵循了 LDAP 的风格和标准??梢韵胂?,生成的密钥对可以看成 LDAP 的一个条目。
命令执行成功后会在当前目录下创建一个叫?examplestanstore?的文件。

查看密钥对

$ keytool -list -keystore examplestanstore -v

列出了examplestanstore密钥库的中所有密钥对。-v参数表示详细信息,详细信息中有证书的失效时间。

导出公钥证书

$ keytool -export -keystore examplestanstore -alias signLegal -file StanSmith.cer

导出的公钥存放在当前目录的 StanSmith.cer 文件中,是个二进制文件。

Java签名和验证

参考了Java安全官方教程。
在该官方教程中,GenSig.java?类生成密钥对,对输入的文件进行签名,输出了一个签名结果文件 sig 和公钥 suepk。
VerSig.java?类接受三个参数:公钥文件名(suepk)、签名文件(sig)、被签名的源文件名(hello.txt)。
该教程解释了两个类的原理,并附加有源码。将源码下载并编译。创建一个 hello.txt 的文件作为被签名的目标文件,里面随便放点字符串。然后执行:

$ java GenSig hello.txt                        (生成文件sig和suepk)
$ java VerSig suepk sig hello.txt
signature verifies: true

在实际使用时,密钥对不可能每次在程序中重新生成。而 keytool 恰好可以生成并相对安全保存密钥对。所以下面结合了 keytool 和 Java 实现的功能。

结合keytool与Java签名/验证

参考”Oracle–The Java Tutorials: Weaknesses and Alternatives”

密钥对由 keytool 生成并保存到 keystore 中?;て鹄矗╧eystore有密码)。公钥也从 keystore 中导出。GenSig.java 类只需要从 keystore 中取得私钥进行签名即可。
VerSig.java 也要做适当的修改。貌似因为从 keystore 中导出的是证书而不是公钥,两者的封装格式估计有差异。

具体步骤

  1. 利用?keytool -genkey?生成密钥对保存在 keystore 中(库文件是examplestanstore);
  2. 利用 `keytool -export` 从 keystore 中导出公钥证书(StanSmith.cer);
  3. 利用新类 GenSig2.java 生成签名(文件名是sig),GenSig2.java 会从 keystore 中取私钥;
  4. 将公钥(StanSmith.cer)、签名(sig)、被签名文件(hello.txt)发给验证方;
  5. 验证方利用 VerSig2.java 进行验证。

下面是 GenSig2.java 和 VerSig2.java 的源码和执行方式。

GenSig2.java

import java.io.*;
import java.security.*;

class GenSig2 {

    public static void main(String[] args) {

        if (args.length != 1) {
            System.out.println("Usage: java GenSig2 <nameOfFileToSign>");
            }
        else try{

                /*create key paire use keytool:
                $ keytool -genkey -alias signLegal -keystore examplestanstore -validity 1800*/
                // read keystore file
                KeyStore ks = KeyStore.getInstance("JKS");
                FileInputStream ksfis = new FileInputStream("examplestanstore");
                BufferedInputStream ksbufin = new BufferedInputStream(ksfis);

                // open keystore and get private key
                // alias is 'signLeal', kpasswd/spasswd is 'vagrant'
                ks.load(ksbufin, "vagrant".toCharArray());
                PrivateKey priv = (PrivateKey) ks.getKey("signLegal", "vagrant".toCharArray());

            /* Create a Signature object and initialize it with the private key */

            Signature dsa = Signature.getInstance("SHA1withDSA", "SUN");

            dsa.initSign(priv);
            /* Update and sign the data */

            FileInputStream fis = new FileInputStream(args[0]);
            BufferedInputStream bufin = new BufferedInputStream(fis);
            byte[] buffer = new byte[1024];
            int len;
            while (bufin.available() != 0) {
                len = bufin.read(buffer);
                dsa.update(buffer, 0, len);
                };

            bufin.close();

            /* Now that all the data to be signed has been read in,
                    generate a signature for it */
            byte[] realSig = dsa.sign();

            /* Save the signature in a file */
            FileOutputStream sigfos = new FileOutputStream("sig");
            sigfos.write(realSig);

            sigfos.close();

            /* public key file can export from keystore use keytool:
            $  keytool -export -keystore examplestanstore -alias signLegal -file StanSmith.cer */

        } catch (Exception e) {
            System.err.println("Caught exception " + e.toString());
        }
    };

编译后,这样运行:

$ java GenSig2 hello.txt

会生成签名文件sig。

VerSig2.java

import java.io.*;
import java.security.*;
import java.security.spec.*;

class VerSig2 {

    public static void main(String[] args) {

        /* Verify a DSA signature */

        if (args.length != 3) {
            System.out.println("Usage: VerSig publickeyfile signaturefile datafile");
            }
        else try{

            /* import encoded public cert */
            FileInputStream certfis = new FileInputStream(args[0]);
            java.security.cert.CertificateFactory cf =
                java.security.cert.CertificateFactory.getInstance("X.509");
            java.security.cert.Certificate cert =  cf.generateCertificate(certfis);
            PublicKey pubKey = cert.getPublicKey();

            /* input the signature bytes */
            FileInputStream sigfis = new FileInputStream(args[1]);
            byte[] sigToVerify = new byte[sigfis.available()];
            sigfis.read(sigToVerify );

            sigfis.close();

            /* create a Signature object and initialize it with the public key */
            Signature sig = Signature.getInstance("SHA1withDSA", "SUN");
            sig.initVerify(pubKey);

            /* Update and verify the data */

            FileInputStream datafis = new FileInputStream(args[2]);
            BufferedInputStream bufin = new BufferedInputStream(datafis);
            byte[] buffer = new byte[1024];
            int len;
            while (bufin.available() != 0) {
                len = bufin.read(buffer);
                sig.update(buffer, 0, len);
                };

            bufin.close();

            boolean verifies = sig.verify(sigToVerify);

            System.out.println("signature verifies: " + verifies);

        } catch (Exception e) {
            System.err.println("Caught exception " + e.toString());
        };
    }
}

编译后,这样运行(StanSmith.cer 是利用 keytool 导出的公钥证书,见前文):

$ java VerSig2 StanSmith.cer sig hello.txt
signature verifies: true

OpenSSL

虽然也研究了一下 OpenSSL,但发现与 Java 难以结合,难度也很大。例如它的教程中采用的是 RSA,而上面的 Java 使用的是 DSA。所以只是贴在这里备忘,可以忽略。

参考”An Introduction to the OpenSSL command line tool”

生成私钥

$ openssl genrsa -out key.pem 1024
$ cat key.pem
-----BEGIN RSA PRIVATE KEY-----
MIICXQIBAAKBgQCzVDmu6Cf2QF7cERCGYU3B8Epm6pkkpMZFgotphXMgAmBBNJbh
Si7qPH4R5JlEm1ZXPr5DZH/pyJBWQhiiHGeUAOve+GOgvt9Rk25r7OEWYvn/GCr/
JBfLBGqwtlzn/t2s2x04IooshsGkOd6YpZoztkEDtu2gKHedFczF607IvwIDAQAB
AoGAMdbIqUmwQYomUvcTJqXIXIwRwYSVx09cI1lisZL7Kfw/ECAzhq19WHAzgXmM
9zpMxraTXluCCVFKfA6mlfda+ZoBlKSYdOecwNB+TSAumf9XK8uHW/g8C+Ykq9OG
g9Uiy8rKnl12Zaiu9H8L82ud0CkTFW2636/PuKgtp+4YbXECQQDhKdh8lwgumg7H
YIw5476QOHnPL7c3OFPGtaOZMZJkjMPfRzgR4B5PjcGnOLDoTlkATcBPmXtLwwJJ
SzaBdaRjAkEAy+NwdOzC1yQrTrkZQx1brNjO3iytfkl3t1xAWyz5Sy1IB7+4fsod
Eh3br5E1o5YRipY2GJZvp2OAAt3tz6iS9QJASvIYwu+qo4hX3vk9847gwTRrJxFk
1JaFHCEdgUJEzf8ku08DVL/alvRCPxzZlZluenFmz5fwuDkCq87DJ7g2rQJBAMDM
+SnIPdMeA8n0pRvfJjLD7pMP4pu6M3fzx3Owiqj5T9TsCjXzQBxCmdxizzs7DKll
tA/6Kek64PFVFa25tgUCQQCTM1VwfNKjFbd+0HuF6WAs3Odjuo0gKk/QIjdn7M5/
I0kxEApKxTto3oiuCQGeYL/sqy3WjM0476w48+xUsQeF
-----END RSA PRIVATE KEY-----

导出公钥

$ openssl rsa -in key.pem -pubout -out pub-key.pem
$ cat pub-key.pem
-----BEGIN PUBLIC KEY-----
MIGfMA0GCSqGSIb3DQEBAQUAA4GNADCBiQKBgQCzVDmu6Cf2QF7cERCGYU3B8Epm
6pkkpMZFgotphXMgAmBBNJbhSi7qPH4R5JlEm1ZXPr5DZH/pyJBWQhiiHGeUAOve
+GOgvt9Rk25r7OEWYvn/GCr/JBfLBGqwtlzn/t2s2x04IooshsGkOd6YpZoztkED
tu2gKHedFczF607IvwIDAQAB
-----END PUBLIC KEY-----

摘要计算

创建一个内容是?1234?的文本文件 hello.txt。用 OpenSSL 计算它的 SHA256 摘要(SHA256 是 jarsigner 的默认摘要算法):

$ cat hello.txt
1234
$ openssl dgst -SHA256 -out hello.sha256 hello.txt
$ cat hello.sha256
SHA256(hello.txt)= a883dafc480d466ee04e0d6da986bd78eb1fdd2178d04693723da3a8f95d42f4

签名和验证

对摘要文件 hello.sha256 进行签名:

$ openssl rsautl -sign -in hello.sha256 -out hello.sign -inkey key.pem

用公钥对签名进行验证:

$ openssl rsautl -verify -in hello.sign -inkey pub-key.pem -pubin
SHA256(hello.txt)= a883dafc480d466ee04e0d6da986bd78eb1fdd2178d04693723da3a8f95d42f4

用公钥验证必须加上?-pubin?参数。 用私钥对签名进行验证:

$ openssl rsautl -verify -in hello.sign -inkey key.pem
SHA256(hello.txt)= a883dafc480d466ee04e0d6da986bd78eb1fdd2178d04693723da3a8f95d42f4

验证的STD输出与摘要文件 hello.sha256 的内容一样,说明验证可以通过。

相关文章

]]>
//www.zk5bt.cn/29455.html/feed 0
Java连接HBase(kerberized集群) - Co. Ltd.四川快乐12 //www.zk5bt.cn/29447.html //www.zk5bt.cn/29447.html#comments Thu, 09 Aug 2018 00:57:40 +0000 唐尤华 //www.zk5bt.cn/?p=29447

社区原文 “Connecting to HBase in a Kerberos Enabled Cluster”

讲解如何通过 Java 或 Scala 在启用 Kerberos 的群集中连接到 HBase。
本测试需要一个启用了kerberos的HDP集群。集群搭建参考《Ambari在本地VM(centos7.3)部署hadoop集群》。本测试在HDP集群的C7302节点(centos7.3)上进行。首先,下载java样例代码:

$ cd /opt
$ git clone https://github.com/wbwangk/hdp-test-examples

这个github库是从jjmeyer0/hdp-test-examples库fork的。主要修改有:

  1. 修改了 pom.xml 文件:增加了对 HDP2.6.1 的支持;去掉了 Scala 相关依赖,因为会导致构建失败
  2. 修改了?src/main/java/com/jj/hbase/HBaseClient.java?中 jj 用户主体为?jj@AMBAR.APACHE.ORGI

创建keytab

在 c7302 节点用管理员账号登录 KDC,然后创建叫jj的主体,并导出 keytab:

$ kinit root/admin@AMBARI.APACHE.ORG
$ kadmin -q "addprinc jj"         (创建jj主体,需要输入两次密码,密码是1)
$ ktutil
ktutil:  addent -password -p jj -k 1 -e RC4-HMAC
Password for jj@AMBARI.APACHE.ORG: 1
ktutil:  wkt jj.keytab                              (生成了keytab文件)
ktutil:  q
$ scp jj.keytab /opt/hdp-test-examples/src/main/resources

准备HBase用户

jj 用户必须在 HBase 中获得正确的权限。Ambari 为 HBase创建一个管理员用户,通过 keytab 查找管理员用户主体。并利用它登录,利用密钥文件登录不需要密码:

$ klist -kt /etc/security/keytabs/hbase.headless.keytab           (查看hbase服务的printcipal )
KVNO Timestamp           Principal
---- ------------------- ------------------------------------------------------
   1 07/06/2017 03:53:35 hbase-hdp2610@AMBARI.APACHE.ORG
$ kinit -kt /etc/security/keytabs/hbase.headless.keytab hbase-hdp2610              (实测只能用这个主体登录,即使root/admin主体都不行)
$ hbase shell
hbase(main):001:0> grant 'jj','RW'

准备配置文件

运行例子需要的文件有三个:

  • hbase-site.xml
  • .keytab
  • krb5.conf ? 前文已经复制了jj.keytab,现在要复制另外两个。

由于使用HDP集群的节点充当客户机,所以直接在本节点复制文件即可:

$ scp /etc/hbase/conf/hbase-site.xml /opt/htp-test-examples/src/main/resources/
$ scp /etc/krb5.conf /opt/htp-test-examples/src/main/resources/

对于测试,建议在 hbase-site.xml 中更改 “hbase.client.retries.number” 属性。默认情况下为35。这个“重试次数”这在运行测试时太大了,复制后可以修改为3。

其它修改

目录/opt/hdp-test-examples/src`下有两个目录:`main`和`test`。`main`目录放置客户端程序,而`test`目录是单元测试目录。 来到目录`/opt/hdp-test-examples/src/test/java/com/jj下看看,发现除了hbase还有个pig目录。如果只是测试java客户端连接hbase,建议删除pig目录。否则在maven构建是也会执行pig的单元测试,而由于没有正确配置pig,导致必然出错使构建失败。

代码讲解

例子的 Java 代码位于?src/main/java/com/jj/hbase/HBaseClient.java。在代码中,首先需要做的是创建和加载 HBase 配置:

// Setting up the HBase configuration
Configuration configuration = new Configuration();
configuration.addResource("src/main/resources/hbase-site.xml");

接下来指向 krb5.conf 文件并设置 Kerberos 主体和 keytab。

// Point to the krb5.conf file.
System.setProperty("java.security.krb5.conf", "src/main/resources/krb5.conf");
System.setProperty("sun.security.krb5.debug", "true");

// Override these values by setting -DkerberosPrincipal and/or -DkerberosKeytab
String principal = System.getProperty("kerberosPrincipal", "jj@AMBARI.APACHE.ORG");
String keytabLocation = System.getProperty("kerberosKeytab", "src/main/resources/jj.keytab");

现在使用上面定义的主键和 keytab 登录。

UserGroupInformation.setConfiguration(configuration);
UserGroupInformation.loginUserFromKeytab(principal, keytabLocation)

Maven构建、测试

$ cd /opt/hdp-test-examples
$ mvn clean test -P hdp-2.6.1    (如果网络差则耗时较长)
[INFO] Scanning for projects...
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building hdp-test-examples 1.0-SNAPSHOT
[INFO] ------------------------------------------------------------------------
[INFO]
[INFO] --- maven-clean-plugin:2.4.1:clean (default-clean) @ hdp-test-examples ---
[INFO] Deleting /opt/hdp-test-examples/target
[INFO]
[INFO] --- maven-resources-plugin:2.5:resources (default-resources) @ hdp-test-examples ---
[debug] execute contextualize
[INFO] Using 'UTF-8' encoding to copy filtered resources.
[INFO] Copying 10 resources
[INFO]
[INFO] --- maven-compiler-plugin:2.3.2:compile (default-compile) @ hdp-test-examples ---
[INFO] Compiling 5 source files to /opt/hdp-test-examples/target/classes
[INFO]
[INFO] --- maven-resources-plugin:2.5:testResources (default-testResources) @ hdp-test-examples ---
[debug] execute contextualize
[INFO] Using 'UTF-8' encoding to copy filtered resources.
[INFO] Copying 1 resource
[INFO]
[INFO] --- maven-compiler-plugin:2.3.2:testCompile (default-testCompile) @ hdp-test-examples ---
[INFO] Compiling 1 source file to /opt/hdp-test-examples/target/test-classes
[INFO]
[INFO] --- maven-surefire-plugin:2.10:test (default-test) @ hdp-test-examples ---
[INFO] Surefire report directory: /opt/hdp-test-examples/target/surefire-reports

-------------------------------------------------------
 T E S T S
-------------------------------------------------------
Running com.jj.hbase.HBaseClientTest
Tests run: 4, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.552 sec

Results :

Tests run: 4, Failures: 0, Errors: 0, Skipped: 0

[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 5.145s
[INFO] Finished at: Wed Jul 19 07:19:34 UTC 2017
[INFO] Final Memory: 38M/91M
[INFO] ------------------------------------------------------------------------

可以自己读一下单元测试代码?/opt/hdp-test-examples/src/test/java/com/jj/hbase/HBaseClientTest.java??瓷先?,代码中它似乎连接上 HBase,然后建表并插入几行数据。

碰到的问题

  • 虚拟机内存不足,将内存由 3G 改成 4G 后问题解决;
  • 构建过程中一些 jar 包下载失败,修改 pom.xml,去掉 Scala相关依赖后问题解决;
  • pig 测试失败,删除 pig 的单元测试目录;
  • 通过 HBase shell 无法进行 grant,改用 hbase-hdp2610 主体并加大虚拟机内存后解决。

这里是完整代码。

Windows下的测试

前文是在 Centos7.3下进行的测试。下面在 Windows下进行测试。毕竟很多人使用 Windows+Eclipse 进行开发。下面的测试并没有直接使用 Eclipse,而是更直接的命令行测试。希望有人能够补充上 Eclipse 下的测试。关于 Eclipse 下的相关配置可以参考 hortonworks 的一篇社区文章(“Hortonworks Data Platform Artifacts”)。

测试使用了git bash命令行工具。git base在 Windows 下模拟的类似 Linux 的命令,但实际上使用的 Windows? 操作系统文件。关于 git base 的安装使用参考这个文档《Ambari 在本地 VM 部署 Hadoop 集群》。在 git base 上测试通过后,之后又直接在 Windows?命令行下进行了测试。需要说明的是,git bash 和 Windows?使用了不同的环境变量,如PATH。

在 Windows?下需要安装 JDK1.8 和 Maven。Maven是 Java 实现的,所以是所有平台通用的。在 Maven 的这篇文档(“Maven on Windows”)中要求 JDK 的安装目录名称不要有空格(如Program Files就不行)。Maven被我安装在了?e:\maven。在 git bash 下运行 Maven 的方法是?/e/maven/bin/mvn。

准备代码和配置文件

测试在 Windows?的?e:\opt?目录下进行。以下操作在 git bash 窗口中进行:

$ cd /e/opt
$ git clone https://github.com/wbwangk/hdp-test-examples
$ cd hdp-test-examples
$ scp root@c7302:/etc/krb5.conf src/main/resources/
$ scp root@c7302:/etc/hbase/conf/hbase-site.xml src/main/resources/
$ scp root@c7302:/opt/hdp-test-examples/src/main/resources/jj.keytab src/main/resources/

上述三个 scp 操作时把测试用到3个配置文件从 Linux 下网络复制到了 Windows?下。确保 Windows?的 hosts 文件中定义了3台虚拟机的 IP 和域名。

执行构建和单元测试

$ /e/maven/bin/mvn clean test -P hdp-2.6.1
(省略一些下载信息)
-------------------------------------------------------
 T E S T S
-------------------------------------------------------
Running com.jj.hbase.HBaseClientTest
Tests run: 4, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.42 sec

Results :

Tests run: 4, Failures: 0, Errors: 0, Skipped: 0

[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 02:27 min
[INFO] Finished at: 2017-07-20T07:40:15+08:00
[INFO] Final Memory: 31M/206M
[INFO] ------------------------------------------------------------------------

直接在Windows命令行下测试

进入 Windows 命令行后:

$ e:
$ cd \opt\hdp-test-examples
E:\opt\hdp-test-examples> mvn clean test -P hdp-2.6.1
[INFO] Scanning for projects...
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building hdp-test-examples 1.0-SNAPSHOT
[INFO] ------------------------------------------------------------------------
[INFO]
[INFO] --- maven-clean-plugin:2.5:clean (default-clean) @ hdp-test-examples ---
[INFO] Deleting E:\opt\hdp-test-examples\target
[INFO]
[INFO] --- maven-resources-plugin:2.6:resources (default-resources) @ hdp-test-examples ---
[INFO] Using 'UTF-8' encoding to copy filtered resources.
[INFO] Copying 10 resources
[INFO]
[INFO] --- maven-compiler-plugin:3.1:compile (default-compile) @ hdp-test-examples ---
[INFO] Changes detected - recompiling the module!
[INFO] Compiling 5 source files to E:\opt\hdp-test-examples\target\classes
[INFO]
[INFO] --- maven-resources-plugin:2.6:testResources (default-testResources) @ hdp-test-examples ---
[INFO] Using 'UTF-8' encoding to copy filtered resources.
[INFO] Copying 1 resource
[INFO]
[INFO] --- maven-compiler-plugin:3.1:testCompile (default-testCompile) @ hdp-test-examples ---
[INFO] Changes detected - recompiling the module!
[INFO] Compiling 1 source file to E:\opt\hdp-test-examples\target\test-classes
[WARNING] /E:/opt/hdp-test-examples/src/test/java/com/jj/hbase/HBaseClientTest.java: E:\opt\hdp-test-examples\src\test\java\com\jj\hbase\HBaseClientTest.java使用了未经检查或不安全的操作。
[WARNING] /E:/opt/hdp-test-examples/src/test/java/com/jj/hbase/HBaseClientTest.java: 有关详细信息, 请使用 -Xlint:unchecked 重新编译。
[INFO]
[INFO] --- maven-surefire-plugin:2.12.4:test (default-test) @ hdp-test-examples ---
[INFO] Surefire report directory: E:\opt\hdp-test-examples\target\surefire-reports

-------------------------------------------------------
 T E S T S
-------------------------------------------------------
Running com.jj.hbase.HBaseClientTest
Tests run: 4, Failures: 0, Errors: 0, Skipped: 0, Time elapsed: 0.318 sec

Results :

Tests run: 4, Failures: 0, Errors: 0, Skipped: 0

[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time: 3.624 s
[INFO] Finished at: 2017-07-20T08:15:17+08:00
[INFO] Final Memory: 30M/321M
[INFO] ------------------------------------------------------------------------

相关文章

]]>
//www.zk5bt.cn/29447.html/feed 0
Java结合keytool实现非对称加密和解密 - Co. Ltd.四川快乐12 //www.zk5bt.cn/29440.html //www.zk5bt.cn/29440.html#comments Wed, 08 Aug 2018 02:00:17 +0000 唐尤华 //www.zk5bt.cn/?p=29440 参考:Java结合keytool实现非对称签名与验证

那一篇讲签名,这一篇将加密解密。在Java安全体系中,签名属于JAAS???,加解密属于JCE???。

keytool的使用

keytool是JDK自带的一个密钥库管理工具。这里只用到了keytool的部分功能,包括生成密钥对,导出公钥等。keytool生成的公钥/私钥对存放到一个到了一个文件中,这个文件有密码?;?,通称为keystore。

生成密钥对

$ keytool -genkey -alias signLegal -keystore examplestanstore2 -validity 1800 -keyalg RSA

生成别名为signLegal的密钥对,存放在密钥库examplestanstore2中,证书的有效期是1800天(默认是90天)。
输入一系列的参数。输入的参数遵循了LDAP的风格和标准??梢韵胂?,生成的密钥对可以看成LDAP的一个条目。
命令执行成功后会在当前目录下创建一个叫examplestanstore2的文件。相对另一篇博文,增加了一个keyalg参数。因为keytool默认算法是DSA,而DSA只能用于签名。RSA既能用于签名,也能用于加密。而本文是研究加密问题,只能用RSA算法。

查看密钥对

$ keytool -list -keystore examplestanstore2 -v

列出了examplestanstore2密钥库的中所有密钥对。-v参数表示详细信息,详细信息中有证书的失效时间。

导出公钥证书

$ keytool -export -keystore examplestanstore2 -alias signLegal -file StanSmith.crt -rfc

导出的公钥存放在当前目录的StanSmith.crt文件中。讲“签名”的那篇博文没有加-rfc参数,导出是个二进制文件(CER格式)。加上-rfc后,导出的是文本文件(PEM)格式。在下面的测试中,如果使用CER格式,会报错 ` No installed provider supports this key: sun.security.provider.DSAPublicKeyImpl`。

Java加密和解密

参考了这篇文章《Java-web下使用RSA进行加密解密操作。

在Java程序中,首先从密钥库取出私钥和公钥,然后对测试字符串进行加密。二进制的密文转换成字符串输出到屏幕,然后解密成明文再输出到屏幕。

GenSig2.java

import java.io.*;
import java.security.KeyStore;
import java.security.PrivateKey;
import java.security.PublicKey;
import javax.crypto.Cipher;
import sun.security.provider.*;

public class RSAEntry {
    public static void main(String[] args) {
        try {
        //1.从密钥库中取私钥
        KeyStore ks = KeyStore.getInstance("JKS");
        FileInputStream ksfis = new FileInputStream("examplestanstore2");
        BufferedInputStream ksbufin = new BufferedInputStream(ksfis);

        // open keystore and get private key
        // alias is 'signLeal', kpasswd/spasswd is 'vagrant'
        ks.load(ksbufin, "vagrant".toCharArray());
        PrivateKey prikey = (PrivateKey) ks.getKey("signLegal", "vagrant".toCharArray());

        //2.根据命令行参数取公钥
        FileInputStream certfis = new FileInputStream(args[0]);
        java.security.cert.CertificateFactory cf =
            java.security.cert.CertificateFactory.getInstance("X.509");
        java.security.cert.Certificate cert =  cf.generateCertificate(certfis);
        PublicKey pubKey = cert.getPublicKey();

        //3.使用公钥进行加密
        String data = "测试数据";
        //构建加密解密类
        Cipher cipher = Cipher.getInstance("RSA");
        cipher.init(Cipher.ENCRYPT_MODE, pubKey);//设置为加密模式
        byte[] jmdata = cipher.doFinal(data.getBytes());
        //打印加密后数据
        System.out.println(bytesToHexString(jmdata));
        //改为解密模式进行解密
        cipher.init(Cipher.DECRYPT_MODE, prikey);//会用私钥解密
        jmdata = cipher.doFinal(jmdata);
        System.out.println(new String(jmdata));
        }catch (Exception e) {
                e.printStackTrace();
        }
    }
    //这个方法用于把二进制转换成ASCII字符串。
    public static String bytesToHexString(byte[] bytes) {
        if (bytes == null)
            return "null!";
        int len = bytes.length;
        StringBuilder ret = new StringBuilder(2 * len);

        for (int i = 0; i < len; ++i) {
            int b = 0xF & bytes[(i)] >> 4;
            ret.append("0123456789abcdef".charAt(b));
            b = 0xF & bytes[(i)];
            ret.append("0123456789abcdef".charAt(b));
        }

        return ret.toString();
    }
}

编译,并运行

$ javac RSAEntry.java
$ java RSAEntry StanSmith.crt
8fceea48e34fdc786bde05459f3366714b650ff04f4e81e52eca139d8ee0b4acbcad019cd496de3589765894b2d5f4a2af38914af614d9e9b73e551ae01830cd6f49505685d7e527e3adc2b7a2a75608068627c0a12b338d3c743a5de2af2de327a0de14b548604e5c8905747aef077852ecfd2eb4a134ca0f3a56b23db8ae4beb07add5ba3725ab3ee0ffa7481494856144ba5004a329cfe2c43078f0cd95aebcbbfc6c1894efafacac90615e549cb8432c125d912a5e54ce4884f633f3e96bd7b61c1d538e38713716367f7ec6f5ca01288e6d96ad9e3d6515147369144390e1d002b1beaf5797966e3b498cc7def754816c99456ef380b3a83366a44415f6
测试数据

本文展示的算法是一种非对称算法,计算较慢。在SSL中,非对称算法用于客户端和服务器之间交换对称加密的一次性密钥??突Ф私桓鏊婊梅衿鞯墓考用芊⒏衿?,如果服务器持有私钥,就能解开密文获得随机数(这个随机数就是对称算法的密钥)。有了对称算法密钥,双方就可以用对称加密进行安全通信了。

相关文章

]]>
//www.zk5bt.cn/29440.html/feed 0
JDK源码阅读:InterruptibleChannel与可中断IO - Co. Ltd.四川快乐12 //www.zk5bt.cn/29430.html //www.zk5bt.cn/29430.html#comments Wed, 08 Aug 2018 01:51:54 +0000 唐尤华 //www.zk5bt.cn/?p=29430 Java传统IO是不支持中断的,所以如果代码在read/write等操作阻塞的话,是无法被中断的。这就无法和Thead的interrupt模型配合使用了。JavaNIO众多的升级点中就包含了IO操作对中断的支持。InterruptiableChannel表示支持中断的Channel。我们常用的FileChannel,SocketChannel,DatagramChannel都实现了这个接口。

InterruptibleChannel接口

public interface InterruptibleChannel extends Channel
{

    /**
     * 关闭当前Channel
     *     
     * 任何当前阻塞在当前channel执行的IO操作上的线程,都会收到一个AsynchronousCloseException异常
     */
    public void close() throws IOException;
}

InterruptibleChannel接口没有定义任何方法,其中的close方法是父接口就有的,这里只是添加了额外的注释。

AbstractInterruptibleChannel实现了InterruptibleChannel接口,并提供了实现可中断IO机制的重要的方法,比如begin(),end()。

在解读这些方法的代码前,先了解一下NIO中,支持中断的Channel代码是如何编写的。

第一个要求是要正确使用begin()end()方法:

boolean completed = false;
try {
    begin();
    completed = ...;    // 执行阻塞IO操作
    return ...;         // 返回结果
} finally {
    end(completed);
}

NIO规定了,在阻塞IO的语句前后,需要调用begin()end()方法,为了保证end()方法一定被调用,要求放在finally语句块中。

第二个要求是Channel需要实现java.nio.channels.spi.AbstractInterruptibleChannel#implCloseChannel这个方法。AbstractInterruptibleChannel在处理中断时,会调用这个方法,使用Channel的具体实现来关闭Channel。

接下来我们具体看一下begin()end()方法是如何实现的。

begin方法

// 保存中断处理对象实例
private Interruptible interruptor;
// 保存被中断线程实例
private volatile Thread interrupted;

protected final void begin() {
    // 初始化中断处理对象,中断处理对象提供了中断处理回调
    // 中断处理回调登记被中断的线程,然后调用implCloseChannel方法,关闭Channel
    if (interruptor == null) {
        interruptor = new Interruptible() {
            public void interrupt(Thread target) {
                synchronized (closeLock) {
                    // 如果当前Channel已经关闭,则直接返回
                    if (!open)
                        return;

                    // 设置标志位,同时登记被中断的线程
                    open = false;
                    interrupted = target;
                    try {
                        // 调用具体的Channel实现关闭Channel
                        AbstractInterruptibleChannel.this.implCloseChannel();
                    } catch (IOException x) { }
                }
            }};
    }
    // 登记中断处理对象到当前线程
    blockedOn(interruptor);

    // 判断当前线程是否已经被中断,如果已经被中断,可能登记的中断处理对象没有被执行,这里手动执行一下
    Thread me = Thread.currentThread();
    if (me.isInterrupted())
        interruptor.interrupt(me);
}

begin()方法中,我们可以看出NIO实现可中断IO操作的思路,是在Thread的中断逻辑中,挂载自定义的中断处理对象,这样Thread对象在被中断时,会执行中断处理对象中的回调,这个回调中,执行关闭Channel的操作。这样就实现了Channel对线程中断的响应了。

接下来重点就是研究“Thread添加中断处理逻辑”这个机制是如何实现的了,是通过blockedOn方法实现的:

static void blockedOn(Interruptible intr) {         // package-private
    sun.misc.SharedSecrets.getJavaLangAccess().blockedOn(Thread.currentThread(),intr);
}

blockedOn方法使用的是JavaLangAccessblockedOn方法。

SharedSecrets是一个神奇而糟糕的类,为啥说是糟糕呢,因为这个方法的存在,就是为了访问JDK类库中一些因为类作用域限制而外部无法访问的类或者方法。JDK很多类与方法是私有或者包级别私有的,外部是无法访问的,但是JDK在本身实现的时候又存在互相依赖的情况,所以为了外部可以不依赖反射访问这些类或者方法,在sun包下,存在这么一个类,提供了各种超越限制的方法。

SharedSecrets.getJavaLangAccess()方法返回JavaLangAccess对象。JavaLangAccess对象就和名称所说的一样,提供了java.lang包下一些非公开的方法的访问。这个类在System初始化时被构造:

// java.lang.System#setJavaLangAccess
private static void setJavaLangAccess() {
    sun.misc.SharedSecrets.setJavaLangAccess(new sun.misc.JavaLangAccess(){
        public void blockedOn(Thread t, Interruptible b) {
            t.blockedOn(b);
        }
        //...
    });
}

可以看出,sun.misc.JavaLangAccess#blockedOn保证的就是java.lang.Thread#blockedOn这个包级别私有的方法:

/* The object in which this thread is blocked in an interruptible I/O
 * operation, if any.  The blocker's interrupt method should be invoked
 * after setting this thread's interrupt status.
 */
private volatile Interruptible blocker;
private final Object blockerLock = new Object();

/* Set the blocker field; invoked via sun.misc.SharedSecrets from java.nio code
 */
void blockedOn(Interruptible b) {
    // 串行化blocker相关操作
    synchronized (blockerLock) {
        blocker = b;
    }
}

而这个方法也非常简单,就是设置java.lang.Thread#blocker变量为之前提到的中断处理对象。而且从注释中可以看出,这个方法就是专门为NIO设计的,注释都非常直白的提到了,NIO的代码会通过sun.misc.SharedSecrets调用到这个方法。。

接下来就是重头戏了,看一下Thread在中断时,如何调用NIO注册的中断处理器:

public void interrupt() {
    if (this != Thread.currentThread())
        checkAccess();

    synchronized (blockerLock) {
        Interruptible b = blocker;

        // 如果NIO设置了中断处理器,则只需Thread本身的中断逻辑后,调用中断处理器的回调函数
        if (b != null) {
            interrupt0();           // 这一步会设置interrupt标志位
            b.interrupt(this);
            return;
        }
    }

    // 如果没有的话,就走普通流程
    interrupt0();
}

end方法

begin()方法负责添加Channel的中断处理器到当前线程。end()是在IO操作执行完/中断完后的操作,负责判断中断是否发生,如果发生判断是当前线程发生还是别的线程中断把当前操作的Channel给关闭了,对于不同的情况,抛出不同的异常。

protected final void end(boolean completed) throws AsynchronousCloseException
{
	// 清空线程的中断处理器引用,避免线程一直存活导致中断处理器无法被回收
    blockedOn(null);
    Thread interrupted = this.interrupted;

    if (interrupted != null && interrupted == Thread.currentThread()) {
        interrupted = null;
        throw new ClosedByInterruptException();
    }
    // 如果这次没有读取到数据,并且Channel被另外一个线程关闭了,则排除Channel被异步关闭的异常
    // 但是如果这次读取到了数据,就不能抛出异常,因为这次读取的数据是有效的,需要返回给用户的(重要逻辑)
    if (!completed && !open)
        throw new AsynchronousCloseException();
}

通过代码可以看出,如果是当前线程被中断,则抛出ClosedByInterruptException异常,表示Channel因为线程中断而被关闭了,IO操作也随之中断了。

如果是当前线程发现Channel被关闭了,并且是读取还未执行完毕的情况,则抛出AsynchronousCloseException异常,表示Channel被异步关闭了。

end()逻辑的活动图如下:

场景分析

并发的场景分析起来就是复杂,上面的代码不多,但是场景很多,我们以sun.nio.ch.FileChannelImpl#read(java.nio.ByteBuffer)为例分析一下可能的场景:

  1. A线程read,B线程中断A线程:A线程抛出ClosedByInterruptException异常
  2. A,B线程read,C线程中断A线程
    1. A被中断时,B刚刚进入read方法:A线程抛出ClosedByInterruptException异常,B线程ensureOpen方法抛出ClosedChannelException异常
      1. A被中断时,B阻塞在底层read方法中:A线程抛出ClosedByInterruptException异常,B线程底层方法抛出异常返回,end方法中抛出AsynchronousCloseException异常
      2. A被中断时,B已经读取到数据:A线程抛出ClosedByInterruptException异常,B线程正常返回

sun.nio.ch.FileChannelImpl#read(java.nio.ByteBuffer)代码如下:

public int read(ByteBuffer dst) throws IOException {
    ensureOpen();  // 1
    if (!readable) // 2
        throw new NonReadableChannelException();
    synchronized (positionLock) {
        int n = 0;
        int ti = -1;
        try {            
            begin();
            ti = threads.add();
            if (!isOpen())
                return 0; // 3
            do {
                n = IOUtil.read(fd, dst, -1, nd); // 4
            } while ((n == IOStatus.INTERRUPTED) && isOpen());
            return IOStatus.normalize(n);
        } finally {
            threads.remove(ti);
            end(n > 0);
            assert IOStatus.check(n);
        }
    }
}

总结

在JavaIO时期,人们为了中断IO操作想了不少方法,核心操作就是关闭流,促使IO操作抛出异常,达到中断IO的效果。NIO中,将这个操作植入了java.lang.Thread#interrupt方法,免去用户自己编码特定代码的麻烦。使IO操作可以像其他可中断方法一样,在中断时抛出ClosedByInterruptException异常,业务程序捕获该异常即可对IO中断做出响应。

参考资料

相关文章

]]>
//www.zk5bt.cn/29430.html/feed 0
SpringBoot | 第八章:统一异常、数据校验处理 - Co. Ltd.四川快乐12 //www.zk5bt.cn/29411.html //www.zk5bt.cn/29411.html#comments Fri, 03 Aug 2018 13:05:28 +0000 TiuVe2 //www.zk5bt.cn/?p=29411 前言

在web应用中,请求处理时,出现异常是非常常见的。所以当应用出现各类异常时,进行异常的捕获或者二次处理(比如sql异常正常是不能外抛)是非常必要的,比如在开发对外api服务时,约定了响应的参数格式,如respCode、respMsg,调用方根据错误码进行自己的业务逻辑。本章节就重点讲解下统一异常和数据校验处理。

springboot中,默认在发送异常时,会跳转值/error请求进行错误的展现,根据不同的Content-Type展现不同的错误结果,如json请求时,直接返回json格式参数。

浏览器访问异常时:

使用postman访问时:

统一异常处理

显然,默认的异常页是对用户或者调用者而言都是不友好的,所以一般上我们都会进行实现自己业务的异常提示信息。

创建全局的统一异常处理类

利用@ControllerAdvice@ExceptionHandler定义一个统一异常处理类

  • @ControllerAdvice:控制器增强,使@ExceptionHandler、@InitBinder、@ModelAttribute注解的方法应用到所有的 @RequestMapping注解的方法。
  • @ExceptionHandler:异常处理器,此注解的作用是当出现其定义的异常时进行处理的方法

创建异常类:CommonExceptionHandler

@ControllerAdvice
public class CommonExceptionHandler {

    /**
     *  拦截Exception类的异常
     * @param e
     * @return
     */
    @ExceptionHandler(Exception.class)
    @ResponseBody
    public Map<String,Object> exceptionHandler(Exception e){
        Map<String,Object> result = new HashMap<String,Object>();
        result.put("respCode", "9999");
        result.put("respMsg", e.getMessage());
        //正??⒅?,可创建一个统一响应实体,如CommonResp
        return result; 
    }
}

多余不同异常(如自定义异常),需要进行不同的异常处理时,可编写多个exceptionHandler方法,注解ExceptionHandler指定处理的异常类,如

/**
 * 拦截 CommonException 的异常
 * @param ex
 * @return
 */
@ExceptionHandler(CommonException.class)
@ResponseBody
public Map<String,Object> exceptionHandler(CommonException ex){
    log.info("CommonException:{}({})",ex.getMsg(), ex.getCode());
    Map<String,Object> result = new HashMap<String,Object>();
    result.put("respCode", ex.getCode());
    result.put("respMsg", ex.getMsg());
    return result; 
}

由于加入了@ResponseBody,所以返回的是json格式,

说明异常已经被拦截了。

可拦截不同的异常,进行不同的异常提示,比如NoHandlerFoundException、HttpMediaTypeNotSupportedException、AsyncRequestTimeoutException等等,这里就不列举了,读者可自己加入后实际操作下。

对于返回页面时,返回ModelAndView即可,如

@ExceptionHandler(value = Exception.class)
    public ModelAndView defaultErrorHandler(HttpServletRequest req, Exception e) throws Exception {
        ModelAndView mav = new ModelAndView();
        mav.addObject("exception", e);
        mav.addObject("url", req.getRequestURL());
        mav.setViewName(DEFAULT_ERROR_VIEW);
        return mav;
    }

由于工作中都是才有前后端分离开发模式,所以一般上都没有直接返回资源页的需求了,一般上都是返回固定的响应格式,如respCode、respMsg、data,前端通过判断respCode的值进行业务判断,是弹窗还是跳转页面。

数据校验

在web开发时,对于请求参数,一般上都需要进行参数合法性校验的,原先的写法时一个个字段一个个去判断,这种方式太不通用了,所以java的JSR 303: Bean Validation规范就是解决这个问题的。

JSR 303只是个规范,并没有具体的实现,目前通常都是才有hibernate-validator进行统一参数校验。

JSR303定义的校验类型

Constraint 详细信息
@Null 被注释的元素必须为?null
@NotNull 被注释的元素必须不为?null
@AssertTrue 被注释的元素必须为?true
@AssertFalse 被注释的元素必须为?false
@Min(value) 被注释的元素必须是一个数字,其值必须大于等于指定的最小值
@Max(value) 被注释的元素必须是一个数字,其值必须小于等于指定的最大值
@DecimalMin(value) 被注释的元素必须是一个数字,其值必须大于等于指定的最小值
@DecimalMax(value) 被注释的元素必须是一个数字,其值必须小于等于指定的最大值
@Size(max, min) 被注释的元素的大小必须在指定的范围内
@Digits (integer, fraction) 被注释的元素必须是一个数字,其值必须在可接受的范围内
@Past 被注释的元素必须是一个过去的日期
@Future 被注释的元素必须是一个将来的日期
@Pattern(value) 被注释的元素必须符合指定的正则表达式

Hibernate Validator 附加的 constraint

Constraint 详细信息
@Email 被注释的元素必须是电子邮箱地址
@Length 被注释的字符串的大小必须在指定的范围内
@NotEmpty 被注释的字符串的必须非空
@Range 被注释的元素必须在合适的范围内

创建实体类

@Data
@NoArgsConstructor
@AllArgsConstructor
public class DemoReq {
    
    @NotBlank(message="code不能为空")
    String code;
    
    @Length(max=10,message="name长度不能超过10")
    String name;

}

然后在控制层方法里,加入@Valid即可,这样在访问前,会对请求参数进行检验。

@GetMapping("/demo/valid")
public String demoValid(@Valid DemoReq req) {
    return req.getCode() + "," + req.getName();
}

启动,后访问//127.0.0.1:8080/demo/valid

加上正确参数后,//127.0.0.1:8080/demo/valid?code=3&name=s

这样数据的统一校验就完成了,对于其他注解的使用,大家可自行谷歌下,基本上都很简单的,对于已有的注解无法满足校验需要时,也可进行自定义注解的开发,一下简单讲解下,自定义注解的编写

不使用@valid的情况下,也可利用编程的方式编写一个工具类,进行实体参数校验

public class ValidatorUtil {
    private static Validator validator = ((HibernateValidatorConfiguration) Validation
            .byProvider(HibernateValidator.class).configure()).failFast(true).buildValidatorFactory().getValidator();

    /**
     * 实体校验
     * 
     * @param obj
     * @throws CommonException
     */
    public static <T> void validate(T obj) throws CommonException {
        Set<ConstraintViolation<T>> constraintViolations = validator.validate(obj, new Class[0]);
        if (constraintViolations.size() > 0) {
            ConstraintViolation<T> validateInfo = (ConstraintViolation<T>) constraintViolations.iterator().next();
            // validateInfo.getMessage() 校验不通过时的信息,即message对应的值
            throw new CommonException("0001", validateInfo.getMessage());
        }
    }
}

使用

@GetMapping("/demo/valid")
public String demoValid(@Valid DemoReq req) {
    //手动校验
    ValidatorUtil.validate(req);
    return req.getCode() + "," + req.getName();
}

自定义校验注解

自定义注解,主要时实现ConstraintValidator的处理类即可,这里已编写一个校验常量的注解为例:参数值只能为特定的值。

自定义注解

@Documented
//指定注解的处理类
@Constraint(validatedBy = {ConstantValidatorHandler.class })
@Target({ METHOD, FIELD, ANNOTATION_TYPE, CONSTRUCTOR, PARAMETER })
@Retention(RUNTIME)
public @interface Constant {

   String message() default "{constraint.default.const.message}";

   Class<?>[] groups() default {};

   Class<? extends Payload>[] payload() default {};

   String value();

}

注解处理类

public class ConstantValidatorHandler implements ConstraintValidator<Constant, String> {

    private String constant;

    @Override
    public void initialize(Constant constraintAnnotation) {
        //获取设置的字段值
        this.constant = constraintAnnotation.value();
    }

    @Override
    public boolean isValid(String value, ConstraintValidatorContext context) {
        //判断参数是否等于设置的字段值,返回结果
        return constant.equals(value);
    }

}

使用

@Constant(message = "verson只能为1.0",value="1.0")
String version;

运行:

此时,自定义注解已生效。大家可根据实际需求进行开发。

大家看到在校验不通过时,返回的异常信息是不友好的,此时可利用统一异常处理,对校验异常进行特殊处理,特别说明下,对于异常处理类,共有以下几种情况(被@RequestBody和@RequestParam注解的请求实体,校验异常类是不同的)

@ExceptionHandler(MethodArgumentNotValidException.class)
    public Map<String,Object> handleBindException(MethodArgumentNotValidException ex) {
        FieldError fieldError = ex.getBindingResult().getFieldError();
        log.info("参数校验异常:{}({})", fieldError.getDefaultMessage(),fieldError.getField());
        Map<String,Object> result = new HashMap<String,Object>();
        result.put("respCode", "01002");
        result.put("respMsg", fieldError.getDefaultMessage());
        return result;
    }


    @ExceptionHandler(BindException.class)
    public Map<String,Object> handleBindException(BindException ex) {
        //校验 除了 requestbody 注解方式的参数校验 对应的 bindingresult 为 BeanPropertyBindingResult
        FieldError fieldError = ex.getBindingResult().getFieldError();
        log.info("必填校验异常:{}({})", fieldError.getDefaultMessage(),fieldError.getField());
        Map<String,Object> result = new HashMap<String,Object>();
        result.put("respCode", "01002");
        result.put("respMsg", fieldError.getDefaultMessage());
        return result;
    }

启动后,提示就友好了

所以统一异?;故呛苡斜匾?。

总结

本章节主要是阐述了统一异常处理和数据的合法性校验,同时简单实现了一个自定义的注解类,大家在碰见已有注解无法解决时,可通过自定义的形式进行,当然对于通用而已,利用@Pattern(正则表达式)基本上都是可以实现的。

最后

目前互联网上很多大佬都有springboot系列教程,如有雷同,请多多包涵了。本文是作者在电脑前一字一句敲的,每一步都是实践的。若文中有所错误之处,还望提出,谢谢。

相关文章

]]>
//www.zk5bt.cn/29411.html/feed 1
SpringBoot | 第七章:过滤器、监听器、拦截器 - Co. Ltd.四川快乐12 //www.zk5bt.cn/29401.html //www.zk5bt.cn/29401.html#comments Fri, 03 Aug 2018 12:49:39 +0000 TiuVe2 //www.zk5bt.cn/?p=29401 前言

在实际开发过程中,经?;崤黾恍┍热缦低称舳跏蓟畔?、统计在线人数、在线用户数、过滤敏高词汇、访问权限控制(URL级别)等业务需求。这些对于业务来说一般上是无关的,业务方是无需关系的,业务只需要关系自己内部业务的事情。所以一般上实现以上的功能,都会或多或少的用到今天准备讲解的过滤器、监听器、拦截器来实现以上功能。

过滤器

过滤器Filter,是Servlet的的一个实用技术了??赏ü似?,对请求进行拦截,比如读取session判断用户是否登录、判断访问的请求URL是否有访问权限(黑白名单)等。主要还是可对请求进行预处理。接下来介绍下,在springboot如何实现过滤器功能。

利用WebFilter注解配置

@WebFilterServlet3.0新增的注解,原先实现过滤器,需要在web.xml中进行配置,而现在通过此注解,启动启动时会自动扫描自动注册。

编写Filter类:

//注册器名称为customFilter,拦截的url为所有
@WebFilter(filterName="customFilter",urlPatterns={"/*"})
@Slf4j
public class CustomFilter implements Filter{

    @Override
    public void init(FilterConfig filterConfig) throws ServletException {
        log.info("filter 初始化");
    }

    @Override
    public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
            throws IOException, ServletException {
        // TODO Auto-generated method stub
        log.info("doFilter 请求处理");
        //对request、response进行一些预处理
        // 比如设置请求编码
        // request.setCharacterEncoding("UTF-8");
        // response.setCharacterEncoding("UTF-8");
        //TODO 进行业务逻辑
        
        //链路 直接传给下一个过滤器
        chain.doFilter(request, response);
    }

    @Override
    public void destroy() {
        log.info("filter 销毁");
    }
}

然后在启动类加入@ServletComponentScan注解即可。

@SpringBootApplication
@ServletComponentScan
@Slf4j
public class Chapter7Application {
    
    public static void main(String[] args) {
        SpringApplication.run(Chapter7Application.class, args);
        log.info("chapter7 服务启动");
    }
}

启动后,控制台输出:

过滤器已经生效了。但当注册多个过滤器时,无法指定执行顺序的,原本使用web。xml配置过滤器时,是可指定执行顺序的,但使用@WebFilter时,没有这个配置属性的(需要配合@Order进行),所以接下来介绍下通过FilterRegistrationBean进行过滤器的注册。

–小技巧–

  1. 通过过滤器的名字,进行顺序的约定,比如LogFilterAuthFilter,此时AuthFilter就会比LogFilter先执行,因为首字母AL前面。
  2. 通过@Order指定执行顺序,值越小,越先执行

FilterRegistrationBean方式

FilterRegistrationBeanspringboot提供的,此类提供setOrder方法,可以为filter设置排序值,让spring在注册web filter之前排序后再依次注册。

改写filter

其实就输出了@webFilter注解即可。其他的都没有变化。

启动类中利用@bean注册FilterRegistrationBean

@Bean
    public FilterRegistrationBean  filterRegistrationBean() {
        FilterRegistrationBean registration = new FilterRegistrationBean();
        //当过滤器有注入其他bean类时,可直接通过@bean的方式进行实体类过滤器,这样不可自动注入过滤器使用的其他bean类。
        //当然,若无其他bean需要获取时,可直接new CustomFilter(),也可使用getBean的方式。
        registration.setFilter(customFilter());
        //过滤器名称
        registration.setName("customFilter");
        //拦截路径
        registration.addUrlPatterns("/*");
        //设置顺序
        registration.setOrder(10);
        return registration;
    }

    @Bean
    public Filter customFilter() {
        return new CustomFilter();
    }

注册多个时,就注册多个FilterRegistrationBean即可

启动后,效果和第一种是一样的。

监听器

Listeeshi是servlet规范中定义的一种特殊类。用于监听servletContext、HttpSession和servletRequest等域对象的创建和销毁事件。监听域对象的属性发生修改的事件。用于在事件发生前、发生后做一些必要的处理。一般是获取在线人数等业务需求。

创建一个ServletRequest监听器(其他监听器类似创建)

@WebListener
@Slf4j
public class Customlister implements ServletRequestListener{

    @Override
    public void requestDestroyed(ServletRequestEvent sre) {
        log.info("监听器:销毁");
    }

    @Override
    public void requestInitialized(ServletRequestEvent sre) {
        log.info("监听器:初始化");
    }

}

和创建过滤器一样,在启动类中加入@ServletComponentScan进行自动注册即可。

拦截器

以上的过滤器、监听器都属于Servlet的api,我们在开发中处理利用以上的进行过滤web请求时,还可以使用Spring提供的拦截器(HandlerInterceptor)进行更加精细的控制。

编写自定义拦截器类

@Slf4j
public class CustomHandlerInterceptor implements HandlerInterceptor{

	@Override
	public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler)
			throws Exception {
		log.info("preHandle:请求前调用");
		//返回 false 则请求中断
		return true;
	}

	@Override
	public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
			ModelAndView modelAndView) throws Exception {
		log.info("postHandle:请求后调用");

	}

	@Override
	public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex)
			throws Exception {
		log.info("afterCompletion:请求调用完成后回调方法,即在视图渲染完成后回调");

	}

}

通过继承WebMvcConfigurerAdapter注册拦截器

@Configuration
public class WebMvcConfigurer extends WebMvcConfigurerAdapter{
	
	@Override
	 public void addInterceptors(InterceptorRegistry registry) {
		 //注册拦截器 拦截规则
		//多个拦截器时 以此添加 执行顺序按添加顺序
		registry.addInterceptor(getHandlerInterceptor()).addPathPatterns("/*");
	 }
	
	@Bean
	public static HandlerInterceptor getHandlerInterceptor() {
		return new CustomHandlerInterceptor();
	}
}

启动后,访问某个url,控制台输出

请求链路说明

在整个请求的过程,此一图胜千言,希望对此有个深刻的了解,通过不同组合实现不同的业务功能。

总结

本章节主要介绍了常用web开发时,会用到的一些常用类,本章节对servlet未进行介绍,平时用的比较少,用法和配置其实和拦截器、监听器是类似的,再次就不阐述了。

最后

目前互联网上很多大佬都有SpringBoot系列教程,如有雷同,请多多包涵了。本文是作者在电脑前一字一句敲的,每一步都是实践的。若文中有所错误之处,还望提出,谢谢。

相关文章

]]>
//www.zk5bt.cn/29401.html/feed 0
SpringBoot | 第六章:常用注解介绍及简单使用 - Co. Ltd.四川快乐12 //www.zk5bt.cn/29392.html //www.zk5bt.cn/29392.html#comments Fri, 03 Aug 2018 12:40:18 +0000 TiuVe2 //www.zk5bt.cn/?p=29392 前言

之前几个章节,大部分都是算介绍springboot的一些外围配置,比如日志配置等。这章节开始,开始总结一些关于springboot的综合开发的知识点。由于SpringBoot本身是基于SpringSpringMvc等各类spring家族的一个解决方案,可快速进行集合。故相关知识点其实大部分都是基于spring或者springmvc既有的知识点的。本章节,主要讲解的是关于web开发springboot独有的一些常用注解进行说明。

常用注解

@SpringBootApplication

前几章,在系统启动类里面,都加入了此启动注解,此注解是个组合注解,包括了@SpringBootConfiguration、@EnableAutoConfiguration@ComponentScan注解。

  • @SpringBootConfiguration 继承至@Configuration,对于熟悉spring的开发者而言,此标注当前类是配置类,并会将当前类内声明的一个或多个以@Bean注解标记的方法的实例纳入到srping容器中,并且实例名就是方法名。
  • @EnableAutoConfiguration 这个注解就是springboot能自动进行配置的魔法所在了。主要是通过此注解,能所有符合自动配置条件的bean的定义加载到spring容器中,比如根据spring-boot-starter-web?,来判断你的项目是否需要添加了webmvctomcat,就会自动的帮你配置web项目中所需要的默认配置。具体的使用,会在后期自定义实现一个自动启动类时,会讲解到它的一些机制。此章节就不深入了,只需要它是这个用途即可,一般上也单独使用不要这个注解,但比如需要排除一些无需自动配置的类时,可利用exclude进行排除。
  • @ComponentScan 这个熟悉spring的开发者也应该熟悉,会扫描当前包及其子包下被@Component,@Controller,@Service,@Repository等注解标记的类并纳入到spring容器中进行管理。

@Controller 和 @RestController

@RestController 是Spring4之后加入的注解,原来在@Controller中返回json需要@ResponseBody来配合,如果直接用@RestController替代@Controller就不需要再配置@ResponseBody,默认返回json格式。而@Controller是用来创建处理http请求的对象,一般结合@RequestMapping使用。

@RequestMapping

一个用来处理请求地址映射的注解,可用于类或方法上。用于类上,表示类中的所有响应请求的方法都是以该地址作为父路径。

常用属性(摘抄至网络):

  • value, method;
    value: 指定请求的实际地址,指定的地址可以是URI Template 模式(后面将会说明);
    method: 指定请求的method类型, GET、POST、PUT、DELETE等;
  • consumes,produces;
    consumes: 指定处理请求的提交内容类型(Content-Type),例如application/json, text/html;
    produces: 指定返回的内容类型,仅当request请求头中的(Accept)类型中包含该指定类型才返回;
  • params,headers;
    params: 指定request中必须包含某些参数值是,才让该方法处理。
    headers: 指定request中必须包含某些指定的header值,才能让该方法处理请求。

常用的基本上就valuemethod了。其简化注解有

@GetMapping 等同于 @RequestMapping(method = RequestMethod.GET)
@PostMapping 等同于 @RequestMapping(method = RequestMethod.POST)
@PutMapping 等同于 @RequestMapping(method = RequestMethod.PUT)
@DeleteMapping 等同于 @RequestMapping(method = RequestMethod.DELETE)
@PatchMapping 等同于 @RequestMapping(method = RequestMethod.PATCH)

@RequestBody和@ResponseBody

  • @RequestBody注解允许request的参数在reqeust体中,常常结合前端POST请求,进行前后端交互。
  • @ResponseBody注解支持将的参数在reqeust体中,通常返回json格式给前端。

@PathVariable、@RequestParam、@RequestAttribute

  • @PathVariable用来接收参数,如/path/001,可接收001作为参数

  • @RequestParam 用来接收URL中的参数,如/param?id=001,可接收001作为参数

  • @RequestAttribute用于访问由过滤器或拦截器创建的、预先存在的请求属性,效果等同与request.getAttrbute().

@Component、@Service、@Repository

这三者都是申明一个单例的bean类并纳入spring容器中,后两者其实都是继承于@Component。

  • @Component 最普通的组件,可以被注入到spring容器进行管理
  • @Repository 作用于持久层
  • @Service 作用于业务逻辑层

通常一些类无法确定是使用@Service还是@Component时,注解使用@Component,比如redis的配置类等

@ModelAttribute

主要是绑定请求参数到指定对象上。此注解可被用于方法、参数上。

  • 运用在参数上,会将客户端传递过来的参数按名称注入到指定对象中,并且会将这个对象自动加入ModelMap中,便于View层使用;
  • 运用在方法上,会在每一个@RequestMapping标注的方法前执行,如果有返回值,则自动将该返回值加入到ModelMap中;

由于现在都采用前后端分离开发,故此注解相对用的较少了,但对于一些在每次请求前需要进行一些额外操作时。使用此注解依然是个选择,比如进行统一的业务校验等,但使用此注解实现类似功能时需要注意,使用异步调用时,比如callable或者DeferredResult时,被此注解的方法会执行两次,因为异步请求时,是挂起另一个线程去重新执行,对于配置了拦截器而已,它们的执行顺序为

preHandle ---->afterConcurrentHandlingStarted ----> Controller---->preHandler----> postHandler ----> afterCompletion

拦截器的相关知识点会在下章进行说明,这里只是特殊说明下。解决方案的话可简单根据DispatcherType类型进行判断,异步时对应类型为:ASYNC,第一次请求正常为:REQUEST。

总结

本章节主要是阐述了在web开发时一些常用的注解,但比如一些像@autowired、@resource、@Qualifier等在此就不列举了,这些都比较简单。对于开发者而言这些基本上都了解。

最后

目前互联网上很多大佬都有springboot系列教程,如有雷同,请多多包涵了。本文是作者在电脑前一字一句敲的,每一步都是实践的。若文中有所错误之处,还望提出,谢谢。

相关文章

]]>
//www.zk5bt.cn/29392.html/feed 0
在 Java 的反射中,Class.forName 和 ClassLoader 的区别 - Co. Ltd.四川快乐12 //www.zk5bt.cn/29389.html //www.zk5bt.cn/29389.html#comments Fri, 03 Aug 2018 12:30:40 +0000 TiuVe2 //www.zk5bt.cn/?p=29389 前言

最近在面试过程中有被问到,在Java反射中Class.forName()加载类和使用ClassLoader加载类的区别。当时没有想出来后来自己研究了一下就写下来记录一下。

解释

在java中Class.forName()和ClassLoader都可以对类进行加载。ClassLoader就是遵循双亲委派模型最终调用启动类加载器的类加载器,实现的功能是“通过一个类的全限定名来获取描述此类的二进制字节流”,获取到二进制流后放到JVM中。Class.forName()方法实际上也是调用的CLassLoader来实现的。

Class.forName(String className);这个方法的源码是

@CallerSensitive
    public static Class<?> forName(String className)
                throws ClassNotFoundException {
        Class<?> caller = Reflection.getCallerClass();
        return forName0(className, true, ClassLoader.getClassLoader(caller), caller);
    }

最后调用的方法是forName0这个方法,在这个forName0方法中的第二个参数被默认设置为了true,这个参数代表是否对加载的类进行初始化,设置为true时会类进行初始化,代表会执行类中的静态代码块,以及对静态变量的赋值等操作。

也可以调用Class.forName(String name, boolean initialize,ClassLoader loader)方法来手动选择在加载类的时候是否要对类进行初始化。Class.forName(String name, boolean initialize,ClassLoader loader)的源码如下:

/* @param name       fully qualified name of the desired class
     * @param initialize if {@code true} the class will be initialized.
     *                   See Section 12.4 of <em>The Java Language Specification</em>.
     * @param loader     class loader from which the class must be loaded
     * @return           class object representing the desired class
     *
     * @exception LinkageError if the linkage fails
     * @exception ExceptionInInitializerError if the initialization provoked
     *            by this method fails
     * @exception ClassNotFoundException if the class cannot be located by
     *            the specified class loader
     *
     * @see       java.lang.Class#forName(String)
     * @see       java.lang.ClassLoader
     * @since     1.2
     */
    @CallerSensitive
    public static Class<?> forName(String name, boolean initialize,
                                   ClassLoader loader)
        throws ClassNotFoundException
    {
        Class<?> caller = null;
        SecurityManager sm = System.getSecurityManager();
        if (sm != null) {
            // Reflective call to get caller class is only needed if a security manager
            // is present.  Avoid the overhead of making this call otherwise.
            caller = Reflection.getCallerClass();
            if (sun.misc.VM.isSystemDomainLoader(loader)) {
                ClassLoader ccl = ClassLoader.getClassLoader(caller);
                if (!sun.misc.VM.isSystemDomainLoader(ccl)) {
                    sm.checkPermission(
                        SecurityConstants.GET_CLASSLOADER_PERMISSION);
                }
            }
        }
        return forName0(name, initialize, loader, caller);
    }

源码中的注释只摘取了一部分,其中对参数initialize的描述是:if {@code true} the class will be initialized.意思就是说:如果参数为true,则加载的类将会被初始化。

举例

下面还是举例来说明结果吧:

一个含有静态代码块、静态变量、赋值给静态变量的静态方法的类

public class ClassForName {

    //静态代码块
    static {
        System.out.println("执行了静态代码块");
    }
    //静态变量
    private static String staticFiled = staticMethod();

    //赋值静态变量的静态方法
    public static String staticMethod(){
        System.out.println("执行了静态方法");
        return "给静态字段赋值了";
    }
}

测试方法:

public class MyTest {
    @Test
    public void test44(){

        try {
            Class.forName("com.test.mytest.ClassForName");
            System.out.println("#########分割符(上面是Class.forName的加载过程,下面是ClassLoader的加载过程)##########");
            ClassLoader.getSystemClassLoader().loadClass("com.test.mytest.ClassForName");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

    }
}

运行结果:

执行了静态代码块
执行了静态方法
#########分割符(上面是Class.forName的加载过程,下面是ClassLoader的加载过程)##########

根据运行结果得出Class.forName加载类是将类进了初始化,而ClassLoader的loadClass并没有对类进行初始化,只是把类加载到了虚拟机中。

应用场景

在我们熟悉的Spring框架中的IOC的实现就是使用的ClassLoader。

而在我们使用JDBC时通常是使用Class.forName()方法来加载数据库连接驱动。这是因为在JDBC规范中明确要求Driver(数据库驱动)类必须向DriverManager注册自己。

以MySQL的驱动为例解释:

public class Driver extends NonRegisteringDriver implements java.sql.Driver {  
    // ~ Static fields/initializers  
    // ---------------------------------------------  
  
    //  
    // Register ourselves with the DriverManager  
    //  
    static {  
        try {  
            java.sql.DriverManager.registerDriver(new Driver());  
        } catch (SQLException E) {  
            throw new RuntimeException("Can't register driver!");  
        }  
    }  
  
    // ~ Constructors  
    // -----------------------------------------------------------  
  
    /** 
     * Construct a new driver and register it with DriverManager 
     *  
     * @throws SQLException 
     *             if a database error occurs. 
     */  
    public Driver() throws SQLException {  
        // Required for Class.forName().newInstance()  
    }  
}

我们看到Driver注册到DriverManager中的操作写在了静态代码块中,这就是为什么在写JDBC时使用Class.forName()的原因了。

好了,今天就写到这了,最近在面试,遇到了很多问题,也学习了不少,虽然很累,但是也让人成长了不少,毕竟面试就是一个脱皮的过程,会遇到各种企业各种面试官各种问题,各种场景。给自己加油吧,找一个最少能让自己干个几年的公司,别总是让我遇到工作了没多久公司就垮掉的这种就行了。要不我也很无奈啊。

相关文章

]]>
//www.zk5bt.cn/29389.html/feed 2
编辑 SpringBoot | 第五章:多环境配置 - Co. Ltd.四川快乐12 //www.zk5bt.cn/29368.html //www.zk5bt.cn/29368.html#comments Wed, 01 Aug 2018 01:46:19 +0000 TiuVe2 //www.zk5bt.cn/?p=29368 前言

写上一篇看英文资料,耗费了心力呀,这章,相对来说简单点。也比较熟悉,但是这很实用。不扯了,开始~

多环境配置

在开发应用时,常用部署的应用是多个的,比如:开发、测试、联调、生产等不同的应用环境,这些应用环境都对应不同的配置项,比如swagger一般上在生产时是关闭的;不同环境数据库地址、端口号等都是不尽相同的,要是没有多环境的自由切换,部署起来是很繁琐也容易出错的。

maven的多环境配置

在没有使用过springboot的多环境配置时,原先是利用mavenprofile功能进行多环境配置,这里我简单回顾下。

maven配置

   <profiles>
       <profile>
          <id>dev</id>
          <activation>
                <activeByDefault>true</activeByDefault>
            </activation>
            <properties>
               <pom.port>8080</pom.port>
            </properties>
       </profile>
       <profile>
          <id>test</id>
            <properties>
               <pom.port>8888</pom.port>
            </properties>
       </profile>       
    </profiles>
    <build>
    <resources>
        <resource>
            <directory>src/main/resources</directory>
            <includes>
                <include>**/*</include>
            </includes>
        </resource>
        <resource>
            <directory>${project.basedir}/src/main/resources</directory>
            <includes>
                <include>**/*.properties</include>
            </includes>
            <!-- 加入此属性,才会进行过滤 -->
            <filtering>true</filtering>
        </resource>
    </resources>
    <plugins>
        <plugin>
            <artifactId>maven-resources-plugin</artifactId>
            <configuration>
                <encoding>utf-8</encoding>
                <!-- 需要加入,因为maven默认的是${},而springbooot 默认会把此替换成@{} -->
                <useDefaultDelimiters>true</useDefaultDelimiters>
            </configuration>
        </plugin>
        <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
        </plugin>
    </plugins>
    </build>

然后编译时,加入-Ptest,则会替换test环境下的参数值。 完整参数:

 mvn clean install -DskipTests -Ptest

application.properties

server.port=${pom.port}

利用maven实现多环境配置,比较麻烦的就是每次部署新环境时,都需要再次指定环境编译打包一次。一下进入主题,springboot的多环境,比较优雅了许多。

springboot多环境配置

Profile是Spring针对不同环境不同配置的支持。需要满足application-{profile}.properties,{profile}对应你的环境标识。如:

  • application-dev.properties:开发环境
  • application-test.properties:测试环境

而指定执行哪份配置文件,只需要在application.properties配置spring.profiles.active为对应${profile}的值。

# 指定环境为dev
spring.profiles.active=dev

则会加载:application-dev.properties的配置内容。

2018-07-15 14:52:41.304  INFO 15496 --- [           main] s.b.c.e.t.TomcatEmbeddedServletContainer : Tomcat started on port(s): 8080 (http)
2018-07-15 14:52:41.310  INFO 15496 --- [           main] c.l.l.s.chapter5.Chapter5Application     : Started Chapter5Application in 8.506 seconds (JVM running for 10.81)
2018-07-15 14:52:41.316  INFO 15496 --- [           main] c.l.l.s.chapter5.Chapter5Application     : 多环境应用启动.

还可以在**命令行方式**激活不同环境配置,如

java -jar xxx.jar --spring.profiles.active=test

此时就会加载application-test.properties的配置内容。?test:

这里顺便提一句,可能在不同环境下,可能加载不同的bean时,可利用@Profile注解来动态激活

@Profile("dev")//支持数组:@Profile({"dev","test"})
@Configuration
@Slf4j
public class ProfileBean {

    @PostConstruct
    public void init() {
        log.info("dev环境下激活");
    }    
}

启动时??刂铺ㄊ涑觯?/p>

2018-07-15 15:04:44.540  INFO 11876 --- [           main] c.l.l.springboot.chapter5.ProfileBean    : dev环境下激活

总结

目前互联网上很多大佬都有SpringBoot系列教程,如有雷同,请多多包涵了。本文是作者在电脑前一字一句敲的,每一步都是亲身实践过的。若文中有所错误之处,还望提出,谢谢。

相关文章

]]>
//www.zk5bt.cn/29368.html/feed 1
SpringBoot | 第四章 :日志管理 - Co. Ltd.四川快乐12 //www.zk5bt.cn/29363.html //www.zk5bt.cn/29363.html#comments Wed, 01 Aug 2018 01:39:50 +0000 TiuVe2 //www.zk5bt.cn/?p=29363 Spring Boot在所有内部日志中使用Commons Logging,但是默认配置也提供了对常用日志的支持,如:Java Util Logging,Log4J,?Log4J2Logback。每种Logger都可以通过配置使用控制台或者文件输出日志内容。

格式化日志

默认的日志输出如下:

2016-04-13 08:23:50.120  INFO 37397 --- [           main] org.hibernate.Version                    : HHH000412: Hibernate Core {4.3.11.Final}

输出内容元素具体如下:

  • 时间日期 — 精确到毫秒
  • 日志级别 — ERROR, WARN, INFO, DEBUG or TRACE
  • 进程ID
  • 分隔符 —?---?标识实际日志的开始
  • 线程名 — 方括号括起来(可能会截断控制台输出)
  • Logger名 — 通常使用源代码的类名
  • 日志内容

控制台输出

在Spring Boot中默认配置了ERROR、WARNINFO级别的日志输出到控制台。

我们可以通过两种方式切换至DEBUG级别:

  • 在运行命令后加入--debug标志,如:$ java -jar myapp.jar --debug
  • application.properties中配置debug=true,该属性置为true的时候,核心Logger(包含嵌入式容器、hibernate、spring)会输出更多内容,但是你自己应用的日志并不会输出为DEBUG级别。

多彩输出

如果你的终端支持ANSI,设置彩色输出会让日志更具可读性。通过在application.properties中设置spring.output.ansi.enabled参数来支持。

  • NEVER:禁用ANSI-colored输出(默认项)
  • DETECT:会检查终端是否支持ANSI,是的话就采用彩色输出(推荐项)
  • ALWAYS:总是使用ANSI-colored格式输出,若终端不支持的时候,会有很多干扰信息,不推荐使用

文件输出

Spring Boot默认配置只会输出到控制台,并不会记录到文件中,但是我们通常生产环境使用时都需要以文件方式记录。

若要增加文件输出,需要在application.properties中配置logging.filelogging.path属性。

  • logging.file,设置文件,可以是绝对路径,也可以是相对路径。如:logging.file=my.log
  • logging.path,设置目录,会在该目录下创建spring.log文件,并写入日志内容,如:logging.path=/var/log

日志文件会在10Mb大小的时候被截断,产生新的日志文件,默认级别为:ERROR、WARN、INFO

级别控制

在Spring Boot中只需要在application.properties中进行配置完成日志记录的级别控制。

配置格式:logging.level.*=LEVEL

  • logging.level:日志级别控制前缀,*为包名或Logger名
  • LEVEL:选项TRACE, DEBUG, INFO, WARN, ERROR, FATAL, OFF

举例:

  • logging.level.com.didispace=DEBUGcom.didispace包下所有class以DEBUG级别输出
  • logging.level.root=WARN:root日志以WARN级别输出

自定义日志配置

由于日志服务一般都在ApplicationContext创建前就初始化了,它并不是必须通过Spring的配置文件控制。因此通过系统属性和传统的Spring Boot外部配置文件依然可以很好的支持日志控制和管理。

根据不同的日志系统,你可以按如下规则组织配置文件名,就能被正确加载:

  • Logback:logback-spring.xml,?logback-spring.groovy,?logback.xml,?logback.groovy
  • Log4j:log4j-spring.properties,?log4j-spring.xml,?log4j.properties,?log4j.xml
  • Log4j2:log4j2-spring.xml,?log4j2.xml
  • JDK (Java Util Logging):logging.properties

Spring Boot官方推荐优先使用带有-spring的文件名作为你的日志配置(如使用logback-spring.xml,而不是logback.xml

自定义输出格式

在Spring Boot中可以通过在application.properties配置如下参数控制输出格式:

  • logging.pattern.console:定义输出到控制台的样式(不支持JDK Logger)
  • logging.pattern.file:定义输出到文件的样式(不支持JDK Logger)

相关文章

]]>
//www.zk5bt.cn/29363.html/feed 0
Java 动态代理及 RPC 框架介绍 - Co. Ltd.四川快乐12 //www.zk5bt.cn/29359.html //www.zk5bt.cn/29359.html#comments Wed, 01 Aug 2018 01:36:40 +0000 TiuVe2 //www.zk5bt.cn/?p=29359 所谓动态代理,指的是语言提供的一种语法,能够将对对象中不同方法的调用重定向到一个统一的处理函数中来。
python重写__getattr__函数能够做到这一点,就连世界上最好的语言也提供称为魔术方法的__call。
这种语法除了能更好的实现动态代理外,还是RPC框架实现原理的一部分。

快乐12必中5码的方法:1. 动态代理是什么

动态代理提供一种抽象,能够将对象中不同方法的调用重定向到一个统一的处理函数,做自定义的逻辑处理。
但是对于调用者,对此毫无察觉,就好像调用的方法是用传统方式实现的一般。

这种语法,在java中被称为动态代理。之所以叫做动态代理,是因为它能避免传统代理模式实现中人工一个一个的将java函数转发过去,
而是能够让代码自动做到这一点,这样代理类的代码是和业务无关的,不会因为业务类的方法增多而逐渐庞大。
使代码更易维护更易修改,实现自动化搬砖。

实际上,被代理的类不一定位于本机类,动态代理语法提供了一种抽象方式,被代理的类也可以位于远程主机上,这也是RPC框架实现原理的一部分。

理解了动态代理的概念后不难发现,动态代理概念上有着这么几个部分:

  1. 给调用者使用的代理类。在java中,我们发现动态代理提供的抽象天然契合面向接口编程,因此它也有可能是接口。
  2. 一个统一的处理函数,收集不同函数转发过来的请求,可自定义处理逻辑集中处理。java中它可能会成为一个较独立的部分,因此也可能是类。

2. java动态代理机制

理解了概念,就不难理解java动态代理的机制了。下面来看看java动态代理机制如何代理一个本地对象。

2.1. 代理接口

首先看第一个部分,给调用者使用的代理类。在java动态代理机制中,这个角色只能是接口。我们定义一个整数运算接口:

interface NumberOperationInterface {
    int add(int a, int b);
}

2.2. 代理处理器

再看第二个角色,统一的处理函数。在java中它的确是类,通过实现InvocationHandler接口定义。

class NumberOperationImpProxyHandler implements InvocationHandler {
    private Object proxied;
    public RealObjectProxyHandler(Object proxied) {
        this.proxied = proxied;
    }
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        System.out.printf("调用函数%s\n", method.getName());
        return method.invoke(proxied, args);
    }
}
  1. 由于我们的例子是代理本地对象,那么处理函数是需要被代理对象的信息??梢钥吹?,我们从构造函数中将被代理对象保存在该类中,即可从处理函数中访问到。
  2. invoke函数中,对代理对象的所有方法的调用都被转发至该函数处理。在这里可以灵活的自定义各种你能想到的逻辑。在上面的代码中,我们使用反射调用被代理对象的同名方法实现。

2.3. 被代理类

由于我们的示例是代理本地对象,因此还需要一个被代理对象的类:

class NumberOperationImp implements NumerOperationInterface {
    @Override
    public int add(int a, int b) {
        return a + b;
    }
}

2.4. 创建代理对象

好了,各个组成部分都定义完成。现在把它们组合起来:

public NumerOperationInterface wrap(NumerOperationInterface proxied) {
    return (NumerOperationInterface) Proxy.newProxyInstance(
        NumerOperationInterface.class.getClassLoader(),
        new Class[]{NumerOperationInterface.class},
        new NumberOperationImpProxyHandler(proxied));
}
  1. 由于java提供的这个写法实在是太啰嗦了,所以把它放入一个辅助函数中。
  2. Proxy.newProxyInstance?方法能够根据提供的接口和代理处理器创建代理对象。

java提供的写法太啰嗦了,可以考虑使用Guake提供的辅助函数简化下代码。如下:

public NumerOperationInterface wrap(NumerOperationInterface proxied) {
    return Reflection.newProxy(NumerOperationInterface.class, new NumberOperationImpProxyHandler(proxied));
}

好了,现在调用下试试:

NumerOperationInterface proxied = new NumberOperationImp();
real = wrap(proxied);
real.add(1, 2);

2.5. 总结

动态代理听起来是代理模式的动态实现,可是结合上面的最终效果,不觉得这个叫做动态装饰器更合适吗?

3. 动态代理的应用

说完了动态代理的概念和实现机制,该看看使用动态代理有哪些应用。

3.1. 应用一:代理模式/装饰器模式的动态实现

这个应用场景前面据已经提到过。
代理模式和装饰器模式是编程当中很常用的技巧,用于提升代码的灵活性和可扩展性。
传统代理模式的实现方式比较暴力直接,需要将所有被代理类的所有方法都写一遍,并且一个个的手动转发过去。
在维护被代理类的同时,作为java码工还需要同时维护代理类的相关代码,实在是累心。

通过使用动态代理,动态代理能够自动将代理类的相关方法转发到被代理类,可以看到:

  1. 代理转发的过程自动化了,实现自动化搬砖。
  2. 代理类的代码逻辑和具体业务逻辑解耦,与业务无关。

3.2. 应用二:实现AOP

是的,利用动态代理也能实现AOP。仔细推演一下不能得出这个结论。我们知道:

  1. 动态代理提供了一种方式,能够将分散的方法调用转发到一个统一的处理函数处理。
  2. AOP的实现需要能够提供这样一种机制,即在执行函数前和执行函数后都能执行自己定义的钩子。

那么,首先使用动态代理让代理类忠实的代理被代理类,然后处理函数中插入我们的自定义的钩子。
之后让代理类替换被代理类需要使用的场景,这样,相当于对该类的所有方法定义了一个切面。

不过,使用动态代理实现AOP特别麻烦,啰嗦。这仅仅作为一个探讨的思路,来说明动态代理这一通用概念可以实现很多特定技术。
实际使用中当然使用spring提供的AOP更为方便。

3.3. 应用三:实现RPC

RPC即远程过程调用,在分布式的网站架构中是一个非常重要的技术,目前现在流行的SOA架构,微服务架构,它们的核心原理之一就是RPC调用。

从概念上来说,RPC的概念是非常简洁优美的。RPC方法的调用和普通的方法并无二异,调用者不需要操心具体的实现,这是抽象提供的威力。
实现上,它将函数调用方和函数的提供方分散在两个不同的进程上,中间使用网络通信来进行数据交互。

动态代理就是实现RPC的技术之一。只要理解了动态代理和RPC,我们很容易发现这样一个事实:
RPC调用其实是对远程另外一台机器进程上的对象的代理。

仔细思考RPC调用的数据流流向,就能梳理出这样的思路:

  1. 调用方调用本地的RPC代理方法,将参数提供给该方法。
  2. 不同的RPC代理方法被转发到一个统一的处理中心,该处理中心知道调用的是那个函数,参数是什么。
  3. 该处理中心将调用的信息封装打包,通过网络发送给另外一个进程。
  4. 另外一个进程接受到调用进程发送过来的数据包。
  5. 该进程根据数据包中记录的RPC调用信息,将调用分发给对应的被代理对象的对应方法去执行。
  6. 返回的话思路类似。

显而易见,第二步,需要使用动态代理将分散的函数调用转发到一个统一的处理中心;第五步,将统一收集来的调用信息分发给具体的函数执行,显然使用反射做到这一点。
有了这个思路,通过利用动态代理,反射,和网络编程技术,实现一个简易版的RPC框架也就不难了。
考虑到本文是介绍动态代理的,关于RPC的细节实现有时间新开一篇博文分析。

4. 最后

总得来说,通过一定的思考,个人觉得动态代理的核心在于:将分散的对对象不同方法的调用转发到一个同一的处理函数中来。

有了这个关键点,很多其它技术的实现需要借助于动态代理的这一个关键点实现,也因此动态代理也有着这么多的应用。

相关文章

]]>
//www.zk5bt.cn/29359.html/feed 0
SpringBoot | 第三章:springboot配置详解 - Co. Ltd.四川快乐12 //www.zk5bt.cn/29352.html //www.zk5bt.cn/29352.html#comments Tue, 31 Jul 2018 22:00:23 +0000 唐尤华 //www.zk5bt.cn/?p=29352 基于springboot的约定优于配置的原则,在多数情况下,启动一个应用时,基本上无需做太多的配置,应用就能正常启动。但在大部分开发环境下,添加额外配置是无所避免的,比如自定义应用端口号(比较在机器比较少的情况下,一台机器还是需要部署多个应用的,当然利用docker的话,是可避免的,这是后话了)、mq的服务地址、缓存服务的服务地址、数据库的配置等,都或多或少的需要一些外部的配置项。

配置文件格式简要说明

springboot默认的全局配置文件名为application.properties或者application.yml(spring官方推荐使用的格式是.yml格式,目前官网都是实例都是使用yml格式进行配置讲解的),应用启动时会自动加载此文件,无需手动引入。除此之外还有一个bootstrap的全局文件,它的加载顺序在application配置文件之前,主要是用于在应用程序上下文的引导阶段,在后期讲解springCloudCofnig时,主要是利用此特性,进行配置文件的动态修改,在此不表,在通常情况下,此两个配置文件是没有差别的,所以一般上都只需要配置application即可。

自定义属性值

application.properties配置文件支持自定义属性的支持,比如

blog.address=https://blog.lqdev.cn
blog.author=oKong

然后可通过@Value("${blog.author}")的形式获取属性值。

@RestController
public class DemoController {

    @Value("${blog.address}")
    String address;

    @Value("${blog.author}")
    String author;

    @Value("${blog.desc}")    
    String desc;

    @RequestMapping("/")
    public String demo() {
        return desc;
    }
}

这里提醒下,在填写一些默认的比如,数据库属性时,可使用alt+/的方式,IDE会自动显示提示,避免了手动嵌入属性值或者忘记属性的尴尬。

关于自定义属性时,特别是一些公用包,会使用到属性值时,建议在创建additional-spring-configuration-metadata.json属性元文件,这样在使用上述快捷方式时,会进行提示,包括属性名和属性说明,这样也方便调用者询问属性名是啥。

相关configuration-metadata说明可查看:https://docs.spring.io/spring-boot/docs/current/reference/html/configuration-metadata.html

属性引用

在配置文件中,各个属性参数可进行引用的,比如:

blog.address=https://blog.lqdev.cn
blog.author=oKong
blog.desc=${blog.author},${blog.address}

最后blog.desc的值即可:oKong,https://blog.lqdev.cn。利用此特性,并可实现一些特殊的功能。比如后期讲解spring cloud时,注册eurka注册中心的实例名时,并会使用类似如下配置,使得实例名一眼就知道哪台服务地址:

eureka.instance.instance-id=${spring.cloud.client.ipAddress}:${server.port}

这里需要注意,由于springboot在读取properties文件时,使用的是PropertiesPropertySourceLoader类进行读取,默认读取的编码是ISO 8859-1,故在默认的配置文件中使用中文时,会出现乱码,此时可以将中文转成Unicode编码或者使用yml配置格式(默认就支持utf-8),再不济可以将作为配置写入到一个自定义配置文件,利用@PropertySource注解的encoding属性指定编码

随机数

Spring Boot的属性配置文件中可以通过${random}来产生int值、long值或者string字符串,来支持属性的随机值。

# 随机字符串
.blog.value=${random.value}
# 随机int
.blog.number=${random.int}
# 随机long
.blog.bignumber=${random.long}
# 10以内的随机数
.blog.test1=${random.int(10)}
# 1-20的随机数
.blog.test2=${random.int[1,20]}

自定义配置文件

在多数情况下,配置信息基本上都是放入application.properties文件中,但在一些场景下,比如某个配置项比较多时,为了分开存放,也可自定义配置文件,如my.properties。由于自定义的文件,系统不会自动加载,这个时候就需要手动引入了。 利用@PropertySource注解既可以引入配置文件,需要引入多个时,可使用@PropertySources设置数组,引入多个文件。

@SpringBootApplication
@PropertySource(value="classpath:my.properties",encoding="utf-8")
public class Chapter3Application {

    public static void main(String[] args) {
        SpringApplication.run(Chapter3Application.class, args);
    }
}

配置绑定对象

虽然使用@Value()方式,能方便的引入自定义的属性值,但在多某个配置项属于某一配置时,希望对应到一个实体配置类中,springboot也提供了支持。利用@ConfigurationProperties属性,即可完成 my.properties配置文件:

config.code=code
config.name=趔趄的猿
config.hobby[0]=看电影
config.hobby[1]=旅游

实体类:

@Component
//@EnableConfigurationProperties(value= {Config.class})
@ConfigurationProperties(prefix="config")
@Data
public class Config {

    String code;

    String name;

    List<String> hobby;
}

这里可直接加入@Component使其在启动时被自动扫描到,或者使用@EnableConfigurationProperties注解注册此实体bean. 其次,在引入@ConfigurationProperties时,IDE会提示你引入spring-boot-configuration-processor依赖,前面提到,在自定义属性时,创建additional-spring-configuration-metadata.json可进行属性提示,而此依赖功能类似,会编译时自动生成spring-configuration-metadata.json文件,此文件主要给IDE使用,用于提示使用。添加后在配置文件点击属性时,会自动跳转到对应绑定的实体类中

数组形式

配置了以下配置,然后利用List<String>就能获取hobby的值了。

config.code=code
config.name=趔趄的猿
config.hobby[0]=看电影
config.hobby[1]=旅游


相关文章

]]>
//www.zk5bt.cn/29352.html/feed 0
深入理解单例模式(下) - Co. Ltd.四川快乐12 //www.zk5bt.cn/29343.html //www.zk5bt.cn/29343.html#comments Tue, 31 Jul 2018 22:00:18 +0000 唐尤华 //www.zk5bt.cn/?p=29343 Effective Java》已经告诉我们,在单例类中提供一个readResolve方法就可以完成单例特性。这里大家可以自己去测试。

接下来,我们去看看Java提供的反序列化是如何创建对象的!

ObjectInputStream

对象的序列化过程通过ObjectOutputStream和ObjectInputputStream来实现的,那么带着刚刚的问题,分析一下ObjectInputputStream的readObject 方法执行情况到底是怎样的。

为了节省篇幅,这里给出ObjectInputStream的readObject的调用栈:

大家顺着此图的关系,去看readObject方法的实现。
首先进入readObject0方法里,关键代码如下:

switch (tc) {
    //省略部分代码

    case TC_STRING:
    case TC_LONGSTRING:
        return checkResolve(readString(unshared));

    case TC_ARRAY:
        return checkResolve(readArray(unshared));

    case TC_ENUM:
        return checkResolve(readEnum(unshared));

    case TC_OBJECT:
        return checkResolve(readOrdinaryObject(unshared));

    case TC_EXCEPTION:
        IOException ex = readFatalException();
        throw new WriteAbortedException("writing aborted", ex);

    case TC_BLOCKDATA:
    case TC_BLOCKDATALONG:
        if (oldMode) {
            bin.setBlockDataMode(true);
            bin.peek();             // force header read
            throw new OptionalDataException(
                bin.currentBlockRemaining());
        } else {
            throw new StreamCorruptedException(
                "unexpected block data");
        }

    //省略部分代码

这里就是判断目标对象的类型,不同类型执行不同的动作。我们的是个普通的Object对象,自然就是进入case TC_OBJECT的代码块中。然后进入readOrdinaryObject方法中。
readOrdinaryObject方法的代码片段:

private Object readOrdinaryObject(boolean unshared)
        throws IOException {
    //此处省略部分代码

    Object obj;
    try {
        obj = desc.isInstantiable() ? desc.newInstance() : null;
    } catch (Exception ex) {
        throw (IOException) new InvalidClassException(
            desc.forClass().getName(),
            "unable to create instance").initCause(ex);
    }

    //此处省略部分代码

    if (obj != null &&
        handles.lookupException(passHandle) == null &&
        desc.hasReadResolveMethod())
    {
        Object rep = desc.invokeReadResolve(obj);
        if (unshared && rep.getClass().isArray()) {
            rep = cloneArray(rep);
        }
        if (rep != obj) {
            handles.setObject(passHandle, obj = rep);
        }
    }

    return obj;
}

重点看代码块:

 Object obj;
 try {
      obj = desc.isInstantiable() ? desc.newInstance() : null;
  } catch (Exception ex) {
      throw (IOException) new InvalidClassException(
          desc.forClass().getName(),
          "unable to create instance").initCause(ex);
  }

这里创建的这个obj对象,就是本方法要返回的对象,也可以暂时理解为是ObjectInputStream的readObject返回的对象。

isInstantiable:如果一个serializable/externalizable的类可以在运行时被实例化,那么该方法就返回true。针对serializable和externalizable我会在其他文章中介绍。?
desc.newInstance:该方法通过反射的方式调用无参构造方法新建一个对象。

所以。到目前为止,也就可以解释,为什么序列化可以破坏单例了?即序列化会通过反射调用无参数的构造方法创建一个新的对象。

接下来再看,为什么在单例类中定义readResolve就可以解决该问题呢?还是在readOrdinaryObjec方法里继续往下看。

if (obj != null &&
            handles.lookupException(passHandle) == null &&
            desc.hasReadResolveMethod())
{
    Object rep = desc.invokeReadResolve(obj);
     if (unshared && rep.getClass().isArray()) {
         rep = cloneArray(rep);
     }
     if (rep != obj) {
         handles.setObject(passHandle, obj = rep);
     }
}

这段代码也很清楚地给出答案了!
如果目标类有readResolve方法,那就通过反射的方式调用要被反序列化的类的readResolve方法,返回一个对象,然后把这个新的对象复制给之前创建的obj(即最终返回的对象)。那readResolve?方法里是什么?就是直接返回我们的单例对象。

public class Elvis implements Serializable {
    public static final Elvis INSTANCE = new Elvis();

    private Elvis() { 
        System.err.println("Elvis Constructor is invoked!");
    }

    private Object readResolve() {
       return INSTANCE;
    }
}

所以,原理也就清楚了,主要在Singleton中定义readResolve方法,并在该方法中指定要返回的对象的生成策略,就可以防止单例被破坏。

单元素枚举类型

第三种实现单例的方式是,声明一个单元素的枚举类:

// Enum singleton - the preferred approach
public enum Elvis {
    INSTANCE;
    public void leaveTheBuilding() { ... }
}

这个方法跟提供公有的字段方法很类似,但它更简洁,提供天然的可序列化机制和能够强有力地保证不会出现多次实例化的情况 ,甚至面对复杂的序列化和反射的攻击下。这种方法可能看起来不太自然,但是拥有单元素的枚举类型可能是实现单例模式的最佳实践。注意,如果单例必须要继承一个父类而非枚举的情况下是无法使用该方式的(不过可以声明一个实现了接口的枚举)。
我们分析一下,枚举类型是如何阻止反射来创建实例的?直接源码:
看Constructor类的newInstance方法。

public T newInstance(Object ... initargs)
        throws InstantiationException, IllegalAccessException,
               IllegalArgumentException, InvocationTargetException
{
    if (!override) {
        if (!Reflection.quickCheckMemberAccess(clazz, modifiers)) {
            Class<?> caller = Reflection.getCallerClass();
            checkAccess(caller, clazz, null, modifiers);
        }
    }
    if ((clazz.getModifiers() & Modifier.ENUM) != 0)
        throw new IllegalArgumentException("Cannot reflectively create enum objects");
    ConstructorAccessor ca = constructorAccessor;   // read volatile
    if (ca == null) {
        ca = acquireConstructorAccessor();
    }
    @SuppressWarnings("unchecked")
    T inst = (T) ca.newInstance(initargs);
    return inst;
}

这行代码(clazz.getModifiers() & Modifier.ENUM) != 0?就是用来判断目标类是不是枚举类型,如果是抛出异常IllegalArgumentException("Cannot reflectively create enum objects"),无法通过反射创建枚举对象!很显然,反射无效了。

接下来,再看一下反序列化是如何预防的。依然按照上面说的顺序去找到枚举类型对应的readEnum方法,如下:

private Enum<?> readEnum(boolean unshared) throws IOException {
    if (bin.readByte() != TC_ENUM) {
        throw new InternalError();
    }

    ObjectStreamClass desc = readClassDesc(false);
    if (!desc.isEnum()) {
        throw new InvalidClassException("non-enum class: " + desc);
    }

    int enumHandle = handles.assign(unshared ? unsharedMarker : null);
    ClassNotFoundException resolveEx = desc.getResolveException();
    if (resolveEx != null) {
        handles.markException(enumHandle, resolveEx);
    }

    String name = readString(false);
    Enum<?> result = null;
    Class<?> cl = desc.forClass();
    if (cl != null) {
        try {
            @SuppressWarnings("unchecked")
            Enum<?> en = Enum.valueOf((Class)cl, name);
            result = en;
        } catch (IllegalArgumentException ex) {
            throw (IOException) new InvalidObjectException(
                "enum constant " + name + " does not exist in " +
                cl).initCause(ex);
        }
        if (!unshared) {
            handles.setObject(enumHandle, result);
        }
    }

    handles.finish(enumHandle);
    passHandle = enumHandle;
    return result;
}

readString(false):首先获取到枚举对象的名称name。
Enum<?> en = Enum.valueOf((Class)cl, name):再指定名称的指定枚举类型获得枚举常量,由于枚举中的name是唯一,切对应一个枚举常量。所以我们获取到了唯一的常量对象。这样就没有创建新的对象,维护了单例属性。

看看Enum.valueOf?的JavaDoc文档:

  • 返回具有指定名称的指定枚举类型的枚举常量。?该名称必须与用于声明此类型中的枚举常量的标识符完全匹配。 (不允许使用无关的空白字符。)

具体实现:

public static <T extends Enum<T>> T valueOf(Class<T> enumType,
                                                String name) {
        T result = enumType.enumConstantDirectory().get(name);
        if (result != null)
            return result;
        if (name == null)
            throw new NullPointerException("Name is null");
        throw new IllegalArgumentException(
            "No enum constant " + enumType.getCanonicalName() + "." + name);
    }

enumConstantDirectory():返回一个Map,维护着名称到枚举常量的映射。我们就是从这个Map里获取已经声明的枚举常量,通过这个缓存池一样的组件,让我们可以重用这个枚举常量!

总结

  1. 常见的单例写法有他的弊端,存在安全性问题,如:反射,序列化的影响。
  2. 《Effective Java》作者Josh Bloch 提倡使用单元素枚举类型的方式来实现单例,首先创建一个枚举很简单,其次枚举常量是线程安全的,最后有天然的可序列化机制和防反射的机制。

参考

相关文章

]]>
//www.zk5bt.cn/29343.html/feed 1
深入理解单例模式(上) - Co. Ltd.四川快乐12 //www.zk5bt.cn/29338.html //www.zk5bt.cn/29338.html#comments Tue, 31 Jul 2018 01:20:33 +0000 唐尤华 //www.zk5bt.cn/?p=29338 最近在阅读《Effective Java 》这本书,第3个条款专门提到了单例属性,并给出了使用单例的最佳实践建议。让我对这个单例模式(原本我以为是设计模式中最简单的一种)有了更深的认识。

单例模式

单例模式(Singleton Pattern)是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。

在应用这个模式时,单例对象的类必须保证只有一个实例存在。许多时候整个系统只需要拥有一个的全局对象,这样有利于我们协调系统整体的行为。

单例的特点

  1. 单例类只能有一个实例。
  2. 单例类必须自己创建自己的唯一实例。
  3. 单例类必须给所有其他对象提供这一实例。

单例模式的7种写法

单例模式的写法很多,涉及到了线程安全和性能问题。在这里我不重复介绍。这篇《单例模式的七种写法》写得很详细,博主也给出了每一种写法的优缺点。

但是,单例模式真的能够实现实例的唯一性吗?答案是否定的。

如何破坏单例

反射

有两种常见的方式来实现单例。他们的做法都是将构造方法设为私有,并导出一个公有的静态成员来提供对唯一实例的访问。在第1种方式中,成员是个final字段:

// Singleton with public final field
public class Elvis {
    public static final Elvis INSTANCE = new Elvis();
    private Elvis() { ... }
    public void leaveTheBuilding() { ... }
}

只调用私有构造函数一次,以初始化公共静态final字段elvi.instance。不提供公有的或者受?;さ墓乖旌Vち巳治ㄒ恍裕旱盓lvis类初始化的时候,仅仅只会有一个Elvis实例存在——不多也不少 。无论客户端怎么做都无法改变这一点,只不过我还是要警告一下 :授权的客户端可以通过反射来调用私有构造方法,借助于AccessibleObject.setAccessible方法即可做到 。如果需要防范这种攻击,请修改构造函数,使其在被要求创建第二个实例时抛出异常。

测试代码:

public class TestSingleton {

    /**
     * 通过反射破坏单例
     */
    @Test
    public void testReflection() throws Exception {
        /**
         * 验证单例有效性
         */
        Elvis elvis1 = Elvis.INSTANCE;
        Elvis elvis2 = Elvis.INSTANCE;

        System.out.println("elvis1 == elvis2 ? ===>" + (elvis1 == elvis2));
        System.err.println("-----------------");

        /**
         * 反射调用构造方法
         */
        Class clazz = Elvis.class;
        Constructor cons = clazz.getDeclaredConstructor(null); 
        cons.setAccessible(true);

        Elvis elvis3 = (Elvis) cons.newInstance(null);

        System.out.println("elvis1 == elvis3 ? ===> "
            + (elvis1 == elvis3));
    }
}

运行结果:

Elvis Constructor is invoked!
elvis1 == elvis2 ? ===> true
elvis1 == elvis3 ? ===> false
-----------------
Elvis Constructor is invoked!

结论:

反射是可以破坏单例属性的。因为我们通过反射把它的构造函数设成可访问的,然后去生成一个新的对象。

改进版的单例写法:

public class Elvis {
    public static final Elvis INSTANCE = new Elvis();

    private Elvis() { 
        System.err.println("Elvis Constructor is invoked!");
        if (INSTANCE != null) {
            System.err.println("实例已存在,无法初始化!");
            throw new UnsupportedOperationException("实例已存在,无法初始化!");
        }
    }

}

结果:

Elvis Constructor is invoked!
elvis1 == elvis2 ? ===> true
-----------------
Elvis Constructor is invoked!
实例已存在,无法初始化!

第2种实现单例模式的方法是,提供一个公有的静态工厂方法:

// Singleton with static factory
public class Elvis {
    private static final Elvis INSTANCE = new Elvis();
    private Elvis() { ... }
    public static Elvis getInstance() { return INSTANCE; }
    public void leaveTheBuilding() { ... }
}

所有调用Elvis类的getInstance方法,返回相同的对象引用,并且不会有其它的Elvis对象被创建。但同样有上面第1个方法提到的反射破坏单例属性的问题存在。

序列化和反序列化

如果对上述2种方式实现的单例类进行序列化,反序列化得到的对象是否是同一个对象呢?答案是否定的。
看下面的测试代码:
单例类:

public class Elvis implements Serializable {
    public static final Elvis INSTANCE = new Elvis();

    private Elvis() { 
        System.err.println("Elvis Constructor is invoked!");
    }

}

测试代码:

    /**
     * 序列化对单例属性的影响
     * @throws Exception 
     */
    @Test
    public void testSerialization() throws Exception {
        Elvis elvis1 = Elvis.INSTANCE;
        FileOutputStream fos = new FileOutputStream("a.txt");
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(elvis1);
        oos.flush();
        oos.close();

        Elvis elvis2 = null;
        FileInputStream fis = new FileInputStream("a.txt");
        ObjectInputStream ois = new ObjectInputStream(fis);
        elvis2 = (Elvis) ois.readObject();

        System.out.println("elvis1 == elvis2 ? ===>" + (elvis1 == elvis2));
    }

结果是:

Elvis Constructor is invoked! 
elvis1 == elvis2 ? ===>false

说明:

通过对序列化后的Elvis 进行反序列化得到的对象是一个新的对象,这就破坏了Elvis 的单例性。

相关文章

]]>
//www.zk5bt.cn/29338.html/feed 0
MYSQL事务隔离级别 - Co. Ltd.四川快乐12 //www.zk5bt.cn/29321.html //www.zk5bt.cn/29321.html#comments Mon, 30 Jul 2018 07:09:12 +0000 唐尤华 //www.zk5bt.cn/?p=29321 本文会根据实际工作中碰到的例子,梳理清楚数据库事务的隔离级别。内容很简单,如果你能静下心来看完,一定会对你理解隔离级别有很大的帮助。

想象一个场景。抽奖,如果用户中奖了,一般有如下几个流程:

  • 扣减奖品数量;
  • 记录用户中奖信息;
  • 试想如果扣减奖品数量了,结果记录用户中奖数据的时候失败了,那么数据就会出现不一致的问题。

这种场景,就可以使用事务。因为事务的一个特性,就是原子性:要么不做,要么全做。

上述问题解决了。再想一下这样的场景:
在抽奖前,先查询奖品剩余数量,如果剩余数量<1,则任务抽奖活动已经结束,不再进行抽奖。如果事务A扣减奖品数量但未提交,事务B查询剩余奖品数量,此时应该是多少呢?这就和事务的隔离级别有关系了。

在讨论隔离级别前,我们先做一些数据库的初始化操作:

建表:

CREATE TABLE `Tran_test` (
  `id` bigint(20) NOT NULL,
  `userId` bigint(20) NOT NULL DEFAULT '0',
  `weChatId` varchar(50) NOT NULL DEFAULT '' COMMENT '微信id(openId、uninId)',
  `orderId` bigint(20) NOT NULL DEFAULT '0' COMMENT '商城订单id',
  `count` bigint(10) DEFAULT NULL,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8

初始化1个奖品:

insert into Tran_test (id,count) values(1,1)

未提交读

事务中的修改,即使没有提交,也会被其他事务读取。

下面通过mysql演示:

设置隔离级别为为提交读:

SET GLOBAL TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;

可以看到,事务B读取到了事务A未提交的数据,它任务抽奖活动已经结束。但如果此时事务A回滚,count仍然为1,则活动实际是未结束的,这就是脏读。因此,实际中,一般不会采用这种隔离级别。

提交读

提交读隔离级别可以解决上述脏读问题,其只能读到其他事务已经提交的数据。

更改数据库隔离级别:

SET GLOBAL TRANSACTION ISOLATION LEVEL READ COMMITTED;

可以看到,在事务A提交前的改动,事务B是读取不到的。只有A事务提交后,B才能读取到事务A的改动。

我们看到,在事务B中,先后两次读取,count的值是不一样的,这就是不可重复读。而可重复读隔离级别可以解决这个问题。

可重复读

更改数据库隔离级别:

SET GLOBAL TRANSACTION ISOLATION LEVEL REPEATABLE READ;

可以看到,不论事务A是否提交,事务B读到的count值都是不变的。这就是可重复读。

除了上面提到的脏读、不可重复读,还有一种情况是幻读:在事务中,前后两次查询,记录数量是不一样的。

比如事务B是事务A插入一条记录的前后执行查询,会发现相同的查询条件,查出来的记录数不一样。由于mysql的RR(可重复读)一并解决了幻读的问题,所以我们直接看上述场景,在mysql中的表现:

可见,在事务A提交前后,事务B查询的结果数量是一直的,并没有出现幻读的情况。

一点思考

下面默认都是讨论的msyql RR隔离级别的情况。

如果两个用户同时抽奖,而且同时中奖。两者都进入了中奖的事务。A事务扣减了奖品数量,B也执行了扣减数量。假设奖品数量是N,如果是可重复读,那么,如果两个事务并行进行,那么不论A有没有提交,B读到的数量都是N,执行后为N-1,而事务A也是N-1,这样不就有问题了吗?我们期望的是N-2。

当初这个问题让我很困惑。这反应了当时我对数据库锁和快照读、当前读两个知识点的欠缺。

快照读、当前读

将设事务A已经提交,由于是可重复读,那事务B读到的奖品数量一致是N,执行-1,数据变成N-1,而不是我们期望的N-2。

如果理解了快照读和当前读的概念,上面的困惑就不会存在了。

在事务中,执行普通select查询之后,会创建快照,后面再执行相同的select语句时,查询的其实是前面生成的快照。这也就是为什么会有可重复读。

而如果执行

select * from table where ? lock in share mode;
select * from table where ? for update;
insert into table values (…); 
update table set ? where ?; 
delete from table where ?;

会执行当前读,获取最新数据?;氐角懊娴奈侍?,如果事务B执行N-1操作,会触发当前读,读取事务A提交后的数据,也就是N-1,在此基础上执行-1操作,最终N变成N-2。

并发更新

上面解决了事务A已经提交的额情况。但如果事务A更新奖品数量后但还未提交呢?此时事务B执行当前读拿到的也是N啊。了解数据库锁机制的话,就不会有这种困惑了。事务A提交前,会一直持有排他锁(具体是行锁还是表锁,要看查询条件有没有走索引),此时事务B更新是会阻塞的。也就是说,只有事务A提交,或回滚之后,事务B才能获得排它锁,从而进行更新奖品的操作。

关于数据库的锁,大家可以参考这篇文章://hedengcheng.com/?p=771

相关文章

]]>
//www.zk5bt.cn/29321.html/feed 0
JVM面试题 - Co. Ltd.四川快乐12 //www.zk5bt.cn/29299.html //www.zk5bt.cn/29299.html#comments Mon, 30 Jul 2018 06:55:51 +0000 唐尤华 //www.zk5bt.cn/?p=29299 1、你知道哪些或者你们线上使?什么GC策略?它有什么优势,适?于什么场景?

参考?触发JVM进行Full GC的情况及应对策略。

2、Java类加载器包括?种?它们之间的??关系是怎么样的?双亲委派机制是什么意思?有什么好处?

启动Bootstrap类加载、扩展Extension类加载、系统System类加载。

父子关系如下:

  • 启动类加载器 ,由C++ 实现,没有父类;
  • 扩展类加载器,由Java语言实现,父类加载器为null;
  • 系统类加载器,由Java语言实现,父类加载器为扩展类加载器;
  • 自定义类加载器,父类加载器肯定为AppClassLoader。

双亲委派机制:类加载器收到类加载请求,自己不加载,向上委托给父类加载,父类加载不了,再自己加载。
优势避免Java核心API篡改。详细查看:深入理解Java类加载器(ClassLoader)

3、如何?定义?个类加载器?你使?过哪些或者你在什么场景下需要?个?定义的类加载器吗?

自定义类加载的意义:

  1. 加载特定路径的class文件
  2. 加载一个加密的网络class文件
  3. 热部署加载class文件

4、堆内存设置的参数是什么?

  • -Xmx 设置堆的最大空间大小
  • -Xms 设置堆的最小空间大小

5、Perm Space中保存什么数据?会引起OutOfMemory吗?

加载class文件。

会引起,出现异??梢陨柚?-XX:PermSize 的大小。JDK 1.8后,字符串常量不存放在永久带,而是在堆内存中,JDK8以后没有永久代概念,而是用元空间替代,元空间不存在虚拟机中,二是使用本地内存。

详细查看Java8内存模型—永久代(PermGen)和元空间(Metaspace)

6、做GC时,?个对象在内存各个Space中被移动的顺序是什么?

标记清除法,复制算法,标记整理、分代算法。

新生代一般采用复制算法 GC,老年代使用标记整理算法。
垃圾收集器:串行新生代收集器、串行老生代收集器、并行新生代收集器、并行老年代收集器。
CMS(Current Mark Sweep)收集器是一种以获取最短回收停顿时间为目标的收集器,它是一种并发收集器,采用的是Mark-Sweep算法。

详见?Java GC机制。

7、你有没有遇到过OutOfMemory问题?你是怎么来处理这个问题的?处理 过程中有哪些收获?

permgen space、heap space 错误。

常见的原因

  • 内存加载的数据量太大:一次性从数据库取太多数据;
  • 集合类中有对对象的引用,使用后未清空,GC不能进行回收;
  • 代码中存在循环产生过多的重复对象;
  • 启动参数堆内存值小。

详见?Java 内存溢出(java.lang.OutOfMemoryError)的常见情况和处理方式总结。

8、JDK 1.8之后Perm Space有哪些变动? MetaSpace??默认是?限的么? 还是你们会通过什么?式来指定???

JDK 1.8后用元空间替代了 Perm Space;字符串常量存放到堆内存中。

MetaSpace大小默认没有限制,一般根据系统内存的大小。JVM会动态改变此值。

  • -XX:MetaspaceSize:分配给类元数据空间(以字节计)的初始大?。∣racle逻辑存储上的初始高水位,the initial high-water-mark)。此值为估计值,MetaspaceSize的值设置的过大会延长垃圾回收时间。垃圾回收过后,引起下一次垃圾回收的类元数据空间的大小可能会变大。
  • -XX:MaxMetaspaceSize:分配给类元数据空间的最大值,超过此值就会触发Full GC,此值默认没有限制,但应取决于系统内存的大小。JVM会动态地改变此值。

9、jstack 是?什么的? jstat 呢?如果线上程序周期性地出现卡顿,你怀疑可 能是 GC 导致的,你会怎么来排查这个问题?线程?志?般你会看其中的什么 部分?

jstack 用来查询 Java 进程的堆栈信息。

jvisualvm 监控内存泄露,跟踪垃圾回收、执行时内存、cpu分析、线程分析。

详见Java jvisualvm简要说明,可参考?线上FullGC频繁的排查。

10、StackOverflow异常有没有遇到过??般你猜测会在什么情况下被触发?如何指定?个线程的堆栈????般你们写多少?

栈内存溢出,一般由栈内存的局部变量过爆了,导致内存溢出。出现在递归方法,参数个数过多,递归过深,递归没有出口。

答案如有不正确,还请各位指正。

可能感兴趣的文章

]]>
//www.zk5bt.cn/29299.html/feed 0
深入 Spring Boot:编写兼容 Spring Boot1 和 Spring Boot2 的 Starter - Co. Ltd.四川快乐12 //www.zk5bt.cn/29294.html //www.zk5bt.cn/29294.html#comments Sun, 29 Jul 2018 05:02:32 +0000 TiuVe2 //www.zk5bt.cn/?p=29294 前言

Spring Boot 2正式发布已经有段时间,应用升级之前,starter先要升级,那么如何支持Spring Boot 2?

为什么选择starter同时兼容spring boot 1和spring boot 2

从用户角度来看

如果不在一个starter里兼容,比如用版本号来区分,spring boot 1的用户使用1.*,spring boot 2用户使用2.*,这样用户升级会有很大困扰。

另外,我们的starter是以日期为版本号的,如果再分化,则就会出现2018-06-stable-boot1,2018-06-stable-boot2,这样子很丑陋。

从开发者角度来看

要同时维护两个分支,修改代码时要合到两个分支上,发版本时要同时两个。如果有统一的bom文件,也需要维护两份。工作量翻倍,而且很容易出错。

因此,我们决定在同一个代码分支里,同时支持spring boot 1/2。减少开发维护成本,减少用户使用困扰。

编写兼容的starter的难点

spring boot starter的代码入口都是在各种@Configuration类里,这为我们编写兼容starter提供了条件。

但还是有一些难点:

  • 某些类不兼容,比如在spring boot 2里删除掉了
  • 代码???,maven依赖怎样组织
  • 怎样保证starter在spring boot 1/2里都能正常工作

通过ASM分析现有的starter里不兼容的类

springboot-classchecker可以从jar包里扫描出哪些类在spring boot 2里不存在的。

工作原理:springboot-classchecker自身在pom.xml里依赖的是spring boot 2,扫描jar包里通过ASM分析到所有的String,提取出类名之后,再尝试在ClassLoader里加载,如果加载不到,则说明这个类在spring boot 2里不存在。

例如扫描demo-springboot1-starter.jar?:

mvn clean package
java -jar target/classchecker-0.0.1-SNAPSHOT.jar demo-springboot1-starter.jar

结果是:

path: demo-springboot1-starter.jar
org.springframework.boot.actuate.autoconfigure.ConditionalOnEnabledHealthIndicator
org.springframework.boot.actuate.autoconfigure.EndpointAutoConfiguration
org.springframework.boot.actuate.autoconfigure.HealthIndicatorAutoConfiguration

那么这些类在spring boot 2在哪里了?

实际上是改了package:

org.springframework.boot.actuate.autoconfigure.health.ConditionalOnEnabledHealthIndicator
org.springframework.boot.actuate.autoconfigure.endpoint.EndpointAutoConfiguration
org.springframework.boot.actuate.autoconfigure.health.HealthIndicatorAutoConfiguration

通过扫描20多个starter jar包,发现不兼容的类有:

  • org.springframework.boot.env.PropertySourcesLoader
  • org.springframework.boot.autoconfigure.jdbc.DataSourceBuilder
  • org.springframework.boot.bind.RelaxedDataBinder
  • Endpoint/HealthIndicator 相关的类

可以总结:

  • spring boot核心的类,autoconfigure相关的没有改动
  • 大部分修改的是Endpoint/HealthIndicator 相关的类

spring-boot-utils兼容工具类

spring-boot-utils提供兼容工具类,同时支持spring boot 1/2。

BinderUtils

在spring boot 1里,注入环境变量有时需要用到RelaxedDataBinder

MyProperties myProperties = new MyProperties();
MutablePropertySources propertySources = environment.getPropertySources();
new RelaxedDataBinder(myProperties, "spring.my").bind(new PropertySourcesPropertyValues(propertySources));

在spring boot 2里,RelaxedDataBinder删除掉了,新的写法是用Binder

Binder binder = Binder.get(environment);
MyProperties myProperties = binder.bind("spring.my", MyProperties.class).get();

通过BinderUtils,则可以同时支持spring boot1/2:

MyProperties myProperties = BinderUtils.bind(environment, "spring.my", MyProperties.class);

@ConditionalOnSpringBoot1/@ConditionalOnSpringBoot2

spring boot starter的功能大部分都是通过@Configuration组装起来的。spring boot 1的Configuration类,不能在spring boot 2里启用。则可以通过@ConditionalOnSpringBoot1,@ConditionalOnSpringBoot2这两个注解来分别支持。

其实原理很简单,判断spring boot 1/2里各自有的存在的类就可以了。

@ConditionalOnClass(name = "org.springframework.boot.bind.RelaxedDataBinder")
public @interface ConditionalOnSpringBoot1 {
}
@ConditionalOnClass(name = "org.springframework.boot.context.properties.bind.Binder")
public @interface ConditionalOnSpringBoot2 {
}

Starter代码??樽橹?/h2>

下面以实际的一个starter来说明。

spring boot web应用的mappings信息,可以在/mappings?endpoint查询到。但是这么多endpoint,它们都提供了哪些url?

endpoints-spring-boot-starter的功能是展示所有endpoints的url mappings信息

endpoints-spring-boot-starter里需要给spring boot 1/2同时提供endpoint功能,代码??槿缦拢?/p>

endpoints-spring-boot-starter
|__ endpoints-spring-boot-autoconfigure1
|__ endpoints-spring-boot-autoconfigure2
  • endpoints-spring-boot-autoconfigure1??樵趐om.xml里依赖的是spring boot 1相关的jar,并且都设置为<optional>true</optional>
  • endpoints-spring-boot-autoconfigure2的配置类似
  • endpoints-spring-boot-starter依赖autoconfigure1 和 autoconfigure2
  • 如果有公共的逻辑,可以增加一个commons???/li>

Endpoint兼容

以 endpoints-spring-boot-autoconfigure1??槲得髟跹?。

EndPointsEndPoint类继承自spring boot 1的AbstractMvcEndpoint

@ConfigurationProperties("endpoints.endpoints")
public class EndPointsEndPoint extends AbstractMvcEndpoint {

通过@ManagementContextConfiguration引入

@ManagementContextConfiguration
public class EndPointsEndPointManagementContextConfiguration {

    @Bean
    @ConditionalOnMissingBean
    @ConditionalOnEnabledEndpoint("endpoints")
    public EndPointsEndPoint EndPointsEndPoint() {
        EndPointsEndPoint endPointsEndPoint = new EndPointsEndPoint();
        return endPointsEndPoint;
    }

}

在META-INF/resources/spring.factories里配置

org.springframework.boot.actuate.autoconfigure.ManagementContextConfiguration=\
io.github.hengyunabc.endpoints.autoconfigure1.EndPointsEndPointManagementContextConfiguration

因为org.springframework.boot.actuate.autoconfigure.ManagementContextConfiguration是只在spring boot 1里,在spring boot 2的应用里不会加载它,所以autoconfigure1??樘烊患嫒輘pring boot 2。

那么类似的,autoconfigure2??槔镌?code>META-INF/resources/spring.factories配置的是

org.springframework.boot.actuate.autoconfigure.web.ManagementContextConfiguration=\
io.github.hengyunabc.endpoints.autoconfigure2.ManagementApplicationcontextHolderConfiguration

仔细对比,可以发现是spring boot 2下面修改了ManagementContextConfiguration的包名,所以对于Endpoint天然是兼容的,不同的??樽约罕嘁锞涂梢粤?。

HealthIndicator的兼容

类似Endpoint的处理,spring boot 1/2的代码分别放不同的autoconfigure??槔?,然后各自的@Configuration类分别使用@ConditionalOnSpringBoot1/@ConditionalOnSpringBoot2来判断。

通过集成测试保证兼容性

还是以endpoints-spring-boot-autoconfigure1??槲?。

这个??槭俏猻pring boot 1准备的,则它的集成测试要配置为spring boot 2。

参考相关的代码:查看

  • springboot2demo/pom.xml里依赖spring boot 2
  • verify.groovy里检测应用是否启动成功

总结

  • 通过ASM分析现有的starter里不兼容的类
  • 配置注入通过BinderUtils解决
  • 各自的@Configuration类分别用@ConditionalOnSpringBoot1/@ConditionalOnSpringBoot2来判断
  • 代码分??椋篶ommons放公共逻辑, autoconfigure1/autoconfigure2 对应 spring boot 1/2的自动装配,starter给应用依赖
  • Endpoint的Configuration入口是ManagementContextConfiguration,因为spring boot 2里修改了package,所以直接在spring.factories里配置即可
  • 通过集成测试保证兼容性
  • 如果某一天,不再需要支持spring boot 1了,则直接把autoconfigure1??槿サ艏纯?/li>

链接

相关文章

]]>
//www.zk5bt.cn/29294.html/feed 0
SQL Server 与 MySQL 中排序规则与字符集相关知识的一点总结 - Co. Ltd.四川快乐12 //www.zk5bt.cn/29284.html //www.zk5bt.cn/29284.html#comments Sun, 29 Jul 2018 04:22:03 +0000 TiuVe2 //www.zk5bt.cn/?p=29284 字符集&&排序规则

字符集是针对不同语言的字符编码的集合,比如UTF-8字符集,GBK字符集,GB2312字符集等等,不同的字符集使用不同的规则给字符进行编码。排序规则则是在特定字符集的基础上特定的字符排序方式,排序规则是基于字符集的,是对字符集在排序方式维度上的一个划分。

排序规则是依赖于字符集的,一种字符集可以有多种排序规则,但是一种排序规则只能基于某一种字符集的,比如中文字符集,也即汉字,可以按照“拼音排序”、“按姓氏笔划排序”等等。而对于英语,就没有“拼音”和“姓氏笔画”,但是可以分为区分大小写、不区分大小写等等,而其他语言下面也有自己特定的排序规则。

在SQL Server中,任何一种字符集的数据库,都能存储任何一种语言的字符。

并不是说拉?。↙atin)字符集的数据就存储不了中文,中文(Chinese)字符集的数据库就存储不了蒙古语(只要操作系统本身支持)。sqlserver中,不管哪种字符集(实际上是排序规则)的数据库(或者字段),都是可以使用nvarchar(或者nchar),而nvarchar(或者nchar)是可以存储任意非Unicode字符的。至于排序规则,那是根据不同的字符集所支持的不同的排序规则人为定义的。

SQL Server中的字符集和排序规则

排序规则只不过是指定了存储的数据的排序(比较)规则而已,换句话说就是,排序规则中已经包含了字符集的信息。因此在sqlserver中 ,不需要关心字符集,只需要关心排序规则,sqlserver中在创建只能指定排序规则(不能直接指定字符集),如截图,只能指定collation,也就是字符集

?

在MySQL中的字符集和排序规则

上面说了,排序规则是依赖于字符集的,一种字符集可以有多种排序规则,但是一种排序规则只能基于某一种字符集的。如下是MySQL中排序规则和字符集的对应关系。

MySQL的建库语法比较扯,可以指定字符集和排序规则,如果指定的排序规则在字符集的下面,则是没有问题的,如果指定的排序规则不在字符集下面,则会报错。

比如下面这一句,排序规则utf8_bin是属于字符集utf8下面的一种排序规则,这个语句执行是没有问题的
create database test_database2 charset utf8 collate utf8_bin;
再比如下面这一句,排序规则latin1_bin不是属于字符集utf8下面的一种排序规则,这个语句执行是会报错的
create database test_database2 charset utf8 collate latin1_bin;

以上是字符集和排序规则在sqlserver和MySQL中的一些基本应用,再说说常用的排序规则的区别

***_genera_ci & ***_genera_cs & ***_bin 常见排序规则的特点

以上是某种字符集下常用的三种排序规则,下面以常见的utf8为例说明。

  • utf8_genera_ci不区分大小写,ci为case insensitive的缩写,即大小写不敏感,
  • utf8_general_cs区分大小写,cs为case sensitive的缩写,即大小写敏感,但是目前MySQL版本中已经不支持类似于***_genera_cs的排序规则,直接使用utf8_bin替代。
  • utf8_bin将字符串中的每一个字符用二进制数据存储,区分大小写。

那么,同样是区分大小写,utf8_general_cs和utf8_bin有什么区别?

  • cs为case sensitive的缩写,即大小写敏感;bin的意思是二进制,也就是二进制编码比较。
  • utf8_general_cs排序规则下,即便是区分了大小写,但是某些西欧的字符和拉丁字符是不区分的,比如?=a,但是有时并不需要?=a,所以才有utf8_bin
  • utf8_bin的特点在于使用字符的二进制的编码进行运算,任何不同的二进制编码都是不同的,因此在utf8_bin排序规则下:?<>a

在utf8_genera_ci的情况下A=a,?=a

?

在utf8_bin排序规则下,A<>a,?<>a

所以要想区分大小写,有没有特殊需求,就直接使用utf8_bin(实际上***_general_cs在MySQL中本身就不支持,在SQL Server中支持)。以上字符集的特点以及使用情况在SQL Server中表现为类似。

相关文章

]]>
//www.zk5bt.cn/29284.html/feed 0
  • 送你一份时代天街附近必吃的火锅名单 2018-12-11
  • 施艾珠:统战工作更有底气和定力了 2018-12-09
  • 山东搭建“灯塔—党建在线”网络平台 2018-12-06
  • 端午假期扫尾 粽子价格大跳水 2018-12-04
  • 比亚迪秦EV450 稳居北京市占率第一 2018-12-03
  • 第二届未来汽车大会暨日照新能源汽车人才与产业峰会在日照举办 2018-12-03
  • 运城市两部微电影喜获全国奖 2018-11-28
  • [微笑]所谓的卖地,表面上卖的是土地,实际上卖的是关联资源!这就是为什么同样面积的土地处于不同的城市不同的地段,价值可以有云泥之别的原因。 2018-11-28
  • 【大考2018】2018高考首日众生相(组图) 2018-11-21
  • 昌吉州:让绿色成为生态底色发展主色 2018-11-21
  • 河北遵化清东陵打响景区环境提升攻坚战 2018-11-18
  • 河北馆陶:端午节火了“艾旅游” 2018-11-18
  • 媒体人:姚文智“起风了” 民进党雪崩式危机开始了 2018-11-17
  • 变相“现金贷”重出江湖 利率畸高个别超过1000% 2018-11-17
  • 马英九出席佛教祈福活动用喇叭高喊:“两岸和平 台湾繁荣” 2018-11-16