ArrayIndexOutOfBoundsException数组越界 --- 之二

现象：

Caused by: java.lang.ArrayIndexOutOfBoundsException: 7786
    at org.springframework.asm.ClassReader.readClass(Unknown Source)
    at org.springframework.asm.ClassReader.accept(Unknown Source)
    at org.springframework.asm.ClassReader.accept(Unknown Source)
    at org.springframework.core.type.classreading.SimpleMetadataReader.<init>(SimpleMetadataReader.java:54)
    at org.springframework.core.type.classreading.SimpleMetadataReaderFactory.getMetadataReader(SimpleMetadataReaderFactory.java:80)
    at org.springframework.core.type.classreading.CachingMetadataReaderFactory.getMetadataReader(CachingMetadataReaderFactory.java:101)
    at org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider.findCandidateComponents(ClassPathScanningCandidateComponentProvider.java:236)
    ... 45 more

问题及解决方案：

executor.execute(() -> threadTask(activityId, mobiles, content));

改为:

executor.execute(new Runnable() {
    @Override 
    public void run() {
        threadTask(activityId, mobiles, content);
    }
});

今天关于Gif读取之解决ArrayIndexOutOfBoundsException:4096读取gif文件和gif文件解析的讲解已经结束，谢谢您的阅读，如果想了解更多关于android – TextView样式ArrayIndexOutOfBoundsException、ArrayIndexOutOfBoundsException 160、ArrayIndexOutOfBoundsException >> arr lenght 引起的异常、ArrayIndexOutOfBoundsException数组越界 --- 之二的相关知识，请在本站搜索。

在本文中，我们将详细介绍Derby使用3—Embedded模式的各个方面，并为您提供关于de embedding的相关解答，同时，我们也将为您带来关于@Embeddable中具有@GeneratedValue的@EmbeddedId、Action: Consider the following: If you want an embedded database (H2, HSQL or Derby), please pu...、com.amazonaws.services.dynamodbv2.local.embedded.DynamoDBEmbedded的实例源码、Elixir Ranch: Embedded 模式的有用知识。

• Derby使用3—Embedded模式（de embedding）
• @Embeddable中具有@GeneratedValue的@EmbeddedId
• Action: Consider the following: If you want an embedded database (H2, HSQL or Derby), please pu...
• com.amazonaws.services.dynamodbv2.local.embedded.DynamoDBEmbedded的实例源码
• Elixir Ranch: Embedded 模式

Derby使用3—Embedded模式（de embedding）

零、回顾

这部分先来回顾一下上两篇博客中的主要内容。第一篇博客中主要简单介绍了Derby数据的历史，特点，安装以及使用的两种模式。第二篇文章主要介绍了客户机-服务器(C/S)模式的使用。今天继续介绍第二种使用模式，内嵌模式(Embedded Mode)。

一、客户端使用内嵌模式

与之前介绍的C/S模式不同，使用内嵌模式时不需要开启一个数据库的服务进程来监听并处理客户端的请求，客户端可以自行的完成这些命令。所以使用内嵌模式是有一定优势的。

下面来具体介绍这种模式的使用。首先还是要设置好CLASSPATH的环境变量。同样有两种方法，即使用Derby数据库编译好的脚本文件。可以执行命令：

setEmbeddedCP

将所需要的jar文件配置在CLASSPATH环境变量中。或者自己手动加入，执行命令：

export CLASSPATH=$DERBY_HOME/lib/derbytools.jar:$DERBY_HOME\lib\derby.jar:

我们还是需要运行ij工具，运行方式可以参照上一篇博客。之后还是执行连接数据库的命令：

jdbc:derby:DB_Path/DB_NAME;create=true''

这里需要多说一句，就是查找数据路径的根目录位置，如果没有设置derby.system.home(即数据库主目录的位置)，那么默认的将会从启动ij的当前目录作为主目录对数据库的位置进行递归查找，后面第二部分介绍的程序运行Embedded模式也会遇到相同的问题。这部分先来介绍一下怎么来设置derby.system.home。设置这个时需要在启动ij工具的同时就不值设定好，所以可以执行命令：

java -Dderby.system.home=DB_ROOT_DIR org.apache.derby.tools.ij

上述设置完derby.system.home后再连接数据库会有一个ERROR XBM0H的错误，不知道怎么解决，希望知道的可以指出一下，亦或是我设置derby.system.home的方式有问题，谢谢大家给出问题的解决方案。另外这个模式只能访问本地的数据库，对其操作。连接上数据库后就可以执行SQL语句了，这里就不在赘述了。关闭数据库只须执行exit;即可。

二、程序使用内嵌模式

这里给出的程序是根据Apache Derby文件夹demo/program/sample中的例子改写的，下面附上程序：

package trianlge23.derby.embedded.demo;

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;

public class DerbyEmbeddedDemo {
	// the default framework is embedded if you want to use client framework
	// please pass the "derbyclient" in the first argument
	private String framework = "embedded";
	private String driver = "org.apache.derby.jdbc.EmbeddedDriver";
	private String protocol = "jdbc:derby:";

	public static void main(String[] args) {

		new DerbyEmbeddedDemo().run(args);
		System.out.println("DerbyEmbeddedDemo finished");
	}

	public void run(String[] args) {
		parseArguments(args);

		System.out.println("DerbyEmbeddedDemo starting in " + framework
				+ " mode");

		loaddriver();

		Connection conn = null;
		ArrayList<Statement> statements = new ArrayList<Statement>();
		PreparedStatement psInsert = null;
		PreparedStatement psUpdate = null;
		Statement s = null;
		ResultSet rs = null;

		String userHomeDir = System.getProperty("user.home", ".");
		String dbPath = userHomeDir + "/Testdata/";
		System.setProperty("derby.system.home", dbPath);
		String dbName = "testDB";

		String dbURL = protocol + dbPath + dbName + ";create=true";
		try {
			conn = DriverManager.getConnection(dbURL);

			conn.setAutoCommit(false);

			s = conn.createStatement();
			statements.add(s);

			s.execute("CREATE TABLE basicinfo(id INT, name VARCHAR(18), cityname VARCHAR(12))");
			System.out.println("Created table basicinfo");

			psInsert = conn
					.prepareStatement("INSERT INTO basicinfo VALUES (?, ?, ?)");
			statements.add(psInsert);

			psInsert.setInt(1, 100);
			psInsert.setString(2, "Triangle23.lzl");
			psInsert.setString(3, "Shanghai");
			psInsert.executeUpdate();
			System.out.println("Inserted 100 Triangle23.lzl Shanghai");

			psInsert.setInt(1, 1);
			psInsert.setString(2, "Adrastos");
			psInsert.setString(3, "Shanghai");
			psInsert.executeUpdate();
			System.out.println("Inserted 1 Adrastos Shanghai");

			psUpdate = conn
					.prepareStatement("UPDATE basicinfo SET id=?, name=?, cityname=? WHERE id=?");
			statements.add(psUpdate);

			psUpdate.setInt(1, 0);
			psUpdate.setString(2, "Triangle23");
			psUpdate.setString(3, "Beijing");
			psUpdate.setInt(4, 100);
			psUpdate.executeUpdate();
			System.out
					.println("Updated 0 Triangle23.lzl Shanghai to 0 Triangle23 Beijing");

			rs = s.executeQuery("SELECT * FROM basicinfo ORDER BY id");

			int id;
			boolean failure = false;
			if (!rs.next()) {
				failure = true;
				reportFailure("No rows in ResultSet");
			}
			if ((id = rs.getInt(1)) != 0) {
				failure = true;
				reportFailure("Wrong row returned, expected id=0, got " + id);
			}

			if (!failure) {
				System.out.println("Verified the rows");
			}

			s.execute("drop table basicinfo");
			System.out.println("Dropped table basicinfo");

			conn.commit();
			System.out.println("Committed the transaction");

			if (framework.equals("embedded")) {
				try {
					DriverManager.getConnection("jdbc:derby:;shutdown=true");
				} catch (SQLException se) {
					if (((se.getErrorCode() == 50000) && ("XJ015".equals(se
							.getSQLState())))) {
						// we got the expected exception
						System.out.println("Derby shut down normally");
						// Note that for single database shutdown, the expected
						// SQL state is "08006", and the error code is 45000.
					} else {
						System.err.println("Derby did not shut down normally");
						printSQLException(se);
					}
				}
			}

		} catch (SQLException sqle) {
			printSQLException(sqle);
		} finally {
			// release all open resources to avoid unnecessary memory usage

			// ResultSet
			try {
				if (rs != null) {
					rs.close();
					rs = null;
				}
			} catch (SQLException sqle) {
				printSQLException(sqle);
			}
			// Remove Statements and PreparedStatements
			int i = 0;
			while (!statements.isEmpty()) {
				// PreparedStatement extend Statement
				Statement st = (Statement) statements.remove(i);
				try {
					if (st != null) {
						st.close();
						st = null;
					}
				} catch (SQLException sqle) {
					printSQLException(sqle);
				}
			}

			// Close Connection
			try {
				if (conn != null) {
					conn.close();
					conn = null;
				}
			} catch (SQLException sqle) {
				printSQLException(sqle);
			}
		}

	}

