import org.springframework.aop.SpringProxy; //导入依赖的package包/类
public void testGetObjectWithFilterOnly() throws Exception {
	this.serviceFactoryBean.setBundleContext(new MockBundleContext());
	this.serviceFactoryBean.setInterfaces(new Class<?>[] { Serializable.class });
	String filter = "(beanName=myBean)";
	this.serviceFactoryBean.setFilter(filter);

	MockServiceReference ref = new MockServiceReference();
	Dictionary dict = new Hashtable();
	dict.put(Constants.OBJECTCLASS, new String[] { Serializable.class.getName() });
	ref.setProperties(dict);

	serviceFactoryBean.setBeanClassLoader(getClass().getClassLoader());
	serviceFactoryBean.afterPropertiesSet();

	Object proxy = serviceFactoryBean.getObject();
	assertTrue(proxy instanceof Serializable);
	assertTrue("should be proxied", proxy instanceof SpringProxy);
}
 

import org.springframework.aop.SpringProxy; //导入依赖的package包/类
/**
 * Extract the user-specified interfaces that the given proxy implements,
 * i.e. all non-Advised interfaces that the proxy implements.
 * @param proxy the proxy to analyze (usually a JDK dynamic proxy)
 * @return all user-specified interfaces that the proxy implements,
 * in the original order (never {@code null} or empty)
 * @see Advised
 */
public static Class<?>[] proxiedUserInterfaces(Object proxy) {
	Class<?>[] proxyInterfaces = proxy.getClass().getInterfaces();
	int nonUserIfcCount = 0;
	if (proxy instanceof SpringProxy) {
		nonUserIfcCount++;
	}
	if (proxy instanceof Advised) {
		nonUserIfcCount++;
	}
	if (proxy instanceof DecoratingProxy) {
		nonUserIfcCount++;
	}
	Class<?>[] userInterfaces = new Class<?>[proxyInterfaces.length - nonUserIfcCount];
	System.arraycopy(proxyInterfaces, 0, userInterfaces, 0, userInterfaces.length);
	Assert.notEmpty(userInterfaces, "JDK proxy must implement one or more interfaces");
	return userInterfaces;
}
 

import org.springframework.aop.SpringProxy; //导入依赖的package包/类
public void testGetObjectWithFilterOnly() throws Exception {
	this.serviceFactoryBean.setBundleContext(new MockBundleContext());
	this.serviceFactoryBean.setInterfaces(new Class[] { Serializable.class });
	String filter = "(beanName=myBean)";
	this.serviceFactoryBean.setFilter(filter);

	MockServiceReference ref = new MockServiceReference();
	Dictionary dict = new Hashtable();
	dict.put(Constants.OBJECTCLASS, new String[] { Serializable.class.getName() });
	ref.setProperties(dict);

	serviceFactoryBean.setBeanClassLoader(getClass().getClassLoader());
	serviceFactoryBean.afterPropertiesSet();

	Object proxy = serviceFactoryBean.getObject();
	assertTrue(proxy instanceof Serializable);
	assertTrue("should be proxied", proxy instanceof SpringProxy);
}
 

import org.springframework.aop.SpringProxy; //导入依赖的package包/类
public void testProxyForUnaryCardinality() throws Exception {
	long time = 1234;
	Date date = new Date(time);
	ServiceRegistration reg = publishService(date);

	fb.setAvailability(Availability.MANDATORY);

	fb.setInterfaces(new Class<?>[] { Date.class });
	fb.afterPropertiesSet();

	ImportedOsgiServiceProxy refAware = null;
	try {
		Object result = fb.getObject();
		assertTrue(result instanceof Date);
		// check it's our object
		assertEquals(time, ((Date) result).getTime());
		assertTrue(result instanceof SpringProxy);
		assertTrue(result instanceof ImportedOsgiServiceProxy);
		assertTrue(result instanceof InfrastructureProxy);

		refAware = (ImportedOsgiServiceProxy) result;
		assertNotNull(refAware.getServiceReference());

		assertEquals("wrong target returned", date, ((InfrastructureProxy) result).getWrappedObject());
	}
	finally {
		if (reg != null)
			reg.unregister();
	}

	// test reference after the service went down
	assertNotNull(refAware.getServiceReference());
	assertNull(refAware.getServiceReference().getBundle());
}
 

