JNI Kickstart 小结 01

原创
自由狼-台风
日志 / 检查单
2015/04/23 15:12
阅读数 200

JNI 程序小结 01

Java + JNI 本地库 异构程序构建示例。
下文 (加强版) ： http://my.oschina.net/typhoon/blog/470904

  1. 创建 Java 源代码文件：

    [typhoon@TFW-CENT6-LT sandbox]$ mkdir -p src/tfw/rsch/jni
    [typhoon@TFW-CENT6-LT sandbox]$ ls
    0_guide.txt  src
    [typhoon@TFW-CENT6-LT sandbox]$ vi src/tfw/rsch/jni/Main.java
    [typhoon@TFW-CENT6-LT sandbox]$ vi src/tfw/rsch/jni/JniLoader.java
    [typhoon@TFW-CENT6-LT sandbox]$ vi src/tfw/rsch/jni/JniCall.java
    [typhoon@TFW-CENT6-LT sandbox]$ vi src/tfw/rsch/jni/JniCall_02.java
    [typhoon@TFW-CENT6-LT sandbox]$ ls src/tfw/rsch/jni
    JniCall_02.java  JniCall.java  JniLoader.java  Main.java
    [typhoon@TFW-CENT6-LT sandbox]$

    文件内容明细：
     
    1. src/tfw/rsch/jni/Main.java 
      /**
 * ...<br />
 */
package tfw.rsch.jni;

import tfw.base.util.array.ArrayToolE;
import tfw.base.util.text.TextToolE;

/**
 * 启动类，启动整个程序。<br />
 * 
 * @author Typhoon.Free.Wolf
 * @version 2015-04-23_00-06
 */
public class Main
{

	/**
	 * 主函数，启动加载和测试 JNI 的用例。<br />
	 * 
	 * @author Typhoon.Free.Wolf
	 * @version 2015-04-09_15-54
	 * @param str1dCmdArgs
	 *            - 字符串型数组，来自命令行的参数。<br />
	 */
	public static void main(String[] str1dCmdArgs)
	{
		new Main().test(str1dCmdArgs);
	}

	/**
	 * JNI 加载与调用测试。<br />
	 * 
	 * @author Typhoon.Free.Wolf
	 * @version 2015-04-23_00-05
	 * @param str1dArgs
	 *            来自命令行的参数，字符串型数组。<br />
	 */
	private void test(String[] str1dArgs)
	{
		try
		{
			// [S] 对数组型参数做预处理，把数组元素组合进单一的字符串。
			String strArgsText = ArrayToolE.arrayForConsole(str1dArgs);
			if (null == strArgsText)
			{
				strArgsText = "";
			}
			else if ("null".equals(strArgsText))
			{
				strArgsText = null;
			}
			// [E] 对数组型参数做预处理，把数组元素组合进单一的字符串。

			// 测试用例 01 ：加载本地库。
			new JniLoader();

			// 测试用例 01 ：调用本地函数 (本地库中的函数)。
			JniCall jc = new JniCall();
			jc.println();
			jc.nativePrintln();

			// [S] 测试用例 02 ：加载本地库、调用本地函数。
			JniCall_02 jc_02 = new JniCall_02();
			{
				{
					String strMethodHead =
							TextToolE.concat("\tjc_02.javaManipulate(",
									((null == strArgsText) ? "null" : ("\""
											+ strArgsText + "\""))
											+ ")\n\t{");
					System.out.println(strMethodHead);

					String strRst = jc_02.javaManipulate(strArgsText);

					String strMethodTail =
							TextToolE.concat("\t}\n\tGot Return Value: ",
									((null == strRst) ? "null"
											: ("\"" + strRst + "\"")));
					System.out.println(strMethodTail);
				}

				System.out.println();

				{
					String strMethodHead =
							TextToolE.concat("\tjc_02.nativeManipulate(",
									((null == strArgsText) ? "null" : ("\""
											+ strArgsText + "\""))
											+ ")\n\t{");
					System.out.println(strMethodHead);

					// 此处：调用本地函数！
					String strOut = jc_02.nativeManipulate(strArgsText);

					String strMethodTail =
							TextToolE.concat("\t}\n\tGot Return Value: ",
									((null == strOut) ? "null"
											: ("\"" + strOut + "\"")));
					System.out.println(strMethodTail);
				}
			}
			// [E] 测试用例 02 ：加载本地库、调用本地函数。
		}
		catch (Throwable t)
		{
			t.printStackTrace();
		}
	}

}
    2. src/tfw/rsch/jni/JniLoader.java 
      /**
 * ...<br />
 */