	private void reportFailure(String message) {
		System.err.println("\nData verification failed:");
		System.err.println(''\t'' + message);
	}

	public static void printSQLException(SQLException e) {
		while (e != null) {
			System.err.println("\n----- SQLException -----");
			System.err.println("  SQL State:  " + e.getSQLState());
			System.err.println("  Error Code: " + e.getErrorCode());
			System.err.println("  Message:    " + e.getMessage());
			e = e.getNextException();
		}

	}

	private void loaddriver() {
		try {
			Class.forName(driver).newInstance();
			System.out.println("Loaded the appropriate driver");
		} catch (InstantiationException ie) {
			System.err.println("\nUnable to instantiate the JDBC driver "
					+ driver);
			ie.printStackTrace(System.err);
		} catch (IllegalAccessException iae) {
			System.err.println("\nNot allowed to access the JDBC driver "
					+ driver);
			iae.printStackTrace(System.err);
		} catch (ClassNotFoundException cnfe) {
			System.err.println("\nUnable to load the JDBC driver " + driver);
			System.err.println("Please check your CLASSPATH.");
			cnfe.printStackTrace(System.err);
		}
	}

	/* parse arguments choosing client mode whether or not */
	private void parseArguments(String[] args) {
		if (0 < args.length) {
			if ("derbyclient".equalsIgnoreCase(args[0])) {
				framework = "derbyclient";
				driver = "org.apache.derby.jdbc.ClientDriver";
				protocol = "jdbc:derby://localhost:1527/";
			}
		}
	}
}

上述中有程序中有设置derby.system.home的代码段，可以自行体会一下，另外程序给提供了两种模式模式的方式，也算是对之前博客示例的一个追加吧。如果需要查看更完整的注释内容，可以参考Apache给出的示例(之前所述的文件位置)。另外还需要说一点就是，在程序运行时，不能有另一个指向程序所用数据库的服务进程，简单的讲，一个数据库不应该有两个服务进程(不是线程)同时监听请求并处理(不知道解释的对不对啊)，内嵌模式是和程序共用jvm的。

三、后面的话

Derby的使用大概就介绍这三篇博客，后续的可能还会有一些derby数据库使用方面的心得。希望这三篇博客可以让大家对使用Derby数据库可以快速上手，也希望大家一起交流给出补充或不足，谢谢。

四、参考资料

1. Embedded Derby：http://db.apache.org/derby/papers/DerbyTut/embedded_intro.html
2. permission denied on derby.log： 
   http://apache-database.10148.n7.nabble.com/permission-denied-on-derby-log-td106537.html
3. Derby 笔记： http://pengyan.iteye.com/blog/207355

@Embeddable中具有@GeneratedValue的@EmbeddedId

我有一个具有以下结构的MySQL数据库（节选）：

CREATE TABLE MENU(    id_menu    TINYINT      UNSIGNED    NOT NULL    AUTO_INCREMENT,    name       VARCHAR(50)              NOT NULL,    PRIMARY KEY (id_menu));CREATE TABLE OPERATION(    id_operation    SMALLINT        UNSIGNED    NOT NULL    AUTO_INCREMENT,    id_menu         TINYINT         UNSIGNED    NOT NULL,    operation       VARCHAR(50)                 NOT NULL,    url             VARCHAR(100)                NOT NULL,    PRIMARY KEY (id_operation, id_menu));CREATE TABLE operation_role(    id_operation    SMALLINT    UNSIGNED    NOT NULL,    id_menu         TINYINT     UNSIGNED    NOT NULL,    role            CHAR(15)                NOT NULL,    id_user         BIGINT      UNSIGNED    NOT NULL,   PRIMARY KEY (id_operation, id_menu, role, id_user));CREATE TABLE role_user(    role          CHAR(15)              NOT NULL    id_user       BIGINT      UNSIGNED  NOT NULL,    PRIMARY KEY (role, id_user));-- RELATIONSHIPS-- -- TABLE: OPERATION -- Meaning: a MENU has several OPERATION (One to Many relationship)ALTER TABLE OPERACION ADD CONSTRAINT fk_menu_operacion     FOREIGN KEY (id_menu)    REFERENCES MENU(id_menu);-- -- TABLE: operation_rol -- This is the join table for the Many to Many relatioship OPERATION-role_userALTER TABLE operation_role ADD CONSTRAINT fk_operation_oprole     FOREIGN KEY (id_operation, id_menu)    REFERENCES OPERATION(id_operation, id_menu);ALTER TABLE operaciones_rol ADD CONSTRAINT fk_roles_operation     FOREIGN KEY (role, id_user)    REFERENCES role_user(role, id_user);-- -- TABLE: roles_usuario -- Meaning: a user can have several roles (One to Many)ALTER TABLE roles_usuario ADD CONSTRAINT fk_usuario_roles     FOREIGN KEY (id_usuario)    REFERENCES USUARIO(id_usuario);

另外，还有一个USER表，但这并不重要，有了这些表，您可以了解问题的全貌。

如您所见，某些列具有AUTO_INCREMENT将@GeneratedValue(strategy =GenerationType.IDENTITY)在@Entity类中变为的属性。

OPERATION并且role_user由于它们与其他表的关系而具有复合主键，因此我无法更改。由于为Composite
PK，因此映射的类必须具有一个@EmbeddedId带有相应@Embeddable类的。

