Я новичок в spring, и я читаю это:
В основном bean имеет области, определяющие их существование в приложении
Singleton: означает одиночное определение bean для экземпляра одного объекта в контейнере IOC spring.
Прототип: означает одно определение bean для любого количества экземпляров объектов.
Итак, что такое "экземпляр объекта".
Область прототипа= Новый объект создается каждый раз, когда он вводится/просматривается. Он будет использовать new SomeClass() каждый раз.
Singleton scope= (по умолчанию) Тот же объект возвращается каждый раз, когда он вводится/просматривается. Здесь он будет создавать экземпляр одного экземпляра SomeClass, а затем возвращать его каждый раз.
См. также:
Давайте просто посмотрим это через код.
Ниже приводится описание компонента TennisCoach Bean с singleton областью действия по умолчанию.
@Component
@Scope("singleton")
public class TennisCoach implements Coach {
public TennisCoach(){
}
@Autowired
public void setFortuneService(FortuneService fortuneService) {
this.fortuneService = fortuneService;
}
@Override
public String getDailyWorkout() {
return "Practice your backhand volley";
}
@Override
public String getDailyFortune() {
return "Tennis Coach says : "+fortuneService.getFortune();
}
}
Ниже представлен бин TennisCoach с прототипом
@Component
@Scope("prototype")
public class TennisCoach implements Coach {
public TennisCoach(){
System.out.println(">> TennisCoach: inside default constructor");
}
@Autowired
public void setFortuneService(FortuneService fortuneService) {
System.out.println(">> Tennis Coach: inside setFortuneService");
this.fortuneService = fortuneService;
}
@Override
public String getDailyWorkout() {
return "Practice your backhand volley";
}
@Override
public String getDailyFortune() {
return "Tennis Coach says : "+fortuneService.getFortune();
}
}
Ниже приводится основной класс:
public class AnnotationDemoApp {
public static void main(String[] args) {
// read spring config file
ClassPathXmlApplicationContext context =
new ClassPathXmlApplicationContext("applicationContext.xml");
// get the bean from the spring container
Coach theCoach = context.getBean("tennisCoach",Coach.class);
Coach alphaCoach = context.getBean("tennisCoach",Coach.class);
// call a method on the bean
System.out.println("Are the two beans same :" + (theCoach==alphaCoach));
System.out.println("theCoach : " + theCoach);
System.out.println("alphaCoach: "+ alphaCoach);
context.close()
}
}
Для одноэлементной области видимости:
Are the two beans same :true
theCoach : [email protected]
alphaCoach: [email protected]
Для объема прототипа вывод:
Are the two beans same :false
theCoach : [email protected]
alphaCoach: [email protected]
Добавление к приведенному выше. Не путайте с синглэтом java. в соответствии с JAVA spec singleton означает, что только один экземпляр этого bean будет создан для JVM. но в spring singleton означает, что один экземпляр для этого конкретного bean будет создан для каждого контекста приложения. поэтому, если ваше приложение имеет более одного контекста, вы все равно можете иметь более одного экземпляра для этого bean.
Они оба являются образцовыми шаблонами дизайна.
Singleton, создаст новый экземпляр в первом вызове и вернет его в последующих вызовах.
Прототип будет возвращать новый экземпляр каждый раз.
Singleton Scope: В области Singleton создается один и только один экземпляр bean с предоставленным bean определением и последующими запросами для тех же bean, Spring контейнер вернет тот же экземпляр.
Из документации Spring:
.. когда вы определяете определение bean, и оно определяется как одноэлементное, контейнер Spring IoC создает ровно один экземпляр объекта определяемый этим определением bean. Этот единственный экземпляр хранится в кеш такого синглета beans, и все последующие запросы и ссылки для имени с именем bean возвращают кешированный объект...
Пример:
Допустим, мы определили bean accountDao, как показано ниже:
<bean id="accountDao" class="" />
И еще два beans, которые используют этот accountDao bean
<bean id="someBean" ref="accountDao" />
<bean id="anotherBean" ref="accountDao" />
Spring будет сначала создавать accountDao bean и кэшировать его. А затем для someBean, а также anotherBean, он предоставит тот же экземпляр accountDao.
Примечание. Если в определении bean не указана область видимости, Singleton - это область по умолчанию.
Область прототипа. Для области прототипа для каждого запроса для bean будет создан и возвращен новый экземпляр bean. Это похоже на вызов нового оператора в java для класса.
Пример:
Допустим, мы определили bean accountDao, как показано ниже:
<bean id="accountDao" class="" scope="prototype"/>
И еще два beans, которые используют этот accountDao bean
<bean id="someBean" ref="accountDao" />
<bean id="anotherBean" ref="accountDao" />
Для someBean и anotherBean Spring вернет два отдельных экземпляра объекта accountDao.
Одно важное отличие заключается в том, что для области прототипа Spring не управляет полным жизненным циклом bean, очистка должна выполняться клиентским кодом.
Из документации Spring:
Spring не управляет полным жизненным циклом прототипа bean: контейнер создает, настраивает и иным образом собирает прототип объекта и передает его клиенту, без дальнейшей записи этого экземпляра прототипа. Таким образом, хотя жизненный цикл инициализации методы обратного вызова вызываются на всех объектах независимо от области действия, в случай прототипов, сконфигурированные обратные вызовы жизненного цикла разрушения не являются называется. Клиентский код должен очищать объекты с прототипом и освободить дорогостоящие ресурсы, которые держат прототип bean (s).
Синглтон: если для параметра задано значение singleton, контейнер Spring IoC создает ровно один экземпляр объекта, определенного этим определением bean. Этот единственный экземпляр хранится в кеше такого singleton beans, и все последующие запросы и ссылки для имени с именем bean возвращают кешированный объект.
Прототип: если для параметра задано прототип, контейнер Spring IoC создает новый экземпляр bean объекта каждый раз, когда выполняется запрос для этого конкретного bean. Как правило, используйте область прототипа для всех полноразмерных beans и одноэлементных объектов для безстоящих beans.
Я хочу добавить дополнительную информацию, которая поможет нам узнать значение "экземпляра объекта" в указанных предложениях. Этот абзац из Spring Doc пытается определить "экземпляр объекта":
Когда вы создаете определение bean, вы создаете рецепт для создания фактических экземпляров класса, определенного этим определением bean. Идея о том, что определение bean является рецептом, важно, потому что это означает, что, как и в классе, вы можете создать много экземпляров объектов из одного рецепта.
Поэтому, как упоминалось в предыдущем разделе, каждый кадр определения bean рассматривается как класс (с точки зрения объектно-ориентированного). Согласно данным, которые вы определили в нем (например, scope,...), этот класс (или определение bean) может иметь только один экземпляр объекта (Singleton scope только одним общим экземпляром) или любое количество экземпляров объекта (для пример области прототипа, создавая новый экземпляр bean каждый раз, когда выполняется запрос для этого конкретного bean).
Если scope задан как singleton, контейнер Spring IoC создает ровно один экземпляр объекта, определенного этим определением bean. Этот единственный экземпляр хранится в кеше такого singleton beans, и все последующие запросы и ссылки для имени с именем bean возвращают кешированный объект.
Область по умолчанию всегда одиночная, но если вам нужен один и только один экземпляр bean, вы можете установить свойство scope в singleton
Разница между Singleton и Prototype - это область Prototype для всех состояний с полным полным beans и областью Singleton для безстоящих beans.
Singleton - это тот же самый экземпляр в приложении
Прототип - это новый экземпляр для каждого нового запроса getBean
Область прототипа: Новый объект создается каждый раз, когда он вводится.
Singleton scope: Тот же объект возвращается каждый раз, когда он вводится.
Область прототипа используется для всех beans, которые являются состояниями, в то время как область singleton должна использоваться для stateless beans. Позвольте мне объяснить на моем примере. Скопируйте и запустите его самостоятельно, чтобы получить четкое представление. Рассмотрим интерфейс тренера.
public interface Coach {
public String getDailyWorkout();
public String getDailyFortune();
}
У нас есть еще один класс под названием TrackCoach, который реализует Coach.
public class TrackCoach implements Coach {
private FortuneService fortuneService;
public TrackCoach(FortuneService fortuneService) {
this.fortuneService = fortuneService;
}
@Override
public String getDailyWorkout() {
return "Run a hard 5k";
}
@Override
public String getDailyFortune() {
return "Just Do it: " + fortuneService.getFortune();
}
}
Теперь есть интерфейс FortuneService.
public interface FortuneService {
public String getFortune();
}
Он реализуется нашим классом HappyFortuneService.
public class HappyFortuneService implements FortuneService {
@Override
public String getFortune() {
return "Today is your lucky day!";
}
}
Проложите два класса и введите объект bean одного класса в другой с помощью Xml. Позвольте выполнить инъекцию зависимостей. Обратите внимание, что мы можем сделать это, используя аннотацию java.
<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:context="http://www.springframework.org/schema/context"
xsi:schemaLocation="http://www.springframework.org/schema/beans
http://www.springframework.org/schema/beans/spring-beans.xsd
http://www.springframework.org/schema/context
http://www.springframework.org/schema/context/spring-context.xsd">
<!-- Define your beans here -->
<!-- define the dependency -->
<bean id = "myFortuneService"
class = "com.luv2code.springdemo.HappyFortuneService">
</bean>
<bean id = "myCoach"
class = "com.luv2code.springdemo.TrackCoach"
scope = "singleton">
<!-- set up construction injection -->
<constructor-arg ref = "myFortuneService" />
</bean>
</beans>
Обратите внимание, что scope = singleton.
Теперь давайте определим наш BeanScopeDemoApp, который имеет наш основной метод.
import org.springframework.context.support.ClassPathXmlApplicationContext;
public class BeanScopeDemoApp {
public static void main(String[] args) {
// load the spring configuration file
ClassPathXmlApplicationContext context =
new ClassPathXmlApplicationContext("beanScope-applicationContext.xml");
// retrieve bean from spring container
Coach theCoach = context.getBean("myCoach", Coach.class);
Coach alphaCoach = context.getBean("myCoach", Coach.class);
// check if they are the same
boolean result = (theCoach == alphaCoach);
// print out the results
System.out.println("\nPointing to the same object: " + result);
System.out.println("\nMemory location for theCoach: " + theCoach);
System.out.println("\nMemory location for alphaCoach: " + alphaCoach +"\n");
// close the context
context.close();
}
}
После запуска вышеуказанного кода вы увидите следующие результаты:
Pointing to the same object: true
Memory location for theCoach: [email protected]
Memory location for alphaCoach: [email protected]
Он указывает один и тот же объект и занимает одно и то же место памяти после вызова его дважды.
Теперь измените scope = prototype в нашем Xml файле, сохраните его и снова запустите BeanScopeDemoApp.
Вы увидите следующие результаты:
Pointing to the same object: false
Memory location for theCoach: [email protected]
Memory location for alphaCoach: [email protected]
Он указывает на другой объект и занимает разные ячейки памяти после вызова его дважды.
Это будет графическая иллюстрация того, что я только что сказал.
Примечание. bean с любой областью действия будет создана, если она будет передана другим beans и вызвана с использованием контекста приложения.
Пример кода, чтобы проверить это.
public class PrototypeClass {
PrototypeClass()
{
System.out.println("prototype class is created"+this.toString());
}
}
Это приведет к печати соответствующего текста при вызове конструктора.
для приведенного ниже кода
for(int i=0;i<10;i++) {
PrototypeClass pct= (PrototypeClass) context.getBean("protoClass");
}
прототип класса создан[email protected] прототип класс создан[email protected] прототип класса [email protected] - это прототип класса [email protected] класс прототипов [email protected] класс прототипа [email protected] класс прототипа [email protected] прототип класса [email protected] - прототип класса [email protected] класс прототипа Созданный класс[email protected] [email protected]
Bean определение
<bean id="protoClass" class="Spring.PrototypeClass" scope="prototype</bean>
Теперь я изменил область действия в определении bean на singleton. Конструктор вызывается только один раз при инициализации контекста. Затем я удалил атрибут scope и наблюдал такое же поведение, как singleton.