import org.springframework.aop.SpringProxy; //导入依赖的package包/类
public SimpleServiceJDKProxyCreator(BundleContext context, Class<?>[] classes, ClassLoader loader) {
	// add Spring-DM proxies
	Object[] obj = ObjectUtils.addObjectToArray(classes, ImportedOsgiServiceProxy.class);
	this.classes = (Class[]) ObjectUtils.addObjectToArray(obj, SpringProxy.class);
	System.out.println("given classes " + ObjectUtils.nullSafeToString(classes) + " | resulting classes "
			+ ObjectUtils.nullSafeToString(this.classes));
	this.loader = loader;
	this.context = context;
}
 

import org.springframework.aop.SpringProxy; //导入依赖的package包/类
/**
 * Determine the complete set of interfaces to proxy for the given AOP configuration.
 * <p>This will always add the {@link Advised} interface unless the AdvisedSupport's
 * {@link AdvisedSupport#setOpaque "opaque"} flag is on. Always adds the
 * {@link org.springframework.aop.SpringProxy} marker interface.
 * @return the complete set of interfaces to proxy
 * @see Advised
 * @see org.springframework.aop.SpringProxy
 */
public static Class<?>[] completeProxiedInterfaces(AdvisedSupport advised) {
	Class<?>[] specifiedInterfaces = advised.getProxiedInterfaces();
	if (specifiedInterfaces.length == 0) {
		// No user-specified interfaces: check whether target class is an interface.
		Class<?> targetClass = advised.getTargetClass();
		if (targetClass != null && targetClass.isInterface()) {
			specifiedInterfaces = new Class<?>[] {targetClass};
		}
	}
	boolean addSpringProxy = !advised.isInterfaceProxied(SpringProxy.class);
	boolean addAdvised = !advised.isOpaque() && !advised.isInterfaceProxied(Advised.class);
	int nonUserIfcCount = 0;
	if (addSpringProxy) {
		nonUserIfcCount++;
	}
	if (addAdvised) {
		nonUserIfcCount++;
	}
	Class<?>[] proxiedInterfaces = new Class<?>[specifiedInterfaces.length + nonUserIfcCount];
	System.arraycopy(specifiedInterfaces, 0, proxiedInterfaces, 0, specifiedInterfaces.length);
	if (addSpringProxy) {
		proxiedInterfaces[specifiedInterfaces.length] = SpringProxy.class;
	}
	if (addAdvised) {
		proxiedInterfaces[proxiedInterfaces.length - 1] = Advised.class;
	}
	return proxiedInterfaces;
}
 

import org.springframework.aop.SpringProxy; //导入依赖的package包/类
/**
 * Extract the user-specified interfaces that the given proxy implements,
 * i.e. all non-Advised interfaces that the proxy implements.
 * @param proxy the proxy to analyze (usually a JDK dynamic proxy)
 * @return all user-specified interfaces that the proxy implements,
 * in the original order (never {@code null} or empty)
 * @see Advised
 */
public static Class<?>[] proxiedUserInterfaces(Object proxy) {
	Class<?>[] proxyInterfaces = proxy.getClass().getInterfaces();
	int nonUserIfcCount = 0;
	if (proxy instanceof SpringProxy) {
		nonUserIfcCount++;
	}
	if (proxy instanceof Advised) {
		nonUserIfcCount++;
	}
	Class<?>[] userInterfaces = new Class<?>[proxyInterfaces.length - nonUserIfcCount];
	System.arraycopy(proxyInterfaces, 0, userInterfaces, 0, userInterfaces.length);
	Assert.notEmpty(userInterfaces, "JDK proxy must implement one or more interfaces");
	return userInterfaces;
}
 

import org.springframework.aop.SpringProxy; //导入依赖的package包/类
/**
 * Determine the complete set of interfaces to proxy for the given AOP configuration.
 * <p>This will always add the {@link Advised} interface unless the AdvisedSupport's
 * {@link AdvisedSupport#setOpaque "opaque"} flag is on. Always adds the
 * {@link org.springframework.aop.SpringProxy} marker interface.
 * @return the complete set of interfaces to proxy
 * @see Advised
 * @see org.springframework.aop.SpringProxy
 */