package tfw.rsch.jni;

/**
 * 测试用例 01 ：<br />
 * 这个类在初始化时加载测试用例 01 的本地库 (*.so 共享模块 或 *.dll 动态链接库
 * 之类)。<br />
 * 
 * @author Typhoon.Free.Wolf
 * @version 2015-04-22_23-12
 */
public class JniLoader
{

	/**
	 * 静态代码块，确保在类初始化时即自动执行共享库加载函数。<br />
	 */
	static
	{
		loadNativeLibrary();
	}

	/**
	 * 测试用例 01 ：<br />
	 * 本地库 (*.so 共享模块 或 *.dll 动态链接库 之类) 加载函数。<br />
	 * 
	 * @author Typhoon.Free.Wolf
	 * @version 2015-04-22_21-37
	 */
	private static void loadNativeLibrary()
	{
		// 将从系统属性“java.library.path”中搜索本地库。
		String strJavaLibraryPath = System.getProperty("java.library.path");

		// 将根据本地库的名称“JniCall_name1”加载相应的库文件
		// “libJniCall_name1.so”(或“JniCall_name1.dll”之类)。
		String strNativeLibraryName = "JniCall_name1";
		System.out.println("java.library.path=" + strJavaLibraryPath);
		System.out.println("Loading \"" + strNativeLibraryName + "\"...");

		// 此处：加载本地库！
		System.loadLibrary(strNativeLibraryName);
		System.out.println("Loaded.");
	}

}
    3. src/tfw/rsch/jni/JniCall.java 
      /**
 * ...<br />
 */
package tfw.rsch.jni;

/**
 * 测试用例 01 ：<br />
 * 这个类提供一个测试用例 01 本地库中函数 (本地函数) 的入口，供 java 程序调用。<br />
 * 
 * @author Typhoon.Free.Wolf
 * @version 2015-04-22_23-32
 */
public class JniCall
{

	/**
	 * 测试用例 01 ：一个 java 函数。向标准输出打印一条信息。<br />
	 * 
	 * @author Typhoon.Free.Wolf
	 * @version 2015-04-11_14-09
	 */
	public void println()
	{
		System.out.println("\tJava:\tWorks!");
	}

	/**
	 * 测试用例 01 ：本地库中函数 (本地函数) 的入口。<br />
	 * 预计相应的本地函数也将向标准输出打印一条信息，类似于上述的 java 函数。<br />
	 * 
	 * @author Typhoon.Free.Wolf
	 * @version 2015-04-11_14-09
	 */
	public native void nativePrintln();

}
    4. src/tfw/rsch/jni/JniCall_02.java 
      /**
 * ...<br />
 */
package tfw.rsch.jni;

import tfw.base.util.misc.MiscToolE;
import tfw.base.util.text.TextToolE;

/**
 * 测试用例 02 ：这个类<br />
 * * 在初始化时加载测试用例 01 的本地库 (*.so 共享模块 或 *.dll 动态链接库 之类)；<br />
 * * 提供一个测试用例 02 本地库中函数 (本地函数) 的入口，供 java 程序调用。<br />
 * 
 * @author Typhoon.Free.Wolf
 * @version 2015-04-22_23-56
 */
public class JniCall_02
{

	/**
	 * 静态代码块，确保在类初始化时即自动执行共享库加载函数。<br />
	 */
	static
	{
		loadNativeLibrary();
	}

