Вы можете использовать spark-submit для Spark 2.X после установки следующих переменных среды:
1) SPARK_HOME для пути к клиенту spark2 (например, / usr / hdp / current / spark2-client) 2) SPARK_MAJOR_VERSION = 2
Используя эти две конфигурации, даже если на кластере установлены Spark 1.x и Spark 2.x, вы можете запускать задания с использованием Spark 2.x с помощью одних и тех же команд, таких как spark-shell, spark -submit
См. Сглаживающийся Код Стрелки для справки.
- Условия замены с защитными пунктами.
- Разложите условные блоки на отдельные функции.
- Преобразуйте отрицательные проверки в положительные проверки.
Возвратитесь рано:
if (input == null) {
return output;
}
И никогда код как этот (если Вы не поддерживаете свой собственный код),
Я должен был поддержать код как этот, и так же ужасно как фильм Charles_Bronsonn (некоторые люди как те фильмы хотя)
Этот вид кода является обычным прибытием из процедурных языков, таких как C (C процедурный :P), Так или иначе.
Это было причиной, почему ObjectOrientedProgrammng стал господствующей тенденцией. Это позволяет Вам создавать объекты и добавлять состояние к ним. Создайте операции с тем состоянием. Они не только держатели свойства.
Я знаю, что Вы составили тот сценарий, но большинство времен все те условия является бизнес-правилами!!. Большинство времен те правила ИЗМЕНЕНИЕ, и если исходный разработчик не длиннее там (или несколько месяцев уже передали) не будет выполнимым способом изменить тот код. Правила неудобно прочитать. И много боли прибывает из этого.
1.) Сохраните состояние объекта В объекте с помощью переменных члена парламента, не занимающего официального поста (иначе атрибуты, свойства, экземпляры Вар и т.д.)
2.) Сделайте методы частными (это - то, что тот уровень доступа для), таким образом, ни один не может назвать их по ошибке и поместить программу в земле NullPointerException.
3.) Создайте методы, которые определяют, каково условие. Это - то, что они называют сам документирующий код
Таким образом вместо
// validates the user has amount
if( amount > other && that != var || startsAligned() != false ) {
}
Создайте метод
if( isValidAmount() ) {
}
private boolean isValidAmount() {
return ( amount > other && that != var || startsAligned() != false );
}
Я знаю, что это выглядит подробным, но позволяет человеку смочь прочитать код. Компилятор не заботится об удобочитаемости.
Таким образом, как это было бы похоже на Ваш гипервложенный с этим подходом?
Как это.
// these are business rules
// then it should be clear that those rules are
// and what they do.
// internal state of the object.
private SomeClass2 obj2;
private SomeClass3 obj3;
private SomeClass4 obj4;
//public String myFunc( SomeClass input ) {
public String myComplicatedValidation( SomeClass input ) {
this.input = input;
if ( isValidInput() &&
isRuleTwoReady() &&
isRuleTreeDifferentOf( BAD_OBJECT ) &&
isRuleFourDifferentOf( BAD_VALUE ) &&
isMessageLengthInRenge( MIN_VALUE , MAX_VALUE ) ) {
message = resultOfStuffActuallyDone();
}
}
// These method names are self explaining what they do.
private final boolean isValidInput() {
return this.input != null;
}
private final boolean isRuleTwoReady() {
obj2 = input.getSomeClass2();
return obj2 != null ;
}
private final boolean isRuleTreeDifferentOf( Object badObject ) {
obj3 = obj2.getSomeClass3();
return obj3 != null && !badObject.equals( obj3.getSomeProperty() );
}
private final boolean isRuleFourDifferentOf( int badValue ) {
obj4 = obj3.getSomeClass4();
return obj4 != null && obj4.getSomeValue() != badValue;
}
private final boolean isMessageLengthInRenge( int min, int max ) {
String message = getMessage( obj4.getSomeValue() );
int length = message.length();
return length >= min && length <= max;
}
Я знаю, Это похоже на большее количество кодирования. Но думайте об этом. Правила почти человекочитаемы
if ( isValidInput() &&
isRuleTwoReady() &&
isRuleTreeDifferentOf( BAD_OBJECT ) &&
isRuleFourDifferentOf( BAD_VALUE ) &&
isMessageLengthInRenge( MIN_VALUE , MAX_VALUE ) ) {
message = resultOfStuffActuallyDone();
}
Может быть почти считан как
if is valid input
and rule two is ready
and rule three is not BAD OBJECT
and rule four is no BAD_VALUE
and the message length is in range
И соблюдением правила варьируются маленькие, кодер может понять их очень легко и не бояться тормоза что-то.
Намного больше может быть считано об этом в: http://www.refactoring.com/
Да, Вы могли удалить отступы следующим образом:
В основном сделайте проверки последовательно и сравните с отказом, а не успехом. Это удаляет вложение и помогает следовать (IMO).
public String myFunc(SomeClass input)
{
Object output = null;
if (input == null)
{
return null;
}
SomeClass2 obj2 = input.getSomeClass2();
if (obj2 == null)
{
return null;
}
SomeClass3 obj3 = obj2.getSomeClass3();
if (obj3 == null || BAD_OBJECT.equals(obj3.getSomeProperty()))
{
return null;
}
SomeClass4 = obj3.getSomeClass4();
if (obj4 == null)
{
return null;
}
int myVal = obj4.getSomeValue();
if (BAD_VALUE == myVal)
{
return null;
}
String message = this.getMessage(myVal);
if (MIN_VALUE <= message.length() &&
message.length() <= MAX_VALUE)
{
//now actually do stuff!
message = result_of_stuff_actually_done;
}
return output;
}
Можно избавиться от части вложения при помощи защитных пунктов.
public String myFunc(SomeClass input)
{
Object output = null;
if(input == null) return "";
SomeClass2 obj2 = input.getSomeClass2();
if(obj2 == null) return "";
SomeClass3 obj3 = obj2.getSomeClass3();
if(obj3 == null || BAD_OBJECT.equals(obj3.getSomeProperty()))
{
return "";
}
SomeClass4 = obj3.getSomeClass4();
if(obj4 == null) return "";
int myVal = obj4.getSomeValue();
if(BAD_VALUE == myVal) return "";
String message = this.getMessage(myVal);
if(MIN_VALUE <= message.length() &&
message.length() <= MAX_VALUE)
{
//now actually do stuff!
message = result_of_stuff_actually_done;
}
return output;
}
Измените весь из return "";
операторы, что я раньше иллюстрировал тезис к операторам, которые бросают описательное разнообразие Исключения, все же.
Если Вы не должны обрабатывать остановку, не встраивать.
Например, можно сделать:
if(input == null && input.getSomeClass2() == null && ...)
return null;
// Do what you want.
Принятие Вы используете язык как Java, который заказывает условные выражения.
Кроме того, Вы могли:
if(input == null && input.getSomeClass2() == null)
return null;
SomeClass2 obj2 = input.getSomeClass2();
if(obj2 == null)
return null;
...
// Do what you want.
Для более сложных случаев.
Идея состоит в том, чтобы возвратиться из метода, если Вы не должны обрабатывать. Встраивание в большое, вложенное, если почти невозможно читать.
если это - просто проблема удобочитаемости, Вы могли бы сделать это более ясным путем перемещения вложения в другой метод. Дополнительно преобразуйте в защитный стиль, если Вам нравится.
public String myFunc(SomeClass input)
{
Object output = null;
if (inputIsValid(input))
{
//now actually do stuff!
message = result_of_stuff_actually_done;
}
return output;
}
private bool inputIsValid(SomeClass input)
{
// *****************************************
// convert these to guard style if you like
// *****************************************
if(input != null)
{
SomeClass2 obj2 = input.getSomeClass2();
if(obj2 != null)
{
SomeClass3 obj3 = obj2.getSomeClass3();
if(obj3 != null && !BAD_OBJECT.equals(obj3.getSomeProperty()))
{
SomeClass4 = obj3.getSomeClass4();
if(obj4 != null)
{
int myVal = obj4.getSomeValue();
if(BAD_VALUE != myVal)
{
String message = this.getMessage(myVal);
if(MIN_VALUE <= message.length() &&
message.length() <= MAX_VALUE)
{
return true;
}
}
}
}
}
}
return false;
}