public IProxyPool start() throws InstantiationException, IllegalAccessException {
		DummyClass proxyPool = new DummyClass(IProxyPool.class.getName() + "Impl").public_().implements_(IProxyPool.class)
				                                                                  .setClassOutPutPath(SampleConstant.classOutPutPath);
		proxyPool.newMethod("getProxy").public_().return_(Object.class).argTypes(Object.class).argNames("target").body(new MethodBody() {

			@Override
			public void body(final LocVar... args) {

				for(Entry<Class<?>, List<Method>> entry : map.entrySet()) {
					final Class<?> targetType = entry.getKey();
					List<Method> targetMethods = entry.getValue();
					DummyClass proxy = new DummyClass(targetType.getName() + "Proxy").public_().setClassOutPutPath(SampleConstant.classOutPutPath);
					if(targetType.isInterface()) {
						proxy.implements_(targetType);
					} else {
						proxy.extends_(targetType);
					}
					
					proxy.newField(targetType, "target").private_();
					
					proxy.newMethod("setTarget").public_().argTypes(targetType).body(new MethodBody() {

						@Override
						public void body(LocVar... args) {
							assign(this_().field("target"), args[0]);
							return_();
						}
						
					});
					
					//Override all public method
					Method[] publicMethods = targetType.getMethods();
					for(Method pubMet : publicMethods) {
						if(targetMethods.contains(pubMet)) {
							doProxyOverride(proxy, targetType, pubMet, adviceMap.get(pubMet));
						} else {
							doCommonOverride(proxy, pubMet);
						}
					}
					
					final Class<?> targetProxyClass = proxy.build();
					
					if_(new IF(instanceof_(args[0], targetType)) {

						@Override
						public void body() {
							LocVar proxy = var("proxy", targetProxyClass, new_(targetProxyClass));
							call(proxy, "setTarget", checkcast(args[0], targetType));
							return_(proxy);
						}
						
					});
					
				}
				
				return_(args[0]);
			}
			
		});
		
		return (IProxyPool) proxyPool.build().newInstance();
	}