org.xdi.oxd.common.CoreUtils クラス

org.xdi.oxd.common.CoreUtils 連携図

クラス
class	JacksonMapperHolder

静的公開メンバ関数
static boolean	isExpired (Date expiredAt)
static ScheduledExecutorService	createExecutor ()
static ThreadFactory	daemonThreadFactory ()
static void	sleep (int i)
static String	asJson (Object p_object) throws IOException
static String	asJsonSilently (Object p_object)
static ObjectMapper	createJsonMapper ()
static Command	asCommand (String commandAsJson) throws IOException
static long	parseSilently (String p_str)
static String	normalizeLengthPrefixString (int p_length)
static ReadResult	readCommand (String p_leftString, BufferedReader p_reader) throws IOException
static boolean	allNotBlank (String... p_strings)
static HttpClient	createHttpClientWithKeyStore (File pathToKeyStore, String password) throws Exception
static HttpClient	createHttpClientTrustAll () throws NoSuchAlgorithmException, KeyManagementException, KeyStoreException, UnrecoverableKeyException
static String	secureRandomString ()
static Map< String, String >	splitQuery (String url) throws UnsupportedEncodingException, MalformedURLException
static Map< String, String >	splitQuery (URL url) throws UnsupportedEncodingException

静的公開変数類
static final String	UTF8 = "UTF-8"
static final int	COMMAND_STR_LENGTH_SIZE = 4
static final int	BUFFER_SIZE = 8192

非公開メンバ関数
	CoreUtils ()

静的非公開変数類
static final Logger	LOG = LoggerFactory.getLogger(CoreUtils.class)

詳解

Core utility class.

著者

Yuriy Zabrovarnyy

バージョン

0.9, 27/07/2013

構築子と解体子

CoreUtils()

org.xdi.oxd.common.CoreUtils.CoreUtils ( )

inlineprivate

Avoid instance creation.

                        {
    }

関数詳解

allNotBlank()

static boolean org.xdi.oxd.common.CoreUtils.allNotBlank ( String...  p_strings )

inlinestatic

                                                           {
        if (p_strings != null && p_strings.length > 0) {
            for (String s : p_strings) {
                if (org.apache.commons.lang.StringUtils.isBlank(s)) {
                    return false;
                }
            }
            return true;
        }
        return false;
    }

asCommand()

static Command org.xdi.oxd.common.CoreUtils.asCommand ( String  commandAsJson ) throws IOException

inlinestatic

                                                                             {
        return createJsonMapper().readValue(commandAsJson, Command.class);
    }

asJson()

static String org.xdi.oxd.common.CoreUtils.asJson ( Object  p_object ) throws IOException

inlinestatic

Converts object to json string.

引数

p_object

object to convert to string

戻り値

json object representation in string format

例外

java.io.IOException

if io problems occurs

                                                                    {
        final ObjectMapper mapper = createJsonMapper().configure(SerializationConfig.Feature.WRAP_ROOT_VALUE, false);
        return mapper.writeValueAsString(p_object);
    }

asJsonSilently()

static String org.xdi.oxd.common.CoreUtils.asJsonSilently ( Object  p_object )

inlinestatic

                                                         {
        try {
            final ObjectMapper mapper = createJsonMapper().configure(SerializationConfig.Feature.WRAP_ROOT_VALUE, false);
            return mapper.writeValueAsString(p_object);
        } catch (Exception e) {
            LOG.error("Failed to serialize object into json.", e);
            return "";
        }
    }

createExecutor()

static ScheduledExecutorService org.xdi.oxd.common.CoreUtils.createExecutor ( )

inlinestatic

                                                            {
        return Executors.newSingleThreadScheduledExecutor(daemonThreadFactory());
    }

createHttpClientTrustAll()

static HttpClient org.xdi.oxd.common.CoreUtils.createHttpClientTrustAll ( ) throws NoSuchAlgorithmException, KeyManagementException, KeyStoreException, UnrecoverableKeyException

