/** * Assumes that the factory will keep cranking out instances of the same class. * * @since 1.1 */ private Class constructBridgeProxyClass(Object service) { ProxyBuilder builder = new ProxyBuilder("BridgeProxy", getServicePoint()); ClassFab cf = builder.getClassFab(); Class serviceType = service.getClass(); cf.addField("_service", serviceType); cf.addConstructor(new Class[] { serviceType }, null, "{ super(); _service = $1; }"); builder.addServiceMethods("_service"); return cf.createClass(); }
/** @since 1.1 */ private void addSerializable(String pointId) { _classFab.addInterface(Serializable.class); BodyBuilder bb = new BodyBuilder(); bb.add( "return {0}.getServiceSerializationSupport().getServiceTokenForService(\"{1}\");", ServiceSerializationHelper.class.getName(), pointId); MethodSignature sig = new MethodSignature(Object.class, "writeReplace", null, null); _classFab.addMethod(Modifier.PRIVATE, sig, bb.toString()); }
/** * Adds a field, _serviceExtensionPoint, whose type matches this class, and a constructor which * sets the field. */ private static void addConstructor(ClassFab classFab, ServiceModel model) { Class modelClass = model.getClass(); classFab.addField("_serviceModel", modelClass); classFab.addConstructor(new Class[] { modelClass }, null, "{ super(); _serviceModel = $1; }"); }
classFab.addInterface(ExpressionAccessor.class); if (!classFab.containsMethod(expressionSetter)) classFab.addField("_node", Node.class); classFab.addMethod(Modifier.PUBLIC, expressionSetter, "{ _node = $1; }"); classFab.addMethod(Modifier.PUBLIC, valueGetter, generateOgnlGetter(classFab, valueGetter)); classFab.addMethod(Modifier.PUBLIC, valueSetter, generateOgnlSetter(classFab, valueSetter)); classFab.addConstructor(new Class[0], new Class[0], "{}"); if (classFab.containsMethod(expressionSetter))
/** * Adds a <code>toString()</code> method to a class that returns a fixed, pre-computed value. * * @param classFab * ClassFab used to construct the new class. * @param toStringResult * fixed result to be returned by the method. */ public static void addToStringMethod(ClassFab classFab, String toStringResult) { StringBuffer buffer = new StringBuffer("return "); buffer.append(QUOTE); buffer.append(toStringResult); buffer.append(QUOTE); buffer.append(";"); classFab.addMethod(Modifier.PUBLIC, new MethodSignature(String.class, "toString", null, null), buffer.toString()); }
private Class constructInterceptorClass(InterceptorStack stack, List parameters) { Class serviceInterfaceClass = stack.getServiceInterface(); String name = ClassFabUtils.generateClassName(serviceInterfaceClass); ClassFab classFab = _factory.newClass(name, Object.class); classFab.addInterface(serviceInterfaceClass); createInfrastructure(stack, classFab); addServiceMethods(stack, classFab, parameters); return classFab.createClass(); }
/** * We construct a method that always goes through this service model's * {@link #getServiceImplementationForCurrentThread())} method. */ private static void addServiceAccessor(ClassFab classFab, String serviceModelMethodName, ServicePoint servicePoint) { Class serviceInterface = servicePoint.getServiceInterface(); classFab.addField(SERVICE_ACCESSOR_METHOD_NAME, serviceInterface); BodyBuilder builder = new BodyBuilder(); builder.begin(); builder.add("return ("); builder.add(serviceInterface.getName()); builder.add(") _serviceModel."); builder.add(serviceModelMethodName); builder.add("();"); builder.end(); classFab.addMethod(Modifier.PRIVATE | Modifier.FINAL, new MethodSignature(serviceInterface, SERVICE_ACCESSOR_METHOD_NAME, null, null), builder.toString()); } }
private void addInterfaceIfNeeded(Class interfaceClass) { if (implementsInterface(interfaceClass)) return; _classFab.addInterface(interfaceClass); _addedInterfaces.add(interfaceClass); }
if( !_classFab.containsMethod( m ) ) builder.addln("($$);"); builder.end(); _classFab.addMethod(Modifier.PUBLIC, m, builder.toString());
private Constructor findConstructor() { Class componentClass = _classFab.createClass(); // The fabricated base class always has exactly one constructor return componentClass.getConstructors()[0]; }
public void addField(String name, Class type) { _classFab.addField(name, type); }
void finalizeEnhancedClass() { finalizeIncompleteMethods(); if (_constructorBuilder != null) { _constructorBuilder.end(); Class[] types = (Class[]) _constructorTypes.toArray(new Class[_constructorTypes.size()]); _classFab.addConstructor(types, null, _constructorBuilder.toString()); } if (_log != null && _log.isDebugEnabled()) _log.debug("Creating class:\n\n" + _classFab); }
classFab.addInterface(ExpressionAccessor.class); if (!classFab.containsMethod(expressionSetter)) classFab.addField("_node", Node.class); classFab.addMethod(Modifier.PUBLIC, expressionSetter, "{ _node = $1; }"); classFab.addMethod(Modifier.PUBLIC, valueGetter, generateOgnlGetter(classFab, valueGetter)); classFab.addMethod(Modifier.PUBLIC, valueSetter, generateOgnlSetter(classFab, valueSetter)); classFab.addConstructor(new Class[0], new Class[0], "{}"); if (classFab.containsMethod(expressionSetter))
private void finalizeIncompleteMethods() { Iterator i = _incompleteMethods.entrySet().iterator(); while(i.hasNext()) { Map.Entry e = (Map.Entry) i.next(); MethodSignature sig = (MethodSignature) e.getKey(); BodyBuilder builder = (BodyBuilder) e.getValue(); // Each BodyBuilder is created and given a begin(), this is // the matching end() builder.end(); _classFab.addMethod(Modifier.PUBLIC, sig, builder.toString()); } }
private void createInfrastructure(InterceptorStack stack, ClassFab classFab) { Class topClass = ClassFabUtils.getInstanceClass(stack.peek(), stack.getServiceInterface()); classFab.addField("_log", Log.class); // This is very important: since we know the instance of the top object (the next // object in the pipeline for this service), we can build the instance variable // and constructor to use the exact class rather than the service interface. // That's more efficient at runtime, lowering the cost of using interceptors. // One of the reasons I prefer Javassist over JDK Proxies. classFab.addField("_delegate", topClass); classFab.addConstructor( new Class[] { Log.class, topClass }, null, "{ _log = $1; _delegate = $2; }"); }
private void addInterfaceIfNeeded(Class interfaceClass) { if (implementsInterface(interfaceClass)) return; _classFab.addInterface(interfaceClass); _addedInterfaces.add(interfaceClass); }
private Constructor findConstructor() { Class componentClass = _classFab.createClass(); // The fabricated base class always has exactly one constructor return componentClass.getConstructors()[0]; }
public void addField(String name, Class type) { _classFab.addField(name, type); }
void finalizeEnhancedClass() { finalizeIncompleteMethods(); if (_constructorBuilder != null) { _constructorBuilder.end(); Class[] types = (Class[]) _constructorTypes.toArray(new Class[_constructorTypes.size()]); _classFab.addConstructor(types, null, _constructorBuilder.toString()); } if (_log != null && _log.isDebugEnabled()) _log.debug("Creating class:\n\n" + _classFab); }
/** @since 1.1 */ private static void addDelegateAccessor(ClassFab classFab, ServicePoint servicePoint, Object delegate) { classFab.addField("_shutdown", boolean.class); Class delegateClass = ClassFabUtils.getInstanceClass(delegate, servicePoint .getServiceInterface()); classFab.addField("_delegate", delegateClass); classFab.addConstructor(new Class[] { delegateClass }, null, "{ super(); _delegate = $1; }"); classFab.addInterface(RegistryShutdownListener.class); if( RegistryShutdownListener.class.isAssignableFrom( delegateClass ) ) { classFab.addMethod(Modifier.PUBLIC | Modifier.FINAL, new MethodSignature(void.class, "registryDidShutdown", null, null), "{ _delegate.registryDidShutdown(); _delegate = null; _shutdown = true; }"); } else { classFab.addMethod(Modifier.PUBLIC | Modifier.FINAL, new MethodSignature(void.class, "registryDidShutdown", null, null), "{ _delegate = null; _shutdown = true; }"); } BodyBuilder builder = new BodyBuilder(); builder.begin(); builder.addln("if (_shutdown)"); builder.addln(" throw org.apache.hivemind.HiveMind#createRegistryShutdownException();"); builder.add("return _delegate;"); builder.end(); classFab.addMethod(Modifier.FINAL | Modifier.PRIVATE, new MethodSignature(delegateClass, DELEGATE_ACCESSOR_METHOD_NAME, null, null), builder.toString()); }