public static Class<?>[] completeProxiedInterfaces(AdvisedSupport advised) {
	Class<?>[] specifiedInterfaces = advised.getProxiedInterfaces();
	if (specifiedInterfaces.length == 0) {
		// No user-specified interfaces: check whether target class is an interface.
		Class<?> targetClass = advised.getTargetClass();
		if (targetClass != null) {
			if (targetClass.isInterface()) {
				advised.setInterfaces(targetClass);
			}
			else if (Proxy.isProxyClass(targetClass)) {
				advised.setInterfaces(targetClass.getInterfaces());
			}
			specifiedInterfaces = advised.getProxiedInterfaces();
		}
	}
	boolean addSpringProxy = !advised.isInterfaceProxied(SpringProxy.class);
	boolean addAdvised = !advised.isOpaque() && !advised.isInterfaceProxied(Advised.class);
	int nonUserIfcCount = 0;
	if (addSpringProxy) {
		nonUserIfcCount++;
	}
	if (addAdvised) {
		nonUserIfcCount++;
	}
	Class<?>[] proxiedInterfaces = new Class<?>[specifiedInterfaces.length + nonUserIfcCount];
	System.arraycopy(specifiedInterfaces, 0, proxiedInterfaces, 0, specifiedInterfaces.length);
	if (addSpringProxy) {
		proxiedInterfaces[specifiedInterfaces.length] = SpringProxy.class;
	}
	if (addAdvised) {
		proxiedInterfaces[proxiedInterfaces.length - 1] = Advised.class;
	}
	return proxiedInterfaces;
}
 

import org.springframework.aop.SpringProxy; //导入依赖的package包/类
@Test
public void testCompleteProxiedInterfacesWorksWithNull() {
	AdvisedSupport as = new AdvisedSupport();
	Class<?>[] completedInterfaces = AopProxyUtils.completeProxiedInterfaces(as);
	assertEquals(2, completedInterfaces.length);
	List<?> ifaces = Arrays.asList(completedInterfaces);
	assertTrue(ifaces.contains(Advised.class));
	assertTrue(ifaces.contains(SpringProxy.class));
}
 

import org.springframework.aop.SpringProxy; //导入依赖的package包/类
/**
 * Determine the complete set of interfaces to proxy for the given AOP configuration.
 * <p>This will always add the {@link Advised} interface unless the AdvisedSupport's
 * {@link AdvisedSupport#setOpaque "opaque"} flag is on. Always adds the
 * {@link org.springframework.aop.SpringProxy} marker interface.
 * @return the complete set of interfaces to proxy
 * @see Advised
 * @see org.springframework.aop.SpringProxy
 */
public static Class[] completeProxiedInterfaces(AdvisedSupport advised) {
	Class[] specifiedInterfaces = advised.getProxiedInterfaces();
	if (specifiedInterfaces.length == 0) {
		// No user-specified interfaces: check whether target class is an interface.
		Class targetClass = advised.getTargetClass();
		if (targetClass != null && targetClass.isInterface()) {
			specifiedInterfaces = new Class[] {targetClass};
		}
	}
	boolean addSpringProxy = !advised.isInterfaceProxied(SpringProxy.class);
	boolean addAdvised = !advised.isOpaque() && !advised.isInterfaceProxied(Advised.class);
	int nonUserIfcCount = 0;
	if (addSpringProxy) {
		nonUserIfcCount++;
	}
	if (addAdvised) {
		nonUserIfcCount++;
	}
	Class[] proxiedInterfaces = new Class[specifiedInterfaces.length + nonUserIfcCount];
	System.arraycopy(specifiedInterfaces, 0, proxiedInterfaces, 0, specifiedInterfaces.length);
	if (addSpringProxy) {
		proxiedInterfaces[specifiedInterfaces.length] = SpringProxy.class;
	}
	if (addAdvised) {
		proxiedInterfaces[proxiedInterfaces.length - 1] = Advised.class;
	}
	return proxiedInterfaces;
}
 

import org.springframework.aop.SpringProxy; //导入依赖的package包/类
/**
 * Extract the user-specified interfaces that the given proxy implements,
 * i.e. all non-Advised interfaces that the proxy implements.
 * @param proxy the proxy to analyze (usually a JDK dynamic proxy)
 * @return all user-specified interfaces that the proxy implements,
 * in the original order (never {@code null} or empty)
 * @see Advised
 */
