Java SerializationInl类代码示例

import com.vangav.backend.content.formatting.SerializationInl; //导入依赖的package包/类
/**
 * Constructor JavaEmailDispatchable
 * initializes through serializing a JavaEmail Object
 * @param javaEmail
 * @return new JavaEmailDispatchable Object
 * @throws Exception
 */
@JsonIgnore
public JavaEmailDispatchable (
  JavaEmail javaEmail) throws Exception {
  
  this.type = "java_email";
  
  this.serialized_message =
    SerializationInl.serializeObject(javaEmail);
}
 

import com.vangav.backend.content.formatting.SerializationInl; //导入依赖的package包/类
/**
 * Constructor MailGunEmailDispatchable
 * initializes through serializing a MailGunEmail Object
 * @param mailGunEmail
 * @return new MailGunEmailDispatchable Object
 * @throws Exception
 */
@JsonIgnore
public MailGunEmailDispatchable (
  MailGunEmail mailGunEmail) throws Exception {
  
  this.type = "mail_gun_email";
  
  this.serialized_message =
    SerializationInl.serializeObject(mailGunEmail);
}
 

import com.vangav.backend.content.formatting.SerializationInl; //导入依赖的package包/类
/**
 * Constructor TwilioMmsDispatchable
 * initializes through serializing a TwilioMms Object
 * @param twilioMms
 * @return new TwilioMmsDispatchable Object
 * @throws Exception
 */
@JsonIgnore
public TwilioMmsDispatchable (TwilioMms twilioMms) throws Exception {
  
  this.type = "twilio_mms";
  
  this.serialized_message =
    SerializationInl.serializeObject(twilioMms);
}
 

import com.vangav.backend.content.formatting.SerializationInl; //导入依赖的package包/类
/**
 * Constructor TwilioSmsDispatchable
 * initializes through serializing a TwilioSms Object
 * @param twilioSms
 * @return new TwilioSmsDispatchable Object
 * @throws Exception
 */
@JsonIgnore
public TwilioSmsDispatchable (TwilioSms twilioSms) throws Exception {
  
  this.type = "twilio_sms";
  
  this.serialized_message =
    SerializationInl.serializeObject(twilioSms);
}
 

import com.vangav.backend.content.formatting.SerializationInl; //导入依赖的package包/类
/**
 * Constructor QueryDispatchable
 * initializes through serializing a Query
 * @param query
 * @return new QueryDispatchable Object
 * @throws Exception
 */
@JsonIgnore
public QueryDispatchable (Query query) throws Exception {
  
  this.type = "cassandra_query";

  this.serialized_message =
    SerializationInl.serializeObject(new WorkerQuery(query) );
}
 

import com.vangav.backend.content.formatting.SerializationInl; //导入依赖的package包/类
/**
 * fromQueryDispatchable
 * @param queryDispatchable
 * @return new WorkerQuery Object reflecting param queryDispatchable
 * @throws Exception
 */
public static WorkerQuery fromQueryDispatchable (
  QueryDispatchable queryDispatchable) throws Exception {
  
  return
    SerializationInl.<WorkerQuery>deserializeObject(
      queryDispatchable.serialized_message);
}
 

import com.vangav.backend.content.formatting.SerializationInl; //导入依赖的package包/类
/**
 * Constructor AppleNotificationDispatchable
 * initializes through serializing an AppleNotification
 * @param appleNotification
 * @return new AppleNotificationDispatchable Object
 * @throws Exception
 */
@JsonIgnore
public AppleNotificationDispatchable (
  AppleNotification appleNotification) throws Exception {
  
  this.type = "apple_notification";
  
  this.serialized_message =
    SerializationInl.serializeObject(appleNotification);
}
 

import com.vangav.backend.content.formatting.SerializationInl; //导入依赖的package包/类
/**
 * Constructor AndroidNotificationDispatchable
 * initialized through serializing an AndroidNotification
 * @param androidNotification
 * @return new AndroidNotificationDispatchable Object
 * @throws Exception
 */
@JsonIgnore
public AndroidNotificationDispatchable (
  AndroidNotification androidNotification) throws Exception {
  
  this.type = "android_notification";
  
  this.serialized_message =
    SerializationInl.serializeObject(androidNotification);
}
 