	/**
	 * 测试用例 02 ：<br />
	 * 本地库 (*.so 共享模块 或 *.dll 动态链接库 之类) 加载函数。<br />
	 * 
	 * @author Typhoon.Free.Wolf
	 * @version 2015-04-22_23-15
	 */
	private static void loadNativeLibrary()
	{
		// 将从系统属性“java.library.path”中搜索本地库。
		String strJavaLibraryPath = System.getProperty("java.library.path");

		// 将根据本地库的名称“JniCall_02”加载相应的库文件“libJniCall_02.so”
		// (或“JniCall_02.dll”之类)。
		String strNativeLibraryName = "JniCall_02";
		System.out.println("java.library.path=" + strJavaLibraryPath);
		System.out.println("Loading \"" + strNativeLibraryName + "\"...");

		// 此处：加载本地库！
		System.loadLibrary(strNativeLibraryName);
		System.out.println("Loaded.");
	}

	/**
	 * 测试用例 02 ：一个 java 函数。<br />
	 * 将函数入口处传入的字符串参数打印至标准输出；
	 * 之后从标准输入处读取一个字符串，并将其返回。<br />
	 * 
	 * @author Typhoon.Free.Wolf
	 * @version 2015-04-11_14-10
	 * @param strText
	 *            - 传入的参数，字符串。<br />
	 * @return 一个收自标准输入的字符串，<strong>有可能为 null 。</strong><br />
	 */
	public String javaManipulate(String strText)
	{
		// 将传入的字符串参数打印至标准输出。
		String strReceiveText =
				TextToolE.concat("\t\tJava:\n\n\t\tArgument Received:\n\t\t\t",
						(null == strText) ? "null" : ("\"" + strText + "\""));
		System.out.println(strReceiveText);

		// [S] 从标准输入处接收一个字符串，并打印至标准输出。
		System.out
				.print("\t\tUser Input (\"null\" would be considered as null):\n\t\t\t");
		String strUserInput = MiscToolE.getline(System.in);
		System.out.println("\t\tUser Input Received:\n\t\t\t"
				+ ((null == strUserInput) ? "null"
						: ("\"" + strUserInput + "\"")));
		// [E] 从标准输入处接收一个字符串，并打印至标准输出。

		// [S] 把将要返回的值打印至标准输出。
		String strReturnValue =
				"null".equals(strUserInput) ? null : strUserInput;
		System.out.println("\t\tReturns:\n\t\t\t"
				+ ((null == strReturnValue) ? "null"
						: ("\"" + strReturnValue + "\"")));
		// [E] 把将要返回的值打印至标准输出。

		// 返回。
		return strReturnValue;
	}