public static Class[] proxiedUserInterfaces(Object proxy) {
	Class[] proxyInterfaces = proxy.getClass().getInterfaces();
	int nonUserIfcCount = 0;
	if (proxy instanceof SpringProxy) {
		nonUserIfcCount++;
	}
	if (proxy instanceof Advised) {
		nonUserIfcCount++;
	}
	Class[] userInterfaces = new Class[proxyInterfaces.length - nonUserIfcCount];
	System.arraycopy(proxyInterfaces, 0, userInterfaces, 0, userInterfaces.length);
	Assert.notEmpty(userInterfaces, "JDK proxy must implement one or more interfaces");
	return userInterfaces;
}
 

import org.springframework.aop.SpringProxy; //导入依赖的package包/类
protected String getMeaningfulClassName(Class<?> targetClass) {
	if (java.lang.reflect.Proxy.isProxyClass(targetClass)) {
		for (Class<?> iface : targetClass.getInterfaces()) {
			if (iface != SpringProxy.class && iface != Advised.class) {
				return iface.getName();
			}
		}
	}
	return targetClass.getName();
}
 

import org.springframework.aop.SpringProxy; //导入依赖的package包/类
public void testProxyForUnaryCardinality() throws Exception {
	long time = 1234;
	Date date = new Date(time);
	ServiceRegistration reg = publishService(date);

	fb.setCardinality(Cardinality.C_1__1);

	fb.setInterfaces(new Class[] { Date.class });
	fb.afterPropertiesSet();

	ImportedOsgiServiceProxy refAware = null;
	try {
		Object result = fb.getObject();
		assertTrue(result instanceof Date);
		// check it's our object
		assertEquals(time, ((Date) result).getTime());
		assertTrue(result instanceof SpringProxy);
		assertTrue(result instanceof ImportedOsgiServiceProxy);
		assertTrue(result instanceof InfrastructureProxy);

		refAware = (ImportedOsgiServiceProxy) result;
		assertNotNull(refAware.getServiceReference());

		assertEquals("wrong target returned", date, ((InfrastructureProxy) result).getWrappedObject());
	}
	finally {
		if (reg != null)
			reg.unregister();
	}

	// test reference after the service went down
	assertNotNull(refAware.getServiceReference());
	assertNull(refAware.getServiceReference().getBundle());
}
 

import org.springframework.aop.SpringProxy; //导入依赖的package包/类
public SimpleServiceJDKProxyCreator(BundleContext context, Class[] classes, ClassLoader loader) {
	// add Spring-DM proxies
	Object[] obj = ObjectUtils.addObjectToArray(classes, ImportedOsgiServiceProxy.class);
	this.classes = (Class[]) ObjectUtils.addObjectToArray(obj, SpringProxy.class);
	System.out.println("given classes " + ObjectUtils.nullSafeToString(classes) + " | resulting classes "
			+ ObjectUtils.nullSafeToString(this.classes));
	this.loader = loader;
	this.context = context;
}
 

import org.springframework.aop.SpringProxy; //导入依赖的package包/类
/**
 * Determine the complete set of interfaces to proxy for the given AOP configuration.
 * <p>This will always add the {@link Advised} interface unless the AdvisedSupport's
 * {@link AdvisedSupport#setOpaque "opaque"} flag is on. Always adds the
 * {@link org.springframework.aop.SpringProxy} marker interface.
 * @param advised the proxy config
 * @param decoratingProxy whether to expose the {@link DecoratingProxy} interface
 * @return the complete set of interfaces to proxy
 * @since 4.3
 * @see SpringProxy
 * @see Advised
 * @see DecoratingProxy
 */
