Я реализовал несколько приложений Java сейчас, пока только настольные приложения. Я предпочитаю использовать неизменяемые объекты для передачи данных в приложении вместо использования объектов с мутаторами (сеттерами и геттерами ), также называемыми JavaBeans.
Но в мире Java, кажется, гораздо более распространено использование JavaBeans, и я не могу понять, почему я должен использовать их вместо них. Лично код выглядит лучше, если он имеет дело только с неизменяемыми объектами, а не постоянно изменяет состояние.
Неизменяемые объекты также рекомендуются в Правиле 15: Минимизация изменчивости , Эффективная Java 2ed .
Если у меня есть объект, Person
реализованный как JavaBean, он будет выглядеть так:
public class Person {
private String name;
private Place birthPlace;
public Person() {}
public setName(String name) {
this.name = name;
}
public setBirthPlace(Place birthPlace) {
this.birthPlace = birthPlace;
}
public String getName() {
return name;
}
public Place getBirthPlace() {
return birthPlace;
}
}
И то же самое, Person
что и неизменный объект:
public class Person {
private final String name;
private final Place birthPlace;
public Person(String name, Place birthPlace) {
this.name = name;
this.birthPlace = birthPlace;
}
public String getName() {
return name;
}
public Place getBirthPlace() {
return birthPlace;
}
}
Или ближе к struct
C:
public class Person {
public final String name;
public final Place birthPlace;
public Person(String name, Place birthPlace) {
this.name = name;
this.birthPlace = birthPlace;
}
}
У меня также могут быть геттеры в неизменяемом объекте, чтобы скрыть детали реализации. Но поскольку я использую его только как элемент, struct
я предпочитаю пропустить "геттеры" и сохранить простоту.
Просто я не понимаю, почему лучше использовать JavaBeans, или могу и должен продолжать использовать свои неизменяемые POJO?
Многие библиотеки Java, похоже, лучше поддерживают JavaBeans, но, может быть, со временем станет более популярной поддержка неизменных POJO?
источник
Ответы:
Предпочитать JavaBeans, когда
Предпочитайте неизменяемые POJO, когда
источник
Я был удивлен, что слово Thread не появилось нигде в этом обсуждении.
Одним из основных преимуществ неизменяемых классов является то, что они по своей сути более потокобезопасны из-за отсутствия изменяемого общего состояния.
Это не только упростит программирование, но и даст два побочных эффекта в производительности:
Меньше необходимости в синхронизации.
Больше возможностей для использования конечных переменных, которые могут облегчить последующую оптимизацию компилятора.
Я действительно пытаюсь перейти к неизменяемым объектам, а не к классам стиля JavaBean. По-видимому, не следует использовать раскрытие сущности объектов с помощью геттеров и сеттеров.
источник
Ну, это зависит от того, что вы пытаетесь сделать. Если вы работаете с постоянным слоем и извлекаете какую-то строку из базы данных в объект POJO и хотите изменить свойство и сохранить его обратно, лучше использовать стиль JavaBean, особенно если у вас много свойств.
Учтите, что у вашего человека много полей, таких как имя, отчество, фамилия, дата рождения, члены семьи, образование, работа, зарплата и т. Д.
И этот Человек оказался женщиной, которая только что вышла замуж и согласилась на изменение своей фамилии, и вам необходимо обновить базу данных.
Если вы используете неизменяемый POJO, вы выбираете объект Person, представляющий ее, затем вы создаете новый объект Person, которому вы передаете все свойства, которые вы не изменили, как они есть, и новую фамилию, и сохраняете ее.
Если бы это был компонент Java, вы можете просто выполнить setLastName () и сохранить его.
Это «минимизировать изменчивость», а не «никогда не использовать изменяемые объекты». Некоторые ситуации лучше работают с изменяемыми объектами, на самом деле ваша задача - решить, будет ли создание изменяемого объекта лучше соответствовать вашей программе или нет. Вы не должны всегда говорить «необходимо использовать неизменяемые объекты», вместо этого посмотрите, сколько классов вы можете сделать неизменяемыми, прежде чем начнете навредить себе.
источник
Обобщая другие ответы, я думаю, что:
get(id): Client
иsave(MutableClient)
, поскольку MutableClient является потомком Client.Если бы была промежуточная точка (создание, установка свойств, создание неизменяемости), возможно, фреймворки поощряли бы более неизменный подход.
В любом случае я предлагаю думать о неизменяемых объектах как о «Java Beans только для чтения», подчеркивая, что если вы хороший мальчик и не трогаете опасный метод setProperty, все будет в порядке.
источник
Начиная с Java 7, вы можете иметь неизменяемые бины, лучшее из обоих миров. Используйте аннотацию @ConstructorProperties в своем конструкторе.
public class Person { private final String name; private final Place birthPlace; @ConstructorProperties({"name", "birthPlace"}) public Person(String name, Place birthPlace) { this.name = name; this.birthPlace = birthPlace; } public String getName() { return name; } public Place getBirthPlace() { return birthPlace; } }
источник
Честно говоря, я не думаю, что неизменные объекты станут настолько популярными.
Я действительно вижу преимущества, но такие фреймворки, как Hibernate и Spring, сейчас очень популярны (и на то есть веская причина), и они действительно лучше всего работают с beans.
Поэтому я не думаю, что неизменяемость - это плохо, но она определенно ограничит ваши возможности интеграции с текущими фреймворками.
ИЗМЕНИТЬ Комментарии побуждают меня немного уточнить свой ответ.
Безусловно, существуют проблемные области, в которых неизменяемость очень полезна и действительно используется. Но я думаю, что текущее значение по умолчанию кажется изменяемым, поскольку это то, что в основном ожидается, и неизменным только в том случае, если это имеет явное преимущество.
И хотя в Spring действительно можно использовать конструкторы с аргументами, похоже, что это предназначено как способ использовать устаревший и / или сторонний код с красивым совершенно новым кодом Spring. По крайней мере, это то, что я взял из документации.
источник
X
иY
относятся к одному и тому же объекту, и кто-то хочет изменитьX.something
, можно сохранить идентичность X и изменитьY.something
или оставитьY.something
неизменным и изменить идентичность X, но нельзя сохранить идентичность X и состояние Y при изменении состояние X.Неизменяемый с точки зрения программирования на Java: что-то, что однажды было создано, никогда не должно иметь изменения состояния, как ожидаемого, так и неожиданного!
Этот метод полезен в защитном программировании, когда другой объект не может вызвать изменение состояния.
Примеры, в которых вы не ожидаете изменений: внешние системы (однопоточные или многопоточные), которые получают ссылку с вашего уровня, оперируют объектом и сознательно или неосознанно изменяют его. Теперь это может быть объект POJO, коллекция или ссылка на объект, и вы не ожидаете в нем изменений или хотите защитить данные. Вы обязательно сделаете объект неизменным как защитную технику
Примеры, в которых вы ожидаете изменений: На самом деле неизменяемость не нужна, так как она будет мешать правильным процедурам программирования.
источник