	/**
	 * 测试用例 02 ：本地库中函数 (本地函数) 的入口。<br />
	 * 预计相应的本地函数也将把函数入口处传入的字符串参数打印至标准输出、
	 * 之后从标准输入处读取一个字符串，并将其返回。<br />
	 * 
	 * @author Typhoon.Free.Wolf
	 * @version 2015-04-11_14-10
	 * @param strText
	 *            - 传入的参数，字符串。<br />
	 * @return 一个实际上返回自本地函数的字符串，<strong>有可能为 null 。</strong><br />
	 */
	public native String nativeManipulate(String strText);

}

  2. 将 Java 源代码文件编译成二进制程序：

    [typhoon@TFW-CENT6-LT sandbox]$ cp -a ../lib . # ← 上述源代码引用的工具类在这个文件夹里。
    [typhoon@TFW-CENT6-LT sandbox]$ ls
    0_guide.txt  lib  src
    [typhoon@TFW-CENT6-LT sandbox]$ ls lib
    tfw-base.aij.jar  tfw-base.v2.2.8_2014-12-22_22-00.longest_night.jre150.aij.jar
    #   ↑               ↖_ 工具类“ArrayToolE”、“MiscToolE”和“TextToolE”所在。
    #    `- 指向“tfw-base.v2.2.8_2014-12-22_22-00.longest_night.jre150.aij.jar”的符号链接。
    [typhoon@TFW-CENT6-LT sandbox]$ mkdir -p classes
    [typhoon@TFW-CENT6-LT sandbox]$ javac -classpath lib/tfw-base.aij.jar -d classes src/tfw/rsch/jni/*.java
    [typhoon@TFW-CENT6-LT sandbox]$ ls classes/tfw/rsch/jni
    JniCall_02.class  JniCall.class  JniLoader.class  Main.class
    [typhoon@TFW-CENT6-LT sandbox]$

  3. 为将要调用本地库的 Java 类生成 JNI 头文件：

    [typhoon@TFW-CENT6-LT sandbox]$ mkdir c_include
    [typhoon@TFW-CENT6-LT sandbox]$ ls
    0_guide.txt  c_include  classes  lib  src
    [typhoon@TFW-CENT6-LT sandbox]$ javah -classpath classes -o c_include/JniCall_name2.h tfw.rsch.jni.JniCall
    [typhoon@TFW-CENT6-LT sandbox]$ javah -classpath classes -o c_include/JniCall_02.h tfw.rsch.jni.JniCall_02
    [typhoon@TFW-CENT6-LT sandbox]$ ls c_include
    JniCall_02.h  JniCall_name2.h
    [typhoon@TFW-CENT6-LT sandbox]$

    头文件的文件名和将要使用的本地库文件名没有关系；在不违反操作系统命名规则、不违反编译器限制的情况下可以随意命名。
    用例 01 ，类“tfw.rsch.jni.JniCall”将使用本地库“JniCall_name1”，但头文件命名为“JniCall_name2.h”并不会导致错误。
    用例 02 ，类“tfw.rsch.jni.JniCall_02”，为了降低记错、输错文件名的几率，将类名、本地库名、头文件名统一规格，这是推荐的做法。

    文件内容明细：
     
    1. c_include/JniCall_name2.h 
      /* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class tfw_rsch_jni_JniCall */

#ifndef _Included_tfw_rsch_jni_JniCall
#define _Included_tfw_rsch_jni_JniCall
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     tfw_rsch_jni_JniCall
 * Method:    nativePrintln
 * Signature: ()V
 */
JNIEXPORT void JNICALL Java_tfw_rsch_jni_JniCall_nativePrintln
  (JNIEnv *, jobject);

#ifdef __cplusplus
}
#endif
#endif
    2. c_include/JniCall_02.h 
      /* DO NOT EDIT THIS FILE - it is machine generated */
#include <jni.h>
/* Header for class tfw_rsch_jni_JniCall_02 */

#ifndef _Included_tfw_rsch_jni_JniCall_02
#define _Included_tfw_rsch_jni_JniCall_02
#ifdef __cplusplus
extern "C" {
#endif
/*
 * Class:     tfw_rsch_jni_JniCall_02
 * Method:    nativeManipulate
 * Signature: (Ljava/lang/String;)Ljava/lang/String;
 */
JNIEXPORT jstring JNICALL Java_tfw_rsch_jni_JniCall_102_nativeManipulate
  (JNIEnv *, jobject, jstring);

#ifdef __cplusplus
}
#endif
#endif

  4. 创建 C 语言源代码文件：

    [typhoon@TFW-CENT6-LT sandbox]$ mkdir c_src
    [typhoon@TFW-CENT6-LT sandbox]$ ls
    0_guide.txt  c_include  classes  c_src  lib  src
    [typhoon@TFW-CENT6-LT sandbox]$ vi c_src/JniCall_name3.c
    [typhoon@TFW-CENT6-LT sandbox]$ vi c_src/JniCall_02.c
    [typhoon@TFW-CENT6-LT sandbox]$ ls c_src
    JniCall_02.c  JniCall_name3.c
    [typhoon@TFW-CENT6-LT sandbox]$

    C 语言源代码文件的文件名和将要调用的本地库文件名没有关系；在不违反操作系统命名规则、不违反编译器限制的情况下可以随意命名。
    用例 01 ，类名、本地库名、头文件名、C 语言源代码文件名互相全无关系并不会导致错误。
    用例 02 ，为了降低记错、输错文件名的几率，将类名、本地库名、头文件名、C 语言源代码文件名统一规格，这是推荐的做法。

    文件内容明细：
     
    1. c_src/JniCall_name3.c 
      #include <jni.h>
