.name(String.format("%s$%s$%d", source.getName(), "MockitoModuleProbe", Math.abs(random.nextInt()))) .invokable(isTypeInitializer()).intercept(implementation) .make() .load(source.getClassLoader(), loader.resolveStrategy(source, source.getClassLoader(), false)) .getLoaded()
ProtectionDomain.class, byte[].class)).onSuper().withAllArguments()) .make() .load(ExecutingTransformer.class.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER_PERSISTENT.with(ExecutingTransformer.class.getProtectionDomain()))
public static <E> E createInstance(Class<E> entityClass) { Class<? extends E> loaded = new ByteBuddy() .subclass( entityClass ) .method( ElementMatchers.named( "toString" ) ) .intercept( FixedValue.value( "transformed" ) ) .make() // we use our internal helper to get a class loading strategy suitable for the JDK used .load( entityClass.getClassLoader(), resolveClassLoadingStrategy( entityClass ) ) .getLoaded(); try { return loaded.newInstance(); } catch (Exception e) { throw new RuntimeException( "Unable to create new instance of " + entityClass.getSimpleName(), e ); } }
private <T extends ViewContext> T generateViewContextProxy(Class<T> clazz, Map<String, ContextProperty> properties) throws InstantiationException, IllegalAccessException, NoSuchMethodException { final Constructor<ViewContextBase> targetCtor = ViewContextBase.class.getConstructor(Map.class); return clazz.cast(new ByteBuddy() .subclass(ViewContextBase.class, ConstructorStrategy.Default.NO_CONSTRUCTORS) .implement(clazz, Serializable.class) .method(named("getViewContextType")).intercept(value(clazz)) .method(returns(ContextProperty.class)) .intercept(to(new StatePropertyGetterDelegate())) .defineConstructor(Modifier.PUBLIC) .intercept(invoke(targetCtor) .with(properties) .andThen(to(new ContextInitializer()))) .make() .load(getClass().getClassLoader(), WRAPPER) .getLoaded() .newInstance()); }
private <P extends PropertyContext<?, ?>> P createPropertyMappingContext(Class<? extends EntityContext<?, ?>> entityContextImplType, Class<? extends P> propertyContextImplType) { // ByteBuddyState#resolveClassLoadingStrategy static method is an Hibernate ORM internal, // please remove its use here as soon the issue HHH-13014 has been closed. // url https://hibernate.atlassian.net/browse/HHH-13014. Class<? extends P> propertyContextType = new ByteBuddy() .subclass( propertyContextImplType ) .method( filterEntityMethod().or( filterPropertyMethod() ) ) .intercept( to( new EntityOrPropertyMethodInterceptor( entityContextImplType, propertyContextImplType ) ) ) .make().load( propertyContextImplType.getClassLoader(), resolveClassLoadingStrategy( entityContextImplType ) ).getLoaded(); try { return propertyContextType.getConstructor( ConfigurationContext.class ).newInstance( this ); } catch (InstantiationException | IllegalAccessException | InvocationTargetException | NoSuchMethodException e) { throw log.cannotCreatePropertyContextProxy( propertyContextType, e ); } }
private <E extends EntityContext<?, ?>> E createEntityMappingContext(Class<? extends E> entityContextImplType, Class<? extends PropertyContext<?, ?>> propertyContextImplType) { // ByteBuddyState#resolveClassLoadingStrategy static method is an Hibernate ORM internal, // please remove its use here as soon the issue HHH-13014 has been closed. // url https://hibernate.atlassian.net/browse/HHH-13014. Class<? extends E> entityContextType = new ByteBuddy() .subclass( entityContextImplType ) .method( filterEntityMethod().or( filterPropertyMethod() ) ) .intercept( to( new EntityOrPropertyMethodInterceptor( entityContextImplType, propertyContextImplType ) ) ) .make().load( entityContextImplType.getClassLoader(), resolveClassLoadingStrategy( entityContextImplType ) ).getLoaded(); try { return entityContextType.getConstructor( ConfigurationContext.class ).newInstance( this ); } catch (InstantiationException | IllegalAccessException | InvocationTargetException | NoSuchMethodException e) { throw log.cannotCreateEntityContextProxy( entityContextType, e ); } }
@SuppressWarnings("unchecked") public <T extends SebElement> T constructSebElement(Class<T> element, SebContext context, WebElement webElement, boolean optional) { try { if (optional) { element = (Class<T>) new ByteBuddy().subclass(element).method(ElementMatchers.isPublic()) .intercept(MethodDelegation.to(SebElementInterceptor.class).andThen(SuperMethodCall.INSTANCE)) .make().load(context.getClass().getClassLoader(), ClassLoadingStrategy.Default.WRAPPER).getLoaded(); } Constructor<T> ctor = element.getConstructor(); return (T) ctor.newInstance().with(context, webElement, optional); } catch (Exception e) { throw new SebElementConstructException("Unable to construct module " + element.getName(), e); } }
private <T> Class<? extends T> generateProviderProxyClass(ProviderProxyHandler proxyHandler, Class<T> providerCls) { try { return new ByteBuddy() .subclass(providerCls) .method(isDeclaredBy(providerCls)) .intercept(to(proxyHandler, "handler").filter(not(isDeclaredBy(Object.class)))) .make() .load(providerCls.getClassLoader(), INJECTION) .getLoaded(); } catch (Exception e) { logger.error("Generate proxy [{}, handler: {}] fail: {}.", providerCls, proxyHandler,e.getMessage()); return providerCls; } }
private <I, T extends I> T newLazyUnsafely(Class<I> cls, String eid) throws NoSuchMethodException, IllegalAccessException, InstantiationException { Method toStringMethod = Object.class.getDeclaredMethod("toString"); DynamicType.Unloaded<?> dynamicType = new ByteBuddy() .subclass(cls) .method(noneOf(toStringMethod)) .intercept(throwingEid(eid)) .make(); DynamicType.Loaded<?> loaded = dynamicType.load(getClass().getClassLoader()); @SuppressWarnings("unchecked") Class<T> resultCls = (Class<T>) loaded.getLoaded(); return resultCls.newInstance(); }
private static Object crateForParameters(Class<?> effectiveTargetClass, Set<Class<?>> interfacesToImplement, ClassLoader classLoader, Class<?> interceptorClass) { List<Type> interfacesToImplementAsList = new ArrayList<Type>(interfacesToImplement); Class<?> proxyType = new ByteBuddy() .subclass(effectiveTargetClass) .implement(interfacesToImplementAsList) .method(not(isFinalizer())) .intercept(MethodDelegation.to(interceptorClass)) .make() .load(classLoader) .getLoaded(); return instantiate(proxyType); }
@Override public Class<?> generateProxyClass(ClassLoader classLoader, Class<?>... proxyClasses) { Class/*<? extends Echo>*/ dynamicUserType = new ByteBuddy() .subclass(proxyClasses[0]) .implement(ObjectInvokerAccessor.class).intercept(FieldAccessor.ofBeanProperty()) .method(not(isDeclaredBy(Object.class))) .intercept(MethodDelegation.to(DynamicDelegator.class)) .make() .load(getClass().getClassLoader()) .getLoaded(); return dynamicUserType; } }
@Override public <T> T newProxy(Class<T> interfaceType, Object handler) { Class<? extends T> cls = new ByteBuddy() .subclass(interfaceType) .method(isDeclaredBy(interfaceType)) .intercept(to(handler, "handler").filter(not(isDeclaredBy(Object.class)))) .make() .load(interfaceType.getClassLoader(), INJECTION) .getLoaded(); return Reflects.newInstance(cls); } });
protected T generateProxy() throws Exception { return (T) new net.bytebuddy.ByteBuddy() .subclass(target) .method(net.bytebuddy.matcher.ElementMatchers.any()) .intercept(net.bytebuddy.implementation.InvocationHandlerAdapter.of(this)) .make() .load(target.getClassLoader()).getLoaded().getDeclaredConstructor().newInstance(); }
.make().load(entityClass.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER) .getLoaded();
.make().load(entityClass.getClassLoader(), ClassLoadingStrategy.Default.WRAPPER) .getLoaded();
@Override public <T> T newProxy(Class<T> interfaceType, Object handler) { Class<? extends T> cls = new ByteBuddy() .subclass(interfaceType) .method(ElementMatchers.isDeclaredBy(interfaceType)) .intercept(MethodDelegation.to(handler, "handler")) .make() .load(interfaceType.getClassLoader(), ClassLoadingStrategy.Default.INJECTION) .getLoaded(); try { return cls.newInstance(); } catch (Throwable t) { ThrowUtil.throwException(t); } return null; // never get here } });
@Override public <T> T newProxy(Class<T> interfaceType, Object handler) { Class<? extends T> cls = new ByteBuddy() .subclass(interfaceType) .method(ElementMatchers.isDeclaredBy(interfaceType)) .intercept(MethodDelegation.to(handler, "handler")) .make() .load(interfaceType.getClassLoader(), ClassLoadingStrategy.Default.INJECTION) .getLoaded(); try { return cls.newInstance(); } catch (Throwable t) { ThrowUtil.throwException(t); } return null; // never get here } });
private static Object crateForParameters(Class<?> effectiveTargetClass, Set<Class<?>> interfacesToImplement, ClassLoader classLoader, Class<?> interceptorClass) { List<Type> interfacesToImplementAsList = new ArrayList<Type>(interfacesToImplement); Class<?> proxyType = new ByteBuddy() .subclass(effectiveTargetClass) .implement(interfacesToImplementAsList) .method(not(isFinalizer())) .intercept(MethodDelegation.to(interceptorClass)) .make() .load(classLoader) .getLoaded(); return instantiate(proxyType); }
/** * {@inheritDoc} */ public DynamicType make(String auxiliaryTypeName, ClassFileVersion classFileVersion, MethodAccessorFactory methodAccessorFactory) { return new ByteBuddy(classFileVersion) .with(TypeValidation.DISABLED) .subclass(morphingType, ConstructorStrategy.Default.NO_CONSTRUCTORS) .name(auxiliaryTypeName) .modifiers(DEFAULT_TYPE_MODIFIER) .implement(serializableProxy ? new Class<?>[]{Serializable.class} : new Class<?>[0]) .defineConstructor().withParameters(specialMethodInvocation.getMethodDescription().isStatic() ? Collections.<TypeDescription>emptyList() : Collections.singletonList(instrumentedType)) .intercept(specialMethodInvocation.getMethodDescription().isStatic() ? StaticFieldConstructor.INSTANCE : new InstanceFieldConstructor(instrumentedType)) .method(ElementMatchers.<MethodDescription>isAbstract().and(isDeclaredBy(morphingType))) .intercept(new MethodCall(methodAccessorFactory.registerAccessorFor(specialMethodInvocation, MethodAccessorFactory.AccessType.DEFAULT), assigner)) .make(); }
/** * {@inheritDoc} */ public DynamicType make(String auxiliaryTypeName, ClassFileVersion classFileVersion, MethodAccessorFactory methodAccessorFactory) { return new ByteBuddy(classFileVersion) .with(TypeValidation.DISABLED) .ignore(ignoreFinalizer ? isFinalizer() : ElementMatchers.<MethodDescription>none()) .subclass(proxiedType) .name(auxiliaryTypeName) .modifiers(DEFAULT_TYPE_MODIFIER) .implement(serializableProxy ? new Class<?>[]{Serializable.class} : new Class<?>[0]) .method(any()).intercept(new MethodCall(methodAccessorFactory)) .defineMethod(REFLECTION_METHOD, TargetType.class, Ownership.STATIC).intercept(SilentConstruction.INSTANCE) .make(); }