inlinestatic

                                                                                                                                                              {
//        System.setProperty("javax.net.debug", "SSL,handshake,trustmanager");

//        SSLSocketFactory sf = new SSLSocketFactory(new TrustStrategy() {
//            @Override
//            public boolean isTrusted(X509Certificate[] chain, String authType) throws CertificateException {
//                return true;
//            }
//        }, new AllowAllHostnameVerifier());

        SSLSocketFactory sf = new SSLSocketFactory(new TrustStrategy() {
            @Override
            public boolean isTrusted(X509Certificate[] chain, String authType) throws CertificateException {
                return true;
            }
        }, new X509HostnameVerifier() {
            @Override
            public void verify(String host, SSLSocket ssl) throws IOException {
            }

            @Override
            public void verify(String host, X509Certificate cert) throws SSLException {
            }

            @Override
            public void verify(String host, String[] cns, String[] subjectAlts) throws SSLException {
            }

            @Override
            public boolean verify(String s, SSLSession sslSession) {
                return true;
            }
        }
        );

        SchemeRegistry registry = new SchemeRegistry();
        registry.register(new Scheme("http", 80, PlainSocketFactory.getSocketFactory()));
        registry.register(new Scheme("https", 443, sf));
        ClientConnectionManager ccm = new PoolingClientConnectionManager(registry);
        return new DefaultHttpClient(ccm);
    }

createHttpClientWithKeyStore()

static HttpClient org.xdi.oxd.common.CoreUtils.createHttpClientWithKeyStore ( File  pathToKeyStore, String  password  ) throws Exception

inlinestatic

引数

pathToKeyStore	path to key store, e.g. D:/Development/gluu_conf/etc/certs/DA855F9895A1CA3B9E7D4BF5-java.jks
password	key store password

戻り値

http client

例外

Exception

                                                                                                                 {
        KeyStore keyStore = KeyStore.getInstance(KeyStore.getDefaultType());
        FileInputStream instream = new FileInputStream(pathToKeyStore);
        try {
            keyStore.load(instream, password.toCharArray());
        } finally {
            instream.close();
        }

        HttpClient httpClient = new DefaultHttpClient();

        SSLSocketFactory socketFactory = new SSLSocketFactory(keyStore);
        socketFactory.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);

        httpClient.getConnectionManager().getSchemeRegistry().register(new Scheme("https", socketFactory, 443));
        httpClient.getConnectionManager().getSchemeRegistry().register(new Scheme("http", PlainSocketFactory.getSocketFactory(), 80));

        return httpClient;
    }

createJsonMapper()

static ObjectMapper org.xdi.oxd.common.CoreUtils.createJsonMapper ( )

inlinestatic

Creates json mapper for json object serialization/deserialization.

戻り値

object mapper

                                                  {
        return JacksonMapperHolder.MAPPER;
    }

daemonThreadFactory()

static ThreadFactory org.xdi.oxd.common.CoreUtils.daemonThreadFactory ( )

inlinestatic

                                                      {
        return new ThreadFactory() {
            public Thread newThread(Runnable p_r) {
                Thread thread = new Thread(p_r);
                thread.setDaemon(true);
                return thread;
            }
        };
    }

isExpired()

static boolean org.xdi.oxd.common.CoreUtils.isExpired ( Date  expiredAt )

inlinestatic

                                                    {
        return expiredAt != null && expiredAt.before(new Date());
    }

normalizeLengthPrefixString()

static String org.xdi.oxd.common.CoreUtils.normalizeLengthPrefixString ( int  p_length )

inlinestatic

                                                                   {
        if (p_length <= 0) {
            throw new IllegalArgumentException("Length must be more than zero.");
        }
        final String s = Integer.toString(p_length);
        final StringBuilder sb = new StringBuilder(s);
        final int sbLength = sb.length();
        if (sbLength < COMMAND_STR_LENGTH_SIZE) {
            for (int i = sbLength; i < COMMAND_STR_LENGTH_SIZE; i++) {
                sb.insert(0, '0');
            }
        }
        if (sb.length() != COMMAND_STR_LENGTH_SIZE) {
            throw new IllegalArgumentException("Normalized length size must be exactly: " + COMMAND_STR_LENGTH_SIZE);
        }
        return sb.toString();
    }

parseSilently()

static long org.xdi.oxd.common.CoreUtils.parseSilently ( String  p_str )