#include <stdio.h>
#include <JniCall_name2.h>

JNIEXPORT void JNICALL Java_tfw_rsch_jni_JniCall_nativePrintln
		(JNIEnv *env, jobject obj)
{
	printf("\tJNI:\tWorks!\n");
	return;
};
    2. c_src/JniCall_02.c 
      #include <jni.h>
#include <stdio.h>
#include <JniCall_02.h>

JNIEXPORT jstring JNICALL Java_tfw_rsch_jni_JniCall_102_nativeManipulate
		(JNIEnv *jniEnv, jobject jobj, jstring jstr)
{
	// 将传入的参数打印至标准输出。
	printf("\t\tJNI:\n\n\t\tArgument Received:\n\t\t\t");
	printf((NULL == jstr) ? "%s\n" : "\"%s\"\n", jstr);

	// 将传入的字符串参数转换成 C 语言字符串，再打印至标准输出。
	const char *strConverted = (NULL == jstr) ? NULL
			: (*jniEnv)->GetStringUTFChars(jniEnv, jstr, 0);
	printf("\t\tConverted:\n\t\t\t");
	printf((NULL == strConverted) ? "%s\n" : "\"%s\"\n", strConverted);

	// [S] 从标准输入处接收一个字符串，并打印至标准输出。
	printf("\t\tUser Input (\"NULL\" would be considered as NULL):\n\t\t\t");
	char *ch1dUserInput;
	gets(ch1dUserInput);
	printf("\t\tUser Input Received:\n\t\t\t");
	printf((0 == strcmp(ch1dUserInput, "NULL")) ? "%s\n" : "\"%s\"\n",
			ch1dUserInput);
	// [E] 从标准输入处接收一个字符串，并打印至标准输出。

	// 把接收到、将要返回的字符串打印至标准输出。
	printf("\t\tReturn Value:\n\t\t\t");
	char *strReturnValue = (0 == strcmp(ch1dUserInput, "NULL")) ? NULL
			: ch1dUserInput;
	printf((NULL == strReturnValue) ? "%s\n" : "\"%s\"\n", strReturnValue);

	// 把将要返回的字符串转换成 java 字符串，并打印至标准输出。
	jstring jstrReturnValue = (*jniEnv)->NewStringUTF(jniEnv, strReturnValue);
	printf("\t\tConverted:\n\t\t\t");
	printf((NULL == jstrReturnValue) ? "%s\n" : "\"%s\"\n", jstrReturnValue);

	// 返回。
	return jstrReturnValue;
};

  5. 将 C 语言源代码文件编译成本地库文件 (本例中为 *.so 共享对象文件)：

    1. 一个定制的 shell 脚本能减少很多手工输入，降低出错的几率：
       
      [typhoon@TFW-CENT6-LT sandbox]$ vi jnicc.sh
      [typhoon@TFW-CENT6-LT sandbox]$ ls
      0_guide.txt  c_include  classes  c_src  jnicc.sh  lib  src
      [typhoon@TFW-CENT6-LT sandbox]$ cat jnicc.sh
      #!/bin/sh
      # date;
      echo $0; echo $1; echo $2;
      # gcc $1 -shared -I c_include -I $JAVA_HOME/include -I $JAVA_HOME/include/linux -o $2;
      # gcc 4.4.7 20120313 of CentOS 6.6 requires "-fPIC".
      gcc $1 -fPIC -shared -I c_include -I $JAVA_HOME/include -I $JAVA_HOME/include/linux -o $2;
      echo $?;
      # date;
      [typhoon@TFW-CENT6-LT sandbox]$ chmod 700 jnicc.sh
      [typhoon@TFW-CENT6-LT sandbox]$
    2. 编译：
       
      [typhoon@localhost sandbox]$ ./jnicc.sh c_src/JniCall_name3.c lib/libJniCall_name1.so
      ./jnicc.sh
      c_src/JniCall_name3.c
      lib/libJniCall_name1.so
      0
      [typhoon@localhost sandbox]$ ./jnicc.sh c_src/JniCall_02.c lib/libJniCall_02.so
      ./jnicc.sh
      c_src/JniCall_02.c
      lib/libJniCall_02.so
      0
      [typhoon@localhost sandbox]$ ls lib
      libJniCall_02.so
      libJniCall_name1.so
      tfw-base.aij.jar
      tfw-base.v2.2.8_2014-12-22_22-00.longest_night.jre150.aij.jar
      [typhoon@TFW-CENT6-LT sandbox]$
    编译出的库文件名称必须与库名相符。
    用例 01 ，类“tfw.rsch.jni.JniCall”将使用本地库“JniCall_name1”，编译出的库文件名称必须为“libJniCall_name1.so”。
    用例 02 ，类“tfw.rsch.jni.JniCall_02”将使用本地库“JniCall_02”，编译出的库文件名称必须为“libJniCall_02.so”。
     

  6. 运行程序：

    1. 一个定制的 alias 设置能减少很多手工输入，降低出错的几率：
       
      [typhoon@TFW-CENT6-LT sandbox]$ vi jrun.alias
      [typhoon@TFW-CENT6-LT sandbox]$ ls
      0_guide.txt  c_include  classes  c_src  jnicc.sh  jrun.alias  lib  src
      [typhoon@TFW-CENT6-LT sandbox]$ cat jrun.alias
      alias jrun='java -classpath classes:lib/tfw-base.aij.jar -Djava.library.path=lib';
      [typhoon@TFW-CENT6-LT sandbox]$
    2. 加载此 alias 设置，并运行此程序：
       
      [typhoon@TFW-CENT6-LT sandbox]$ source jrun.alias
      [typhoon@TFW-CENT6-LT sandbox]$ alias
      ……
      alias jrun='java -classpath classes:lib/tfw-base.aij.jar -Djava.library.path=lib'
      ……
      [typhoon@localhost sandbox]$ jrun tfw.rsch.jni.Main 一二三四五 上山打老虎
      java.library.path=lib
      Loading "JniCall_name1"...
      Loaded.
              Java:  Works!
              JNI:    Works!
      java.library.path=lib
      Loading "JniCall_02"...
      Loaded.
              jc_02.javaManipulate("一二三四五, 上山打老虎")
              {
                      Java:

                      Argument Received:
                              "一二三四五, 上山打老虎"
                      User Input ("null" would be considered as null):
                              老虎没打到，打到小松鼠……
                      User Input Received:
                              "老虎没打到，打到小松鼠……"
                      Returns:
                              "老虎没打到，打到小松鼠……"
              }
              Got Return Value: "老虎没打到，打到小松鼠……"

              jc_02.nativeManipulate("一二三四五, 上山打老虎")
              {
                      JNI:

                      Argument Received:
                              "h#��"
                      Converted:
                              "一二三四五, 上山打老虎"
                      User Input ("NULL" would be considered as NULL):
                              松鼠有几只？一二三四五！
                      User Input Received:
                              "松鼠有几只？一二三四五！"
                      Return Value:
                              "松鼠有几只？一二三四五！"
                      Converted:
                              "�I��"
              }
              Got Return Value: "松鼠有几只？一二三四五！"
      [typhoon@localhost sandbox]$
