import com.stormpath.sdk.client.Client; //导入依赖的package包/类
@Override
protected void internalInit(final WebContext context) {
    CommonHelper.assertNotBlank("accessId", accessId);
    CommonHelper.assertNotBlank("secretKey", secretKey);
    CommonHelper.assertNotBlank("applicationId", applicationId);

    try {
        final Client client = new Client(new DefaultApiKey(accessId, secretKey));
        this.application = client.getDataStore().getResource(
                String.format("/applications/%s", applicationId), Application.class);
    } catch (final Exception e) {
        throw new BadCredentialsException("An exception is caught trying to access Stormpath cloud. " +
                "Please verify that your provided Stormpath <accessId>, " +
                "<secretKey>, and <applicationId> are correct. Original Stormpath error: " + e.getMessage());
    }
}
 

import com.stormpath.sdk.client.Client; //导入依赖的package包/类
@Override
public Application create(Client client, String applicationHref, String applicationName) {
    if (applicationName.isEmpty() && applicationHref.isEmpty()) {
        throw new IllegalArgumentException(
            "Either one of (smt.spring.security.stormpath.application.name) or " +
                "(smt.spring.security.stormpath.application.href) must be set."
        );
    }

    if (!applicationHref.isEmpty()) {
        return client.getResource(applicationHref, Application.class);
    }

    return client.getCurrentTenant()
        .getApplications(
            applicationCriteriaFactory.where(applicationCriteriaFactory.name().eqIgnoreCase(applicationName))
        ).iterator().next();
}
 

import com.stormpath.sdk.client.Client; //导入依赖的package包/类
public Application buildStormpathApplication(Environment env) {

        final Properties apiKeyProperties = new Properties();
        apiKeyProperties.setProperty(API_KEY_ID, getApiKeyId());
        apiKeyProperties.setProperty(API_KEY_SECRET, getApiKeySecret());

        // setup stormapth client with apikey properties
        ApiKey apiKey = ApiKeys.builder().setProperties(apiKeyProperties).build();
        Client client = Clients.builder().setApiKey(apiKey).build();
        this.client = client;

        // setup stormpath application
        Application application = client.getResource(getApiRestUrl(), Application.class);
        this.application = application;

        // this will initialize stormpath api
        StormpathApi.initStormpathApi(application, client);

        return application;
    }
 

import com.stormpath.sdk.client.Client; //导入依赖的package包/类
@Post
public String doPost(Representation entity) throws IOException {
    RestletServer.configureRestForm(getResponse());
    String[] body = entity.getText().split("&");
    String username = body[0].split("=")[1];
    String textpass = body[1].split("=")[1];

    String path = "resources/.stormpath/apiKey.properties";
    ApiKey apiKey = ApiKeys.builder().setFileLocation(path).build();
    Client client = Clients.builder().setApiKey(apiKey).build();

    @SuppressWarnings("rawtypes")
    AuthenticationRequest request = new UsernamePasswordRequest(username, textpass);

    Tenant tenant = client.getCurrentTenant();
    ApplicationList applications = tenant.getApplications(
        Applications.where(Applications.name().eqIgnoreCase("SOABA Secure")));
    Application application = applications.iterator().next();

    AuthenticationResult result = application.authenticateAccount(request);
    Account account = result.getAccount();
    
    Session newSession = new Session();
    newSession.setUserAccount(account);
    newSession.setToken(UUID.randomUUID().toString());
    config.getSessions().put(newSession.getToken().toString(), newSession);
    
    return toJSON(newSession);
}
 

