001 /*
002 * Copyright 2008-2015 the original author or authors.
003 *
004 * Licensed under the Apache License, Version 2.0 (the "License");
005 * you may not use this file except in compliance with the License.
006 * You may obtain a copy of the License at
007 *
008 * http://www.apache.org/licenses/LICENSE-2.0
009 *
010 * Unless required by applicable law or agreed to in writing, software
011 * distributed under the License is distributed on an "AS IS" BASIS,
012 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
013 * See the License for the specific language governing permissions and
014 * limitations under the License.
015 */
016 package org.codehaus.griffon.runtime.core;
017
018 import griffon.core.ApplicationBootstrapper;
019 import griffon.core.GriffonApplication;
020 import griffon.core.env.GriffonEnvironment;
021 import griffon.core.injection.Binding;
022 import griffon.core.injection.Injector;
023 import griffon.core.injection.InjectorFactory;
024 import griffon.core.injection.Module;
025 import griffon.util.GriffonClassUtils;
026 import org.codehaus.griffon.runtime.core.injection.AbstractModule;
027 import org.slf4j.Logger;
028 import org.slf4j.LoggerFactory;
029
030 import javax.annotation.Nonnull;
031 import java.util.ArrayList;
032 import java.util.Collection;
033 import java.util.Iterator;
034 import java.util.LinkedHashMap;
035 import java.util.List;
036 import java.util.Map;
037 import java.util.ServiceLoader;
038
039 import static griffon.core.GriffonExceptionHandler.sanitize;
040 import static griffon.util.AnnotationUtils.sortByDependencies;
041 import static java.util.Collections.unmodifiableCollection;
042 import static java.util.Objects.requireNonNull;
043
044 /**
045 * @author Andres Almiray
046 * @since 2.0.0
047 */
048 public abstract class AbstractApplicationBootstrapper implements ApplicationBootstrapper {
049 private static final Logger LOG = LoggerFactory.getLogger(DefaultApplicationBootstrapper.class);
050 private static final String INJECTOR = "injector";
051 protected final GriffonApplication application;
052
053 public AbstractApplicationBootstrapper(@Nonnull GriffonApplication application) {
054 this.application = requireNonNull(application, "Argument 'application' must not be null");
055 }
056
057 @Override
058 public void bootstrap() throws Exception {
059 // 1 initialize environment settings
060 LOG.info("Griffon {}", GriffonEnvironment.getGriffonVersion());
061 LOG.info("Build: {}", GriffonEnvironment.getBuildDateTime());
062 LOG.info("JVM: {}", GriffonEnvironment.getJvmVersion());
063 LOG.info("OS: {}", GriffonEnvironment.getOsVersion());
064
065 // 2 create bindings
066 LOG.debug("Creating module bindings");
067 Iterable<Binding<?>> bindings = createBindings();
068
069 if (LOG.isTraceEnabled()) {
070 for (Binding<?> binding : bindings) {
071 LOG.trace(binding.toString());
072 }
073 }
074
075 // 3 create injector
076 LOG.debug("Creating application injector");
077 createInjector(bindings);
078 }
079
080 @Override
081 public void run() {
082 application.initialize();
083 application.startup();
084 application.ready();
085 }
086
087 @Nonnull
088 protected Iterable<Binding<?>> createBindings() {
089 Map<Key, Binding<?>> map = new LinkedHashMap<>();
090
091 List<Module> modules = new ArrayList<>();
092 createApplicationModule(modules);
093 collectModuleBindings(modules);
094
095 for (Module module : modules) {
096 for (Binding<?> binding : module.getBindings()) {
097 map.put(Key.of(binding), binding);
098 }
099 }
100
101 return unmodifiableCollection(map.values());
102 }
103
104 protected void createApplicationModule(@Nonnull List<Module> modules) {
105 modules.add(new AbstractModule() {
106 @Override
107 protected void doConfigure() {
108 bind(GriffonApplication.class)
109 .toInstance(application);
110 }
111 });
112 }
113
114 protected void collectModuleBindings(@Nonnull Collection<Module> modules) {
115 List<Module> moduleInstances = loadModules();
116 moduleInstances.add(0, new DefaultApplicationModule());
117 Map<String, Module> sortedModules = sortModules(moduleInstances);
118 for (Map.Entry<String, Module> entry : sortedModules.entrySet()) {
119 LOG.debug("Loading module bindings from {}:{}", entry.getKey(), entry.getValue());
120 modules.add(entry.getValue());
121 }
122 }
123
124 @Nonnull
125 protected Map<String, Module> sortModules(@Nonnull List<Module> moduleInstances) {
126 return sortByDependencies(moduleInstances, "Module", "module");
127 }
128
129 @Nonnull
130 protected abstract List<Module> loadModules();
131
132 private void createInjector(@Nonnull Iterable<Binding<?>> bindings) throws Exception {
133 ServiceLoader<InjectorFactory> serviceLoader = ServiceLoader.load(InjectorFactory.class);
134 try {
135 Iterator<InjectorFactory> iterator = serviceLoader.iterator();
136 InjectorFactory injectorFactory = iterator.next();
137 LOG.debug("Injector will be created by {}", injectorFactory);
138 Injector<?> injector = injectorFactory.createInjector(application, bindings);
139 GriffonClassUtils.setProperty(application, INJECTOR, injector);
140 } catch (Exception e) {
141 LOG.error("An error occurred while initializing the injector", sanitize(e));
142 throw e;
143 }
144 }
145 }
|