static Class<?>[] completeProxiedInterfaces(AdvisedSupport advised, boolean decoratingProxy) {
	Class<?>[] specifiedInterfaces = advised.getProxiedInterfaces();
	if (specifiedInterfaces.length == 0) {
		// No user-specified interfaces: check whether target class is an interface.
		Class<?> targetClass = advised.getTargetClass();
		if (targetClass != null) {
			if (targetClass.isInterface()) {
				advised.setInterfaces(targetClass);
			}
			else if (Proxy.isProxyClass(targetClass)) {
				advised.setInterfaces(targetClass.getInterfaces());
			}
			specifiedInterfaces = advised.getProxiedInterfaces();
		}
	}
	boolean addSpringProxy = !advised.isInterfaceProxied(SpringProxy.class);
	boolean addAdvised = !advised.isOpaque() && !advised.isInterfaceProxied(Advised.class);
	boolean addDecoratingProxy = (decoratingProxy && !advised.isInterfaceProxied(DecoratingProxy.class));
	int nonUserIfcCount = 0;
	if (addSpringProxy) {
		nonUserIfcCount++;
	}
	if (addAdvised) {
		nonUserIfcCount++;
	}
	if (addDecoratingProxy) {
		nonUserIfcCount++;
	}
	Class<?>[] proxiedInterfaces = new Class<?>[specifiedInterfaces.length + nonUserIfcCount];
	System.arraycopy(specifiedInterfaces, 0, proxiedInterfaces, 0, specifiedInterfaces.length);
	int index = specifiedInterfaces.length;
	if (addSpringProxy) {
		proxiedInterfaces[index] = SpringProxy.class;
		index++;
	}
	if (addAdvised) {
		proxiedInterfaces[index] = Advised.class;
		index++;
	}
	if (addDecoratingProxy) {
		proxiedInterfaces[index] = DecoratingProxy.class;
	}
	return proxiedInterfaces;
}
 

import org.springframework.aop.SpringProxy; //导入依赖的package包/类
/**
 * Select an invocable method on the target type: either the given method itself
 * if actually exposed on the target type, or otherwise a corresponding method
 * on one of the target type's interfaces or on the target type itself.
 * @param method the method to check
 * @param targetType the target type to search methods on (typically an AOP proxy)
 * @return a corresponding invocable method on the target type
 * @throws IllegalStateException if the given method is not invocable on the given
 * target type (typically due to a proxy mismatch)
 * @since 4.3
 * @see MethodIntrospector#selectInvocableMethod(Method, Class)
 */
public static Method selectInvocableMethod(Method method, Class<?> targetType) {
	Method methodToUse = MethodIntrospector.selectInvocableMethod(method, targetType);
	if (Modifier.isPrivate(methodToUse.getModifiers()) && !Modifier.isStatic(methodToUse.getModifiers()) &&
			SpringProxy.class.isAssignableFrom(targetType)) {
		throw new IllegalStateException(String.format(
				"Need to invoke method '%s' found on proxy for target class '%s' but cannot " +
				"be delegated to target bean. Switch its visibility to package or protected.",
				method.getName(), method.getDeclaringClass().getSimpleName()));
	}
	return methodToUse;
}
 

import org.springframework.aop.SpringProxy; //导入依赖的package包/类
/**
 * Check whether the given object is a JDK dynamic proxy or a CGLIB proxy.
 * @param object the object to check
 * @see #isJdkDynamicProxy
 * @see #isCglibProxy
 */
public static boolean isAopProxy(Object object) {
	return (object instanceof SpringProxy &&
			(Proxy.isProxyClass(object.getClass()) || ClassUtils.isCglibProxyClass(object.getClass())));
}
 

import org.springframework.aop.SpringProxy; //导入依赖的package包/类
/**
 * Check whether the given object is a JDK dynamic proxy.
 * @param object the object to check
 * @see java.lang.reflect.Proxy#isProxyClass
 */
public static boolean isJdkDynamicProxy(Object object) {
	return (object instanceof SpringProxy && Proxy.isProxyClass(object.getClass()));
}
 

import org.springframework.aop.SpringProxy; //导入依赖的package包/类
/**
 * Check whether the given object is a CGLIB proxy. Goes beyond the implementation
 * in {@link ClassUtils#isCglibProxy(Object)} by checking also to see if the given
 * object is an instance of {@link SpringProxy}.
 * @param object the object to check
 * @see ClassUtils#isCglibProxy(Object)
 */
public static boolean isCglibProxy(Object object) {
	return (object instanceof SpringProxy && ClassUtils.isCglibProxy(object));
}
 

import org.springframework.aop.SpringProxy; //导入依赖的package包/类
/**
 * Determine whether the supplied {@link AdvisedSupport} has only the
 * {@link org.springframework.aop.SpringProxy} interface specified
 * (or no proxy interfaces specified at all).
 */
private boolean hasNoUserSuppliedProxyInterfaces(AdvisedSupport config) {
	Class<?>[] interfaces = config.getProxiedInterfaces();
	return (interfaces.length == 0 || (interfaces.length == 1 && SpringProxy.class.equals(interfaces[0])));
}