问题是我需要@GeneratedValue在组合的 “本机”
部分中添加一个PK，例如：OPERATION.id_operation必须具有JPA @GeneratedValue @ EmbeddedId@GeneratedValue并OPERATION.id_menu从中传播。我能正确解释情况吗？MENU.id_menu, butdoesnot supportin`

我尝试使用NetBeans 从DataBase 选项的 Entity类 的 “建议”
，但是为具有简单列的标识符（如）的表生成注释，而不为组合对象的表（如）生成注释。 __@GeneratedValue``MENU``OPERATION

所以问题是 我该如何进行映射？ 。更改数据库的结构不是一种选择，因为业务需要，所以要这样做。

任何帮助或指导表示赞赏。提前非常感谢您。

答案1

您的JPA @Id不需要匹配数据库PK列。只要它是唯一的，那么这就是所有要紧的事情，并且由于关联的列是自动递增的列，因此会是这种情况。

从https://en.wikibooks.org/wiki/Java_Persistence/Identity_and_Sequencing：

JPA Id不必总是与数据库表的主键约束匹配，也不需要主键或唯一约束。

因此，尽管可以按照PRIMARY KEY (id_operation,id_menu)看起来的方式配置关联表的PK，但id_operation通过自动递增，它可以单独作为PK，因此可以将操作映射如下：

@Entitypublic class Operation{    @Id    @GeneratedValue(strategy = GenerationType.IDENTITY)    private Long id;    @ManyToOne    @JoinColumn(name = "id_menu")    private Menu menu;}

如果创建相关的IDClass，则可以如下映射OperationRole。有关此方案以及ID类如何查找的示例，请参见：

https://zh.wikibooks.org/wiki/Java_Persistence/Identity_and_Sequencing#Example_JPA_2.0_ManyToOne_id_annotation

@Entity@IdClass(OperationRolePk.class)public class OperationRole{        @Id        @ManyToOne        @JoinColumn(name = "id_operation")        private Operation operation;        @Id        @ManyToOne        @JoinColumn(name = "id_menu")        private Menu menu;        @Id        @ManyToOne        @JoinColumn(name = "id_user")        private User user;}

Action: Consider the following: If you want an embedded database (H2, HSQL or Derby), please pu...

更多精彩关注微信公众号

错误原因

在pom中引入了mybatis-spring-boot-starter ，Spring boot默认会加载org.springframework.boot.autoconfigure.jdbc.DataSourceAutoConfiguration类，DataSourceAutoConfiguration类使用了@Configuration注解向spring注入了dataSource bean。因为工程中没有关于dataSource相关的配置信息，当spring创建dataSource bean因缺少相关的信息就会报错。
解决错误
在Spring boot的启动引导类上增加@EnableAutoConfiguration(exclude={DataSourceAutoConfiguration.class})，阻止Spring boot自动注入dataSource

推荐阅读：

IntelliJ IDEA打开Maven项目，Spring boot所有依赖红名，不可用

 IDEA 导入Springboot 项目

创建Maven项目，GroupId和Artifact Id该如何填写？

问：hibernate的sessionfactory是干嘛的？session又是干嘛的呢？

com.amazonaws.services.dynamodbv2.local.embedded.DynamoDBEmbedded的实例源码

/**
 * setup
 */
@Before
public void setup() {
    // Create an in-memory and in-process instance of DynamoDB Local that skips HTTP
    dynamodbClient = DynamoDBEmbedded.create().amazonDynamoDB();

    // Create and verify table
    final CreateTableResult createTableResult = createTable();
    assertEquals(TABLE_NAME,createTableResult.getTableDescription().getTableName());
}

public static AmazonDynamoDB createInMemoryDb() {
    AmazonDynamoDB dynamodb = null;
    try {
        // Create an in-memory and in-process instance of DynamoDB Local
        AmazonDynamoDBLocal amazonDynamoDBLocal = DynamoDBEmbedded.create();
        dynamodb = amazonDynamoDBLocal.amazonDynamoDB();
        return dynamodb;
    } catch (Exception e){
        if(dynamodb != null)
            dynamodb.shutdown();// Shutdown the thread pools in DynamoDB Local / Embedded
    }
    return dynamodb;
}

@BeforeClass
public static void beforeClass() {
    sDynamoDB = DynamoDBEmbedded.create().amazonDynamoDB();
    sDynamoDBMapper = new DynamoDBMapper(sDynamoDB);
    sDynamoDBRepository = new DynamoDBRepository();
    sDynamoDBRepository.setDynamoDBMapper(sDynamoDBMapper);
    sDynamoDBRepository.setLockDurationMs(LOCK_DURATION_MS);
}

@Override
protected void before() throws Throwable {
    try {
        amazonDynamoDB = DynamoDBEmbedded.create().amazonDynamoDB();
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

@Override
protected void before() throws Throwable {
  nativeLibraryRule.before();
  System.setProperty("sqlite4java.library.path",nativeLibraryRule.getNativeLibrariesFolder().toString());

  client = DynamoDBEmbedded.create().amazonDynamoDB();
}

@Before
public void setup() {
    methodCalls = new HashMap<String,Integer>();
    client = instrument(DynamoDBEmbedded.create(),AmazonDynamoDB.class,methodCalls);
    metastore.createTable(client,TABLE_NAME,new ProvisionedThroughput(1L,1L));
    store = new metastore(client,ENCRYPTOR);
    ctx = new EncryptionContext.Builder().build();
    methodCalls.clear();
}

@Before
public void setup() {
    client = synchronize(DynamoDBEmbedded.create(),AmazonDynamoDB.class);
    metastore.createTable(client,ENCRYPTOR);
    ctx = new EncryptionContext.Builder().build();
}

@Before
public void setUp() {
    client = DynamoDBEmbedded.create();

    ArrayList<AttributeDeFinition> attrDef = new ArrayList<AttributeDeFinition>();
    attrDef.add(new AttributeDeFinition().withAttributeName("hashKey").withAttributeType(ScalarattributeType.N));
    attrDef.add(new AttributeDeFinition().withAttributeName("rangeKey").withAttributeType(ScalarattributeType.N));

    ArrayList<KeySchemaElement> keySchema = new ArrayList<KeySchemaElement>();
    keySchema.add(new KeySchemaElement().withAttributeName("hashKey").withKeyType(KeyType.HASH));
    keySchema.add(new KeySchemaElement().withAttributeName("rangeKey").withKeyType(KeyType.RANGE));

    client.createTable(new CreateTableRequest().withTableName("TableName")
            .withAttributeDeFinitions(attrDef)
            .withKeySchema(keySchema)
            .withProvisionedThroughput(new ProvisionedThroughput(100L,100L)));

    attrDef = new ArrayList<AttributeDeFinition>();
    attrDef.add(new AttributeDeFinition().withAttributeName("hashKey").withAttributeType(ScalarattributeType.S));
    keySchema = new ArrayList<KeySchemaElement>();
    keySchema.add(new KeySchemaElement().withAttributeName("hashKey").withKeyType(KeyType.HASH));

    client.createTable(new CreateTableRequest().withTableName("HashKeyOnly")
            .withAttributeDeFinitions(attrDef)
            .withKeySchema(keySchema)
            .withProvisionedThroughput(new ProvisionedThroughput(100L,100L)));

    attrDef = new ArrayList<AttributeDeFinition>();
    attrDef.add(new AttributeDeFinition().withAttributeName("hashKey").withAttributeType(ScalarattributeType.B));
    attrDef.add(new AttributeDeFinition().withAttributeName("rangeKey").withAttributeType(ScalarattributeType.N));

    keySchema = new ArrayList<KeySchemaElement>();
    keySchema.add(new KeySchemaElement().withAttributeName("hashKey").withKeyType(KeyType.HASH));
    keySchema.add(new KeySchemaElement().withAttributeName("rangeKey").withKeyType(KeyType.RANGE));

    client.createTable(new CreateTableRequest().withTableName("DeterministicTable")
            .withAttributeDeFinitions(attrDef)
            .withKeySchema(keySchema)
            .withProvisionedThroughput(new ProvisionedThroughput(100L,100L)));
}

/**
 * You can use mvn to run DynamoDBLocalFixture,e.g.
 * <p>
 * $ mvn clean package
 * <p>
 * $ mvn exec:java -Dexec.main\
 * -Dexec.classpathScope="test" \
 * -Dsqlite4java.library.path=target/dependencies
 * <p>
 * It's recommended to run "aws configure" one time before you run DynamoDBLocalFixture
 *
 * @param args - no args
 * @throws Exception
 */
public static void main(String[] args) throws Exception {
    AmazonDynamoDB dynamodb = null;
    try {
        // Create an in-memory and in-process instance of DynamoDB Local that skips HTTP
        dynamodb = DynamoDBEmbedded.create().amazonDynamoDB();
        // use the DynamoDB API with DynamoDBEmbedded
        listTables(dynamodb.listTables(),"DynamoDB Embedded");
    } finally {
        // Shutdown the thread pools in DynamoDB Local / Embedded
        if(dynamodb != null) {
            dynamodb.shutdown();
        }
    }

    // Create an in-memory and in-process instance of DynamoDB Local that runs over HTTP
    final String[] localArgs = { "-inMemory" };
    DynamoDBProxyServer server = null;
    try {
        server = ServerRunner.createServerFromCommandLineArgs(localArgs);
        server.start();

        dynamodb = AmazonDynamoDBClientBuilder.standard().withEndpointConfiguration(
            // we can use any region here
            new AwsClientBuilder.EndpointConfiguration("http://localhost:8000","us-west-2"))
            .build();

        // use the DynamoDB API over HTTP
        listTables(dynamodb.listTables(),"DynamoDB Local over HTTP");
    } finally {
        // Stop the DynamoDB Local endpoint
        if(server != null) {
            server.stop();
        }
    }
}

public CloudNoticeDAO(boolean local) {
    ddb = local ? DynamoDBEmbedded.create().amazonDynamoDB()
            : AmazonDynamoDBClientBuilder.defaultClient();
    verifyTables();
    mapper = new DynamoDBMapper(ddb);
}

@Bean
@Primary
public AmazonDynamoDB createAmazonDynamoDBLocal() throws Exception {
    return DynamoDBEmbedded.create().amazonDynamoDB();
}

Elixir Ranch: Embedded 模式

嵌入模式允许你把 Ranch 监听器直接插入到你的监控树中. 如果整个应用程序其他部分挂掉了, 可以通过关闭监听器的方法, 来提供更好的容错控制.

嵌入(Embedding)

要嵌入 Ranch 到你自己的应用程序中, 只需要简单地把子进程规范添加到监控树中即可. 在应用程序的一个(一般在顶层Supervisor, 如果应用程序比较复杂, 也可能是其他层) Supervisor 的 init/1 函数中完成这个过程.

对于嵌入, Ranch 要求最少两种类型的子进程规范. 首先,需要添加 ranch_sup 到监控树, 只需要一次, 不管使用多少个监听器. 然后需要为每个监听器添加子进程规范.

可以添加多个监听器, 比如80端口的HTTP监听器, 和443端口的HTTPS监听器.

Ranch 提供了一个简便的辅助函数 ranch:child_spec/6 获取监听器的子进程规范, 其工作方式类似于 ranch:start_listener/6, 只是它不启动任何进程, 只是返回子进程规范.

对于 ranch_sup, 子进程规范足够的简单, 不需要辅助函数.

下面的例子添加 ranch_sup 和一个监听器到另一个应用程序的监控树中.

直接嵌入 Ranch 到监控树中

init([]) ->
    RanchSupSpec = {
        ranch_sup, 
        {ranch_sup, start_link, []}, 
        permanent, 
        5000, 
        supervisor, 
        [ranch_sup]
    },
    ListenerSpec = ranch:child_spec(
        echo, 
        100, 
        ranch_tcp, 
        [{port, 5555}], 
        echo_protocol, 
        []
    ),
    {ok, {{one_for_one, 10, 10}, [RanchSupSpec, ListenerSpec]}}.

记住, 可以按需要添加多个监听器, 但是只能有一个 ranch_sup 子进程规范!

Elixir 的 Supervisor 实现

嵌入前的 Supervisor

require Logger
defmodule RanchEmbededMode.Supervisor do
  use Supervisor

  def start_link do
    Logger.debug "Start supervisor."
    Supervisor.start_link(__MODULE__, [], name: __MODULE__)
  end

  def init([]) do
    children = [
      worker(RanchEmbededMode.TcpAcceptor, []),
    ]
    Logger.debug "supervisor child spec #{inspect children}"
    opts = [strategy: :one_for_one, max_restarts: 3]
    Logger.debug "strategy #{inspect opts}"
    supervise(children, opts)
  end
end

嵌入前的监控树结构

嵌入前 Ranch 是一个独立的 Application

嵌入前 RanchEmbededMode 应用程序监控树结构

嵌入后的 SupervisorEmbed

require Logger
defmodule RanchEmbededMode.SupervisorEmbed do
  use Supervisor

  def start_link do
    Logger.debug "Start supervisor."
    Supervisor.start_link(__MODULE__, [], name: __MODULE__)
  end

  def init([]) do
    children = [
      ranch_sup(),
      ranch_embeded_mode_listener()
    ]
    Logger.debug "supervisor child spec #{inspect children}"
    opts = [strategy: :one_for_one, name: __MODULE__]
    Logger.debug "strategy #{inspect opts}"
    supervise(children, opts)
  end

  def ranch_sup do
    supervisor(:ranch_sup, [], [shutdown: 5000])
  end

  @doc """
  Ranch 提供了一个辅助函数能够更便捷的创建监听器的 Child Spec
  """
  def ranch_embeded_mode_listener do
    :ranch.child_spec(
      :ranch_embeded_mode_listener,
      10,
      :ranch_tcp,
      [port: 5555],
      RanchEmbededMode.TcpProtocolHandler, []
    )
  end
end

嵌入后的监控树结构, 独立的 Ranch Application 不在了.

需要特别注意的地方

当 Ranch 作为独立的 Application 时, 请确保 Ranch 在当前应用程序之前启动
当 Ranch 作为嵌入模式运行时, 请确保不要在 mix.exs 或其他位置启动 Ranch, 当前应用程序的 Supervisor 会负责启动 Ranch, 并作为当前应用程序监控树的子树运行.

独立模式下, 如果没有在 mix.exs 提前启动 ranch, 报如下错误:

嵌入模式下, 如果在 mix.exs 中提前启动了 ranch, 报如下错误:

建议:
在设计监控树的结构方面, 确保当 ranch_sup 挂掉时, 重启所有监听器. 详情请参考 Ranch 官网 Guide 的 Internal 章节了解如何这样做.

示例程序

本文的示例代码位于 https://github.com/developerworks/ranch_embeded_mode

另外, 如果你想要给你的项目取个你喜欢的名字, 请执行下面的步骤

git clone https://github.com/developerworks/ex_ranch_server_tasks.git
cd ex_ranch_server_tasks
mix archive.build
mix archive.install                # 输入Y确认
mix ranch.new <project_name> --sup # 用实际的项目名称替换 <project_name>

独立模式使用RanchEmbededMode.Supervisor.start_link启动
嵌入模式使用RanchEmbededMode.SupervisorEmbed.start_link启动

参考资料

https://github.com/ninenines/ranch/blob/master/doc/src/guide/embedded.asciidoc

关于Derby使用3—Embedded模式和de embedding的问题我们已经讲解完毕，感谢您的阅读，如果还想了解更多关于@Embeddable中具有@GeneratedValue的@EmbeddedId、Action: Consider the following: If you want an embedded database (H2, HSQL or Derby), please pu...、com.amazonaws.services.dynamodbv2.local.embedded.DynamoDBEmbedded的实例源码、Elixir Ranch: Embedded 模式等相关内容，可以在本站寻找。

本文将带您了解关于Firebug Tutorial (Section 1)– Logging, Profiling and CommandLine (Part I)的新内容，另外，我们还将为您提供关于11:12:21.924 [main] DEBUG org.apache.ibatis.logging.LogFactory - Logging initialized using ''c...、48-Command line is too long. Shorten command line、Angular 2 User Registration and Login Example & Tutorial - Built with Angular 2.0 Final.、Automating code reviews and application profiling with Amazon CodeGuru的实用信息。

• Firebug Tutorial (Section 1)– Logging, Profiling and CommandLine (Part I)
• 11:12:21.924 [main] DEBUG org.apache.ibatis.logging.LogFactory - Logging initialized using ''c...
• 48-Command line is too long. Shorten command line
• Angular 2 User Registration and Login Example & Tutorial - Built with Angular 2.0 Final.
• Automating code reviews and application profiling with Amazon CodeGuru

Firebug Tutorial (Section 1)– Logging, Profiling and CommandLine (Part I)

Firebug Tutorial – Logging, Profiling and CommandLine (Part I)

Firebug Tutorial

Section 1: Console Tab : Logging, Profiling and CommandLine (Part II)

Overview of Console Tab

This tab is mainly used for logging. It also can be used as CommandLine window (like immediate window in Microsoft Visual Studio) while you are debugging the Javascript. It can be used for monitoring the execution of Javascript code by using Profiling service.

The following topic will be covered in this section.

• Logging in Firebug (with String Substitution pattern )
• Grouping the logs or messages
• console.dir and console.dirxml
• Assertion ( console.assert() )
• Tracing ( console.trace() )
• Timing ( Measuring the time of your code)
• Javascript Profiler (An introduction in this tutorial, the details will be covered in next tutorial.)

#1. Logging in Firebug

Firebug supports logging in Console tab. So, you don’t need to use alert(‘something’) or document.write(‘something’) anymore.

There are five types of logging in Firebug.

• console.log : Write a message without icon.
• console.debug : Writes a message to the console, including a hyperlink to the line where it was called
• console.error() : Writes a message to the console with the visual “error” icon and color coding and a hyperlink to the line where it was called.
• console.info() : Writes a message to the console with the visual “info” icon and color coding and a hyperlink to the line where it was called.
• console.warn() : Writes a message to the console with the visual “warning” icon and color coding and a hyperlink to the line where it was called.

Example Code:

• Open the htm file called “Plain HTML” or create one HTML file.
• Paste the following code with <body> tag.

<script language="javascript" type="text/javascript">
console.log(''This is log message'');
console.debug(''This is debug message'');
console.error(''This is error message'');
console.info(''This is info message'');
console.warn(''This is warning message'');
</script>

You will get the following output. If you click on hyperlink (“test.htm” in this case), it will take you to script tab and will highlight the line that wrote this message.

String Substitution Patterns

String substitution parterns can be used in console.log, console.info, console.debug, console.warn and console.error . You can use the same way that we used in C/C++.

%s	String
%d, %i	Integer (numeric formatting is not yet supported)
%f	Floating point number (numeric formatting is not yet supported)
%o	Object hyperlink

Example :

Note: I will use console.log in the example below even all console objects (console.log, console.info, console.debug, console.warn and console.error ) support string substitution.

• Remove “script” tag that we pasted for the previous example.
• Paste the code below within <body> tag.

<script language="javascript" type="text/javascript">

//This is for normal string substitution " %s, %d, %i, %f".
console.log("My Name is <strong>%s</strong>. My Date of Birth is <strong>%dth %s, %i</strong>. My height is <strong>%f</strong> m.", "Nicolas Cage", 7, ''January'', 1964, 1.8542);

function Foo(){
this.LeftHand = function(){
return "Left Hand";
}
this.RightHand = function(){
return "Right Hand";
}
}

//This is for object "%o".
var objFoo = new Foo();
console.log(''This is <strong>%o</strong> of Foo class.'', objFoo);

</script>

If you are using %o in your log, the object will be shown as a hyperlink in green color. This hyperlink is linked to the DOM tab. So, If you click “object” in second line, you will see the list of properties of that object (LeftHand and RightHand in this case.)

#2. Grouping

Firebug allows you to group the message or log in Console tab. If you have some many logs in your code, you can probably divide your log into small group or subgroup

Example ~

<script language="javascript" type="text/javascript">

var groupname = ''group1'';
console.group("message group : %s " , groupname);
console.log("log message 1 from %s", groupname);
console.log("log message 2 from %s", groupname);
console.log("log message 3 from %s", groupname);
console.groupEnd();

groupname = ''group2'';
console.group("message group : %s " , groupname);
console.log("log message 1 from %s", groupname);

var subgroupname = ''subgroup1'';
console.group("message group : %s " , subgroupname);
console.log("log message 1 from %s", subgroupname);
console.log("log message 2 from %s", subgroupname);
console.log("log message 3 from %s", subgroupname);
console.groupEnd();

console.log("log message 3 from %s", groupname);
console.groupEnd();

</script>

#3. console.dir and console.dirxml

• console.dir : It can be used for getting all properties and methods of a particular object. According the example below, we can get the Model (property) and getManufactor (method) of Car object by using console.dir(); You can also pass the object of HTML element (eg: console.dir(document.getElementById(‘tbl1′)); ) instead of objCar and let’s see the result. (You will get all properties and methods of the HTML table called “tbl1′).
• console.dirxml : print the XML source tree of HTML element.

<table id="tbl1" cellpadding="0" cellspacing="0" border="0">
<tr>
<td>A</td>
<td>B</td>
<td>C</td>
</tr>
</table>
<script language="javascript" type="text/javascript">
//Create a class
function Car(){
this.Model = "Old Model";

this.getManufactor = new function(){
return "Toyota";
}
}

//Create a object
var objCar = new Car();

//Firebug
console.dir(objCar);
console.dirxml(document.getElementById(''tbl1''));

</script>

#4. Assertion ( console.assert() )

You can use console.assert() to test whether an expression is true or not. If the expression is false, it will write a message to the console and throw an exception.

Example :

<script language="javascript" type="text/javascript">
function whatIsMyAge(year){
var currYear = 2007;
return currYear - year;
}

var yearOfBirth1 = 1982;
var age1 = 25;
console.assert(whatIsMyAge(yearOfBirth1) == age1);

var yearOfBirth2 = 1982;
var age2 = 11;
console.assert(whatIsMyAge(yearOfBirth2) == age2); //You should get the error here.
</script>

#5. Tracing ( console.trace() )

This function is very interesting. Before I tell you the way that I understand, let’s take a look what console.trace does exactly in official website.

console.trace()

Prints an interactive stack trace of JavaScript execution at the point where it is called.

The stack trace details the functions on the stack, as well as the values that were passed as arguments to each function. You can click each function to take you to its source in the Script tab, and click each argument value to inspect it in the DOM or HTML tabs.

This function will tell you about the route information from start point to end point. If you are not clear what I mean, let’s take a look at the sample code and the result.

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" >
<head>
<title>Firebug</title>
<script language="javascript" type="text/javascript">
function startTrace(str){
return method1(100,200);
}
function method1(arg1,arg2){
return method2(arg1 + arg2 + 100);
}
function method2(arg1){
var var1 = arg1 / 100;
return method3(var1);
}
function method3(arg1){
console.trace();
var total = arg1 * 100;
return total;
}

</script>
</head>
<body>
<input type="button" value="Trace" onclick="startTrace(''Result'');"/>
</body>
</html>

Suppose: we wanna know how “method3′ function is invoked. So, we put this code “console.trace()” in that method. then, we run the program and we got the result as picture above. If we read the result from bottom to top, we will see “onclick(click clientX=34, clientY=26)”. That means the execution of Javascript started at on click event of button. then, we got “startTrace(“Result”)” in second line. That means startTrace function is invoked after firing onclick event and the parameter is “Result”. If we keep on checking from bottom to top, we will figure out the completed route from onclick event to method3.

If you wanna test more, you can move this code “console.trace()” to method2(). then, firebug will give the new route from onclick event which is a started point to method2() which is the end point.

I think that it’s pretty useful if you are debugging the other developer’s source code and you have no idea why this function is invoked.

Let me know if you are not clear what I’m trying to explain about console.trace();.

#6. Timing ( Measuring the time of your code)

You can use console.time(timeName) function to measure how long a particular code or function take. This feature is very helpful if you are trying to improve the performance of your Javascript code.

Example :

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" >
<head>
<title>Firebug</title>
<script language="javascript" type="text/javascript">
function measuretheTime(){
var timeName = ''measuringTime'';
console.time(timeName);

for(var i=0;i&lt;1000;i++){
///do something
for(var j=0;j&lt;100;j++){
//do another thing.
}
}

console.timeEnd(timeName);
}
</script>
</head>
<body>
<input type="button" value="Trace" onclick="measuretheTime();"/>
</body>
</html>

Result : measuringTime: 16ms

#7. Javascript Profiler

You can start the profiler thought code (console.profile(‘profileName’)) or by clicking “Profile” button from “Console” tag. It can be used for improving the performance of Javascript. It is similiar to the console.time() function but profiler can give your more advanced and detailed information.

I will tell you about this more details in next tutorial (Part2) . I hope you all are clear about this tutorial. If you have any comment or suggestion, please drop a comment.. Thanks. C ya tomorrow.

Reference ~

• Console API

Firebug Tutorial – Logging, Profiling and CommandLine (Part I)

11:12:21.924 [main] DEBUG org.apache.ibatis.logging.LogFactory - Logging initialized using ''c...

11:12:21.924 [main] DEBUG org.apache.ibatis.logging.LogFactory - Logging initialized using ''class org.apache.ibatis.logging.slf4j.Slf4jImpl'' adapter.

org.apache.ibatis.exceptions.PersistenceException: 
### Error opening session.  Cause: java.lang.NullPointerException
### Cause: java.lang.NullPointerException

	at org.apache.ibatis.exceptions.ExceptionFactory.wrapException(ExceptionFactory.java:30)
	at org.apache.ibatis.session.defaults.DefaultSqlSessionFactory.openSessionFromDataSource(DefaultSqlSessionFactory.java:100)
	at org.apache.ibatis.session.defaults.DefaultSqlSessionFactory.openSession(DefaultSqlSessionFactory.java:47)
	at com.website.DB.DBAcess.getSqlSession(DBAcess.java:15)
	at com.website.controller.ProductControllerTest.insert(ProductControllerTest.java:58)
	at sun.reflect.NativeMethodAccessorImpl.invoke0(Native Method)
	at sun.reflect.NativeMethodAccessorImpl.invoke(NativeMethodAccessorImpl.java:62)
	at sun.reflect.DelegatingMethodAccessorImpl.invoke(DelegatingMethodAccessorImpl.java:43)
	at java.lang.reflect.Method.invoke(Method.java:498)
	at org.junit.runners.model.FrameworkMethod$1.runReflectiveCall(FrameworkMethod.java:50)
	at org.junit.internal.runners.model.ReflectiveCallable.run(ReflectiveCallable.java:12)
	at org.junit.runners.model.FrameworkMethod.invokeExplosively(FrameworkMethod.java:47)
	at org.junit.internal.runners.statements.InvokeMethod.evaluate(InvokeMethod.java:17)
	at org.junit.runners.ParentRunner.runLeaf(ParentRunner.java:325)
	at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:78)
	at org.junit.runners.BlockJUnit4ClassRunner.runChild(BlockJUnit4ClassRunner.java:57)
	at org.junit.runners.ParentRunner$3.run(ParentRunner.java:290)
	at org.junit.runners.ParentRunner$1.schedule(ParentRunner.java:71)
	at org.junit.runners.ParentRunner.runChildren(ParentRunner.java:288)
	at org.junit.runners.ParentRunner.access$000(ParentRunner.java:58)
	at org.junit.runners.ParentRunner$2.evaluate(ParentRunner.java:268)
	at org.junit.runners.ParentRunner.run(ParentRunner.java:363)
	at org.junit.runner.JUnitCore.run(JUnitCore.java:137)
	at com.intellij.junit4.JUnit4IdeaTestRunner.startRunnerWithArgs(JUnit4IdeaTestRunner.java:68)
	at com.intellij.rt.execution.junit.IdeaTestRunner$Repeater.startRunnerWithArgs(IdeaTestRunner.java:47)
	at com.intellij.rt.execution.junit.JUnitStarter.prepareStreamsAndStart(JUnitStarter.java:242)
	at com.intellij.rt.execution.junit.JUnitStarter.main(JUnitStarter.java:70)
Caused by: java.lang.NullPointerException
	at org.apache.ibatis.session.defaults.DefaultSqlSessionFactory.openSessionFromDataSource(DefaultSqlSessionFactory.java:95)
	... 25 more


Process finished with exit code -1

我使用Mybatis的时候，遇到了这个报错，不明所以，后来发现是因为我没有写数据库配置的原因

<!-- 设置一个默认的连接环境信息 -->
    <environments default="mysql_developer">
        <environment id="mysql_developer">
            <!-- mybatis使用jdbc事务管理方式 -->
            <transactionManager type="JDBC"></transactionManager>
            <!-- mybatis使用连接池方式来获取连接 -->
            <dataSource type="POOLED">
                <!-- 配置与数据库交互的4个必要属性，不要直接写，单独写在一个配置文件中 -->
                <property name="driver" value="com.mysql.cj.jdbc.Driver"/>
                <property name="url" value="jdbc:mysql://127.0.0.1:3306/shuyunquan?serverTimezone=UTC"/>
                <property name="username" value="root"/>
                <property name="password" value="123"/>
            </dataSource>
        </environment>
    </environments>

就是这个，我没配置，我在application.yml里面已经配置了数据库连接了，所以这里没有配置，同时也忘了使用properties标签去引入数据库配置。所以才导致了这个错误。

48-Command line is too long. Shorten command line

Command line is too long. Shorten command line for Test or also for Application default configuration?

报错内容:
Error running ''ServiceStarter'': Command line is too long. Shorten command line for ServiceStarter or also for Application default configuration.

解决办法：
修改项目下 .idea\workspace.xml，找到标签 <component name="PropertiesComponent"> ， 在标签里 <property name="dynamic.classpath" value="true" />

Angular 2 User Registration and Login Example & Tutorial - Built with Angular 2.0 Final.

http://jasonwatmore.com/post/2016/09/29/angular-2-user-registration-and-login-example-tutorial

By Jason Watmore

Tags: Angular 2, Login, Registration, Authentication and Authorization

Automating code reviews and application profiling with Amazon CodeGuru

https://amazonaws-china.com/blogs/devops/automating-code-reviews-and-application-profiling-with-amazon-codeguru/

Amazon CodeGuru is a machine learning-based service released during re:Invent 2019 for automated code reviews and application performance recommendations. CodeGuru equips the development teams with the tools to maintain a high bar for coding standards in their software development process.

CodeGuru Reviewer helps developers avoid introducing issues that are difficult to detect, troubleshoot, reproduce, and root-cause. It also enables them to improve application performance. This not only improves the reliability of the software, but also cuts down the time spent chasing difficult issues like race conditions, slow resource leaks, thread safety issues, use of un-sanitized inputs, inappropriate handling of sensitive data, and application performance impact, to name a few.

CodeGuru is powered by machine learning, best practices, and hard-learned lessons across millions of code reviews and thousands of applications profiled on open source projects and internally at Amazon.

The service leverages machine-learning abilities to provide following two functionalities:

a) Reviewer: provides automated code reviews for static code analysis

b) Profiler: provides visibility into and recommendations about application performance during runtime

This blog post provides a short workshop to get a feel for both the above functionalities.

Solution overview

The following diagram illustrates a typical developer workflow in which the CodeGuru service is used in the code-review stage and the application performance-monitoring stage. The code reviewer is used for static code analysis backed with trained machine-learning models, and the profiler is used to monitor application performance when the code artifact is deployed and executed on the target compute.

The following diagram depicts additional details to show the big picture in the overall schema of the CodeGuru workflow:

This blog workshop automates the deployment of a sample application from a GitHub link via an AWS CloudFormation template, including the dependencies needed. It also demonstrates the Reviewer functionality.

Pre-requisites

Follow these steps to get set up:

1. Set up your AWS Cloud9 environment and access the bash terminal, preferably in the us-east-1 region.

2. Ensure you have an individual GitHub account.

3. Configure an Amazon EC2 key-pair (preferably in the us-east-1 region) and make the .pem file available from the terminal being used.

CodeGuru Reviewer

This section demonstrates how to configure CodeGuru Reviewer functionality and associate it with the GitHub repository. Execute the following configuration steps:

Step 1: Fork the GitHub repository
First, log in to your GitHub account and navigate to this sample code. Choose Fork and wait for it to create a fork in your account, as shown in the following screenshot.

Step 2: Associate the GitHub repository
Log in to the CodeGuru dashboard and follow these steps:

1. Choose Reviewer from the left panel and choose Associate repository.

2. Choose GitHub and then choose Connect to GitHub.

3. Once authenticated and connection made, you can select the repository aws-codeguru-profiler-sample-application from the Repository location drop-down list and choose Associate, as shown in the following screenshot.

This associates the CodeGuru Reviewer with the specified repository and continues to listen for any pull-request events.

Step 3: Prepare your code
From your AWS Cloud9 terminal, clone the repository, create a new branch, using the following example commands:

git clone https://github.com/<your-userid>/aws-codeguru-profiler-sample-application.git
cd aws-codeguru-profiler-sample-application
git branch dev
git checkout dev
cd src/main/java/com/company/sample/application/

Open the file: CreateOrderThread.java and goto the line 63. Below line 63 which adds an order entry, insert the if statement under the comment to introduce an order entry check. Please indent the lines with spaces so they are well aligned as shown below.

SalesSystem.orders.put(orderDate, order);
//Check if the Order entered and present
if (SalesSystem.orders.containsKey(orderDate)) {
        System.out.println("New order verified to be present in hashmap: " + SalesSystem.orders.get(orderDate)); 
}
id++;

Once the above changes are introduced in the file, save and commit it to git and push it to the Repository.

git add .
git commit -s -m "Introducing new code that is potentially thread unsafe and inefficient"
cd ../../../../../../../
ls src/main/java/com/company/sample/application/

Now, upload the new branch to the GitHub repository using the following commands. Enter your credentials when asked to authenticate against your GitHub account:

git status
git push --set-upstream origin dev
ls

Step 4: Create a Pull request on GitHub:
In your GitHub account, you should see a new branch: dev.

1. Go to your GitHub account and choose the Pull requests tab.

2. Select New pull request.

3. Under Comparing Changes, select <userid>/aws-codeguru-profiler-sample-application as the source branch.

4. Select the options from the two drop-down lists that selects a merge proposal from the dev branch to the master branch, as shown in the following screenshot.

5. Review the code diffs shown. It should say that the diffs are mergeable (able to merge). Choose Create Pull request to complete the process.

This sends a Pull request notification to the CodeGuru service and is reflected on the CodeGuru dashboard, as shown in the following screenshot.

After a short time, a set of recommendations appears on the same GitHub page on which the Pull request was created.

The demo profiler configuration and recommendations shown on the dashboard are provided by default as a sample application profile. See the profiler section of this post for further discussion.

The following screenshot shows a recommendation generated about potential thread concurrency susceptibility:

Another example below to show how the developer can provide feedback about recommendations using emojis:

As you can see from the recommendations, not only are the code issues detected, but a detailed recommendation is also provided on how to fix the issues, along with a link to examples, and documentation, wherever applicable. For each of the recommendations, a developer can give feedback about whether the recommendation was useful or not with a simple emoji selection under Pick your reaction.

Please note that the CodeGuru service is used to identify difficult-to-find functional defects and not syntactical errors. Syntax errors should be flagged by the IDE and addressed at an early stage of development. CodeGuru is introduced at a later stage in a developer workflow, when the code is already developed, unit-tested, and ready for code-review.

CodeGuru Profiler

CodeGuru Profiler functionality focuses on searching for application performance optimizations, identifying your most “expensive” lines of code that take unnecessarily long times or higher-than-expected CPU cycles, for which there is a better/faster/cheaper alternative. It generates recommendations with actions you can take in order to reduce your CPU use, lower your compute costs, and overall improve your application’s performance. The profiler simplifies the troubleshooting and exploration of the application’s runtime behavior using visualizations. Examples of such issues include excessive recreation of expensive objects, expensive deserialization, usage of inefficient libraries, and excessive logging.

This post provides two sample application Demo profiles by default in the profiler section to demonstrate the visualization of CPU and latency characteristics of those profiles. This offers a quick and easy way to check the profiler output without onboarding an application. Additionally, there are recommendations shown for the {CodeGuru} DemoProfilingGroup-WithIssues application profile. However, if you would like to run a proof-of-concept with real application, please follow the procedure below.

The following steps launch a sample application on Amazon EC2 and configure Profiler to monitor the application performance from the CodeGuru service.

Step 1: Create a profiling group
Follow these steps to create a profiling group:

1. From the CodeGuru dashboard, choose Profiler from the left panel.

2. Under Profiling groups, select Create profiling group and type the name of your group. This workshop uses the name DemoProfilingGroup.

3. After typing the name, choose Create in the bottom right corner.

The output page shows you instructions on how to onboard the CodeGuru Profiler Agent library into your application, along with the necessary permissions required to successfully submit data to CodeGuru. This workshop uses the AWS CloudFormation template to automate the onboarding configuration and launch Amazon EC2 with the application and its dependencies.

Step 2: Run AWS Cloudformation to launch Amazon EC2 with the Java application:
This example runs an AWS CloudFormation template that does all the undifferentiated heavy lifting of launching an Amazon EC2 machine and installing JDK, Maven, and the sample demo application.

Once done, it configures the application to use a profiling group named DemoProfilingGroup, compiles the application, and executes it as a background process. This results in the sample demo application running in the region you choose, and submits profiling data to the CodeGuru Profiler Service under the DemoProfilingGroup profiling group created in the previous step.

To launch the AWS CloudFormation template that deploys the demo application, choose the following Launch Stack button, and fill in the Stack name, Key-pair name, and Profiling Group name.

Once the AWS CloudFormation deployment succeeds, log in to your terminal of choice and use ssh to connect to the Amazon EC2 machine. Check the running application using the following commands:

ssh -i ''<path-to-keypair.pem-file>'' ec2-user@<ec2-ip-address>
java -version
mvn -v
ps -ef | grep SalesSystem  => This is the java application running in the background
tail /var/log/cloud-init-output.log  => You should see output as INFO: Successfully reported profile

Once the CodeGuru agent is imported into the application, a separate profiler thread spawns when the application runs. It samples the application CPU and Latency characteristics and delivers them to the backend Profiler service for building the application profile.

Step 3: Check the Profiler flame-graphs:
Wait for 10-15 minutes for your profiling-group to become active (if not already) and for profiling data to be submitted and aggregated by the CodeGuru Profiler service.

Visit the Profiling Groups page and choose DemoProfilingGroup. You should see the following page showing your application’s profiling data in a visualization called a flame-graph, as shown in the screenshot below. Detailed explanation about flame-graphs and how to read them follow.

Profiler extensively uses flame-graph visualizations to display your application’s profiling data since they’re a great way to convey issues once you understand how to read them.

The x-axis shows the stack profile population (collection of stack traces) sorted alphabetically (not chronologically), and the y-axis shows stack depth, counting from zero at the bottom. Each rectangle represents a stack frame. The wider a frame is is, the more often it was present in the stacks. The top edge shows what is on CPU, and beneath it is its ancestry. The colors are usually not significant (they’re picked randomly to differentiate frames).

As shown in the preceding screenshot, the stack traces for the three threads are shown, which are triggered by the code in the SalesSystem.java file.

1) createOrderThread.run

2) createIllegalOrderThread.run

3) listOrderThread.run

The flame-graph also depicts the stack depth and points out specific function names when you hover over that block. The marked areas in the flame-graph highlight the top block functions on-CPU and spikes in stack-trace. This may indicate an opportunity to optimize.

It is evident from the preceding diagram that significant CPU time is being used by an exception stack trace (leftmost). It’s also highlighted in the recommendation report as described in Step 4 below.

The exception is caused by trying to instantiate an Enum class giving it invalid String values. If you review the file CreateIllegalOrderThread.java, you should notice the constructors being called with illegal product names, which are defined in ProductName.java.

Step 4: Profiler Recommendations:
Apart from the real-time visualization of application performance described in the preceding section, a recommendation report (generated after a period of time) may appear, pointing out suspected inefficiencies to fix to improve the application performance. Once the recommendation appears, select the Recommendation link to see the details.

Each section in the Recommendations report can be expanded in order to get instructions on how to resolve the issue, or to examine several locations in which there were issues in your data, as shown in the following screenshot.

In the preceding example, the report includes an issue named Checking for Values not in enum, in which it conveys that more time (15.4%) was spent processing exceptions than expected (less than 1%). The reason for the exceptions is described in Step 3 and the resolution recommendations are provided in the report.

CodeGuru supportability:

CodeGuru currently supports native Java-based applications for the Reviewer and Profiler functionality. The Reviewer functionality currently supports AWS CodeCommit and all cloud-hosted non-enterprise versions of GitHub products, including Free/Pro/Team, as code repositories.

Amazon CodeGuru Profiler does not have any code repository dependence and works with Java applications hosted on Amazon EC2, containerized applications running on Amazon ECS and Amazon EKS, serverless applications running on AWS Fargate, and on-premises hosts with adequate AWS credentials.

Cleanup

At the end of this workshop, once the testing is completed, follow these steps to disable the service to avoid incurring any further charges.

1. Reviewer: Remove the association of the CodeGuru service to the repository, so that any further Pull-request notifications don’t trigger the CodeGuru service to perform an automated code-review.

2. Profiler: Remove the profiling group.

3. Amazon EC2 Compute: Go to the Amazon EC2 service, select the CodeGuru EC2 machine, and select the option to terminate the Amazon EC2 compute.

Conclusion

This post reviewed the CodeGuru service and implemented code examples for the Reviewer and Profiler functionalities. It described Reviewer functionality providing automated code-reviews and detailed guidance on fixes. The Profiler functionality enabled you to visualize your real-time application stack for granular inspection and generate recommendations that provided guidance on performance improvements.

I hope this post was informative and enabled you to onboard and test the service, as well as to leverage this service in your application development workflow.

About the Author

Nikunj Vaidya is a Sr. Solutions Architect with Amazon Web Services, focusing in the area of DevOps services. From his past experience in Sr. Engineering roles, he cares about improving the software quality and customer experience, and closely works with the customers to offer technical guidance on building DevOps solutions.

我们今天的关于Firebug Tutorial (Section 1)– Logging, Profiling and CommandLine (Part I)的分享就到这里，谢谢您的阅读，如果想了解更多关于11:12:21.924 [main] DEBUG org.apache.ibatis.logging.LogFactory - Logging initialized using ''c...、48-Command line is too long. Shorten command line、Angular 2 User Registration and Login Example & Tutorial - Built with Angular 2.0 Final.、Automating code reviews and application profiling with Amazon CodeGuru的相关信息，可以在本站进行搜索。