Деловая сцена: В процессе использования Java для развития бизнеса бизнес часто состоит из различных компонентов, и каждый раз при использовании этих компонентов без раздумий будет использоваться новый объект компонента.Это понятно в небольших проектах.Нет никаких проблем. Однако в проектах со сложной бизнес-логикой и совместной разработкой несколькими людьми отношения между бизнесом и компонентами сложны и неудобны в управлении, а связь между объектами становится очень высокой. И эта проблема была решена весной, и ее суть заключается в идее Ioc:
Иок: Полный текст — «Инверсия контроля». Перевод представляет собой инверсию управления, что означает, что отношения между объектами больше не контролируются традиционными программами, а контейнером Spring для единообразного управления созданием, координацией и уничтожением этих объектов, а объектам нужно только завершить бизнес-логику.
Вот объяснение Ioc из блога Bromon:
- В первую очередь хочу рассказать о IoC (Inversion of Control, инверсия управления) Это ядро весны во всем. Так называемый IoC для фреймворка Spring означает, что Spring отвечает за управление жизненным циклом объектов и связью между объектами. Например, как мы находим подруг? Обычная ситуация такова, что мы везде ходим посмотреть, где есть мм красивые и с хорошей фигурой, а потом спрашиваем об их увлечениях, номерах QQ, номерах телефонов..., пытаемся познакомиться с ними, выбираем то, что им нравится. и отправить то, что им нравится, а потом хе-хе… этот процесс сложный и эзотерический, и мы должны сами разработать и обработать каждую ссылку. То же самое верно и для традиционной разработки программ.В объекте, если вы хотите использовать другой объект, вы должны получить его (новый самостоятельно или запросить его из JNDI) и уничтожить объект после использования (например, Connection и т. д. ), Объекты всегда связаны с другими интерфейсами или классами.
- Так как же IoC это делает? Это немного похоже на поиск девушки через брачное агентство: между мной и моей девушкой появилось третье лицо: брачное агентство. Брачное агентство управляет множеством профилей мужчин и женщин, я могу отправить список в агентство и сказать ему, какую девушку я хочу найти, например, она выглядит как Ли Цзясинь, у нее тело, как у Линь Силэй, и обладает навыками как у Зидана.Тогда брачное агентство будет Мы предоставим мм по нашим требованиям,нам нужно только влюбиться в нее и жениться. Проще говоря, мы делаем исключение, если агентство знакомств предлагает нам неподходящего кандидата. Весь процесс больше не контролируется мной, а контейнерным агентством, таким как сватовство.
- Метод разработки, поддерживаемый Spring, таков: все классы будут зарегистрированы в контейнере Spring, сообщая Spring, кто вы и что вам нужно, а затем Spring возьмет на себя инициативу, чтобы дать вам то, что вы хотите, когда система работает на подходящее время, а также передавая вам другие вещи, которые вам нужны. Созданием и уничтожением всех классов управляет Spring, а это значит, что уже не объект ссылается на него, а Spring управляет жизненным циклом объекта. Для конкретного объекта раньше он управлял другими объектами, но теперь все объекты управляются пружиной, поэтому это называется инверсией управления.
- Одним из ключевых моментов IoC является динамическое предоставление объекту других необходимых ему объектов во время работы системы. Это достигается с помощью DI (внедрение зависимостей). Например, объект A должен работать с базой данных. Раньше нам всегда приходилось писать код в A, чтобы получить объект Connection. С Spring нам нужно только сказать Spring, что нам нужно Connection в A. Что касается того, как и когда построить это Соединение, А не нужно знать. Когда система работает, Spring создаст Connection в соответствующее время, а затем внедрит его в A наподобие инъекции, тем самым завершив контроль взаимосвязи между различными объектами. A должен полагаться на Connection для нормальной работы, и это Connection внедряется в A с помощью spring, поэтому название внедрения зависимостей происходит от. Так как же реализован DI? Важной функцией после Java 1.3 является отражение, которое позволяет программам динамически генерировать объекты, выполнять методы объектов и изменять свойства объектов во время выполнения Spring реализует внедрение через отражение.
Давайте посмотрим, как работает Spring
1 public static void main(String[] args) {
2 ApplicationContext context = new FileSystemXmlApplicationContext(
3 "applicationContext.xml");
4 Animal animal = (Animal) context.getBean("animal");
5 animal.say();
6 }
Этот код должен быть вам знаком, но давайте разберем его, в первую очередь applicationContext.xml
1 <bean id="animal" class="phz.springframework.test.Cat">
2 <property name="name" value="kitty" />
3 </bean>
У него есть класс phz.springframework.test.Cat
1 public class Cat implements Animal {
2 private String name;
3 public void say() {
4 System.out.println("I am " + name + "!");
5 }
6 public void setName(String name) {
7 this.name = name;
8 }
9 }
Реализован интерфейс phz.springframework.test.Animal.
1public interface Animal {
2 public void say();
3}
Очевидно, приведенный выше код выводит I am kitty! Итак, как именно Spring это делает? Далее давайте напишем Spring, чтобы посмотреть, как работает Spring! Во-первых, мы определяем класс Bean, который используется для хранения свойств, принадлежащих Bean.
1/* Bean Id */
2 private String id;
3 /* Bean Class */
4 private String type;
5 /* Bean Property */
6 private Map<String, Object> properties = new HashMap<String, Object>();
一个Bean包括id,type,和Properties。
Затем Spring начинает загружать наш файл конфигурации и сохранять информацию о нашей конфигурации в HashMap. Ключ HashMap — это идентификатор Bean-компонента, а значение HasMap — этот Bean-компонент. Только таким образом мы можем передать context.getBean(" животное" ) Этот метод получает класс Animal. Мы все знаем, что Spirng может внедрять базовые типы, а также такие типы, как List и Map.Давайте возьмем Map в качестве примера, чтобы увидеть, как Spring его сохраняет.
Конфигурация карты может быть следующей
1<bean id="test" class="Test">
2 <property name="testMap">
3 <map>
4 <entry key="a">
5 <value>1</value>
6 </entry>
7 <entry key="b">
8 <value>2</value>
9 </entry>
10 </map>
11 </property>
12 </bean>
Как Spring сохраняет приведенную выше конфигурацию? , код показан ниже:
1(beanProperty.element("map") != null) {
2 Map<String, Object> propertiesMap = new HashMap<String, Object>();
3 Element propertiesListMap = (Element) beanProperty
4 .elements().get(0);
5 Iterator<?> propertiesIterator = propertiesListMap
6 .elements().iterator();
7 while (propertiesIterator.hasNext()) {
8 Element vet = (Element) propertiesIterator.next();
9 if (vet.getName().equals("entry")) {
10 String key = vet.attributeValue("key");
11 Iterator<?> valuesIterator = vet.elements()
12 .iterator();
13 while (valuesIterator.hasNext()) {
14 Element value = (Element) valuesIterator.next();
15 if (value.getName().equals("value")) {
16 propertiesMap.put(key, value.getText());
17 }
18 if (value.getName().equals("ref")) {
19 propertiesMap.put(key, new String[] { value
20 .attributeValue("bean") });
21 }
22 }
23 }
24 }
25 bean.getProperties().put(name, propertiesMap);
26 }
Теперь давайте перейдем к основной части. Давайте посмотрим, как Spring реализует внедрение зависимостей. На самом деле идея внедрения зависимостей очень проста. Она реализуется через механизм отражения. Когда создается экземпляр класса, он вызывается посредством отражения. set в классе вводит атрибуты класса, заранее сохраненные в HashMap, в класс. Давайте посмотрим, как именно он это делает. Сначала создайте экземпляр класса, подобного этому
1public static Object newInstance(String className) {
2 Class<?> cls = null;
3 Object obj = null;
4 try {
5 cls = Class.forName(className);
6 obj = cls.newInstance();
7 } catch (ClassNotFoundException e) {
8 throw new RuntimeException(e);
9 } catch (InstantiationException e) {
10 throw new RuntimeException(e);
11 } catch (IllegalAccessException e) {
12 throw new RuntimeException(e);
13 }
14 return obj;
15 }
Затем он внедряет в него зависимости этого класса, вот так
1public static void setProperty(Object obj, String name, String value) {
2 Class<? extends Object> clazz = obj.getClass();
3 try {
4 String methodName = returnSetMthodName(name);
5 Method[] ms = clazz.getMethods();
6 for (Method m : ms) {
7 if (m.getName().equals(methodName)) {
8 if (m.getParameterTypes().length == 1) {
9 Class<?> clazzParameterType = m.getParameterTypes()[0];
10 setFieldValue(clazzParameterType.getName(), value, m,
11 obj);
12 break;
13 }
14 }
15 }
16 } catch (SecurityException e) {
17 throw new RuntimeException(e);
18 } catch (IllegalArgumentException e) {
19 throw new RuntimeException(e);
20 } catch (IllegalAccessException e) {
21 throw new RuntimeException(e);
22 } catch (InvocationTargetException e) {
23 throw new RuntimeException(e);
24 }
25}
Наконец, он возвращает нам экземпляр этого класса, который мы можем использовать. Давайте возьмем Map в качестве примера, чтобы увидеть, как он это делает Код, который я написал, предназначен для создания HashMap и внедрения HashMap в класс, который необходимо внедрить, например:
1if (value instanceof Map) {
2 Iterator<?> entryIterator = ((Map<?, ?>) value).entrySet()
3 .iterator();
4 Map<String, Object> map = new HashMap<String, Object>();
5 while (entryIterator.hasNext()) {
6 Entry<?, ?> entryMap = (Entry<?, ?>) entryIterator.next();
7 if (entryMap.getValue() instanceof String[]) {
8 map.put((String) entryMap.getKey(),
9 getBean(((String[]) entryMap.getValue())[0]));
10 }
11 }
12 BeanProcesser.setProperty(obj, property, map);
13 }
Здесь вы можете примерно понять принцип реализации Ioc в Spring.Эта статья представляет собой простой текст и пример для объяснения Ioc.Для более глубокого понимания требуется больше практического опыта. В этой статье упоминается следующее:
blog.CSDN.net/ будет по адресу 1013… blog.CSDN.net/IT_Full/Арити…
Думаете, эта статья была вам полезна? пожалуйста, поделитесь с большим количеством людей Обратите внимание на «Безграничное программирование» и улучшите свои навыки принуждения.