import com.vangav.backend.content.formatting.SerializationInl; //导入依赖的package包/类
@Override
protected void process(CycleLog cycleLog) throws Exception {
  
  // get cycle's planned start calendar
  Calendar plannedStartCalendar =
    CalendarAndDateOperationsInl.getCalendarFromUnixTime(
      cycleLog.getPlannedStartTime() );
  
  // -1 hour -- this cycle should check for the jobs from the past hour
  plannedStartCalendar.set(Calendar.HOUR_OF_DAY, -1);
  
  // query all jobs within cycle's hour
  ResultSet resultSet =
    HourlyCurrentJobs.i().executeSyncSelect(
      CalendarFormatterInl.concatCalendarFields(
        plannedStartCalendar,
        Calendar.YEAR,
        Calendar.MONTH,
        Calendar.DAY_OF_MONTH,
        Calendar.HOUR_OF_DAY) );
  
  // to to fetch each job
  ResultSet currJobResultSet;
  
  String currSerializedJob;
  Job currJob;
  
  // retry executing every found job (failed to execute job)
  for (Row row : resultSet) {
    
    if (resultSet.getAvailableWithoutFetching() <=
        Constants.kCassandraPrefetchLimit &&
        resultSet.isFullyFetched() == false) {
      
      // this is asynchronous
      resultSet.fetchMoreResults();
    }
    
    // select job
    currJobResultSet =
      CurrentJobs.i().executeSyncSelect(
        row.getUUID(HourlyCurrentJobs.kJobIdColumnName) );
    
    // couldn't get job?
    if (currJobResultSet.isExhausted() == true) {
      
      // may need to log an exception here depending how how this service,
      //   the main service and the dispense work together - in terms of sync
      continue;
    }
    
    // get serialized job
    currSerializedJob =
      EncodingInl.decodeStringFromByteBuffer(
        currJobResultSet.one().getBytes(
          CurrentJobs.kJobColumnName) );
    
    // deserialize
    currJob = SerializationInl.<Job>deserializeObject(currSerializedJob);
    
    // execute job (retry)
    JobsExecutorInl.executeJobsAsync(currJob);
  }
}
 

import com.vangav.backend.content.formatting.SerializationInl; //导入依赖的package包/类
/**
 * fromJavaEmailDispatchable
 * usually used on the worker instance side where dispatch messages are
 *   received then gets executed
 * @param javaEmailDispatchable is a JSON Object with a serialized
 *          version of a JavaEmail Object
 * @return the deserialized version of the JavaEmail Object
 * @throws Exception
 */
public static JavaEmail fromJavaEmailDispatchable (
  JavaEmailDispatchable javaEmailDispatchable) throws Exception {
  
  return
    SerializationInl.<JavaEmail>deserializeObject(
      javaEmailDispatchable.serialized_message);
}
 

import com.vangav.backend.content.formatting.SerializationInl; //导入依赖的package包/类
/**
 * fromMailGunEmailDispatchable
 * usually used on the worker instance side where dispatch messages are
 *   received and gets executed
 * @param mailGunEmailDispatchable is a JSON Object with a serialized
 *          version of a MailGunEmail Object
 * @return the deserialized version of the MailGunEmail Object
 * @throws Exception
 */
public static MailGunEmail fromMailGunEmailDispatchable (
  MailGunEmailDispatchable mailGunEmailDispatchable) throws Exception {
  
  return
    SerializationInl.<MailGunEmail>deserializeObject(
      mailGunEmailDispatchable.serialized_message);
}
 

import com.vangav.backend.content.formatting.SerializationInl; //导入依赖的package包/类
/**
 * fromTwilioSmsDispatchable
 * usually used on the worker instance side where dispatch messages are
 *   received then gets executed
 * @param twilioSmsDispatchable is a JSON Object with a serialized
 *          version of a TwilioSms Object
 * @return the deserialized version of the TwilioSms Object
 * @throws Exception
 */
public static TwilioSms fromTwilioSmsDispatchable (
  TwilioSmsDispatchable twilioSmsDispatchable) throws Exception {
  
  return
    SerializationInl.<TwilioSms>deserializeObject(
      twilioSmsDispatchable.serialized_message);
}
 

import com.vangav.backend.content.formatting.SerializationInl; //导入依赖的package包/类
/**
 * fromTwilioMmsDispatchable
 * usually used on the worker instance side where dispatch messages are
 *   received then gets executed
 * @param twilioMmsDispatchable is a JSON Object with a serialized
 *          version of a TwilioMms Object
 * @return the deserialized version of the TwilioMms Object
 * @throws Exception
 */
public static TwilioMms fromTwilioMmsDispatchable (
  TwilioMmsDispatchable twilioMmsDispatchable) throws Exception {
  
  return
    SerializationInl.<TwilioMms>deserializeObject(
      twilioMmsDispatchable.serialized_message);
}
 

import com.vangav.backend.content.formatting.SerializationInl; //导入依赖的package包/类
/**
 * fromAppleNotificationDispatchable
 * usually used on the worker instance side where dispatch messages are
 *   received then gets executed
 * @param appleNotificationDispatchable is a JSON Object with a serialized
 *          version of an AppleNotification Object
 * @return the deserialized version of the AppleNotification Object
 * @throws Exception
 */
public static AppleNotification fromAppleNotificationDispatchable (
  AppleNotificationDispatchable
    appleNotificationDispatchable) throws Exception {
  
  return
    SerializationInl.<AppleNotification>deserializeObject(
      appleNotificationDispatchable.serialized_message);
}
 

import com.vangav.backend.content.formatting.SerializationInl; //导入依赖的package包/类
/**
 * fromAndroidNotificationDispatchable
 * usually used on the worker instance side where dispatch messages are
 *   received then gets executed
 * @param androidNotificationDispatchable us a JSON Object with a serialized
 *          version of an AndroidNotification Object
 * @return the deserialized version of the AndroidNotification Object
 * @throws Exception
 */
public static AndroidNotification fromAndroidNotificationDispatchable (
  AndroidNotificationDispatchable
    androidNotificationDispatchable) throws Exception {
  
  return SerializationInl.<AndroidNotification>deserializeObject(
    androidNotificationDispatchable.serialized_message);
}