type, Annotation... qualifiers);
52 |
53 | /**
54 | * Start the bean container. Gives the container a chance to scan the
55 | * classpath looking for ./META-INF/beans.xml and setting up the beans to be
56 | * vended.
57 | *
58 | * Throws a {@link BeanContainerInitializationException} if there is a
59 | * problem initializing.
60 | * */
61 | public void start();
62 |
63 | /**
64 | * Stops the bean container. Allows it to do clean up and call any needed
65 | * callback methods, i.e.,
66 | *
67 | * @PostConstruct on singletons
68 | */
69 | public void stop();
70 |
71 | /**
72 | * Returns the root instance of the {@link BeanNamespaceNotNeeded} object that can be
73 | * used to look up {@link Bean} instances by name. Used for looking up beans
74 | * that have longer namespaces such as "org.domain.project.name".
75 | * Particularly useful for expression lookups when you only get the
76 | * expression piece by piece.
77 | *
78 | * @return A {@link BeanNamespaceNotNeeded} instance that can be used to lookup
79 | * beans.
80 | */
81 | public BeanNamespace getBeanNamespace();
82 |
83 |
84 | public void startScope(Class scope);
85 | public void stopScope(Class scope);
86 |
87 |
88 |
89 | }
90 |
--------------------------------------------------------------------------------
/beancontainer/api/src/main/java/org/cdisource/beancontainer/BeanContainerExtention.java:
--------------------------------------------------------------------------------
1 | package org.cdisource.beancontainer;
2 |
3 | import javax.enterprise.event.Observes;
4 | import javax.enterprise.inject.spi.BeforeBeanDiscovery;
5 | import javax.enterprise.inject.spi.Extension;
6 |
7 | public class BeanContainerExtention implements Extension {
8 | void beforeBeanDiscovery(@Observes BeforeBeanDiscovery bbd) {
9 |
10 | }
11 | }
12 |
--------------------------------------------------------------------------------
/beancontainer/api/src/main/java/org/cdisource/beancontainer/BeanContainerImpl.java:
--------------------------------------------------------------------------------
1 | package org.cdisource.beancontainer;
2 |
3 | import javax.enterprise.inject.spi.BeanManager;
4 | import javax.inject.Inject;
5 |
6 | public class BeanContainerImpl extends AbstractBeanContainer {
7 | @Inject protected BeanManager manager;
8 |
9 | public BeanContainerImpl() {
10 |
11 | }
12 |
13 | public BeanContainerImpl(BeanManager manager) {
14 | this.manager = manager;
15 | }
16 |
17 | @Override
18 | protected BeanManager locateBeanManager() {
19 | return manager;
20 | }
21 |
22 | @Override
23 | protected boolean isInitialized() {
24 | return manager != null;
25 | }
26 |
27 | @Override
28 | protected void doStart() throws Exception {
29 | }
30 |
31 | @Override
32 | protected void doStop() {
33 | }
34 |
35 |
36 | }
37 |
--------------------------------------------------------------------------------
/beancontainer/api/src/main/java/org/cdisource/beancontainer/BeanContainerInitializationException.java:
--------------------------------------------------------------------------------
1 | package org.cdisource.beancontainer;
2 |
3 | /**
4 | * Exception class thrown when the {@link BeanContainer} fails to initialize
5 | *
6 | * @author Andy Gibson
7 | *
8 | */
9 | public class BeanContainerInitializationException extends RuntimeException {
10 |
11 | private static final long serialVersionUID = -8787336526656793438L;
12 |
13 | public BeanContainerInitializationException(String message) {
14 | super(message);
15 | }
16 |
17 | public BeanContainerInitializationException(String message, Throwable cause) {
18 | super(message, cause);
19 | }
20 | }
21 |
--------------------------------------------------------------------------------
/beancontainer/api/src/main/java/org/cdisource/beancontainer/BeanContainerManager.java:
--------------------------------------------------------------------------------
1 | package org.cdisource.beancontainer;
2 |
3 | import java.io.PrintWriter;
4 | import java.io.StringWriter;
5 | import java.lang.ref.WeakReference;
6 | import java.util.Collections;
7 | import java.util.Map;
8 | import java.util.Properties;
9 | import java.util.ServiceLoader;
10 | import java.util.WeakHashMap;
11 |
12 | import org.cdisource.logging.Logger;
13 |
14 |
15 | import static org.cdisource.logging.LogFactoryManager.logger;
16 |
17 |
18 | /**
19 | * Thread safe Bean Container Manager that provides access to the CDI
20 | * implementation on the classpath by returning an instance of the
21 | * {@link BeanContainer} that represents that implementation.
22 | *
23 | * You can swap out the BeanContainer just by including the BeanContainer jar
24 | * file for a specific implementation in your project.
25 | *
26 | *
27 | * We look for a file under classpath/META-INF/services called
28 | * org.cdisource.beancontainer.BeanContainer.
29 | *
30 | * This file has one of three values:
31 | *
32 | * - org.cdisource.beancontainer.ResinBeanContainer
33 | * - org.cdisource.beancontainer.OpenWebBeansBeanContainer
34 | * - org.cdisource.beancontainer.WeldBeanContainer
35 | *
36 | *
37 | *
38 | *
39 | * You can also override which container is used using a System property
40 | *
41 | *
42 | *
43 | * $ java -Dorg.cdisource.beancontainer.BeanContainer=org.cdisource.beancontainer.ResinBeanContainer
44 | *
45 | *
46 | *
47 | *
48 | * @see java.util.ServiceLoader.
49 | *
50 | * @author Rick Hightower
51 | * @author Andy Gibson
52 | *
53 | */
54 | public class BeanContainerManager {
55 |
56 | /** Logger */
57 | private static Logger log = logger(BeanContainerManager.class);
58 |
59 | /** Property name that we use to look up the bean container override. */
60 | public static String PROP_NAME = "org.cdisource.beancontainer.BeanContainer";
61 |
62 | private static Map> map = Collections
63 | .synchronizedMap(new WeakHashMap>());
64 |
65 | private static boolean useStatic = false;
66 | private static BeanContainer beanContainer;
67 |
68 | public static void testEnv() {
69 | useStatic=true;
70 | }
71 |
72 | /**
73 | * Thread safe method to create and initialize the {@link BeanContainer}
74 | * implementation on the classpath.
75 | *
76 | */
77 | public static void initialize() {
78 | log.trace("initialize() called using system properties");
79 | initialize(System.getProperties());
80 | }
81 |
82 | /**
83 | * Thread safe method to create and initialize the {@link BeanContainer}
84 | * implementation on the classpath.
85 | *
86 | * @param properties
87 | * Properties to use for initialization
88 | */
89 | public synchronized static void initialize(Properties properties) {
90 | log.trace("initialize(properties)");
91 | startUpInstance(properties);
92 |
93 | }
94 |
95 | /**
96 | * Get the bean container instance using system properties. If this method
97 | * is called before one of the initialize methods is called, then the
98 | * manager creates and initializes a {@link BeanContainer} instance to
99 | * return. This is good for calling from unit tests and/or standalone applications.
100 | * It is not a good idea to use this from a web application due to classloader issues.
101 | *
102 | * Auto initializing this way means that we can call the getter from
103 | * anywhere without being totally concerned about who or where the container
104 | * is initialized.
105 | *
106 | * @see BeanContainerManager.PROP_NAME
107 | * @see {@link BeanContainerManager#initialize()}
108 | * */
109 | public static BeanContainer getInstance() {
110 |
111 | if (useStatic && beanContainer!=null) {
112 | return beanContainer;
113 | }
114 | log.trace("getInstance() called");
115 | synchronized (map) {
116 | WeakReference weakReference = map.get(Thread.currentThread().getContextClassLoader());
117 | if (weakReference==null || weakReference.get()==null) {
118 | log.debug("getInstance():: instance was null");
119 | initialize();
120 | }
121 | return beanContainer();
122 | }
123 | }
124 |
125 | private static BeanContainer beanContainer() {
126 | if (useStatic && beanContainer!=null) {
127 | return beanContainer;
128 | }
129 | WeakReference weakReference = map.get(Thread.currentThread().getContextClassLoader());
130 | if (weakReference== null || weakReference.get() == null) {
131 | throw new IllegalStateException("WeakReference is not set");
132 | }
133 | return weakReference.get();
134 | }
135 |
136 |
137 | /**
138 | * Create the bean container instance using system properties. If this method
139 | * is called before one of the initialize methods is called, then the
140 | * manager creates and initializes a {@link BeanContainer} instance to
141 | * return. This is good for calling from unit tests and/or standalone applications.
142 | * It is not a good idea to use this from a web application due to classloader issues.
143 | *
144 | * Auto initializing this way means that we can call the getter from
145 | * anywhere without being totally concerned about who or where the container
146 | * is initialized.
147 | *
148 | * @see BeanContainerManager.PROP_NAME
149 | * @see {@link BeanContainerManager#initialize()}
150 | * */
151 | public static BeanContainer createInstance() {
152 | log.trace("createInstance() called");
153 | BeanContainer beanContainer = generateInstance(System.getProperties());
154 | log.debug("createInstance():: instance is null? %s", beanContainer == null ? "yes" : "no");
155 | return beanContainer;
156 | }
157 | /**
158 | * Thread safe method to create a new instance of a {@link BeanContainer}
159 | * and start it up and make it available through the
160 | * getInstance() method.
161 | *
162 | * @param properties
163 | * Properties to use for initialization
164 | */
165 | private synchronized static void startUpInstance(Properties properties) {
166 | log.trace("startUpInstance(properties)");
167 | BeanContainer instance = generateInstance(properties);
168 | if (instance != null) {
169 | instance.start();
170 | }
171 |
172 | if (useStatic) {
173 | beanContainer= instance;
174 | } else {
175 | map.put(Thread.currentThread().getContextClassLoader(), new WeakReference(instance));
176 | }
177 | }
178 |
179 | /**
180 | * Internal method to create a new instance of a {@link BeanContainer}
181 | * implementation. The returned container would not have been initialized
182 | * yet.
183 | *
184 | * @param properties
185 | * Properties to use for initialization
186 | * @return new instance of a {@link BeanContainer} implementation which has
187 | * not yet been started.
188 | */
189 | private static BeanContainer generateInstance(Properties properties) {
190 | try {
191 | /* The property should override the ServiceLoader if found. */
192 | String beanContainerClassName = properties.getProperty(PROP_NAME);
193 |
194 | /* If the property was not found, use the service loader. */
195 | if (beanContainerClassName == null) {
196 | ServiceLoader instances = ServiceLoader.load(BeanContainer.class);
197 | if (instances.iterator().hasNext()) {
198 | return instances.iterator().next();
199 |
200 | }
201 | }
202 |
203 | if (beanContainerClassName == null) {
204 | StringWriter stringWriter = new StringWriter();
205 | PrintWriter out = new PrintWriter(stringWriter);
206 | out.println("Unable to find a BeanContainer on your classpath");
207 | out
208 | .println("Expecting to find beancontainer-weld-impl.jar that has org.cdisource.beancontainer.WeldBeanContainer.");
209 | out
210 | .println("OR, Expecting to find beancontainer-resin-impl.jar that has org.cdisource.beancontainer.ResinBeanContainer.");
211 | out
212 | .println("OR, Expecting to find beancontainer-openwebbeans-impl.jar that has org.cdisource.beancontainer.OpenWebBeansBeanContainer.");
213 | out
214 | .println("OR, Expecting to find some class that implements org.cdisource.beancontainer.BeanContainer on the classpath");
215 | out
216 | .println("with a META-INF/services/org.cdisource.beancontainer.BeanContainer file that has a single line which is the implementation.");
217 | out
218 | .println(" If this error message does not make sense refer to the JavaDoc for org.cdisource.beancontainer.BeanContainerManager.");
219 | throw new IllegalStateException(stringWriter.toString());
220 | }
221 |
222 | /*
223 | * Get the classloader associated with the current webapp and not
224 | * the global classloader
225 | */
226 | ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
227 | Class clazz = Class.forName(beanContainerClassName, true, contextClassLoader);
228 | return (BeanContainer) clazz.newInstance();
229 |
230 | } catch (Exception ex) {
231 | throw new RuntimeException(ex);
232 | }
233 | }
234 |
235 | /**
236 | * Thread safe method to shutdown the {@link BeanContainer} instance and
237 | * invalidate it. Further calls to get an instance or initialize will create
238 | * a new instance.
239 | */
240 | public static synchronized void shutdown() {
241 | BeanContainer beanContainer = beanContainer();
242 | if (beanContainer!=null) {
243 | beanContainer.stop();
244 | }
245 | }
246 | }
247 |
--------------------------------------------------------------------------------
/beancontainer/api/src/main/java/org/cdisource/beancontainer/BeanManagerLocator.java:
--------------------------------------------------------------------------------
1 | package org.cdisource.beancontainer;
2 |
3 | import javax.enterprise.inject.spi.BeanManager;
4 |
5 | public interface BeanManagerLocator {
6 | /**
7 | * Returns the underlying {@link BeanManager} instance for this
8 | * implementation of CDI.
9 | *
10 | * @return Instance of the {@link BeanManager} implemented by this CDI
11 | * implementation.
12 | */
13 | BeanManager getBeanManager();
14 |
15 | }
16 |
--------------------------------------------------------------------------------
/beancontainer/api/src/main/java/org/cdisource/beancontainer/BeanNotFoundException.java:
--------------------------------------------------------------------------------
1 | package org.cdisource.beancontainer;
2 |
3 |
4 | /**
5 | * Exception thrown when a bean cannot be located
6 | *
7 | * @author Andy Gibson
8 | *
9 | */
10 | public class BeanNotFoundException extends RuntimeException {
11 |
12 | private static final long serialVersionUID = -1122296335536887240L;
13 |
14 | public BeanNotFoundException(final String message) {
15 | super(message);
16 | }
17 |
18 | public BeanNotFoundException(final String message, Throwable cause) {
19 | super(message, cause);
20 | }
21 | }
22 |
--------------------------------------------------------------------------------
/beancontainer/api/src/main/java/org/cdisource/beancontainer/ScopeController.java:
--------------------------------------------------------------------------------
1 | package org.cdisource.beancontainer;
2 |
3 | public interface ScopeController {
4 | public void stop();
5 | public void start();
6 | }
7 |
--------------------------------------------------------------------------------
/beancontainer/api/src/main/java/org/cdisource/beancontainer/ScopeManager.java:
--------------------------------------------------------------------------------
1 | package org.cdisource.beancontainer;
2 |
3 | import java.lang.annotation.Annotation;
4 | import java.util.HashMap;
5 | import java.util.Map;
6 |
7 | import javax.enterprise.context.spi.Context;
8 | import javax.enterprise.inject.spi.AfterBeanDiscovery;
9 |
10 | public class ScopeManager {
11 | private static ScopeManager instance = new ScopeManager();
12 |
13 | private Map, ScopeController> map = new HashMap, ScopeController>(7);
14 |
15 | public void stop(Class scopeType) {
16 | ScopeController control = map.get(scopeType);
17 | if (control!=null) {
18 | control.stop();
19 | }
20 | }
21 | public static void startScope(Class scopeType) {
22 | instance.start(scopeType);
23 | }
24 | public static void stopScope(Class scopeType) {
25 | instance.stop(scopeType);
26 | }
27 |
28 |
29 | public void start(Class scopeType) {
30 | ScopeController control = map.get(scopeType);
31 | if (control!=null) {
32 | control.start();
33 | }
34 | }
35 |
36 | // public void register(ScopeController control, Context context) {
37 | // BeanContainerManager.getInstance().registerContext(context, true);
38 | // map.put(context.getScope(), control);
39 | // }
40 |
41 | public void register(AfterBeanDiscovery abd, ScopeController control, Context context) {
42 | abd.addContext(context);
43 | map.put(context.getScope(), control);
44 | }
45 |
46 | public static ScopeManager getInstance() {
47 | return instance;
48 | }
49 | public static void reset() {
50 | instance.map.clear();
51 | instance = new ScopeManager();
52 | }
53 |
54 | }
55 |
--------------------------------------------------------------------------------
/beancontainer/api/src/main/java/org/cdisource/beancontainer/namespace/BeanNamespace.java:
--------------------------------------------------------------------------------
1 | package org.cdisource.beancontainer.namespace;
2 |
3 | import java.util.Map;
4 | import java.util.TreeMap;
5 |
6 | /**
7 | *
8 | * @author Rick Hightower
9 | * @author Andy Gibson
10 | *
11 | */
12 | public class BeanNamespace{
13 |
14 | private final Map children = new TreeMap();
15 |
16 | protected String[] splitName(final String name) {
17 | if (name == null) {
18 | throw new IllegalArgumentException("Object name cannot be null");
19 | }
20 |
21 | if (name.length() == 0) {
22 | throw new IllegalArgumentException(
23 | "Cannot add bean with a name of zero length");
24 | }
25 | String[] result = null;
26 | if (name.contains(".")) {
27 | result = name.split("\\.");
28 | } else {
29 | result = new String[] { name };
30 | }
31 | return result;
32 | }
33 |
34 | /**
35 | * Add named object to the tree. Assumes the last element in the name, or
36 | * the only element in the name if it is a single name, is the actual name
37 | * with anything preceeding it is the namespace.
38 | *
39 | * @param name
40 | * @param object
41 | */
42 | public void addObject(String name, Object object) {
43 | if (name == null) {
44 | throw new IllegalArgumentException("Object name cannot be null");
45 | }
46 | String[] path = splitName(name);
47 | BeanNamespace node = this;
48 | // locate the next to last namespace node
49 | for (int i = 0; i < path.length - 1; i++) {
50 |
51 | String key = path[i];
52 | Object next = node.children.get(key);
53 | // no node exists so create one
54 | if (next == null) {
55 | BeanNamespace newNode = new BeanNamespace();
56 | node.children.put(key, newNode);
57 | node = newNode;
58 | } else {
59 | // if this is not a graph node, we have an error because some
60 | // object lives on our path.
61 | if (!(next instanceof BeanNamespace)) {
62 | String error = "Invalid namespace clash when inserting "
63 | + name + " - found instance of " + next.getClass();
64 | throw new IllegalArgumentException(error);
65 | } else {
66 | // move down to the next graph node
67 | node = (BeanNamespace) next;
68 | }
69 | }
70 | }
71 | if (node != null) {
72 | node.children.put(path[path.length - 1], object);
73 | }
74 | }
75 |
76 | /**
77 | * Walks the graph and returns the first non-BeanGraphNode object it finds
78 | * on the expression path. If no non-Node objects are found then we return
79 | * null
80 | *
81 | * @param expression
82 | * Expression used to locate the node.
83 | *
84 | * @return
85 | */
86 | public Object findObject(String expression) {
87 | String[] path = splitName(expression);
88 | BeanNamespace node = this;
89 | for (String s : path) {
90 | Object o = node.children.get(s);
91 | if (o instanceof BeanNamespace) {
92 | node = (BeanNamespace) o;
93 | } else {
94 | return o;
95 | }
96 | }
97 | return node!=this ? node : null;
98 | }
99 |
100 | public void dump() {
101 | dump(" ");
102 | }
103 |
104 | public void dump(String indent) {
105 | for (String k : children.keySet()) {
106 | Object v = children.get(k);
107 | System.out.println(indent + k + " - " + v);
108 | if (v instanceof BeanNamespace) {
109 | BeanNamespace bn = (BeanNamespace) v;
110 | bn.dump(indent + " ");
111 | }
112 |
113 | }
114 | }
115 |
116 | public boolean contains(final String name) {
117 | return children.containsKey(name);
118 | }
119 |
120 | public String toString() {
121 | return children.keySet().toString();
122 | }
123 |
124 | }
125 |
--------------------------------------------------------------------------------
/beancontainer/api/src/main/java/org/cdisource/logging/JDKLogger.java:
--------------------------------------------------------------------------------
1 | package org.cdisource.logging;
2 |
3 | import java.io.Serializable;
4 | import java.util.logging.Level;
5 |
6 | /**
7 | * This is our default logger, it uses JDK logging underneath.
8 | *
9 | * @author Rick Hightower
10 | *
11 | */
12 | public class JDKLogger implements Logger, Serializable{
13 | java.util.logging.Logger delegate;
14 |
15 | public JDKLogger() {
16 |
17 | }
18 |
19 | public JDKLogger(java.util.logging.Logger logger){
20 | this.delegate = logger;
21 | if (delegate==null) {
22 | throw new IllegalStateException("delegate is null");
23 | }
24 | }
25 |
26 | /**
27 | *
28 | */
29 | private static final long serialVersionUID = 1L;
30 |
31 | @Override
32 | public void severe(String msg, Object... args) {
33 | if (delegate.isLoggable(Level.SEVERE)) {
34 | delegate.severe(String.format(msg, args));
35 | }
36 | }
37 |
38 | @Override
39 | public void warning(String msg, Object... args) {
40 | if (delegate.isLoggable(Level.WARNING)) {
41 | delegate.warning(String.format(msg, args));
42 | }
43 | }
44 |
45 | @Override
46 | public void info(String msg, Object... args) {
47 | if (delegate.isLoggable(Level.INFO)) {
48 | delegate.info(String.format(msg, args));
49 | }
50 | }
51 |
52 | @Override
53 | public void config(String msg, Object... args) {
54 | if (delegate.isLoggable(Level.CONFIG)) {
55 | delegate.config(String.format(msg, args));
56 | }
57 | }
58 |
59 | @Override
60 | public void debug(String msg, Object... args) {
61 | if (delegate.isLoggable(Level.FINE)) {
62 | delegate.fine(String.format(msg, args));
63 | }
64 |
65 | }
66 |
67 | @Override
68 | public void trace(String msg, Object... args) {
69 | if (delegate.isLoggable(Level.FINER)) {
70 | delegate.finer(String.format(msg, args));
71 | }
72 | }
73 |
74 | @Override
75 | public void finest(String msg, Object... args) {
76 | if (delegate.isLoggable(Level.FINEST)) {
77 | delegate.finest(String.format(msg, args));
78 | }
79 | }
80 |
81 | public boolean isLevel(LogLevel level) {
82 | switch (level) {
83 | case SEVERE:
84 | return delegate.isLoggable(Level.SEVERE);
85 | case WARNING:
86 | return delegate.isLoggable(Level.WARNING);
87 | case INFO:
88 | return delegate.isLoggable(Level.INFO);
89 | case CONFIG:
90 | return delegate.isLoggable(Level.CONFIG);
91 | case DEBUG:
92 | return delegate.isLoggable(Level.FINE);
93 | case TRACE:
94 | return delegate.isLoggable(Level.FINER);
95 | case FINEST:
96 | return delegate.isLoggable(Level.FINEST);
97 | default:
98 | throw new IllegalStateException("Unknown log level");
99 | }
100 | }
101 | }
102 |
--------------------------------------------------------------------------------
/beancontainer/api/src/main/java/org/cdisource/logging/JDKLoggerFactory.java:
--------------------------------------------------------------------------------
1 | package org.cdisource.logging;
2 |
3 | /**
4 | * This is our default log factory. It uses the JDK logging.
5 | * @author Rick Hightower.
6 | *
7 | */
8 | public class JDKLoggerFactory implements LogFactory {
9 |
10 | @Override
11 | public Logger getLogger(String name) {
12 | return new JDKLogger(java.util.logging.Logger.getLogger(name));
13 | }
14 |
15 | @Override
16 | public Logger getLogger(Class clazz) {
17 | return new JDKLogger(java.util.logging.Logger.getLogger(clazz.getName()));
18 | }
19 |
20 | }
21 |
--------------------------------------------------------------------------------
/beancontainer/api/src/main/java/org/cdisource/logging/LogFactory.java:
--------------------------------------------------------------------------------
1 | package org.cdisource.logging;
2 |
3 | /**
4 | * LogFactory loads a logger.
5 | * @author Rick Hightower
6 | *
7 | */
8 | public interface LogFactory {
9 | Logger getLogger(String string);
10 | Logger getLogger(Class clazz);
11 | }
12 |
--------------------------------------------------------------------------------
/beancontainer/api/src/main/java/org/cdisource/logging/LogFactoryManager.java:
--------------------------------------------------------------------------------
1 | package org.cdisource.logging;
2 | import java.util.Properties;
3 | import java.util.ServiceLoader;
4 |
5 | import org.cdisource.beancontainer.BeanContainer;
6 |
7 | /**
8 | * Our very own logging fetish.
9 | *
10 | * @author Rick Hightower
11 | *
12 | */
13 | public class LogFactoryManager {
14 | public static String PROP_NAME = "org.cdisource.logging.LogFactory";
15 |
16 | private static LogFactory logFactory;
17 |
18 | /**
19 | * Get the log factory instance using system properties. If this method
20 | * is called before one of the initialize methods is called, then the
21 | * manager creates and initializes a {@link LogFactory} instance to
22 | * return.
23 | *
24 | * Auto initializing this way means that we can call the getter from
25 | * anywhere without being totally concerned about who or where the container
26 | * is initialized.
27 | *
28 | * @see LogFactoryManager.PROP_NAME
29 | * @see {@link LogFactoryManager#initialize()}
30 | * */
31 | public static LogFactory getInstance() {
32 | if (logFactory == null) {
33 | initialize();
34 | }
35 | return logFactory;
36 | }
37 |
38 | /** Helper methods to look up the logger.
39 | *
40 | * @param name name of the logger
41 | * @return the logger
42 | */
43 | public static Logger logger(String name) {
44 | return getInstance().getLogger(name);
45 | }
46 |
47 | /**
48 | * Helper method to look up the logger for a class
49 | * @param clazz class associated with the logger
50 | * @return the logger
51 | */
52 | public static Logger logger(Class clazz) {
53 | return getInstance().getLogger(clazz);
54 | }
55 |
56 | /**
57 | * Thread safe method to create and initialize the {@link LogFactory}
58 | * implementation on the classpath.
59 | *
60 | */
61 | public static void initialize() {
62 | initialize(System.getProperties());
63 | }
64 |
65 |
66 | /**
67 | * Thread safe method to create and initialize the {@link LogFactory}
68 | * implementation on the classpath.
69 | *
70 | * @param properties
71 | * Properties to use for initialization
72 | */
73 | public synchronized static void initialize(Properties properties) {
74 | if (logFactory != null) {
75 | return;
76 | }
77 | startUpInstance(properties);
78 |
79 | }
80 |
81 | /**
82 | * Thread safe method to create a new instance of a {@link LogFactory}
83 | * and start it up and make it available through the
84 | * getInstance() method.
85 | *
86 | * @param properties
87 | * Properties to use for initialization
88 | */
89 | private synchronized static void startUpInstance(Properties properties) {
90 | // double check that the instance is null, someone might have created
91 | // it while we were entering this method.
92 | if (logFactory != null) {
93 | return;
94 | }
95 | logFactory = generateInstance(properties);
96 | }
97 |
98 | /**
99 | * Internal method to create a new instance of a {@link LogFactory}
100 | * implementation. The returned container would not have been initialized
101 | * yet.
102 | *
103 | * @param properties
104 | * Properties to use for initialization
105 | * @return new instance of a {@link BeanContainer} implementation which has
106 | * not yet been started.
107 | */
108 | private static LogFactory generateInstance(Properties properties) {
109 | try {
110 | /* The property should override the ServiceLoader if found. */
111 | String logFactoryClassname = properties.getProperty(PROP_NAME);
112 |
113 | /* If the property was not found, use the service loader. */
114 | if (logFactoryClassname == null) {
115 | ServiceLoader instances = ServiceLoader.load(LogFactory.class);
116 | if (instances.iterator().hasNext()) {
117 | return instances.iterator().next();
118 | }
119 | }
120 |
121 | if (logFactoryClassname == null) {
122 | throw new IllegalStateException("Unable to find the logfactory," +
123 | " this should never happen because we always ship with a log factory");
124 | }
125 |
126 | /*
127 | * Get the classloader associated with the current webapp and not
128 | * the global classloader
129 | */
130 | ClassLoader contextClassLoader = Thread.currentThread().getContextClassLoader();
131 | Class clazz = Class.forName(logFactoryClassname, true, contextClassLoader);
132 | return (LogFactory) clazz.newInstance();
133 |
134 | } catch (Exception ex) {
135 | throw new RuntimeException(ex);
136 | }
137 | }
138 |
139 | }
140 |
--------------------------------------------------------------------------------
/beancontainer/api/src/main/java/org/cdisource/logging/LogLevel.java:
--------------------------------------------------------------------------------
1 | package org.cdisource.logging;
2 |
3 | /**
4 | * Our very own log levels.
5 | * @author Rick Hightower
6 | *
7 | */
8 | public enum LogLevel {
9 | SEVERE, WARNING, INFO, CONFIG, DEBUG, TRACE, FINEST;
10 | }
11 |
--------------------------------------------------------------------------------
/beancontainer/api/src/main/java/org/cdisource/logging/Logger.java:
--------------------------------------------------------------------------------
1 | package org.cdisource.logging;
2 |
3 | /**
4 | * Our logging interface. Simple and direct.
5 | * @author Rick Hightower
6 | *
7 | */
8 | public interface Logger {
9 | void severe (String msg, Object... args);
10 | void warning (String msg, Object... args);
11 | void info (String msg, Object... args);
12 | void config(String msg, Object... args);
13 | void debug(String msg, Object... args);
14 | void trace(String msg, Object... args);
15 | void finest(String msg, Object... args);
16 | boolean isLevel(LogLevel level);
17 |
18 | }
19 |
--------------------------------------------------------------------------------
/beancontainer/api/src/main/java/org/cdisource/logging/SystemOutLogger.java:
--------------------------------------------------------------------------------
1 | package org.cdisource.logging;
2 |
3 | import java.io.Serializable;
4 |
5 | import static org.cdisource.logging.LogLevel.*;
6 |
7 | /**
8 | * Useful for when debugging. Sometimes getting log config to do what you want is hard.
9 | * This is as easy as putting the following two props on your command line:
10 | *
11 | *
12 | *
13 | * -Dorg.cdisource.logging.LogLevel=DEBUG -Dorg.cdisource.logging.LogFactory=org.cdisource.logging.SystemOutLoggerFactory
14 | *
15 | * The above is to set the level to DEBUG. The level defaults to INFO.
16 | *
17 | * @see LogLevel
18 | * @author Rick Hightower
19 | *
20 | */
21 | public class SystemOutLogger implements Logger, Serializable {
22 |
23 | private String name;
24 | /**
25 | *
26 | */
27 | private static final long serialVersionUID = 1L;
28 |
29 |
30 | public SystemOutLogger(String name) {
31 | this.name = name;
32 | }
33 |
34 | private LogLevel level() {
35 | String level = System.getProperty("org.cdisource.logging.LogLevel", "INFO");
36 | LogLevel logLevel = LogLevel.valueOf(level);
37 | return logLevel;
38 | }
39 |
40 | private void printMessage(LogLevel msgLevel, String msg, Object... args) {
41 | int level = level().ordinal();
42 | if (level >= msgLevel.ordinal()) {
43 | String message = String.format("%s %s %s", this.name, msgLevel.name(), String.format(msg, args));
44 | System.out.println(message);
45 | }
46 |
47 | }
48 |
49 | @Override
50 | public void severe(String msg, Object... args) {
51 | printMessage(SEVERE, msg, args);
52 | }
53 |
54 | @Override
55 | public void warning(String msg, Object... args) {
56 | printMessage(WARNING, msg, args);
57 | }
58 |
59 | @Override
60 | public void info(String msg, Object... args) {
61 | printMessage(INFO, msg, args);
62 | }
63 |
64 |
65 | @Override
66 | public void config(String msg, Object... args) {
67 | printMessage(CONFIG, msg, args);
68 | }
69 |
70 | @Override
71 | public void debug(String msg, Object... args) {
72 | printMessage(DEBUG, msg, args);
73 | }
74 |
75 | @Override
76 | public void trace(String msg, Object... args) {
77 | printMessage(TRACE, msg, args);
78 | }
79 |
80 | @Override
81 | public void finest(String msg, Object... args) {
82 | printMessage(FINEST, msg, args);
83 | }
84 |
85 | @Override
86 | public boolean isLevel(LogLevel level) {
87 | return level == level();
88 | }
89 |
90 | }
91 |
--------------------------------------------------------------------------------
/beancontainer/api/src/main/java/org/cdisource/logging/SystemOutLoggerFactory.java:
--------------------------------------------------------------------------------
1 | package org.cdisource.logging;
2 |
3 | /**
4 | * Simple logger for using System.out without worrying about logging configuration.
5 | * @author Rick Hightower
6 | *
7 | *@see SystemOutLoggerFactory
8 | */
9 | public class SystemOutLoggerFactory implements LogFactory {
10 |
11 | @Override
12 | public Logger getLogger(String name) {
13 | return new SystemOutLogger(name);
14 | }
15 |
16 | @Override
17 | public Logger getLogger(Class clazz) {
18 | return new SystemOutLogger(clazz.getName());
19 | }
20 |
21 | }
22 |
--------------------------------------------------------------------------------
/beancontainer/api/src/main/resources/META-INF/beans.xml:
--------------------------------------------------------------------------------
1 |
5 |
6 |
--------------------------------------------------------------------------------
/beancontainer/api/src/main/resources/META-INF/services/javax.enterprise.inject.spi.Extension:
--------------------------------------------------------------------------------
1 | org.cdisource.beancontainer.BeanContainerExtention
--------------------------------------------------------------------------------
/beancontainer/api/src/main/resources/META-INF/services/org.cdisource.logging.LogFactory:
--------------------------------------------------------------------------------
1 | org.cdisource.logging.JDKLoggerFactory
2 |
--------------------------------------------------------------------------------
/beancontainer/api/src/test/java/org/cdisource/beancontainer/namespace/BeanNamespaceTest.java:
--------------------------------------------------------------------------------
1 | package org.cdisource.beancontainer.namespace;
2 |
3 | import static junit.framework.Assert.assertEquals;
4 | import static junit.framework.Assert.assertNotNull;
5 | import static junit.framework.Assert.assertNotSame;
6 | import static junit.framework.Assert.assertNull;
7 | import static junit.framework.Assert.assertTrue;
8 |
9 | import org.junit.Before;
10 | import org.junit.Test;
11 |
12 | public class BeanNamespaceTest {
13 |
14 | private BeanNamespace root;
15 |
16 | @Before
17 | public void beforeTest() {
18 | root = new BeanNamespace();
19 | }
20 |
21 | @Test
22 | public void testEmptyNamespaces() {
23 | Object result = root.findObject("Some.item");
24 | assertNull(result);
25 | result = root.findObject("item");
26 | assertNull(result);
27 | }
28 |
29 | @Test
30 | public void testSplitFunctionWithSingleValue() {
31 | String[] value = root.splitName("Single");
32 | assertNotNull(value);
33 | assertEquals(1, value.length);
34 |
35 | }
36 |
37 | @Test(expected = IllegalArgumentException.class)
38 | public void testSplitFunctionWithNoValue() {
39 | root.splitName("");
40 | }
41 |
42 | @Test(expected = IllegalArgumentException.class)
43 | public void testSplitFunctionWithNullValue() {
44 | root.splitName(null);
45 | }
46 |
47 | @Test
48 | public void testSplitFunctionWithMultiLevelName() {
49 | String[] value = root.splitName("Level1.Level2");
50 | assertNotNull(value);
51 | assertEquals(2, value.length);
52 | assertEquals("Level1", value[0]);
53 | assertEquals("Level2", value[1]);
54 |
55 | }
56 |
57 | @Test
58 | public void testTopLevelInsert() {
59 | Integer value = new Integer(23);
60 | root.addObject("number", value);
61 | Object result = root.findObject("number");
62 | Object nonResult = root.findObject("missing");
63 | assertNotNull(result);
64 | assertEquals(value, result);
65 | assertNull(nonResult);
66 | }
67 |
68 | public void testMultiLevelInsert() {
69 | Integer value = new Integer(23);
70 | root.addObject("number.23", value);
71 | Object graphNode = root.findObject("number");
72 | // test we got a graph node back
73 | assertNotNull(graphNode);
74 | assertTrue(graphNode.getClass().equals(BeanNamespace.class));
75 |
76 | // now look for our value
77 | Object number = root.findObject("number.23");
78 | assertEquals(value, number);
79 |
80 | // check we can't find 23
81 | Object nonResult = root.findObject("23");
82 | assertNull(nonResult);
83 | }
84 |
85 | @Test
86 | public void testAddingToExistingPath() {
87 | root.addObject("one.two", new Integer(12));
88 | root.addObject("one.three", new Integer(13));
89 |
90 | }
91 |
92 | @Test
93 | public void testMultipleObjects() {
94 | for (int i = 900; i < 1000; i++) {
95 |
96 | String text = numberToNamespace(i);
97 | root.addObject(text, new Integer(i));
98 | }
99 | Object result = root.findObject("9.5.6");
100 | assertNotNull(result);
101 | assertEquals(new Integer(956), result);
102 | }
103 |
104 | @Test
105 | public void testSimilarPathsNamespace() {
106 | // special case where the insert code doesn't move on and 995 -> 9.5 so
107 | // looking for 9.5.6 ends up with the integer at 9.5
108 | root.addObject("9.5.6", new Integer(956));
109 | root.addObject("9.9.5", new Integer(995));
110 | Object v1 = root.findObject("9.5.6");
111 | Object v2 = root.findObject("9.9.5");
112 | assertEquals(956, v1);
113 | assertEquals(995, v2);
114 |
115 | }
116 |
117 | @Test
118 | public void testNumberToNamespace() {
119 | String v1 = numberToNamespace(3382);
120 | assertEquals("3.3.8.2", v1);
121 |
122 | String v2 = numberToNamespace(4);
123 | assertEquals("4", v2);
124 |
125 | }
126 |
127 | private String numberToNamespace(int number) {
128 | String result = "";
129 |
130 | while (number > 0) {
131 | int digit = number % 10;
132 | String text = String.valueOf(digit);
133 | if (result.length() != 0) {
134 | result = "." + result;
135 | }
136 | result = text + result;
137 | number = number / 10;
138 | }
139 | return result;
140 | }
141 |
142 | @Test
143 | public void testCaseInsensitivity() {
144 | root.addObject("A", new Integer(1));
145 | root.addObject("a", new Integer(2));
146 | Object va = root.findObject("a");
147 | Object vA = root.findObject("A");
148 | assertNotSame(va,vA);
149 | }
150 |
151 | @Test
152 | public void testCaseInsensitivityInPath() {
153 | String name1 = "org.some.Object";
154 | String name2 = "org.SOME.Object";
155 | root.addObject(name1, new Integer(1));
156 | root.addObject(name2, new Integer(2));
157 | Object o1 = root.findObject(name1);
158 | Object o2 = root.findObject(name2);
159 | assertNotSame(o1,o2);
160 | assertEquals(o1, 1);
161 | assertEquals(o2, 2);
162 | }
163 |
164 | }
165 |
166 |
--------------------------------------------------------------------------------
/beancontainer/api/src/test/resource/META-INF/beans.xml:
--------------------------------------------------------------------------------
1 |
2 |
4 |
--------------------------------------------------------------------------------
/beancontainer/jndi-impl/README:
--------------------------------------------------------------------------------
1 | This is CDI Advocate repository.
2 | Currently it hosts CDI beanContainer.
3 | CDI beanContainer is a small wrapper around Caucho Resin Candi and JBoss Seam Weld.
4 | It should be the basis of adding unit tests framework that works with all CDI implementations.
5 |
6 | Apache OpenWebBean support is planned.
7 | We are looking for someone to do the OpenWebBeans work.
8 |
9 | To learn more about this project go here:
10 | * Main website http://sites.google.com/site/cdipojo/
11 | * Google project code http://code.google.com/p/jee6-cdi/
12 | * Comprehensive CDI tutorial http://code.google.com/p/jee6-cdi/wiki/DependencyInjectionAnIntroductoryTutorial
13 | * Google Group for email support for examples http://groups.google.com/group/cdiadvocate4j?pli=1
--------------------------------------------------------------------------------
/beancontainer/jndi-impl/pom.xml:
--------------------------------------------------------------------------------
1 |
2 | 4.0.0
3 | org.cdisource.beancontainer
4 | beancontainer-jndi-impl
5 | jar
6 | 1.0-SNAPSHOT
7 |
8 |
9 | org.cdisource
10 | cdisource-parent
11 | 1.0-SNAPSHOT
12 | ../../parent
13 |
14 |
15 |
16 | 3.0
17 |
18 |
19 | JNDI Bean Container Implementation
20 |
21 |
22 | BeanContainer API Impl accessing a Java EE 6 container managed CDI implementation
23 |
24 |
25 |
26 | org.cdisource.beancontainer
27 | beancontainer-api
28 | 1.0-SNAPSHOT
29 |
30 |
31 | junit
32 | junit
33 | 4.8.2
34 | jar
35 | test
36 |
37 |
38 | org.cdisource.beancontainer
39 | beancontainer-test
40 | 1.0-SNAPSHOT
41 | jar
42 | test
43 |
44 |
45 |
46 |
47 |
48 | repository.jboss.org
49 | JBoss Repository
50 | http://repository.jboss.org/nexus/content/groups/public-jboss/
51 |
52 |
53 |
54 |
55 |
56 |
57 |
--------------------------------------------------------------------------------
/beancontainer/jndi-impl/src/META-INF/MANIFEST.MF:
--------------------------------------------------------------------------------
1 | Manifest-Version: 1.0
2 | Class-Path:
3 |
4 |
--------------------------------------------------------------------------------
/beancontainer/jndi-impl/src/main/java/META-INF/MANIFEST.MF:
--------------------------------------------------------------------------------
1 | Manifest-Version: 1.0
2 | Class-Path:
3 |
4 |
--------------------------------------------------------------------------------
/beancontainer/jndi-impl/src/main/java/org/cdisource/beancontainer/JndiBeanContainer.java:
--------------------------------------------------------------------------------
1 | package org.cdisource.beancontainer;
2 |
3 | //import javax.enterprise.context.spi.Context;
4 | import javax.enterprise.inject.spi.BeanManager;
5 | import javax.naming.InitialContext;
6 |
7 | public class JndiBeanContainer extends AbstractBeanContainer {
8 |
9 |
10 | private BeanManager beanManager;
11 |
12 | private final String BEAN_MANAGER_LOCATION = "java:comp/BeanManager";
13 |
14 | @Override
15 | protected BeanManager locateBeanManager() {
16 | return beanManager;
17 | }
18 |
19 | @Override
20 | protected boolean isInitialized() {
21 | return beanManager != null;
22 | }
23 |
24 | @Override
25 | protected void doStart() throws Exception {
26 | // lookup the bean manager from jndi
27 | InitialContext ic = new InitialContext();
28 | Object bean = null;
29 | try {
30 | bean = ic.lookup(BEAN_MANAGER_LOCATION);
31 | } catch (Exception e) {
32 | throw new BeanContainerInitializationException("Unable to lookup BeanManager instance in JNDI", e);
33 | }
34 | if (bean == null) {
35 | throw new BeanContainerInitializationException(
36 | "Null value returned when looking up the BeanManager from JNDI");
37 | }
38 | if (bean instanceof BeanManager) {
39 | beanManager = (BeanManager) bean;
40 | } else {
41 | String msg = "Looked up JNDI Bean is not a BeanManager instance, bean type is " + bean.getClass().getName();
42 | throw new BeanContainerInitializationException(msg);
43 | }
44 | }
45 |
46 | @Override
47 | protected void doStop() {
48 | beanManager = null;
49 | }
50 |
51 |
52 | }
53 |
--------------------------------------------------------------------------------
/beancontainer/jndi-impl/src/main/resources/META-INF/services/org.cdisource.beancontainer.BeanContainer:
--------------------------------------------------------------------------------
1 | org.cdisource.beancontainer.JndiBeanContainer
2 |
--------------------------------------------------------------------------------
/beancontainer/jndi-impl/src/test/resource/META-INF/beans.xml:
--------------------------------------------------------------------------------
1 |
2 |
4 |
--------------------------------------------------------------------------------
/beancontainer/openwebbeans-impl/README:
--------------------------------------------------------------------------------
1 | This is CDI Advocate repository.
2 | Currently it hosts CDI beanContainer.
3 | CDI beanContainer is a small wrapper around Caucho Resin Candi and JBoss Seam Weld.
4 | It should be the basis of adding unit tests framework that works with all CDI implementations.
5 |
6 | Apache OpenWebBean support is planned.
7 | We are looking for someone to do the OpenWebBeans work.
8 |
9 | To learn more about this project go here:
10 | * Main website http://sites.google.com/site/cdipojo/
11 | * Google project code http://code.google.com/p/jee6-cdi/
12 | * Comprehensive CDI tutorial http://code.google.com/p/jee6-cdi/wiki/DependencyInjectionAnIntroductoryTutorial
13 | * Google Group for email support for examples http://groups.google.com/group/cdiadvocate4j?pli=1
--------------------------------------------------------------------------------
/beancontainer/openwebbeans-impl/pom.xml:
--------------------------------------------------------------------------------
1 |
2 | 4.0.0
3 | org.cdisource.beancontainer
4 | beancontainer-openwebbeans-impl
5 | jar
6 | 1.0-SNAPSHOT
7 |
8 |
9 | org.cdisource
10 | cdisource-parent
11 | 1.0-SNAPSHOT
12 | ../../parent
13 |
14 |
15 |
16 |
17 | 1.1.1-SNAPSHOT
18 |
19 |
20 |
21 | 3.0
22 |
23 |
24 | OpenWebBeans Bean Container Implementation
25 |
26 |
27 | API Impl for Apache OpenWebBeans
28 |
29 |
30 |
31 |
32 |
33 | org.cdisource.beancontainer
34 | beancontainer-api
35 | 1.0-SNAPSHOT
36 |
37 |
38 | org.apache.openwebbeans
39 | openwebbeans-impl
40 | ${openwebbeans.version}
41 |
42 |
43 | org.apache.openwebbeans
44 | openwebbeans-spi
45 | ${openwebbeans.version}
46 |
47 |
48 |
49 | org.apache.geronimo.specs
50 | geronimo-jcdi_1.0_spec
51 | 1.0
52 |
53 |
54 |
55 | org.cdisource.beancontainer
56 | beancontainer-test
57 | 1.0-SNAPSHOT
58 | jar
59 | test
60 |
61 |
62 |
63 | org.apache.geronimo.specs
64 | geronimo-interceptor_1.1_spec
65 | 1.0
66 |
67 |
68 |
69 |
70 |
71 |
72 |
73 | apachesnapshots
74 | http://repository.apache.org/snapshots
75 |
76 | true
77 |
78 |
79 | true
80 |
81 |
82 |
83 |
84 |
85 |
--------------------------------------------------------------------------------
/beancontainer/openwebbeans-impl/src/main/java/META-INF/MANIFEST.MF:
--------------------------------------------------------------------------------
1 | Manifest-Version: 1.0
2 | Class-Path:
3 |
4 |
--------------------------------------------------------------------------------
/beancontainer/openwebbeans-impl/src/main/java/org/cdisource/beancontainer/OpenWebBeansBeanContainer.java:
--------------------------------------------------------------------------------
1 | package org.cdisource.beancontainer;
2 |
3 | import javax.enterprise.inject.spi.BeanManager;
4 |
5 | import org.apache.webbeans.spi.ContainerLifecycle;
6 |
7 | import org.apache.webbeans.config.WebBeansContext;
8 |
9 | public class OpenWebBeansBeanContainer extends AbstractBeanContainer {
10 |
11 | private ContainerLifecycle lifecycle;
12 | private BeanManager beanManager;
13 |
14 | @Override
15 | protected BeanManager locateBeanManager() {
16 | return beanManager;
17 | }
18 |
19 | @Override
20 | protected boolean isInitialized() {
21 | return (lifecycle != null && beanManager != null);
22 | }
23 |
24 | @Override
25 | protected void doStart() throws Exception {
26 | lifecycle = WebBeansContext.getInstance().getService(ContainerLifecycle.class);
27 | lifecycle.startApplication(null);
28 | beanManager = lifecycle.getBeanManager();
29 | }
30 |
31 | @Override
32 | protected void doStop() {
33 | lifecycle.stopApplication(null);
34 | }
35 |
36 | }
37 |
--------------------------------------------------------------------------------
/beancontainer/openwebbeans-impl/src/main/resources/META-INF/services/org.cdisource.beancontainer.BeanContainer:
--------------------------------------------------------------------------------
1 | org.cdisource.beancontainer.OpenWebBeansBeanContainer
2 |
--------------------------------------------------------------------------------
/beancontainer/openwebbeans-impl/src/test/java/org/cdisource/beancontainer/OpenWebBeansBeanContainerTest.java:
--------------------------------------------------------------------------------
1 | package org.cdisource.beancontainer;
2 | import org.cdisource.testing.AbstractBeanContainerTest;
3 | import org.junit.Test;
4 |
5 | /**
6 | * Extends the {@link AbstractBeanContainerTest} to implement testing for the
7 | * OpenWebBeans {@link BeanContainer} implementation.
8 | *
9 | * @author Andy Gibson
10 | *
11 | */
12 | public class OpenWebBeansBeanContainerTest extends AbstractBeanContainerTest {
13 |
14 |
15 | @Test
16 | public void testLookupProducer() {
17 | //this test fails for open web beans.
18 | }
19 |
20 | }
21 |
--------------------------------------------------------------------------------
/beancontainer/openwebbeans-impl/src/test/resource/META-INF/beans.xml:
--------------------------------------------------------------------------------
1 |
2 |
4 |
--------------------------------------------------------------------------------
/beancontainer/resin-impl/README:
--------------------------------------------------------------------------------
1 | This is CDI Advocate repository.
2 | Currently it hosts CDI beanContainer.
3 | CDI beanContainer is a small wrapper around Caucho Resin Candi and JBoss Seam Weld.
4 | It should be the basis of adding unit tests framework that works with all CDI implementations.
5 |
6 | Apache OpenWebBean support is planned.
7 | We are looking for someone to do the OpenWebBeans work.
8 |
9 | To learn more about this project go here:
10 | * Main website http://sites.google.com/site/cdipojo/
11 | * Google project code http://code.google.com/p/jee6-cdi/
12 | * Comprehensive CDI tutorial http://code.google.com/p/jee6-cdi/wiki/DependencyInjectionAnIntroductoryTutorial
13 | * Google Group for email support for examples http://groups.google.com/group/cdiadvocate4j?pli=1
--------------------------------------------------------------------------------
/beancontainer/resin-impl/pom.xml:
--------------------------------------------------------------------------------
1 |
2 | 4.0.0
3 | org.cdisource.beancontainer
4 | beancontainer-resin-impl
5 | jar
6 | 1.0-SNAPSHOT
7 |
8 |
9 | org.cdisource
10 | cdisource-parent
11 | 1.0-SNAPSHOT
12 | ../../parent
13 |
14 |
15 |
16 | 3.0
17 |
18 |
19 | Resin Bean Container Implementation
20 |
21 |
22 | Base API for common bean container
23 |
24 |
25 |
26 |
27 |
28 |
29 | com.caucho
30 | resin
31 | 4.0.17
32 |
33 |
34 |
35 | com.caucho
36 | resin-hessian
37 |
38 |
39 |
40 | org.osgi
41 | osgi_R4_core
42 |
43 |
44 |
45 | javax.mail
46 | mail
47 |
48 |
49 |
50 | javax.activation
51 | activation
52 |
53 |
54 |
55 |
56 |
57 |
58 | org.cdisource.beancontainer
59 | beancontainer-api
60 | 1.0-SNAPSHOT
61 |
62 |
63 | javax.validation
64 | validation-api
65 | 1.0.0.GA
66 |
67 |
68 | org.cdisource.beancontainer
69 | beancontainer-test
70 | 1.0-SNAPSHOT
71 | jar
72 | test
73 |
74 |
75 |
76 |
77 |
78 | caucho.maven.repo
79 | Caucho Repository
80 | http://caucho.com/m2
81 |
82 |
83 | caucho.maven.repo.snapshot
84 | Caucho Repository
85 | http://caucho.com/m2-snapshot
86 |
87 |
88 |
89 |
90 |
91 |
92 | org.apache.maven.plugins
93 | maven-surefire-plugin
94 | 2.8
95 |
96 | true
97 | false
98 |
99 |
100 |
101 |
102 |
103 |
104 |
--------------------------------------------------------------------------------
/beancontainer/resin-impl/src/main/java/META-INF/MANIFEST.MF:
--------------------------------------------------------------------------------
1 | Manifest-Version: 1.0
2 | Class-Path:
3 |
4 |
--------------------------------------------------------------------------------
/beancontainer/resin-impl/src/main/java/org/cdisource/beancontainer/ResinBeanContainer.java:
--------------------------------------------------------------------------------
1 | package org.cdisource.beancontainer;
2 |
3 | import java.lang.annotation.Annotation;
4 |
5 | import javax.enterprise.context.RequestScoped;
6 | import javax.enterprise.context.spi.Context;
7 | import javax.enterprise.inject.spi.BeanManager;
8 |
9 | import com.caucho.resin.BeanContainerRequest;
10 |
11 | public class ResinBeanContainer extends AbstractBeanContainer {
12 |
13 | public Context getContextByScope(Class scopeType){
14 | return delegate.getCdiManager().getContext(scopeType);
15 | }
16 |
17 | com.caucho.resin.ResinBeanContainer delegate;
18 |
19 | @Override
20 | protected BeanManager locateBeanManager() {
21 | return delegate.getCdiManager();
22 | }
23 |
24 | @Override
25 | protected boolean isInitialized() {
26 | return delegate != null;
27 | }
28 |
29 | @Override
30 | protected void doStart() throws Exception {
31 | delegate = new com.caucho.resin.ResinBeanContainer();
32 | String resinConf = System.getProperty("org.cdisource.beancontainer.ResinBeanContainer.resinConf");
33 | if (resinConf!=null) {
34 | delegate.addBeansXml(resinConf);
35 | }
36 | delegate.start();
37 | }
38 |
39 | @Override
40 | protected void doStop() {
41 | delegate.close();
42 | }
43 |
44 | ThreadLocal requestScopeHolder = new ThreadLocal();
45 | @Override
46 | public void startScope(Class scope) {
47 | if (scope == RequestScoped.class) {
48 | BeanContainerRequest beginRequest = delegate.beginRequest();
49 | requestScopeHolder.set(beginRequest);
50 | }else {
51 | //...
52 | }
53 | }
54 |
55 | @Override
56 | public void stopScope(Class scope) {
57 | if (scope == RequestScoped.class) {
58 | requestScopeHolder.set(null);
59 | } else {
60 | //...
61 | }
62 |
63 | }
64 |
65 |
66 | }
67 |
--------------------------------------------------------------------------------
/beancontainer/resin-impl/src/main/resources/META-INF/services/org.cdisource.beancontainer.BeanContainer:
--------------------------------------------------------------------------------
1 | org.cdisource.beancontainer.ResinBeanContainer
--------------------------------------------------------------------------------
/beancontainer/resin-impl/src/test/java/org/cdisource/beancontainer/ResinBeanContainerTest.java:
--------------------------------------------------------------------------------
1 | package org.cdisource.beancontainer;
2 |
3 | import org.cdisource.testing.AbstractBeanContainerTest;
4 |
5 | public class ResinBeanContainerTest extends AbstractBeanContainerTest {
6 |
7 | }
8 |
--------------------------------------------------------------------------------
/beancontainer/resin-impl/src/test/resource/META-INF/beans.xml:
--------------------------------------------------------------------------------
1 |
2 |
4 |
--------------------------------------------------------------------------------
/beancontainer/testing/pom.xml:
--------------------------------------------------------------------------------
1 |
2 | 4.0.0
3 |
4 | org.cdisource
5 | cdisource-parent
6 | 1.0-SNAPSHOT
7 | ../../parent
8 |
9 | org.cdisource.beancontainer
10 | beancontainer-test
11 | Beancontainer testing harness
12 | 1.0-SNAPSHOT
13 |
14 |
15 | junit
16 | junit
17 | 4.8.2
18 | jar
19 | compile
20 |
21 |
22 | org.cdisource.beancontainer
23 | beancontainer-api
24 | 1.0-SNAPSHOT
25 | jar
26 | compile
27 |
28 |
29 |
30 |
--------------------------------------------------------------------------------
/beancontainer/testing/src/main/java/org/cdisource/testing/AbstractBeanContainerTest.java:
--------------------------------------------------------------------------------
1 | package org.cdisource.testing;
2 |
3 | import static junit.framework.Assert.assertEquals;
4 | import static junit.framework.Assert.assertNotNull;
5 | import static junit.framework.Assert.assertTrue;
6 |
7 | import org.cdisource.beancontainer.BeanContainer;
8 | import org.cdisource.beancontainer.BeanContainerManager;
9 | import org.cdisource.beancontainer.BeanNotFoundException;
10 | import org.junit.After;
11 | import org.junit.Before;
12 | import org.junit.Test;
13 |
14 | /**
15 | * Abstract container test that can be used to perform initial tests on a
16 | * {@link BeanContainer} implementation. To use, just create a test case that
17 | * extends this class and make sure an implementation is also in the project so
18 | * it can load the {@link BeanContainer} instance.
19 | *
20 | * @author Andy Gibson
21 | * @author Rick Hightower
22 | *
23 | */
24 | public class AbstractBeanContainerTest {
25 |
26 | private static BeanContainer beanContainer;
27 |
28 | public BeanContainer getBeanContainer() {
29 | return beanContainer;
30 | }
31 |
32 | @Before
33 | public void doBefore() {
34 | BeanContainerManager.initialize();
35 | beanContainer = BeanContainerManager.getInstance();
36 | }
37 |
38 | @After
39 | public void doAfter() {
40 | BeanContainerManager.shutdown();
41 | }
42 |
43 | @Test
44 | public void shouldInitContainer() {
45 | assertNotNull("Bean container is not initialized", beanContainer);
46 | }
47 |
48 | @Test
49 | public void shouldGetBeanInstance() {
50 | assertNotNull(beanContainer);
51 | SimpleBean bean = beanContainer.getBeanByType(SimpleBean.class);
52 | assertNotNull("Could not locate bean instance by type", bean);
53 | assertNotNull("Bean hasn't had InjectedBean injected into it", bean.getInjectedBean());
54 | }
55 |
56 | @Test
57 | public void shouldGetBeanByName() {
58 | assertNotNull(beanContainer);
59 | SimpleBean bean = (SimpleBean) beanContainer.getBeanByName("simpleBean");
60 | assertNotNull("Could not locate bean instance by name", bean);
61 | }
62 |
63 | @Test
64 | public void shouldGetBeanByNameNoCast() {
65 | assertNotNull(beanContainer);
66 | SimpleBean bean = beanContainer.getBeanByName(SimpleBean.class, "simpleBean");
67 | assertNotNull("Could not locate bean instance by name", bean);
68 | }
69 |
70 | @Test(expected = IllegalStateException.class)
71 | public void shouldThrowExceptionOnSecondStartup() {
72 | beanContainer.start();
73 | }
74 |
75 | @Test(expected = BeanNotFoundException.class)
76 | public void shouldThrowExceptionOnMissignBeanByName() {
77 | beanContainer.getBeanByName("missing_bean_name");
78 | }
79 |
80 | @Test(expected = BeanNotFoundException.class)
81 | public void shouldThrowExceptionOnMissignBeanByType() {
82 | beanContainer.getBeanByType(String.class);
83 | }
84 |
85 | @Test
86 | public void shouldHaveSingletonItem() {
87 | SimpleBean bean = beanContainer.getBeanByType(SimpleBean.class);
88 | assertNotNull("Named bean not found", bean);
89 | SingletonBean singleton = beanContainer.getBeanByType(SingletonBean.class);
90 | assertEquals("Found non-equal instances of a singleton bean", bean.getSingletonBean(), singleton);
91 | }
92 |
93 | @Test
94 | public void testSimpleNameSpaces() {
95 | Object bean = beanContainer.getBeanNamespace().findObject("simpleBean");
96 | assertNotNull(bean);
97 | assertTrue("Cannot locate simpleBean ", beanContainer.getBeanNamespace().contains("simpleBean"));
98 | }
99 |
100 | @Test
101 | public void testLookupProducer() {
102 | InjectedBean beanByType = beanContainer.getBeanByType(InjectedBean.class, new SomeOtherQualifierQualifier());
103 | assertNotNull(beanByType);
104 | }
105 |
106 | @Test public void testBeanContainerInjections() {
107 | assertEquals ("foo", beanContainer.getBeanByType(BeanUsingBeanContainer.class).foo());
108 | }
109 |
110 | }
111 |
--------------------------------------------------------------------------------
/beancontainer/testing/src/main/java/org/cdisource/testing/BeanUsingBeanContainer.java:
--------------------------------------------------------------------------------
1 | package org.cdisource.testing;
2 |
3 | import javax.inject.Inject;
4 |
5 | import org.cdisource.beancontainer.BeanContainer;
6 |
7 | public class BeanUsingBeanContainer {
8 | @Inject BeanContainer container;
9 |
10 | public String foo () {
11 | return container.getBeanByType(InjectedBean.class).foo();
12 | }
13 | }
14 |
--------------------------------------------------------------------------------
/beancontainer/testing/src/main/java/org/cdisource/testing/InjectedBean.java:
--------------------------------------------------------------------------------
1 | package org.cdisource.testing;
2 |
3 | /**
4 | * Dummy bean for simple test cases.
5 | *
6 | * @author Andy Gibson
7 | * @author Rick Hightower
8 | *
9 | */
10 | public class InjectedBean {
11 |
12 | public String foo () {
13 | return "foo";
14 | }
15 | }
16 |
--------------------------------------------------------------------------------
/beancontainer/testing/src/main/java/org/cdisource/testing/InjectedBeanFactory.java:
--------------------------------------------------------------------------------
1 | package org.cdisource.testing;
2 |
3 | import javax.enterprise.inject.Produces;
4 |
5 | @SomeOtherQualifier
6 | public class InjectedBeanFactory {
7 | @Produces @SomeOtherQualifier InjectedBean createTransport() {
8 | return new InjectedBean();
9 | }
10 | }
11 |
--------------------------------------------------------------------------------
/beancontainer/testing/src/main/java/org/cdisource/testing/NamedBean.java:
--------------------------------------------------------------------------------
1 | package org.cdisource.testing;
2 |
3 | import javax.inject.Named;
4 |
5 | @Named("org.long.Name")
6 | public class NamedBean {
7 |
8 | }
9 |
--------------------------------------------------------------------------------
/beancontainer/testing/src/main/java/org/cdisource/testing/SimpleBean.java:
--------------------------------------------------------------------------------
1 | package org.cdisource.testing;
2 |
3 | import javax.inject.Inject;
4 | import javax.inject.Named;
5 |
6 | /**
7 | * Simple named bean for testing
8 | *
9 | * @author Andy Gibson
10 | *
11 | */
12 | @Named("simpleBean")
13 | public class SimpleBean {
14 |
15 | @Inject
16 | private InjectedBean injectedBean;
17 |
18 | @Inject @SomeOtherQualifier
19 | private InjectedBean otherInjectedBean;
20 |
21 |
22 |
23 | @Inject
24 | private SingletonBean singletonBean;
25 |
26 |
27 | public InjectedBean getInjectedBean() {
28 | return injectedBean;
29 | }
30 |
31 | public InjectedBean getOtherInjectedBean() {
32 | return otherInjectedBean;
33 | }
34 |
35 | public SingletonBean getSingletonBean() {
36 | return singletonBean;
37 | }
38 |
39 | }
40 |
--------------------------------------------------------------------------------
/beancontainer/testing/src/main/java/org/cdisource/testing/SingletonBean.java:
--------------------------------------------------------------------------------
1 | package org.cdisource.testing;
2 |
3 | import javax.inject.Singleton;
4 | /**
5 | * Singleton bean for testing CDI
6 | *
7 | * @author Andy Gibson
8 | *
9 | */
10 | @Singleton
11 | public class SingletonBean {
12 |
13 | private int counter;
14 |
15 | public int getCounter() {
16 | return counter;
17 | }
18 |
19 | public synchronized void incrementCount() {
20 | counter++;
21 | }
22 | }
23 |
--------------------------------------------------------------------------------
/beancontainer/testing/src/main/java/org/cdisource/testing/SomeOtherQualifier.java:
--------------------------------------------------------------------------------
1 | package org.cdisource.testing;
2 |
3 | import java.lang.annotation.Documented;
4 | import java.lang.annotation.Retention;
5 | import java.lang.annotation.Target;
6 |
7 | import javax.inject.Qualifier;
8 |
9 | import static java.lang.annotation.ElementType.FIELD;
10 | import static java.lang.annotation.ElementType.METHOD;
11 | import static java.lang.annotation.ElementType.PARAMETER;
12 | import static java.lang.annotation.ElementType.TYPE;
13 | import static java.lang.annotation.RetentionPolicy.RUNTIME;
14 |
15 | @Qualifier
16 | @Target({ TYPE, METHOD, PARAMETER, FIELD })
17 | @Retention(RUNTIME)
18 | @Documented
19 | public @interface SomeOtherQualifier {
20 |
21 | }
22 |
--------------------------------------------------------------------------------
/beancontainer/testing/src/main/java/org/cdisource/testing/SomeOtherQualifierQualifier.java:
--------------------------------------------------------------------------------
1 | package org.cdisource.testing;
2 |
3 | import javax.enterprise.util.AnnotationLiteral;
4 |
5 | @SuppressWarnings("all")
6 | public class SomeOtherQualifierQualifier extends AnnotationLiteral implements SomeOtherQualifier {
7 |
8 | /**
9 | *
10 | */
11 | private static final long serialVersionUID = 1L;
12 |
13 | }
14 |
--------------------------------------------------------------------------------
/beancontainer/testing/src/main/java/org/cdisource/testing/SomeQualifier.java:
--------------------------------------------------------------------------------
1 | package org.cdisource.testing;
2 |
3 | import java.lang.annotation.Documented;
4 | import java.lang.annotation.Retention;
5 | import java.lang.annotation.Target;
6 |
7 | import javax.inject.Qualifier;
8 |
9 | import static java.lang.annotation.ElementType.FIELD;
10 | import static java.lang.annotation.ElementType.METHOD;
11 | import static java.lang.annotation.ElementType.PARAMETER;
12 | import static java.lang.annotation.ElementType.TYPE;
13 | import static java.lang.annotation.RetentionPolicy.RUNTIME;
14 |
15 | @Qualifier
16 | @Target({ TYPE, METHOD, PARAMETER, FIELD })
17 | @Retention(RUNTIME)
18 | @Documented
19 | public @interface SomeQualifier {
20 |
21 | }
22 |
--------------------------------------------------------------------------------
/beancontainer/testing/src/main/resources/META-INF/beans.xml:
--------------------------------------------------------------------------------
1 |
2 |
4 |
--------------------------------------------------------------------------------
/beancontainer/weld-impl/README:
--------------------------------------------------------------------------------
1 | This is CDI Advocate repository.
2 | Currently it hosts CDI beanContainer.
3 | CDI beanContainer is a small wrapper around Caucho Resin Candi and JBoss Seam Weld.
4 | It should be the basis of adding unit tests framework that works with all CDI implementations.
5 |
6 | Apache OpenWebBean support is planned.
7 | We are looking for someone to do the OpenWebBeans work.
8 |
9 | To learn more about this project go here:
10 | * Main website http://sites.google.com/site/cdipojo/
11 | * Google project code http://code.google.com/p/jee6-cdi/
12 | * Comprehensive CDI tutorial http://code.google.com/p/jee6-cdi/wiki/DependencyInjectionAnIntroductoryTutorial
13 | * Google Group for email support for examples http://groups.google.com/group/cdiadvocate4j?pli=1
--------------------------------------------------------------------------------
/beancontainer/weld-impl/pom.xml:
--------------------------------------------------------------------------------
1 |
2 | 4.0.0
3 | org.cdisource.beancontainer
4 | beancontainer-weld-impl
5 | jar
6 | 1.0-SNAPSHOT
7 |
8 |
9 | org.cdisource
10 | cdisource-parent
11 | 1.0-SNAPSHOT
12 | ../../parent
13 |
14 |
15 |
16 | 3.0
17 |
18 |
19 | Weld Bean Container Implementation
20 |
21 |
22 | API Impl for JBoss Seam Weld
23 |
24 |
25 |
26 |
27 |
28 | org.jboss.weld.se
29 | weld-se-core
30 | 1.1.0.Final
31 |
32 |
33 | org.slf4j
34 | slf4j-simple
35 | 1.5.10
36 |
37 |
38 | org.cdisource.beancontainer
39 | beancontainer-api
40 | 1.0-SNAPSHOT
41 |
42 |
43 | junit
44 | junit
45 | 4.8.2
46 | jar
47 | test
48 |
49 |
50 | org.cdisource.beancontainer
51 | beancontainer-test
52 | 1.0-SNAPSHOT
53 | jar
54 | test
55 |
56 |
57 |
58 |
59 |
60 |
61 | jboss.maven.repo
62 | JBoss Repository
63 | http://repository.jboss.org/nexus/content/groups/public-jboss/
64 |
65 |
66 |
67 |
68 |
69 |
--------------------------------------------------------------------------------
/beancontainer/weld-impl/src/main/java/org/cdisource/beancontainer/WeldBeanContainer.java:
--------------------------------------------------------------------------------
1 | package org.cdisource.beancontainer;
2 |
3 | //import javax.enterprise.context.spi.Context;
4 | import javax.enterprise.inject.spi.BeanManager;
5 |
6 | import org.jboss.weld.environment.se.Weld;
7 | import org.jboss.weld.environment.se.WeldContainer;
8 |
9 | public class WeldBeanContainer extends AbstractBeanContainer {
10 |
11 | // @Override
12 | // public void registerContext(Context context, boolean replace) {
13 | // throw new UnsupportedOperationException("TODO");
14 | // }
15 |
16 | WeldContainer delegate;
17 | Weld weld;
18 |
19 | @Override
20 | protected void doStart() throws Exception {
21 | weld = new Weld();
22 | delegate = weld.initialize();
23 | }
24 |
25 | @Override
26 | protected void doStop() {
27 | weld.shutdown();
28 | }
29 |
30 | @Override
31 | protected boolean isInitialized() {
32 | return weld != null;
33 | }
34 |
35 | @Override
36 | protected BeanManager locateBeanManager() {
37 | return delegate.getBeanManager();
38 | }
39 |
40 | }
41 |
--------------------------------------------------------------------------------
/beancontainer/weld-impl/src/main/resources/META-INF/services/org.cdisource.beancontainer.BeanContainer:
--------------------------------------------------------------------------------
1 | org.cdisource.beancontainer.WeldBeanContainer
2 |
--------------------------------------------------------------------------------
/beancontainer/weld-impl/src/test/java/org/cdisource/beancontainer/WeldBeanContainerTest.java:
--------------------------------------------------------------------------------
1 | package org.cdisource.beancontainer;
2 |
3 | import org.cdisource.testing.AbstractBeanContainerTest;
4 |
5 | /**
6 | * Extends the {@link AbstractBeanContainerTest} to implement testing for the
7 | * Weld {@link BeanContainer} implementation.
8 | *
9 | * @author Andy Gibson
10 | *
11 | */
12 | public class WeldBeanContainerTest extends AbstractBeanContainerTest {
13 |
14 | }
15 |
16 |
--------------------------------------------------------------------------------
/beancontainer/weld-impl/src/test/resource/META-INF/beans.xml:
--------------------------------------------------------------------------------
1 |
2 |
4 |
--------------------------------------------------------------------------------
/cdsource-eclipse-formatter.xml:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
7 |
8 |
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 |
19 |
20 |
21 |
22 |
23 |
24 |
25 |
26 |
27 |
28 |
29 |
30 |
31 |
32 |
33 |
34 |
35 |
36 |
37 |
38 |
39 |
40 |
41 |
42 |
43 |
44 |
45 |
46 |
47 |
48 |
49 |
50 |
51 |
52 |
53 |
54 |
55 |
56 |
57 |
58 |
59 |
60 |
61 |
62 |
63 |
64 |
65 |
66 |
67 |
68 |
69 |
70 |
71 |
72 |
73 |
74 |
75 |
76 |
77 |
78 |
79 |
80 |
81 |
82 |
83 |
84 |
85 |
86 |
87 |
88 |
89 |
90 |
91 |
92 |
93 |
94 |
95 |
96 |
97 |
98 |
99 |
100 |
101 |
102 |
103 |
104 |
105 |
106 |
107 |
108 |
109 |
110 |
111 |
112 |
113 |
114 |
115 |
116 |
117 |
118 |
119 |
120 |
121 |
122 |
123 |
124 |
125 |
126 |
127 |
128 |
129 |
130 |
131 |
132 |
133 |
134 |
135 |
136 |
137 |
138 |
139 |
140 |
141 |
142 |
143 |
144 |
145 |
146 |
147 |
148 |
149 |
150 |
151 |
152 |
153 |
154 |
155 |
156 |
157 |
158 |
159 |
160 |
161 |
162 |
163 |
164 |
165 |
166 |
167 |
168 |
169 |
170 |
171 |
172 |
173 |
174 |
175 |
176 |
177 |
178 |
179 |
180 |
181 |
182 |
183 |
184 |
185 |
186 |
187 |
188 |
189 |
190 |
191 |
192 |
193 |
194 |
195 |
196 |
197 |
198 |
199 |
200 |
201 |
202 |
203 |
204 |
205 |
206 |
207 |
208 |
209 |
210 |
211 |
212 |
213 |
214 |
215 |
216 |
217 |
218 |
219 |
220 |
221 |
222 |
223 |
224 |
225 |
226 |
227 |
228 |
229 |
230 |
231 |
232 |
233 |
234 |
235 |
236 |
237 |
238 |
239 |
240 |
241 |
242 |
243 |
244 |
245 |
246 |
247 |
248 |
249 |
250 |
251 |
252 |
253 |
254 |
255 |
256 |
257 |
258 |
259 |
260 |
261 |
262 |
263 |
264 |
265 |
266 |
267 |
268 |
269 |
270 |
271 |
272 |
273 |
274 |
275 |
276 |
277 |
278 |
279 |
280 |
--------------------------------------------------------------------------------
/parent/README:
--------------------------------------------------------------------------------
1 | This is CDI Advocate repository.
2 | Currently it hosts CDI beanContainer.
3 | CDI beanContainer is a small wrapper around Caucho Resin Candi and JBoss Seam Weld.
4 | It should be the basis of adding unit tests framework that works with all CDI implementations.
5 |
6 | Apache OpenWebBean support is planned.
7 | We are looking for someone to do the OpenWebBeans work.
8 |
9 | To learn more about this project go here:
10 | * Main website http://sites.google.com/site/cdipojo/
11 | * Google project code http://code.google.com/p/jee6-cdi/
12 | * Comprehensive CDI tutorial http://code.google.com/p/jee6-cdi/wiki/DependencyInjectionAnIntroductoryTutorial
13 | * Google Group for email support for examples http://groups.google.com/group/cdiadvocate4j?pli=1
--------------------------------------------------------------------------------
/parent/pom.xml:
--------------------------------------------------------------------------------
1 |
2 | 4.0.0
3 | org.cdisource
4 | cdisource-parent
5 | pom
6 | 1.0-SNAPSHOT
7 |
8 |
9 | org.sonatype.oss
10 | oss-parent
11 | 3
12 |
13 |
14 | CDI Advocate Parent
15 |
16 |
17 | TODO put address to website here
18 |
19 |
20 | The parent POM for Weld, specifying the build parameters
21 |
22 |
23 |
24 |
25 | Apache License, Version 2.0
26 | http://www.apache.org/licenses/LICENSE-2.0
27 |
28 |
29 |
30 |
31 |
32 | Rob Williams
33 |
34 |
35 | Andy Gibson
36 |
37 |
38 | Rick Hightower
39 |
40 |
41 |
42 |
43 | CDI Advocate
44 | TODO Put URL here
45 |
46 |
47 |
48 |
49 | UTF-8
50 | UTF-8
51 | yyyyMMdd-HHmm
52 |
53 |
54 |
55 | 3.0
56 |
57 |
58 |
59 |
60 |
61 | javax.enterprise
62 | cdi-api
63 | 1.0-SP1
64 | provided
65 | jar
66 |
67 |
68 |
69 |
70 |
71 |
72 |
73 | org.apache.maven.plugins
74 | maven-source-plugin
75 |
76 |
77 | attach-sources
78 |
79 | jar
80 |
81 |
82 |
83 |
84 |
85 | org.apache.maven.plugins
86 | maven-enforcer-plugin
87 | true
88 |
89 |
90 | org.codehaus.mojo
91 | build-helper-maven-plugin
92 |
93 |
94 | org.codehaus.mojo
95 | buildnumber-maven-plugin
96 |
97 |
98 | package
99 |
100 |
101 |
102 |
103 |
104 | org.apache.maven.plugins
105 | maven-antrun-plugin
106 | 1.3
107 |
108 |
109 | org.apache.maven.plugins
110 | maven-release-plugin
111 |
112 | -Drelease
113 | true
114 | forked-path
115 | true
116 |
117 | 2.0-beta-9
118 |
119 |
120 | org.apache.maven.plugins
121 | maven-surefire-report-plugin
122 | 2.6
123 |
124 |
125 | org.apache.maven.plugins
126 | maven-surefire-plugin
127 | 2.6
128 |
129 |
130 | org.apache.maven.plugins
131 | maven-clean-plugin
132 | 2.4.1
133 |
134 |
135 | org.apache.maven.plugins
136 | maven-deploy-plugin
137 | 2.5
138 |
139 |
140 | org.apache.maven.plugins
141 | maven-assembly-plugin
142 | 2.2-beta-5
143 |
144 |
145 | distribution
146 | package
147 |
148 | single
149 |
150 |
151 |
152 | src/main/assembly/assembly.xml
153 |
154 | ${project.build.finalName}-${project.version}
155 |
156 |
157 |
158 |
159 |
160 | org.apache.maven.plugins
161 | maven-install-plugin
162 | 2.3.1
163 |
164 |
165 | org.apache.maven.plugins
166 | maven-site-plugin
167 | 2.0.1
168 |
169 |
170 | org.apache.maven.plugins
171 | maven-source-plugin
172 | 2.1.2
173 |
174 |
175 | org.apache.maven.plugins
176 | maven-resources-plugin
177 | 2.4.3
178 |
179 |
180 | org.apache.maven.plugins
181 | maven-dependency-plugin
182 | 2.1
183 |
184 |
185 | org.apache.maven.plugins
186 | maven-javadoc-plugin
187 | 2.7
188 |
189 | true
190 |
191 |
192 |
193 | org.codehaus.mojo
194 | exec-maven-plugin
195 | 1.1.1
196 |
197 |
198 | org.apache.maven.plugins
199 | maven-enforcer-plugin
200 | 1.0-beta-1
201 |
202 |
203 | enforce
204 |
205 | enforce
206 |
207 |
208 |
209 |
210 | [${minimum.maven.version},)
211 |
212 |
213 |
214 | org.apache.maven.plugins:maven-eclipse-plugin
215 | org.codehaus.mojo:versions-maven-plugin
216 |
217 |
218 |
219 |
220 |
221 |
222 |
223 |
224 | org.apache.maven.plugins
225 | maven-compiler-plugin
226 | 2.3.1
227 |
228 | 1.6
229 | 1.6
230 |
231 |
232 |
233 | org.apache.maven.plugins
234 | maven-jar-plugin
235 | 2.3.1
236 |
237 |
238 |
239 | ${project.url}
240 | ${project.name}
241 | ${maven.build.timestamp}
242 | ${project.organization.name}
243 | ${project.name}
244 | ${parsedVersion.osgiVersion}
245 | ${project.organization.name}
246 |
247 |
248 |
249 | Build-Information
250 |
251 | ${maven.version}
252 | ${java.version}
253 | ${java.vendor}
254 | ${os.name}
255 | ${os.arch}
256 | ${os.version}
257 | r${buildNumber}
258 | ${maven.build.timestamp}
259 |
260 |
261 |
262 |
263 |
264 |
265 |
266 | org.codehaus.mojo
267 | build-helper-maven-plugin
268 | 1.5
269 |
270 |
271 | validate
272 |
273 | maven-version
274 | parse-version
275 |
276 |
277 |
278 |
279 |
280 | org.apache.maven.plugins
281 | maven-eclipse-plugin
282 |
283 |
284 | org.eclipse.jdt.launching.JRE_CONTAINER
285 |
286 |
287 |
288 |
289 | org.codehaus.mojo
290 | buildnumber-maven-plugin
291 | 1.0-beta-4
292 |
293 |
294 | set-build-properties
295 |
296 | create
297 |
298 |
299 | none
300 |
301 | true
302 | unavailable
303 | {0, date, long} {0, time, long}
304 |
305 |
306 |
307 | true
308 |
309 |
310 | org.twdata.maven
311 | maven-cli-plugin
312 | 1.0.3
313 |
314 |
315 | org.glassfish
316 | maven-embedded-glassfish-plugin
317 | 3.0
318 |
319 | glassfish
320 | ${project.build.directory}/${project.build.finalName}.war
321 | 7070
322 | ${project.build.finalName}
323 |
324 |
325 |
326 | install
327 |
328 | run
329 |
330 |
331 |
332 |
333 |
334 | org.mortbay.jetty
335 | maven-jetty-plugin
336 | 6.1.21
337 |
338 |
339 |
340 |
341 | 9090
342 |
343 |
344 |
345 | ${project.build.finalName}
346 |
348 | ${basedir}/src/main/resources/jetty-env.xml
349 |
350 |
352 | 3
353 |
354 |
355 |
356 |
357 |
358 |
359 | org.codehaus.mojo
360 | tomcat-maven-plugin
361 | 1.0-beta-1
362 | true
363 |
364 | /${project.build.finalName}
365 |
366 | 6060
367 |
370 | http://localhost:8080/manager
371 |
372 |
373 |
374 | org.apache.maven.plugins
375 | maven-war-plugin
376 | 2.1-beta-1
377 | true
378 |
379 | false
380 | ${project.build.finalName}
381 |
382 |
383 |
384 | org.apache.maven.plugins
385 | maven-archetype-plugin
386 | 2.0-alpha-5
387 | true
388 |
389 |
390 | org.codehaus.mojo
391 | jboss-maven-plugin
392 | 1.4
393 |
394 |
395 | org.codehaus.mojo
396 | emma-maven-plugin
397 | 1.0-alpha-2
398 |
399 |
400 | org.sonatype.maven.plugin
401 | emma4it-maven-plugin
402 | 1.3
403 |
404 |
405 | org.codehaus.cargo
406 | cargo-maven2-plugin
407 | 1.0.1
408 |
409 |
410 | org.codehaus.mojo
411 | selenium-maven-plugin
412 | 1.0.1
413 |
414 |
415 | org.codehaus.mojo
416 | failsafe-maven-plugin
417 | 2.4.3-alpha-1
418 |
419 |
420 | org.apache.maven.plugins
421 | maven-scm-plugin
422 | 1.4
423 |
424 |
425 |
426 |
427 |
428 |
429 |
430 | release
431 |
432 |
433 | release
434 |
435 |
436 |
437 |
438 |
439 | org.apache.maven.plugins
440 | maven-gpg-plugin
441 |
442 | ${gpg.passphrase}
443 | ${gpg.useAgent}
444 |
445 |
446 |
447 | sign-artifacts
448 | verify
449 |
450 | sign
451 |
452 |
453 |
454 |
455 |
456 | org.sonatype.plugins
457 | nexus-maven-plugin
458 |
459 | true
460 | [nexus-maven-plugin] closing
461 | repository after
462 | release:perform
463 |
464 |
465 |
466 | org.codehaus.mojo
467 | buildnumber-maven-plugin
468 |
469 |
470 | validate-scm
471 |
472 | create
473 |
474 |
475 | none
476 |
477 | true
478 | true
479 |
480 |
481 |
482 | true
483 |
484 |
485 |
486 |
487 |
488 | distribution
489 |
490 |
491 | dist
492 |
493 |
494 |
495 |
496 | true
497 |
498 |
499 |
500 |
501 | org.apache.maven.plugins
502 | maven-javadoc-plugin
503 |
504 |
505 | javadoc
506 | package
507 |
508 | jar
509 |
510 |
511 |
512 |
513 |
514 | org.apache.maven.plugins
515 | maven-deploy-plugin
516 |
517 | ${maven.deploy.skip}
518 |
519 |
520 |
521 |
522 |
523 |
524 | code-coverage
525 |
526 |
527 | code-coverage
528 |
529 |
530 |
531 |
532 |
533 |
534 | org.codehaus.mojo
535 | emma-maven-plugin
536 |
537 |
538 | instrumentation
539 | process-classes
540 |
541 | instrument
542 |
543 |
544 | true
545 |
546 |
547 |
548 | instrumentation-clean
549 | clean
550 |
551 | clean
552 |
553 |
554 |
555 |
556 |
557 |
558 | org.apache.maven.plugins
559 | maven-surefire-plugin
560 | true
561 |
562 | once
563 | ${project.build.directory}/generated-classes/emma/classes
564 |
565 |
566 |
567 |
568 | org.sonatype.maven.plugin
569 | emma4it-maven-plugin
570 |
571 |
572 | report
573 | test
574 |
575 | report
576 |
577 |
578 |
579 |
580 | ${project.build.sourceDirectory}
581 |
582 |
583 |
584 |
585 |
586 |
587 |
588 |
589 |
590 |
591 |
592 |
593 |
594 |
595 |
596 |
597 | cdi.advocate
598 | CDI Advocacy
599 | http://jee6-cdi.googlecode.com/svn/m2/repository/
600 |
601 |
602 | TBD
603 | TBD
604 | TBD
605 |
606 |
607 |
608 |
609 |
610 |
611 | cdi.advocate
612 | CDI Advocacy
613 | http://jee6-cdi.googlecode.com/svn/m2/repository/
614 |
615 |
616 | java.net
617 | Java.net repository for common APIs
618 | http://download.java.net/maven/2/
619 |
620 |
621 |
622 |
--------------------------------------------------------------------------------
/pom.xml:
--------------------------------------------------------------------------------
1 |
2 | 4.0.0
3 | org.cdisource.beancontainer
4 | cdisource-build-aggregator
5 | pom
6 | 1.0-SNAPSHOT
7 |
8 |
9 | org.cdisource
10 | cdisource-parent
11 | 1.0-SNAPSHOT
12 | parent
13 |
14 |
15 |
16 | 3.0
17 |
18 |
19 | CDISource Project Build Aggregator
20 |
21 |
22 | The build aggregator for CDI Advocate APIs, which takes care of calling the modules which make up CDI Advocate APIs
23 |
24 |
25 |
26 | scm:git:git://github.com/CDISource/cdisource.git
27 | http://github.com/CDISource/cdisource
28 | scm:git:git@github.com:CDISource/cdisource.git
29 |
30 |
31 |
32 | parent
33 | beancontainer/api
34 | beancontainer/resin-impl
35 | beancontainer/weld-impl
36 | beancontainer/testing
37 | beancontainer/openwebbeans-impl
38 | beancontainer/jndi-impl
39 | testing/junit
40 | web
41 | spring
42 |
43 |
44 |
45 | cdisource-${build.version}
46 |
47 |
48 |
49 |
--------------------------------------------------------------------------------
/spring/pom.xml:
--------------------------------------------------------------------------------
1 |
3 | 4.0.0
4 | org.cdisource.springbridge
5 | springbridge
6 | jar
7 | Spring Bridge
8 | 1.0-SNAPSHOT
9 |
10 |
11 | org.cdisource
12 | cdisource-parent
13 | 1.0-SNAPSHOT
14 | ../parent
15 |
16 |
17 |
18 | 3.0
19 |
20 |
21 |
22 |
23 | Spring CDI bridge to bridge the two technologies
24 |
25 |
26 | 3.0.5.RELEASE
27 | 1.6.11.M2
28 |
29 |
30 |
31 |
32 | spring-maven-release
33 | Spring Maven Release Repository
34 | http://maven.springframework.org/release
35 |
36 |
37 | spring-maven-milestone
38 | Spring Maven Milestone Repository
39 | http://maven.springframework.org/milestone
40 |
41 |
42 |
43 |
44 |
45 | javax.enterprise
46 | cdi-api
47 | 1.0-SP1
48 | jar
49 | compile
50 |
51 |
52 | junit
53 | junit
54 | 4.8.2
55 | jar
56 | test
57 |
58 |
59 |
60 | org.aspectj
61 | aspectjrt
62 | ${aspectj.version}
63 |
64 |
65 |
66 | org.springframework
67 | spring-test
68 | ${spring.version}
69 | test
70 |
71 |
72 | org.springframework
73 | spring-context
74 | ${spring.version}
75 |
76 |
77 | org.springframework
78 | spring-aop
79 | ${spring.version}
80 |
81 |
82 | org.springframework
83 | spring-aspects
84 | ${spring.version}
85 |
86 |
87 | org.springframework
88 | spring-web
89 | ${spring.version}
90 |
91 |
92 |
93 | org.springframework
94 | spring-tx
95 | ${spring.version}
96 |
97 |
98 |
99 | org.apache.geronimo.specs
100 | geronimo-servlet_3.0_spec
101 | 1.0
102 | provided
103 |
104 |
105 |
106 | org.cdisource.beancontainer
107 | beancontainer-api
108 | 1.0-SNAPSHOT
109 |
110 |
111 |
112 | org.cdisource.testing
113 | cdisource-testing-junit
114 | 1.0-SNAPSHOT
115 | test
116 |
117 |
118 |
119 |
120 |
121 |
122 |
123 | org.apache.maven.plugins
124 | maven-jar-plugin
125 | 2.3.1
126 |
127 |
128 |
129 | ${project.url}
130 | ${project.name}
131 | ${maven.build.timestamp}
132 | ${project.organization.name}
133 | ${project.name}
134 | ${parsedVersion.osgiVersion}
135 | ${project.organization.name}
136 |
137 |
138 |
139 | Build-Information
140 |
141 | ${maven.version}
142 | ${java.version}
143 | ${java.vendor}
144 | ${os.name}
145 | ${os.arch}
146 | ${os.version}
147 | r${buildNumber}
148 | ${maven.build.timestamp}
149 |
150 |
151 |
152 |
153 |
154 |
155 |
156 |
157 |
158 |
159 |
160 | resin
161 |
162 | true
163 |
164 |
165 |
166 | org.cdisource.beancontainer
167 | beancontainer-resin-impl
168 | 1.0-SNAPSHOT
169 | test
170 |
171 |
172 |
173 |
174 |
175 | org.apache.maven.plugins
176 | maven-surefire-plugin
177 | 2.8
178 |
179 | true
180 | false
181 |
182 |
183 |
184 |
185 |
186 |
187 |
188 | weld
189 |
190 |
191 | weld
192 | true
193 |
194 |
195 |
196 |
197 | org.cdisource.beancontainer
198 | beancontainer-weld-impl
199 | 1.0-SNAPSHOT
200 | test
201 |
202 |
203 |
204 |
205 |
206 | org.apache.maven.plugins
207 | maven-surefire-plugin
208 | 2.8
209 |
210 | true
211 | false
212 |
213 |
214 |
215 |
216 |
217 |
218 |
219 | openwebbeans
220 |
221 |
222 | openwebbeans
223 | true
224 |
225 |
226 |
227 |
228 | org.cdisource.beancontainer
229 | beancontainer-openwebbeans-impl
230 | 1.0-SNAPSHOT
231 | test
232 |
233 |
234 |
235 |
236 |
237 |
238 | org.apache.maven.plugins
239 | maven-surefire-plugin
240 | 2.8
241 |
242 | true
243 | false
244 |
245 |
246 |
247 |
248 |
249 |
250 |
251 |
252 |
253 |
--------------------------------------------------------------------------------
/spring/src/main/java/org/cdisource/springintegration/BeanManagerLocationUtil.java:
--------------------------------------------------------------------------------
1 | package org.cdisource.springintegration;
2 |
3 | import javax.enterprise.inject.spi.BeanManager;
4 | import javax.naming.InitialContext;
5 |
6 | import org.cdisource.beancontainer.BeanContainer;
7 | import org.cdisource.beancontainer.BeanContainerManager;
8 | import org.cdisource.beancontainer.BeanManagerLocator;
9 |
10 | public class BeanManagerLocationUtil {
11 |
12 | private final String BEAN_MANAGER_LOCATION = "java:comp/BeanManager";
13 | private BeanManager beanManager;
14 |
15 | BeanManager beanManager() {
16 | if (this.beanManager!=null) {
17 | return this.beanManager;
18 | }
19 | if (lookupInJNDI() == null) {
20 | BeanContainer beanContainer = BeanContainerManager.getInstance();
21 | this.beanManager = ((BeanManagerLocator) beanContainer)
22 | .getBeanManager();
23 | }
24 |
25 | if (this.beanManager==null) {
26 | throw new IllegalStateException("BEAN MANAGER IS NULL");
27 | }
28 | return this.beanManager;
29 |
30 | }
31 |
32 | private BeanManager lookupInJNDI() {
33 | try {
34 | InitialContext ic = new InitialContext();
35 | return (this.beanManager = (BeanManager) ic.lookup(BEAN_MANAGER_LOCATION));
36 | } catch (Exception e) {// need to log this
37 | return null;
38 | }
39 | }
40 |
41 | }
42 |
--------------------------------------------------------------------------------
/spring/src/main/java/org/cdisource/springintegration/CdiApplicationContext.java:
--------------------------------------------------------------------------------
1 | package org.cdisource.springintegration;
2 |
3 | import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
4 | import org.springframework.context.support.AbstractApplicationContext;
5 |
6 | public class CdiApplicationContext extends AbstractApplicationContext {
7 |
8 | private final ConfigurableListableBeanFactory beanFactory
9 | = new CdiBeanFactory();
10 |
11 |
12 | public CdiApplicationContext () {
13 | //refresh();
14 | }
15 |
16 | @Override
17 | protected void refreshBeanFactory() {
18 | }
19 |
20 | @Override
21 | protected void closeBeanFactory() {
22 | }
23 |
24 | @Override
25 | public ConfigurableListableBeanFactory getBeanFactory() {
26 | return beanFactory;
27 | }
28 |
29 | }
30 |
--------------------------------------------------------------------------------
/spring/src/main/java/org/cdisource/springintegration/CdiBeanFactory.java:
--------------------------------------------------------------------------------
1 | package org.cdisource.springintegration;
2 |
3 | import java.util.Set;
4 |
5 | import javax.enterprise.inject.spi.Bean;
6 | import javax.enterprise.inject.spi.BeanManager;
7 | import javax.naming.InitialContext;
8 |
9 | import org.cdisource.beancontainer.BeanContainer;
10 | import org.cdisource.beancontainer.BeanContainerImpl;
11 | import org.cdisource.beancontainer.BeanContainerInitializationException;
12 | import org.cdisource.beancontainer.BeanManagerLocator;
13 | import org.springframework.beans.factory.support.DefaultListableBeanFactory;
14 |
15 | public class CdiBeanFactory extends DefaultListableBeanFactory {
16 |
17 |
18 | /**
19 | * Creates a new bean factory adapter
20 | */
21 | public CdiBeanFactory() {
22 | }
23 |
24 | /**
25 | * Returns true for defined beans
26 | */
27 | @Override
28 | public boolean containsBeanDefinition(String beanName) {
29 | BeanManager beanManager = ((BeanManagerLocator)beanContainer()).getBeanManager();
30 | Set> beans = beanManager.getBeans(beanName);
31 | return beans.isEmpty();
32 | }
33 |
34 | /**
35 | * Returns the named beans
36 | */
37 | @Override
38 | public String[] getBeanDefinitionNames() {
39 | return super.getBeanDefinitionNames();
40 | }
41 |
42 | @SuppressWarnings({ "unchecked", "rawtypes" })
43 | @Override
44 | public Object getBean(String name, Class requiredType, Object... args) {
45 | return beanContainer().getBeanByName(requiredType, name);
46 | }
47 |
48 | @Override
49 | public T getBean(Class type) {
50 | return beanContainer().getBeanByType(type);
51 | }
52 |
53 | private final String BEAN_MANAGER_LOCATION = "java:comp/BeanManager";
54 |
55 | private BeanContainer beanContainer;
56 |
57 | private BeanContainer beanContainer() {
58 | if (beanContainer == null) {
59 | Object bean = null;
60 |
61 | try {
62 | InitialContext ic = new InitialContext();
63 | bean = ic.lookup(BEAN_MANAGER_LOCATION);
64 | } catch (Exception e) {
65 | throw new BeanContainerInitializationException(
66 | "Unable to lookup BeanManager instance in JNDI", e);
67 | }
68 | if (bean == null) {
69 | throw new BeanContainerInitializationException(
70 | "Null value returned when looking up the BeanManager from JNDI");
71 | }
72 | if (bean instanceof BeanManager) {
73 | beanContainer = new BeanContainerImpl((BeanManager) bean);
74 | } else {
75 | String msg = "Looked up JNDI Bean is not a BeanManager instance, bean type is "
76 | + bean.getClass().getName();
77 | throw new BeanContainerInitializationException(msg);
78 | }
79 | }
80 | return beanContainer;
81 |
82 | }
83 |
84 | }
85 |
--------------------------------------------------------------------------------
/spring/src/main/java/org/cdisource/springintegration/CdiBeanFactoryPostProcessor.java:
--------------------------------------------------------------------------------
1 | package org.cdisource.springintegration;
2 |
3 | import java.util.Set;
4 |
5 | import javax.enterprise.inject.spi.Bean;
6 | import javax.inject.Named;
7 | import org.springframework.beans.BeansException;
8 | import org.springframework.beans.factory.config.BeanFactoryPostProcessor;
9 | import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
10 | import org.springframework.beans.factory.support.BeanDefinitionBuilder;
11 | import org.springframework.beans.factory.support.DefaultListableBeanFactory;
12 |
13 |
14 | public class CdiBeanFactoryPostProcessor implements BeanFactoryPostProcessor {
15 |
16 | private boolean useLongName;
17 |
18 | private BeanManagerLocationUtil beanManagerLocationUtil = new BeanManagerLocationUtil();
19 |
20 |
21 | @Override
22 | public void postProcessBeanFactory(
23 | ConfigurableListableBeanFactory beanFactory) throws BeansException {
24 |
25 | DefaultListableBeanFactory factory = (DefaultListableBeanFactory) beanFactory;
26 |
27 | Set> beans = beanManagerLocationUtil.beanManager().getBeans(Object.class);
28 | for (Bean bean : beans) {
29 | if (bean instanceof SpringIntegrationExtention.SpringBean) {
30 | continue;
31 | }
32 |
33 | if (bean.getName()!=null && bean.getName().equals("Spring Injection")){
34 | continue;
35 | }
36 | BeanDefinitionBuilder definition = BeanDefinitionBuilder.rootBeanDefinition(CdiFactoryBean.class)
37 | .addPropertyValue("beanClass", bean.getBeanClass())
38 | .addPropertyValue("beanManager", beanManagerLocationUtil.beanManager())
39 | .setLazyInit(true);
40 | String name = generateName(bean);
41 | factory.registerBeanDefinition(name, definition.getBeanDefinition());
42 | }
43 | }
44 |
45 | private String generateName(Bean bean) {
46 | Named named = (Named) bean.getBeanClass().getAnnotation(Named.class);
47 | String name = named != null ? named.value() : generateNameBasedOnClassName(bean);
48 | return name;
49 | }
50 |
51 | private String generateNameBasedOnClassName(Bean bean) {
52 | return !useLongName ? bean.getBeanClass().getSimpleName() + "FactoryBean" : bean.getBeanClass().getName().replace(".", "_") + "FactoryBean";
53 | }
54 |
55 |
56 |
57 | public void setUseLongName(boolean useLongName) {
58 | this.useLongName = useLongName;
59 | }
60 |
61 |
62 | }
63 |
--------------------------------------------------------------------------------
/spring/src/main/java/org/cdisource/springintegration/CdiFactoryBean.java:
--------------------------------------------------------------------------------
1 | package org.cdisource.springintegration;
2 |
3 |
4 | import javax.enterprise.inject.spi.BeanManager;
5 |
6 | import org.springframework.beans.factory.FactoryBean;
7 | import org.springframework.beans.factory.InitializingBean;
8 | import org.cdisource.beancontainer.BeanContainer;
9 | import org.cdisource.beancontainer.BeanContainerImpl;
10 |
11 | public class CdiFactoryBean implements FactoryBean