展开阅读全文
一二三四五上山打老虎老虎没打到打到小松鼠JNI

© 著作权归作者所有

举报
打赏
0 赞
0 收藏
分享

作者的其它热门文章

jQuery AJAX 乱码牵出的问题，及解决过程。
临时思路
满满的“自撰一良方，服之，卒”即视感……
检查单 2015-02-01-01
加载中
取消
发布
更多评论

其他人还在看

更多精彩内容

没搞清楚网络I/O模型？那怎么入门Netty

本文是Netty系列笔记第2篇 Netty是网络应用框架，所以从最本质的角度来看，是对网络I/O模型的封装使用。 因此，要深刻理解Netty的高性能，也必须从网络I/O模型说起。 看完本文，可以回答这三个问题： 五种I/O模型...
0
3

怎么提升写代码的能力

作者 | 毕玄 来源|阿里巴巴云原生公众号 对于程序员而言，我始终认为代码是展现能力的关键，一个优秀程序员写的代码，和一个普通程序员写的代码是很容易看出差别的，代码作为程序员的硬实力和名片的展示，怎么提升...
0
3

WebRTC 的现状和未来：专访 W3C WebRTC Chair Bernard Aboba

WebRTC 无疑推动和改变了互联网视频，而这仅仅是刚刚开始，除了大家熟悉的 WebRTC-PC、Simulcast 和 SVC，有太多的新技术和新架构出现在 WebRTC 新的标准中，比如 WebTransport、WebCodecs、AV1、E2EE、SFrame、M...
0
1

