001 /*
002 * Copyright 2008-2017 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.artifact;
017
018 import griffon.core.GriffonApplication;
019 import griffon.core.artifact.GriffonArtifact;
020 import griffon.core.artifact.GriffonClass;
021 import griffon.core.artifact.GriffonController;
022 import griffon.core.artifact.GriffonModel;
023 import griffon.core.artifact.GriffonMvcArtifact;
024 import griffon.core.artifact.GriffonView;
025 import griffon.core.i18n.NoSuchMessageException;
026 import griffon.core.mvc.MVCFunction;
027 import griffon.core.mvc.MVCGroup;
028 import griffon.core.mvc.MVCGroupFunction;
029 import griffon.core.mvc.TypedMVCGroup;
030 import griffon.core.mvc.TypedMVCGroupFunction;
031 import org.slf4j.Logger;
032 import org.slf4j.LoggerFactory;
033
034 import javax.annotation.Nonnull;
035 import javax.annotation.Nullable;
036 import javax.annotation.concurrent.GuardedBy;
037 import javax.inject.Inject;
038 import java.io.InputStream;
039 import java.net.URL;
040 import java.util.List;
041 import java.util.Map;
042 import java.util.concurrent.Callable;
043 import java.util.concurrent.ExecutorService;
044 import java.util.concurrent.Future;
045
046 /**
047 * Base implementation of the GriffonArtifact interface.
048 *
049 * @author Andres Almiray
050 * @since 2.0.0
051 */
052 public abstract class AbstractGriffonArtifact implements GriffonArtifact {
053 private final Logger log;
054 private final Object lock = new Object[0];
055 @Inject
056 protected GriffonApplication application;
057 @GuardedBy("lock")
058 private GriffonClass griffonClass;
059
060 public AbstractGriffonArtifact() {
061 log = LoggerFactory.getLogger("griffon.app." + getArtifactType() + "." + getTypeClass().getName());
062 }
063
064 @Override
065 @Nonnull
066 public Class<? extends GriffonArtifact> getTypeClass() {
067 return getClass();
068 }
069
070 /**
071 * Creates a new instance of this class.
072 *
073 * @param application the GriffonApplication that holds this artifact.
074 *
075 * @deprecated Griffon prefers field injection over constructor injector for artifacts as of 2.1.0
076 */
077 @Inject
078 @Deprecated
079 public AbstractGriffonArtifact(@Nonnull GriffonApplication application) {
080 this();
081 this.application = application;
082 }
083
084 @Nonnull
085 public GriffonApplication getApplication() {
086 return application;
087 }
088
089 @Nonnull
090 @Override
091 @SuppressWarnings("ConstantConditions")
092 public GriffonClass getGriffonClass() {
093 synchronized (lock) {
094 if (griffonClass == null) {
095 griffonClass = application.getArtifactManager().findGriffonClass(getTypeClass());
096 }
097 return griffonClass;
098 }
099 }
100
101 @Nonnull
102 @Override
103 public Logger getLog() {
104 return log;
105 }
106
107 @Nonnull
108 protected abstract String getArtifactType();
109
110 @Override
111 public boolean isUIThread() {
112 return application.getUIThreadManager().isUIThread();
113 }
114
115 @Nonnull
116 @Override
117 public <R> Future<R> runFuture(@Nonnull ExecutorService executorService, @Nonnull Callable<R> callable) {
118 return application.getUIThreadManager().runFuture(executorService, callable);
119 }
120
121 @Nonnull
122 @Override
123 public <R> Future<R> runFuture(@Nonnull Callable<R> callable) {
124 return application.getUIThreadManager().runFuture(callable);
125 }
126
127 @Override
128 public void runInsideUISync(@Nonnull Runnable runnable) {
129 application.getUIThreadManager().runInsideUISync(runnable);
130 }
131
132 @Override
133 public void runOutsideUI(@Nonnull Runnable runnable) {
134 application.getUIThreadManager().runOutsideUI(runnable);
135 }
136
137 @Override
138 public void runOutsideUIAsync(@Nonnull Runnable runnable) {
139 application.getUIThreadManager().runOutsideUIAsync(runnable);
140 }
141
142 @Override
143 public void runInsideUIAsync(@Nonnull Runnable runnable) {
144 application.getUIThreadManager().runInsideUIAsync(runnable);
145 }
146
147 @Nullable
148 @Override
149 public <R> R runInsideUISync(@Nonnull Callable<R> callable) {
150 return application.getUIThreadManager().runInsideUISync(callable);
151 }
152
153 @Nonnull
154 @Override
155 public ClassLoader classloader() {
156 return application.getResourceHandler().classloader();
157 }
158
159 @Nullable
160 @Override
161 public URL getResourceAsURL(@Nonnull String name) {
162 return application.getResourceHandler().getResourceAsURL(name);
163 }
164
165 @Nullable
166 @Override
167 public List<URL> getResources(@Nonnull String name) {
168 return application.getResourceHandler().getResources(name);
169 }
170
171 @Nullable
172 @Override
173 public InputStream getResourceAsStream(@Nonnull String name) {
174 return application.getResourceHandler().getResourceAsStream(name);
175 }
176
177 @Override
178 @Nonnull
179 public MVCGroup createMVCGroup(@Nonnull String mvcType) {
180 return application.getMvcGroupManager().createMVCGroup(mvcType);
181 }
182
183 @Override
184 @Nonnull
185 public MVCGroup createMVCGroup(@Nonnull String mvcType, @Nonnull String mvcId) {
186 return application.getMvcGroupManager().createMVCGroup(mvcType, mvcId);
187 }
188
189 @Override
190 @Nonnull
191 public MVCGroup createMVCGroup(@Nonnull Map<String, Object> args, @Nonnull String mvcType) {
192 return application.getMvcGroupManager().createMVCGroup(args, mvcType);
193 }
194
195 @Override
196 @Nonnull
197 public MVCGroup createMVCGroup(@Nonnull String mvcType, @Nonnull Map<String, Object> args) {
198 return application.getMvcGroupManager().createMVCGroup(mvcType, args);
199 }
200
201 @Override
202 @Nonnull
203 public MVCGroup createMVCGroup(@Nonnull Map<String, Object> args, @Nonnull String mvcType, @Nonnull String mvcId) {
204 return application.getMvcGroupManager().createMVCGroup(args, mvcType, mvcId);
205 }
206
207 @Override
208 @Nonnull
209 public MVCGroup createMVCGroup(@Nonnull String mvcType, @Nonnull String mvcId, @Nonnull Map<String, Object> args) {
210 return application.getMvcGroupManager().createMVCGroup(mvcType, mvcId, args);
211 }
212
213 @Override
214 @Nonnull
215 public <MVC extends TypedMVCGroup> MVC createMVCGroup(@Nonnull Class<? extends MVC> mvcType) {
216 return application.getMvcGroupManager().createMVCGroup(mvcType);
217 }
218
219 @Override
220 @Nonnull
221 public <MVC extends TypedMVCGroup> MVC createMVCGroup(@Nonnull Class<? extends MVC> mvcType, @Nonnull String mvcId) {
222 return application.getMvcGroupManager().createMVCGroup(mvcType, mvcId);
223 }
224
225 @Override
226 @Nonnull
227 public <MVC extends TypedMVCGroup> MVC createMVCGroup(@Nonnull Map<String, Object> args, @Nonnull Class<? extends MVC> mvcType) {
228 return application.getMvcGroupManager().createMVCGroup(args, mvcType);
229 }
230
231 @Override
232 @Nonnull
233 public <MVC extends TypedMVCGroup> MVC createMVCGroup(@Nonnull Class<? extends MVC> mvcType, @Nonnull Map<String, Object> args) {
234 return application.getMvcGroupManager().createMVCGroup(mvcType, args);
235 }
236
237 @Override
238 @Nonnull
239 public <MVC extends TypedMVCGroup> MVC createMVCGroup(@Nonnull Map<String, Object> args, @Nonnull Class<? extends MVC> mvcType, @Nonnull String mvcId) {
240 return application.getMvcGroupManager().createMVCGroup(args, mvcType, mvcId);
241 }
242
243 @Override
244 @Nonnull
245 public <MVC extends TypedMVCGroup> MVC createMVCGroup(@Nonnull Class<? extends MVC> mvcType, @Nonnull String mvcId, @Nonnull Map<String, Object> args) {
246 return application.getMvcGroupManager().createMVCGroup(mvcType, mvcId, args);
247 }
248
249 @Override
250 @Nonnull
251 public List<? extends GriffonMvcArtifact> createMVC(@Nonnull String mvcType) {
252 return application.getMvcGroupManager().createMVC(mvcType);
253 }
254
255 @Override
256 @Nonnull
257 public List<? extends GriffonMvcArtifact> createMVC(@Nonnull Map<String, Object> args, @Nonnull String mvcType) {
258 return application.getMvcGroupManager().createMVC(args, mvcType);
259 }
260
261 @Override
262 @Nonnull
263 public List<? extends GriffonMvcArtifact> createMVC(@Nonnull String mvcType, @Nonnull Map<String, Object> args) {
264 return application.getMvcGroupManager().createMVC(mvcType, args);
265 }
266
267 @Override
268 @Nonnull
269 public List<? extends GriffonMvcArtifact> createMVC(@Nonnull String mvcType, @Nonnull String mvcId) {
270 return application.getMvcGroupManager().createMVC(mvcType, mvcId);
271 }
272
273 @Override
274 @Nonnull
275 public List<? extends GriffonMvcArtifact> createMVC(@Nonnull Map<String, Object> args, @Nonnull String mvcType, @Nonnull String mvcId) {
276 return application.getMvcGroupManager().createMVC(args, mvcType, mvcId);
277 }
278
279 @Override
280 @Nonnull
281 public List<? extends GriffonMvcArtifact> createMVC(@Nonnull String mvcType, @Nonnull String mvcId, @Nonnull Map<String, Object> args) {
282 return application.getMvcGroupManager().createMVC(mvcType, mvcId, args);
283 }
284
285 @Override
286 @Nonnull
287 public <MVC extends TypedMVCGroup> List<? extends GriffonMvcArtifact> createMVC(@Nonnull Class<? extends MVC> mvcType) {
288 return application.getMvcGroupManager().createMVC(mvcType);
289 }
290
291 @Override
292 @Nonnull
293 public <MVC extends TypedMVCGroup> List<? extends GriffonMvcArtifact> createMVC(@Nonnull Map<String, Object> args, @Nonnull Class<? extends MVC> mvcType) {
294 return application.getMvcGroupManager().createMVC(args, mvcType);
295 }
296
297 @Override
298 @Nonnull
299 public <MVC extends TypedMVCGroup> List<? extends GriffonMvcArtifact> createMVC(@Nonnull Class<? extends MVC> mvcType, @Nonnull Map<String, Object> args) {
300 return application.getMvcGroupManager().createMVC(mvcType, args);
301 }
302
303 @Override
304 @Nonnull
305 public <MVC extends TypedMVCGroup> List<? extends GriffonMvcArtifact> createMVC(@Nonnull Class<? extends MVC> mvcType, @Nonnull String mvcId) {
306 return application.getMvcGroupManager().createMVC(mvcType, mvcId);
307 }
308
309 @Override
310 @Nonnull
311 public <MVC extends TypedMVCGroup> List<? extends GriffonMvcArtifact> createMVC(@Nonnull Map<String, Object> args, @Nonnull Class<? extends MVC> mvcType, @Nonnull String mvcId) {
312 return application.getMvcGroupManager().createMVC(args, mvcType, mvcId);
313 }
314
315 @Override
316 @Nonnull
317 public <MVC extends TypedMVCGroup> List<? extends GriffonMvcArtifact> createMVC(@Nonnull Class<? extends MVC> mvcType, @Nonnull String mvcId, @Nonnull Map<String, Object> args) {
318 return application.getMvcGroupManager().createMVC(mvcType, mvcId, args);
319 }
320
321 @Override
322 public void destroyMVCGroup(@Nonnull String mvcId) {
323 application.getMvcGroupManager().destroyMVCGroup(mvcId);
324 }
325
326 @Override
327 public <M extends GriffonModel, V extends GriffonView, C extends GriffonController> void withMVC(@Nonnull String mvcType, @Nonnull MVCFunction<M, V, C> handler) {
328 application.getMvcGroupManager().withMVC(mvcType, handler);
329 }
330
331 @Override
332 public <M extends GriffonModel, V extends GriffonView, C extends GriffonController> void withMVC(@Nonnull String mvcType, @Nonnull String mvcId, @Nonnull MVCFunction<M, V, C> handler) {
333 application.getMvcGroupManager().withMVC(mvcType, mvcId, handler);
334 }
335
336 @Override
337 public <M extends GriffonModel, V extends GriffonView, C extends GriffonController> void withMVC(@Nonnull String mvcType, @Nonnull String mvcId, @Nonnull Map<String, Object> args, @Nonnull MVCFunction<M, V, C> handler) {
338 application.getMvcGroupManager().withMVC(mvcType, mvcId, args, handler);
339 }
340
341 @Override
342 public <M extends GriffonModel, V extends GriffonView, C extends GriffonController> void withMVC(@Nonnull Map<String, Object> args, @Nonnull String mvcType, @Nonnull String mvcId, @Nonnull MVCFunction<M, V, C> handler) {
343 application.getMvcGroupManager().withMVC(args, mvcType, mvcId, handler);
344 }
345
346 @Override
347 public <M extends GriffonModel, V extends GriffonView, C extends GriffonController> void withMVC(@Nonnull String mvcType, @Nonnull Map<String, Object> args, @Nonnull MVCFunction<M, V, C> handler) {
348 application.getMvcGroupManager().withMVC(mvcType, args, handler);
349 }
350
351 @Override
352 public <M extends GriffonModel, V extends GriffonView, C extends GriffonController> void withMVC(@Nonnull Map<String, Object> args, @Nonnull String mvcType, @Nonnull MVCFunction<M, V, C> handler) {
353 application.getMvcGroupManager().withMVC(args, mvcType, handler);
354 }
355
356 @Override
357 public <MVC extends TypedMVCGroup, M extends GriffonModel, V extends GriffonView, C extends GriffonController> void withMVC(@Nonnull Class<? extends MVC> mvcType, @Nonnull MVCFunction<M, V, C> handler) {
358 application.getMvcGroupManager().withMVC(mvcType, handler);
359 }
360
361 @Override
362 public <MVC extends TypedMVCGroup, M extends GriffonModel, V extends GriffonView, C extends GriffonController> void withMVC(@Nonnull Class<? extends MVC> mvcType, @Nonnull String mvcId, @Nonnull MVCFunction<M, V, C> handler) {
363 application.getMvcGroupManager().withMVC(mvcType, mvcId, handler);
364 }
365
366 @Override
367 public <MVC extends TypedMVCGroup, M extends GriffonModel, V extends GriffonView, C extends GriffonController> void withMVC(@Nonnull Class<? extends MVC> mvcType, @Nonnull String mvcId, @Nonnull Map<String, Object> args, @Nonnull MVCFunction<M, V, C> handler) {
368 application.getMvcGroupManager().withMVC(mvcType, mvcId, args, handler);
369 }
370
371 @Override
372 public <MVC extends TypedMVCGroup, M extends GriffonModel, V extends GriffonView, C extends GriffonController> void withMVC(@Nonnull Map<String, Object> args, @Nonnull Class<? extends MVC> mvcType, @Nonnull String mvcId, @Nonnull MVCFunction<M, V, C> handler) {
373 application.getMvcGroupManager().withMVC(args, mvcType, mvcId, handler);
374 }
375
376 @Override
377 public <MVC extends TypedMVCGroup, M extends GriffonModel, V extends GriffonView, C extends GriffonController> void withMVC(@Nonnull Class<? extends MVC> mvcType, @Nonnull Map<String, Object> args, @Nonnull MVCFunction<M, V, C> handler) {
378 application.getMvcGroupManager().withMVC(mvcType, args, handler);
379 }
380
381 @Override
382 public <MVC extends TypedMVCGroup, M extends GriffonModel, V extends GriffonView, C extends GriffonController> void withMVC(@Nonnull Map<String, Object> args, @Nonnull Class<? extends MVC> mvcType, @Nonnull MVCFunction<M, V, C> handler) {
383 application.getMvcGroupManager().withMVC(args, mvcType, handler);
384 }
385
386 @Override
387 public void withMVCGroup(@Nonnull String mvcType, @Nonnull MVCGroupFunction handler) {
388 application.getMvcGroupManager().withMVCGroup(mvcType, handler);
389 }
390
391 @Override
392 public void withMVCGroup(@Nonnull String mvcType, @Nonnull String mvcId, @Nonnull MVCGroupFunction handler) {
393 application.getMvcGroupManager().withMVCGroup(mvcType, mvcId, handler);
394 }
395
396 @Override
397 public void withMVCGroup(@Nonnull String mvcType, @Nonnull String mvcId, @Nonnull Map<String, Object> args, @Nonnull MVCGroupFunction handler) {
398 application.getMvcGroupManager().withMVCGroup(mvcType, mvcId, args, handler);
399 }
400
401 @Override
402 public void withMVCGroup(@Nonnull Map<String, Object> args, @Nonnull String mvcType, @Nonnull String mvcId, @Nonnull MVCGroupFunction handler) {
403 application.getMvcGroupManager().withMVCGroup(args, mvcType, mvcId, handler);
404 }
405
406 @Override
407 public void withMVCGroup(@Nonnull String mvcType, @Nonnull Map<String, Object> args, @Nonnull MVCGroupFunction handler) {
408 application.getMvcGroupManager().withMVCGroup(mvcType, args, handler);
409 }
410
411 @Override
412 public void withMVCGroup(@Nonnull Map<String, Object> args, @Nonnull String mvcType, @Nonnull MVCGroupFunction handler) {
413 application.getMvcGroupManager().withMVCGroup(args, mvcType, handler);
414 }
415
416 @Override
417 public <MVC extends TypedMVCGroup> void withMVCGroup(@Nonnull Class<? extends MVC> mvcType, @Nonnull TypedMVCGroupFunction<MVC> handler) {
418 application.getMvcGroupManager().withMVCGroup(mvcType, handler);
419 }
420
421 @Override
422 public <MVC extends TypedMVCGroup> void withMVCGroup(@Nonnull Class<? extends MVC> mvcType, @Nonnull String mvcId, @Nonnull TypedMVCGroupFunction<MVC> handler) {
423 application.getMvcGroupManager().withMVCGroup(mvcType, mvcId, handler);
424 }
425
426 @Override
427 public <MVC extends TypedMVCGroup> void withMVCGroup(@Nonnull Class<? extends MVC> mvcType, @Nonnull String mvcId, @Nonnull Map<String, Object> args, @Nonnull TypedMVCGroupFunction<MVC> handler) {
428 application.getMvcGroupManager().withMVCGroup(mvcType, mvcId, args, handler);
429 }
430
431 @Override
432 public <MVC extends TypedMVCGroup> void withMVCGroup(@Nonnull Map<String, Object> args, @Nonnull Class<? extends MVC> mvcType, @Nonnull String mvcId, @Nonnull TypedMVCGroupFunction<MVC> handler) {
433 application.getMvcGroupManager().withMVCGroup(args, mvcType, mvcId, handler);
434 }
435
436 @Override
437 public <MVC extends TypedMVCGroup> void withMVCGroup(@Nonnull Class<? extends MVC> mvcType, @Nonnull Map<String, Object> args, @Nonnull TypedMVCGroupFunction<MVC> handler) {
438 application.getMvcGroupManager().withMVCGroup(mvcType, args, handler);
439 }
440
441 @Override
442 public <MVC extends TypedMVCGroup> void withMVCGroup(@Nonnull Map<String, Object> args, @Nonnull Class<? extends MVC> mvcType, @Nonnull TypedMVCGroupFunction<MVC> handler) {
443 application.getMvcGroupManager().withMVCGroup(args, mvcType, handler);
444 }
445
446 /**
447 * Try to resolve the message.
448 *
449 * @param key Key to lookup, such as 'log4j.appenders.console'
450 *
451 * @return The resolved message at the given key for the default locale
452 *
453 * @throws NoSuchMessageException if no message is found
454 * @since 2.4.0
455 */
456 @Nonnull
457 protected String msg(@Nonnull String key) throws NoSuchMessageException {
458 return getApplication().getMessageSource().getMessage(key);
459 }
460
461 /**
462 * Try to resolve the message.
463 *
464 * @param key Key to lookup, such as 'log4j.appenders.console'
465 * @param args Arguments that will be filled in for params within the message (params look like "{0}" within a
466 * message, but this might differ between implementations), or null if none.
467 *
468 * @return The resolved message at the given key for the default locale
469 *
470 * @throws NoSuchMessageException if no message is found
471 * @since 2.4.0
472 */
473 @Nonnull
474 protected String msg(@Nonnull String key, @Nonnull List<?> args) throws NoSuchMessageException {
475 return getApplication().getMessageSource().getMessage(key, args);
476 }
477
478 /**
479 * Try to resolve the message.
480 *
481 * @param key Key to lookup, such as 'log4j.appenders.console'
482 * @param args Arguments that will be filled in for params within the message (params look like "{0}" within a
483 * message, but this might differ between implementations), or null if none.
484 *
485 * @return The resolved message at the given key for the default locale
486 *
487 * @throws NoSuchMessageException if no message is found
488 * @since 2.4.0
489 */
490 @Nonnull
491 protected String msg(@Nonnull String key, @Nonnull Object[] args) throws NoSuchMessageException {
492 return getApplication().getMessageSource().getMessage(key, args);
493 }
494
495 /**
496 * Try to resolve the message.
497 *
498 * @param key Key to lookup, such as 'log4j.appenders.console'
499 * @param args Arguments that will be filled in for params within the message (params look like "{:key}"
500 * within a message, but this might differ between implementations), or null if none.
501 *
502 * @return The resolved message at the given key for the default locale
503 *
504 * @throws NoSuchMessageException if no message is found
505 * @since 2.4.0
506 */
507 @Nonnull
508 protected String msg(@Nonnull String key, @Nonnull Map<String, Object> args) throws NoSuchMessageException {
509 return getApplication().getMessageSource().getMessage(key, args);
510 }
511 }
|