import org.vertx.java.platform.PlatformLocator; //导入依赖的package包/类
private static void startProxy()
{
	if (pm == null)
	{
		pm = PlatformLocator.factory.createPlatformManager();
		JsonObject config;

		try
		{
			config = new JsonObject(Resources.toString(Resources.getResource("ramlvalidation_config.json"), Charsets.UTF_8));
		}
		catch (Exception e)
		{
			config = null;
		}

		pm.deployVerticle(ProxyServerApplication.class.getCanonicalName(), config,
				((URLClassLoader) ProxyServerApplication.class.getClassLoader()).getURLs(), 1, null, null);
	}
}
 

import org.vertx.java.platform.PlatformLocator; //导入依赖的package包/类
/** It starts vertx and deploys this project module */
public static void main(String[] args) throws InterruptedException, IOException {

   PlatformManager pm = PlatformLocator.factory.createPlatformManager(5558,"localhost");
   
   pm.deployModule("com.chuidiang.examples~vertx~1.0.0", null, 1, new Handler<AsyncResult<String>>() {
      
      @Override
      public void handle(AsyncResult<String> arg0) {
         System.out.println("module deploying result "+arg0.result());
      }
   });
}
 

import org.vertx.java.platform.PlatformLocator; //导入依赖的package包/类
private void createPlatform(final YamlDocument conf) {

        //
        // Create platform manager only once (configuration change doesn't matter)
        //
        if (m_manager == null) {
            YamlDocument confCluster = conf.getDocument(CONF_KEY_CLUSTER);

            if (confCluster.getValue(CONF_KEY_ENABLED, DEF_CLUSTERED)) {
                //
                // Create clustered platform
                //
                m_logger.info("Starting in clustered mode");
                YamlDocument confHazelcast = conf.getDocument(CONF_KEY_HAZELCAST);
                int hostPort = confHazelcast.getValue(CONF_KEY_HOST_PORT);
                List<String> hostAddrs = confHazelcast.getList(CONF_KEY_HOST_ADDRESS);
                m_manager = PlatformLocator.factory.createPlatformManager(hostPort, hostAddrs.get(0));
                //
                // Retrieve hazelcast used by Vert.x (first instance)
                //
                Set<HazelcastInstance> hzInstances = Hazelcast.getAllHazelcastInstances();
                HazelcastInstance hzInstance = hzInstances.iterator().next();
                Config hzConfig = hzInstance.getConfig();
                hzConfig.getNetworkConfig().getInterfaces().clear();

                String clusterName = confCluster.getValue(CONF_KEY_NAME);
                String clusterPasswd = confCluster.getValue(CONF_KEY_PASSWORD);

                //
                // Sanity checks
                //
                Preconditions.checkNotNull(clusterName, "No cluster name "
                        + "defined in configuration file");
                Preconditions.checkNotNull(clusterPasswd, "No cluster password "
                        + "defined in configuration file");

                hzConfig.getGroupConfig().setName(clusterName);
                hzConfig.getGroupConfig().setPassword(clusterPasswd);

                boolean autoIncrement = confHazelcast.getValue(CONF_KEY_HOST_PORT_AUTO_INCR);
                int portCount = confHazelcast.getValue(CONF_KEY_HOST_PORT_COUNT);
                hzConfig.getNetworkConfig().setPort(hostPort);
                hzConfig.getNetworkConfig().setPortAutoIncrement(autoIncrement);
                hzConfig.getNetworkConfig().setPortCount(portCount);

                // Enable interfaces
                hzConfig.getNetworkConfig().getInterfaces().setInterfaces(hostAddrs);

            } else {
                //
                // Create non-clustered platform
                //
                m_logger.info("Starting in non-clustered mode");
                m_manager = PlatformLocator.factory.createPlatformManager();
            }
        }
    }
 

import org.vertx.java.platform.PlatformLocator; //导入依赖的package包/类
@Override
public void start(StartContext context) throws StartException {
    this.platformManager = PlatformLocator.factory.createPlatformManager();
}