JAR冲突问题的解决以及运行状态下如何查看加载的类

今天碰到群里小伙伴问，线上程序好像有多个不同版本的Netty包，怎么去看到底加载了哪一个？ 在说如何看之前，先来说说，当你开始意识到项目里有多个不同版本的Jar包，都是因为遇到了这几个异常： java.lang.NoSu...
0
3

测试一年多，上线就崩溃！微服务到底应该怎么测试？

简介： 只有了解风险，才能及时应对，保障服务高可用。 不久前，也就是11月16日，澳大利亚交易所（Australian Securities Exchange, ASX）上线了一个新的交易系统，但因为出现故障而被迫关闭。这是其 2016 年因硬...
0
2

亿级大表在线不锁表变更字段与索引

摘要：在业界中有一个比较成熟的工具，针对大表的场景，可以在线进行Alter变更，且不会出现锁表的风险。除此之外，它还有其他的一些优点，让我们开始探索吧。 背景 大家在日常工作中，往往需要对数据库的表结构做...
0
3

应用层安全架构设计-访问控制

权限控制，或者说访问控制，广泛应用于各个系统中。抽象地说，是某个主体（subject）对某个客体（object）需要实施某种操作（operation），而系统对这种操作的限制就是权限控制。 在网络中，为了保护网络资源的安...
0
1

数据库高可用架构了解一下

看多了应用服务的高可用架构，我们来看看数据库的高可用吧。 数据存储高可用的方案本质都是通过将数据复制到多个存储设备，通过数据冗余的方式来实现高可用。常见的高可用架构有主备、主从、主主、集群、分区等，...
0
0

说说 Ruby 与 Serverless

本文来源：ServerlessLife 公众号。 引言 最近查阅 Serverless 相关资讯，注意到一个 Ruby Serverless 框架——Jets。 心中便有一些疑问：为什么会有这个项目？它是用来做什么的？作为一门小众语言，有哪些 Serv...
0
0

万亿级数据库MongoDB集群性能数十倍提升及机房多活容灾实践

说明： 本文是2020年深圳Qcon全球软件开发大会《专题：现代数据架构》专场、dbaplus专场：万亿级数据库MongoDB集群性能优化实践、mongodb2020年终盛会分享，分享内容如下(体验万亿级mongodb服务层、存储引擎、高并...
2
4
查看更多
加载更多

关于作者

自由狼-台风
Lv1
自由狼-台风
程序员
私信
提问
文章
35
经验值
140
粉丝
1
关注
0

作者的专辑

全部
日志 / 检查单(23)
问题及解决办法(6)
设计草稿(2)
杂项(4)
源创计划
立即入驻

自媒体入驻开源社区，

获百万流量，打造个人技术品牌

推荐关注

换一批
Jenkins中文社区
Jenkins中文社区
文章 401
访问 10.6W
tobe的呓语
tobe的呓语
文章 16
访问 5.6W
九州暮云
九州暮云
文章 158
访问 68.2W
淡茗
淡茗
开源软件作者
乱世之牙
乱世之牙
文章 1
访问 131
打赏
0 评论
0 收藏
0 赞
分享
ad close
返回顶部
顶部