import com.stormpath.sdk.client.Client; //导入依赖的package包/类
@Provides
@Singleton
private Application registerApplication(final Configuration configuration) {
    try {
        final String apiKeyId = configuration.getString("stormpath.apiKey.id");
        final String apiKeySecret = configuration.getString("stormpath.apiKey.secret");

        final DefaultApiKey apiKey = new DefaultApiKey(apiKeyId, apiKeySecret);
        final Client client = new ClientBuilder().setApiKey(apiKey).build();
        final String applicationName = configuration.getString("stormpath.application.name");

        final Tenant tenant = client.getCurrentTenant();
        Application application = null;

        final ApplicationList applications = tenant.getApplications(Applications
                .where(Applications.name().eqIgnoreCase(applicationName)));

        // Iterator is necessary, to check if the ApplicationsList is empty, because there's no size() method or something equal, in the ApplicationsList class.
        final Iterator<Application> iterator = applications.iterator();

        if (iterator.hasNext()) {
            application = iterator.next();
        }

        if (application == null) {
            application = client.instantiate(Application.class);
            application.setName(applicationName);
            application = client.getCurrentTenant()
                    .createApplication(Applications.newCreateRequestFor(application).createDirectory().build());
        }

        return application;
    } catch (Exception e) {
        log.error("An error occured while authenticating with Stormpath", e);
    }
    return null;
}
 

import com.stormpath.sdk.client.Client; //导入依赖的package包/类
@Override
public void setUp() throws Exception {
  super.setUp();
  // Setup our shiro+stormpath+vertx integration
  File file = ((VertxInternal) vertx).resolveFile("stormpath.properties");
  ApiKey apiKey = ApiKeys.builder().setFileLocation(file.getAbsolutePath()).build();
  Client client = Clients.builder().setApiKey(apiKey).build();
  ApplicationRealm stormpathAppRealm = new ApplicationRealm();
  stormpathAppRealm.setClient(client);
  stormpathAppRealm.setApplicationRestUrl("https://api.stormpath.com/v1/applications/2oFtzixwgN0wYKt25euKpg");
  authProvider = ShiroAuth.create(vertx, stormpathAppRealm);
}
 

import com.stormpath.sdk.client.Client; //导入依赖的package包/类
@Bean
@ConditionalOnMissingBean(Application.class)
public Application application(ApplicationFactory applicationFactory, Client client) {
    return applicationFactory.create(client, applicationHref, applicationName);
}
 

import com.stormpath.sdk.client.Client; //导入依赖的package包/类
@Bean
@ConditionalOnMissingBean(Client.class)
public Client client() {
    return Clients.builder().setApiKey(ApiKeys.builder().setId(apiKeyId).setSecret(apiKeySecret).build()).build();
}
 

import com.stormpath.sdk.client.Client; //导入依赖的package包/类
@Before
public void setUp() {
    applicationCriteriaFactory = mock(ApplicationCriteriaFactory.class);
    client = mock(Client.class);
    factory = new StormpathApplicationFactory(applicationCriteriaFactory);
}
 

import com.stormpath.sdk.client.Client; //导入依赖的package包/类
public Client getClient() {
    return client;
}
 

import com.stormpath.sdk.client.Client; //导入依赖的package包/类
public static Client getStormpathClient() {
    return stormpathClient;
}
 

import com.stormpath.sdk.client.Client; //导入依赖的package包/类
public static Client getClient() {
	return client;
}
 

import com.stormpath.sdk.client.Client; //导入依赖的package包/类
public static void setClient(final Client clientIn) {
	client = clientIn;
}
 

import com.stormpath.sdk.client.Client; //导入依赖的package包/类
public final Client getClient() {
	return client;
}
 

import com.stormpath.sdk.client.Client; //导入依赖的package包/类
public final void setClient(final Client clientIn) {
	client = clientIn;
}
 

import com.stormpath.sdk.client.Client; //导入依赖的package包/类
/**
 * This is where we inject stormpath stormpathApplicaiton instance
 *
 * @param application Application instance from stormpath
 */
public static void initStormpathApi(Application application, Client client) {
    StormpathApi.stormpathClient = client;
    StormpathApi.stormpathApplicaiton = application;
}
 

import com.stormpath.sdk.client.Client; //导入依赖的package包/类
Application create(Client client, String applicationHref, String applicationName);