inlinestatic

                                                   {
        try {
            return Long.parseLong(p_str);
        } catch (Exception e) {
            return -1;
        }
    }

readCommand()

static ReadResult org.xdi.oxd.common.CoreUtils.readCommand ( String  p_leftString, BufferedReader  p_reader  ) throws IOException

inlinestatic

                                                                                                          {
        int commandSize = -1;
        final StringBuilder storage = new StringBuilder(p_leftString != null ? p_leftString : "");
        while (true) {
            LOG.trace("commandSize: {}, stringStorage: {}", commandSize, storage.toString());

            final char[] buffer = new char[BUFFER_SIZE];
            final int readCount = p_reader.read(buffer, 0, BUFFER_SIZE);
            if (readCount == -1) {
                LOG.trace("End of stream. Quit.");
                return null;
            }

            storage.append(buffer, 0, readCount);

            final int storageLength = storage.length();
            if (commandSize == -1 && storageLength >= CoreUtils.COMMAND_STR_LENGTH_SIZE) {
                final String sizeString = storage.substring(0, CoreUtils.COMMAND_STR_LENGTH_SIZE);
                commandSize = (int) CoreUtils.parseSilently(sizeString);
                LOG.trace("Parsed sizeString: {}, commandSize: {}", sizeString, commandSize);

                if (commandSize == -1) {
                    LOG.trace("Unable to identify command size. Quit.");
                    return null;
                }
            }

            final int totalSize = commandSize + CoreUtils.COMMAND_STR_LENGTH_SIZE;
            if (commandSize != -1 && storageLength >= totalSize) {
                final String commandAsString = storage.substring(
                        CoreUtils.COMMAND_STR_LENGTH_SIZE, totalSize);

                String leftString = "";
                if (storageLength > (totalSize + 1)) {
                    storage.substring(totalSize + 1);
                }
                final ReadResult result = new ReadResult(commandAsString, leftString);
                LOG.trace("Read result: {}", result);
                return result;
            }
        }
    }

secureRandomString()

static String org.xdi.oxd.common.CoreUtils.secureRandomString ( )

inlinestatic

                                              {
        return new BigInteger(130, new SecureRandom()).toString(32);
    }

sleep()

static void org.xdi.oxd.common.CoreUtils.sleep ( int  i )

inlinestatic

                                    {
        try {
            Thread.sleep(i * 1000);
        } catch (InterruptedException e) {
            LOG.error(e.getMessage(), e);
        }
    }

splitQuery() [1/2]

static Map<String, String> org.xdi.oxd.common.CoreUtils.splitQuery ( String  url ) throws UnsupportedEncodingException, MalformedURLException

inlinestatic

                                                                                                                        {
        return splitQuery(new URL(url));
    }

splitQuery() [2/2]

static Map<String, String> org.xdi.oxd.common.CoreUtils.splitQuery ( URL  url ) throws UnsupportedEncodingException

inlinestatic

                                                                                              {
        Map<String, String> queryPairs = new LinkedHashMap<>();
        String query = url.getQuery();
        String[] pairs = query.split("&");
        for (String pair : pairs) {
            int idx = pair.indexOf("=");
            queryPairs.put(URLDecoder.decode(pair.substring(0, idx), "UTF-8"), URLDecoder.decode(pair.substring(idx + 1), "UTF-8"));
        }
        return queryPairs;
    }

メンバ詳解

BUFFER_SIZE

final int org.xdi.oxd.common.CoreUtils.BUFFER_SIZE = 8192

static

COMMAND_STR_LENGTH_SIZE

final int org.xdi.oxd.common.CoreUtils.COMMAND_STR_LENGTH_SIZE = 4

static

LOG

final Logger org.xdi.oxd.common.CoreUtils.LOG = LoggerFactory.getLogger(CoreUtils.class)

staticprivate

Logger

UTF8

final String org.xdi.oxd.common.CoreUtils.UTF8 = "UTF-8"

static

UTF-8 encoding string

---

このクラス詳解は次のファイルから抽出されました:

• D:/AppData/OpenId/gluu/src/oxd/oxd-common/src/main/java/org/xdi/oxd/common/CoreUtils.java