private void addRoutes(Object handler) {
Class clazz = handler.getClass();
for (Method method : clazz.getMethods()) {
int modifier = method.getModifiers();
if (!(Modifier.isPublic(modifier))) continue;
Class<?>[] paramTypes = method.getParameterTypes();
if (paramTypes.length != 2
|| !paramTypes[0].equals(Request.class)
|| !paramTypes[1].equals(Response.class)) continue;
Before beforeAnn = method.getAnnotation(Before.class);
After afterAnn = method.getAnnotation(After.class);
Route routeAnn = method.getAnnotation(Route.class);
if (routeAnn != null) routes.add(new MatchEntity(handler, method, routeAnn));
else if (beforeAnn != null) before.add(new MatchEntity(handler, method, beforeAnn));
else if (afterAnn != null) after.add(new MatchEntity(handler, method, afterAnn));
}
if (L.isInfoEnabled()) {
for (MatchEntity e : routes) L.info(null, "route " + ObjectUtils.toString(e));
for (MatchEntity e : before) L.info(null, "before " + ObjectUtils.toString(e));
for (MatchEntity e : after) L.info(null, "after " + ObjectUtils.toString(e));
}
}
private void initApiInfo() throws Exception {
int apiCounter = 0;
String[] beanNames = applicationContext.getBeanNamesForAnnotation(Controller.class);
if (beanNames == null) {
logger.info("No controller bean found. stop server and fix it.");
throw new Exception("No controller bean found. stop server and fix it.");
}
Map<String, Object> checkMap = new HashMap<String, Object>();
for (String beanName : beanNames) {
logger.info("Controller bean found: " + beanName);
Class<?> beanType = applicationContext.getType(beanName);
Method[] methods = beanType.getMethods();
for (Method method : methods) {
if (method.getAnnotation(Api.class) != null
&& method.getAnnotation(RequestMapping.class) != null) {
logger.info("Controller Api Method found: " + method.getName());
if (checkMap.get(method.getName()) != null) {
logger.info("Controller method name is duplicated! stop server and fix it.");
throw new Exception("Controller method name is duplicated! stop server and fix it.");
}
checkMap.put(method.getName(), new Object());
apiCounter++;
}
}
}
logger.info("Total {} api listed.", apiCounter);
this.apiInfoCache = new ConcurrentHashMap<String, ApiInfo>();
}
public static OptionSchema newOptionSchema(Class<?> optionHolderType) {
OptionSchema optionSchema = new OptionSchema();
// traverses through super classes
for (Class<?> optionHolderClass = optionHolderType;
optionHolderClass != null;
optionHolderClass = optionHolderClass.getSuperclass()) {
// looks for bean methods annotated with Option or Argument
for (Method eachMethod : optionHolderClass.getDeclaredMethods()) {
if (eachMethod.getAnnotation(Option.class) != null) optionSchema.addOptionItem(eachMethod);
if (eachMethod.getAnnotation(Argument.class) != null)
optionSchema.addArgumentItem(eachMethod);
}
// looks for bean fields annotated with Option or Argument
for (Field f : optionHolderClass.getDeclaredFields()) {
if (f.getAnnotation(Option.class) != null) optionSchema.addOptionItem(f);
if (f.getAnnotation(Argument.class) != null) optionSchema.addArgumentItem(f);
}
if (optionHolderClass.getAnnotation(Usage.class) != null) {
optionSchema.setUsage(optionHolderClass);
}
}
return optionSchema;
}
public boolean run(CommandSender sender, String[] args) {
for (Map.Entry<CommandBase, Method> e : map.entrySet()) {
if (Util.hasString(args[0], e.getKey().getCommand())) {
Method method = e.getValue();
try {
if (!(sender instanceof Player)
|| sender.hasPermission(
((AddCommand) method.getAnnotation(AddCommand.class)).permission())) {
return (boolean) method.invoke(method.getDeclaringClass().newInstance(), sender, args);
} else {
sender.sendMessage(
((AddCommand) method.getAnnotation(AddCommand.class)).permissionmessage());
return true;
}
} catch (IllegalAccessException
| IllegalArgumentException
| InvocationTargetException
| SecurityException
| InstantiationException e1) {
e1.printStackTrace();
return false;
}
}
}
return false;
}
public final Set<Action> listActions() {
Set<Action> result = new HashSet<Action>();
/*
* Search on this entity, climbing up the class hierarchy.
*/
Class<?> self = this.getClass();
while (!Object.class.equals(self)) {
for (Method m : self.getClass().getDeclaredMethods()) {
if (m.isAnnotationPresent(Action.class)) {
result.add(m.getAnnotation(Action.class));
} // if
} // for
self = self.getSuperclass();
} // while
/*
* Search on all mixins.
*/
for (Object o : this.getMixins()) {
for (Method m : o.getClass().getDeclaredMethods()) {
if (m.isAnnotationPresent(Action.class)) {
result.add(m.getAnnotation(Action.class));
} // if
} // for
} // for
return result;
}
private Status getProperties(Class<?> busInterface) throws AnnotationBusException {
for (Method method : busInterface.getMethods()) {
if (method.getAnnotation(BusProperty.class) != null) {
String name = getName(method);
Property property = properties.get(name);
BusAnnotations propertyAnnotations = method.getAnnotation(BusAnnotations.class);
TreeMap<String, String> annotations = new TreeMap<String, String>();
if (propertyAnnotations != null) {
for (BusAnnotation propertyAnnotation : propertyAnnotations.value()) {
annotations.put(propertyAnnotation.name(), propertyAnnotation.value());
}
}
if (property == null) {
property = new Property(name, getPropertySig(method), annotations);
} else if (!property.signature.equals(getPropertySig(method))) {
return Status.BAD_ANNOTATION;
}
if (method.getName().startsWith("get")) {
property.get = method;
} else if (method.getName().startsWith("set")
&& (method.getGenericReturnType().equals(void.class))) {
property.set = method;
} else {
return Status.BAD_ANNOTATION;
}
properties.put(name, property);
}
}
return Status.OK;
}
/**
* Gets an annotation from the property. Checks fields, setters, and getters, in that order, for
* the annotation specified.
*
* @param <T> The annotation type.
* @param annotationType The type of the annotation
* @return The first found instance of that annotation, per above.
*/
public <T extends Annotation> T getAnnotation(final Class<T> annotationType) {
T annotation = null;
if (field != null) {
annotation = this.field.getAnnotation(annotationType);
if (annotation != null) {
return annotation;
}
}
if (setter != null) {
annotation = setter.getAnnotation(annotationType);
if (annotation != null) {
return annotation;
}
}
if (getter != null) {
return getter.getAnnotation(annotationType);
}
return null;
}
private static void handleAfters(Http.Request request) throws Exception {
List<Method> afters =
Java.findAllAnnotatedMethods(Controller.getControllerClass(), After.class);
ControllerInstrumentation.stopActionCall();
for (Method after : afters) {
String[] unless = after.getAnnotation(After.class).unless();
String[] only = after.getAnnotation(After.class).only();
boolean skip = false;
for (String un : only) {
if (!un.contains(".")) {
un = after.getDeclaringClass().getName().substring(12) + "." + un;
}
if (un.equals(request.action)) {
skip = false;
break;
} else {
skip = true;
}
}
for (String un : unless) {
if (!un.contains(".")) {
un = after.getDeclaringClass().getName().substring(12) + "." + un;
}
if (un.equals(request.action)) {
skip = true;
break;
}
}
if (!skip) {
after.setAccessible(true);
inferResult(invokeControllerMethod(after));
}
}
}
/** * Internal method to load class methods annotated with {@link MethodMapping} */
private void loadAnnotatedMethods() {
Method[] methods = getClass().getDeclaredMethods();
boolean isUsingAuthAnnot = false;
for (int i = 0; i < methods.length; i++) {
Method method = methods[i];
MethodMapping methodMapped = method.getAnnotation(MethodMapping.class);
AuthorizeInvocation authorizeInvocation = method.getAnnotation(AuthorizeInvocation.class);
isUsingAuthAnnot = isUsingAuthAnnot || authorizeInvocation != null;
if (methodMapped != null) {
HttpMethod httpMethod = methodMapped.httpMethod();
MethodMappingInfo urlMappingInfo =
new MethodMappingInfo(method, getMimeTypeResolver(method));
if (!isMimeTypesSupported(urlMappingInfo.getMimeInputFormat())
|| !isMimeTypesSupported(urlMappingInfo.getMimeOutputFormat()))
throw new WicketRuntimeException(
"Mapped methods use a MIME type not supported by obj serializer/deserializer!");
mappedMethods.addValue(
urlMappingInfo.getSegmentsCount() + "_" + httpMethod.getMethod(), urlMappingInfo);
}
}
// if AuthorizeInvocation has been found but no role-checker has been
// configured, throw an exception
if (isUsingAuthAnnot && roleCheckingStrategy == null)
throw new WicketRuntimeException(
"Annotation AuthorizeInvocation is used but no role-checking strategy has been set for the controller!");
}
@Override
public void beforeTestMethod(TestContext testContext) throws Exception {
checkInitialized();
Method testMethod = getTestMethod(testContext);
Expectations expectations = testMethod.getAnnotation(Expectations.class);
Expectation expectation = testMethod.getAnnotation(Expectation.class);
NoQueriesAllowed notAllowedQueries = testMethod.getAnnotation(NoQueriesAllowed.class);
// If no annotations present, check the test class and its superclasses
for (Class<?> testClass = testMethod.getDeclaringClass();
null == expectations
&& null == expectation
&& null == notAllowedQueries
&& !Object.class.equals(testClass);
testClass = testClass.getSuperclass()) {
expectations = testClass.getAnnotation(Expectations.class);
expectation = testClass.getAnnotation(Expectation.class);
notAllowedQueries = testClass.getAnnotation(NoQueriesAllowed.class);
}
if (null != expectation && null != notAllowedQueries) {
throw new IllegalArgumentException(
"Cannot specify @Expectation and @NotAllowedQueries on one test method");
} else if (null != expectations && null != notAllowedQueries) {
throw new IllegalArgumentException(
"Cannot specify @Expectations and @NotAllowedQueries on one test method");
} else if (null != expectations || null != expectation) {
List<Expectation> expectationList = new ArrayList<Expectation>();
if (null != expectation) {
expectationList.add(expectation);
}
if (null != expectations) {
expectationList.addAll(Arrays.asList(expectations.value()));
}
for (Expectation expectation1 : expectationList) {
if (expectation1.value() != -1) {
if (expectation1.atMost() != -1 || expectation1.atLeast() != -1) {
throw new IllegalArgumentException(
"Cannot specify value parameter together with atLeast or atMost parameters");
}
}
}
setAttribute(testContext, SPY_ATTRIBUTE_NAME, Sniffer.expect(expectationList));
} else if (null != notAllowedQueries) {
setAttribute(
testContext,
SPY_ATTRIBUTE_NAME,
Sniffer.expect(
Collections.singletonList(NoQueriesAllowed.class.getAnnotation(Expectation.class))));
}
}
/** 获取public菜单,未登陆时使用 */
public static Map<String, List<String[]>> getPublicMenu() {
Map<String, List<String[]>> map = MENU.get(-10);
if (map == null) {
map = new LinkedHashMap<String, List<String[]>>();
List<String[]> list = new LinkedList<String[]>();
for (Class<?> clazz : Scans.me().scanPackage("app.module")) {
if (clazz.getAnnotation(At.class) != null) {
for (Method method : clazz.getMethods()) {
Menu menu = method.getAnnotation(Menu.class);
At at = method.getAnnotation(At.class);
if (menu != null
&& at != null
&& (clazz.getAnnotation(Public.class) != null
|| method.getAnnotation(Public.class) != null)) {
String[] tmp = new String[2];
tmp[0] = menu.value();
tmp[1] = clazz.getSimpleName().toLowerCase() + "/" + method.getName().toLowerCase();
list.add(tmp);
}
}
}
}
map.put("", list);
MENU.put(-10, map);
}
return map;
}
/* */ public static Map po2Map(Object po) /* */ {
/* 102 */ Map poMap = new HashMap();
/* 103 */ Map map = new HashMap();
/* */ try {
/* 105 */ map = BeanUtils.describe(po);
/* */ } catch (Exception ex) {
/* */ }
/* 108 */ Object[] keyArray = map.keySet().toArray();
/* 109 */ for (int i = 0; i < keyArray.length; i++) {
/* 110 */ String str = keyArray[i].toString();
/* 111 */ if ((str == null) || (str.equals("class")) || /* 112 */ (map.get(str) == null))
continue;
/* 113 */ poMap.put(str, map.get(str));
/* */ }
/* */
/* 118 */ Method[] ms = po.getClass().getMethods();
/* 119 */ for (Method m : ms) {
/* 120 */ String name = m.getName();
/* */
/* 122 */ if (((!name.startsWith("get")) && (!name.startsWith("is")))
|| (
/* 123 */ (m.getAnnotation(NotDbField.class) == null)
&& (m.getAnnotation(PrimaryKeyField.class) == null))) continue;
/* 124 */ poMap.remove(getFieldName(name));
/* */ }
/* */
/* 133 */ if ((po instanceof DynamicField)) {
/* 134 */ DynamicField dynamicField = (DynamicField) po;
/* 135 */ Map fields = dynamicField.getFields();
/* 136 */ poMap.putAll(fields);
/* */ }
/* 138 */ return poMap;
/* */ }
@Override
public void onTestStart(ITestResult result) {
logsResults.clear();
StringBuilder builder = new StringBuilder();
String testName = result.getName().toString();
String className = result.getTestClass().getName().toString();
Method testMethod = result.getMethod().getConstructorOrMethod().getMethod();
builder.append("<table>" + "<h1>Class: <em>" + className + "." + testName + " </em></h1>");
if (testMethod.isAnnotationPresent(RelatedIssue.class)) {
String issueID = testMethod.getAnnotation(RelatedIssue.class).issueID();
String jiraUrl = jiraPath + issueID;
builder.append(
"<tr class=\"step\"><td>Known failure</td><td><h1><em>"
+ testName
+ " - "
+ "<a href=\""
+ jiraUrl
+ "\">"
+ issueID
+ "</a> "
+ testMethod.getAnnotation(RelatedIssue.class).comment()
+ "</em></h1></td><td> <br/> </td></tr>");
} else {
builder.append(
"<tr class=\"step\"><td> </td><td><h1><em>"
+ testName
+ "</em></h1></td><td> <br/> </td></tr>");
}
CommonUtils.appendTextToFile(logPath, builder.toString());
System.out.println(className + " " + testName);
}
public ControllerMapping(Class<?> classInfo) {
try {
this.classInfo = classInfo;
this.object = classInfo.newInstance();
Method[] methods = classInfo.getDeclaredMethods();
for (int i = 0; i < methods.length; i++) {
Method tmp = methods[i];
if (tmp.getName().equals("index")) {
defaultMethod = tmp;
}
String methodPath = null;
if (tmp.isAnnotationPresent(Path.class)) {
methodPath = tmp.getAnnotation(Path.class).value();
} else if (tmp.isAnnotationPresent(Code.class)) {
methodPath = tmp.getAnnotation(Code.class).value();
} else {
methodPath = tmp.getName();
}
methodPath = methodPath.replaceAll("/", "");
controllerMethods.put(methodPath.toLowerCase(), tmp);
controllerMethods.put(methodPath.toUpperCase(), tmp);
controllerMethods.put(methodPath, tmp);
Class<?>[] classInfos = tmp.getParameterTypes();
methodParameters.put(tmp, classInfos);
}
} catch (Exception e) {
logger.error(e.getMessage(), e);
}
}
/**
* class filter of an action to use it
*
* @param p_method method for checking
* @param p_root root class
* @return boolean flag of check result
*/
private static boolean isActionFiltered(final Method p_method, final Class<?> p_root) {
return p_method.isAnnotationPresent(IAgentActionFilter.class)
&& ((p_method.getAnnotation(IAgentActionFilter.class).classes().length == 0)
|| (Arrays.stream(p_method.getAnnotation(IAgentActionFilter.class).classes())
.parallel()
.anyMatch(p_root::equals)));
}
protected void handleListenerMethods(Method method, Class managedClass, BundleContext context) {
se.natusoft.osgi.aps.tools.annotation.activator.ServiceListener serviceListener =
method.getAnnotation(se.natusoft.osgi.aps.tools.annotation.activator.ServiceListener.class);
if (serviceListener != null) {
ServiceListenerWrapper serviceListenerWrapper =
new ServiceListenerWrapper(method, getManagedInstance(managedClass));
serviceListenerWrapper.start(context);
this.listeners.add(serviceListenerWrapper);
}
se.natusoft.osgi.aps.tools.annotation.activator.BundleListener bundleListener =
method.getAnnotation(se.natusoft.osgi.aps.tools.annotation.activator.BundleListener.class);
if (bundleListener != null) {
BundleListenerWrapper bundleListenerWrapper =
new BundleListenerWrapper(method, getManagedInstance(managedClass));
bundleListenerWrapper.start(context);
this.listeners.add(bundleListenerWrapper);
}
se.natusoft.osgi.aps.tools.annotation.activator.FrameworkListener frameworkListener =
method.getAnnotation(
se.natusoft.osgi.aps.tools.annotation.activator.FrameworkListener.class);
if (frameworkListener != null) {
FrameworkListenerWrapper frameworkListenerWrapper =
new FrameworkListenerWrapper(method, getManagedInstance(managedClass));
frameworkListenerWrapper.start(context);
this.listeners.add(frameworkListenerWrapper);
}
}
public static void main(String[] args) throws Exception {
Class clazz = BizHandler.class;
Method method = clazz.getMethod("handle", new Class[] {});
BeforeAdvice before = method.getAnnotation(BeforeAdvice.class);
AfterAdvice after = method.getAnnotation(AfterAdvice.class);
ExceptionAdvice ex = method.getAnnotation(ExceptionAdvice.class);
ReturnAdvice ret = method.getAnnotation(ReturnAdvice.class);
try {
if (before != null) {
System.out.println(before.advice());
}
method.invoke(new BizHandler(), new Object[] {});
if (after != null) {
System.out.println(after.advice());
}
} catch (Exception e) {
if (ex != null) {
System.out.println(ex.advice());
}
} finally {
if (ret != null) {
System.out.println(ret.advice());
}
}
}
private void callBeforeMethods(HttpServletRequest request, HttpServletResponse response) {
if (!beforeList.isEmpty()) {
for (Method beforeMethod : beforeList) {
String[] only = ((Before) beforeMethod.getAnnotation(Before.class)).only();
if (only.length > 0) {
for (String path : only) {
if (path.equals(urlPath(request))) {
callMethod(beforeMethod, request, response);
}
}
} else {
String[] unless = ((Before) beforeMethod.getAnnotation(Before.class)).unless();
if (unless.length > 0) {
boolean call = true;
for (String path : unless) {
if (path.equals(urlPath(request))) {
call = false;
}
}
if (call) callMethod(beforeMethod, request, response);
} else callMethod(beforeMethod, request, response);
}
}
}
}
@SuppressWarnings("rawtypes")
public static ApiObjectDoc buildFromAnnotation(ApiObject annotation, Class clazz) {
final List<ApiObjectFieldDoc> fieldDocs = new ArrayList<ApiObjectFieldDoc>();
for (Field field : clazz.getDeclaredFields())
if (field.getAnnotation(ApiObjectField.class) != null)
fieldDocs.add(
ApiObjectFieldDoc.buildFromAnnotation(
field.getAnnotation(ApiObjectField.class), field));
for (Method getter : clazz.getDeclaredMethods())
if (getter.getAnnotation(ApiObjectGetter.class) != null
&& getter.getName().startsWith("get")
&& getter.getParameterTypes().length == 0)
fieldDocs.add(
ApiObjectFieldDoc.buildFromAnnotation(
getter.getAnnotation(ApiObjectGetter.class), getter));
Class<?> c = clazz.getSuperclass();
if (c != null) {
if (c.isAnnotationPresent(ApiObject.class)) {
ApiObjectDoc objDoc = ApiObjectDoc.buildFromAnnotation(c.getAnnotation(ApiObject.class), c);
fieldDocs.addAll(objDoc.getFields());
}
}
return new ApiObjectDoc(annotation.name(), annotation.description(), fieldDocs);
}
private void callAfterMethods(HttpServletRequest request, HttpServletResponse response) {
if (!afterList.isEmpty()) {
for (Method afterMethod : afterList) {
String[] paths = ((After) afterMethod.getAnnotation(After.class)).only();
if (paths.length > 0) {
for (String path : paths) {
if (path.equals(urlPath(request))) {
callMethod(afterMethod, request, response);
}
}
} else {
String[] unless = ((After) afterMethod.getAnnotation(After.class)).unless();
if (unless.length > 0) {
boolean call = true;
for (String path : unless) {
if (path.equals(urlPath(request))) {
call = false;
}
}
if (call) callMethod(afterMethod, request, response);
} else callMethod(afterMethod, request, response);
}
}
}
}
private List<String> createTreeForStatsProvider(TreeNode parentNode, Object statsProvider) {
/* construct monitoring tree at PluginPoint using subTreePath */
List<String> childNodeNames = new ArrayList();
/* retrieve ManagedAttribute attribute id (v2 compatible) and method names */
/* Check for custom reset method and store for later to be called instead of
standard reset methods on Statistic classes*/
for (Method m : statsProvider.getClass().getMethods()) {
ManagedAttribute ma = m.getAnnotation(ManagedAttribute.class);
Reset resetMeth = m.getAnnotation(Reset.class);
if (resetMeth != null) {
StatsProviderRegistryElement spre =
this.statsProviderRegistry.getStatsProviderRegistryElement(statsProvider);
spre.setResetMethod(m);
}
if (ma != null) {
String methodName = m.getName();
String id = ma.id();
if ((id == null) || id.isEmpty()) { // if id not specified, derive from method name
String methodNameLower = methodName.toLowerCase(Locale.ENGLISH);
if (methodNameLower.startsWith("get") && methodNameLower.length() > 3) {
id = methodNameLower.substring(3);
}
}
TreeNode attrNode = TreeNodeFactory.createMethodInvoker(id, statsProvider, id, m);
parentNode.addChild(attrNode);
childNodeNames.add(attrNode.getName());
}
}
return childNodeNames;
}
private static void findNotImplemented(Class<?> type, Map<String, Method> result) {
Class<?> superclass = type.getSuperclass();
if (superclass != null) {
findNotImplemented(superclass, result);
}
for (Method m : type.getDeclaredMethods()) {
NotImplemented ni = m.getAnnotation(NotImplemented.class);
if (ni != null) {
result.put(ni.value(), m);
} else {
BindSelector bs = m.getAnnotation(BindSelector.class);
if (bs != null) {
result.remove(bs.value());
} else {
String mName = m.getName();
Class<?>[] mParamTypes = m.getParameterTypes();
for (Iterator<Entry<String, Method>> it = result.entrySet().iterator(); it.hasNext(); ) {
Entry<String, Method> entry = it.next();
Method m2 = entry.getValue();
if (m2.getName().equals(mName) && Arrays.equals(m2.getParameterTypes(), mParamTypes)) {
it.remove();
}
}
}
}
}
}
private void populateLifeCycleMethods(Component c) {
if (!c.methodsScanned) {
c.methodsScanned = true;
c.startMethods.clear();
c.stopMethods.clear();
List<Method> methods = getAllMethodsViaReflection(c.instance.getClass(), Start.class);
for (Method m : methods) {
PrioritizedMethod em = new PrioritizedMethod();
em.component = c;
em.method = m;
em.priority = m.getAnnotation(Start.class).priority();
c.startMethods.add(em);
}
methods = getAllMethodsViaReflection(c.instance.getClass(), Stop.class);
for (Method m : methods) {
PrioritizedMethod em = new PrioritizedMethod();
em.component = c;
em.method = m;
em.priority = m.getAnnotation(Stop.class).priority();
c.stopMethods.add(em);
}
}
}
private static void findCallbacks(Class<?> type, Map<String, Method> result) {
ArrayList<Class<?>> classes = new ArrayList<Class<?>>();
if (!type.isInterface()) {
// No need to search interfaces since interfaces cannot have
// static methods and callbacks must be static.
classes.add(type);
} else {
Class<?> objCProxy = allObjCProxyClasses.get(type.getName());
if (objCProxy != null) {
classes.add(objCProxy);
}
}
try {
classes.add(Class.forName(type.getName() + "$Callbacks", true, type.getClassLoader()));
} catch (ClassNotFoundException ignored) {
}
for (Class<?> c : classes) {
for (Method m : c.getDeclaredMethods()) {
if (m.getAnnotation(Callback.class) != null) {
BindSelector bindSelector = m.getAnnotation(BindSelector.class);
if (bindSelector != null) {
if (!result.containsKey(bindSelector.value())) {
result.put(bindSelector.value(), m);
}
}
}
}
}
}
private void visitProperties(SharpExpression expr, String oldName, String newName) {
try {
for (Method m : expr.getClass().getMethods()) {
if (m.getAnnotation(RdfProperty.class) != null) {
String propIri = m.getAnnotation(RdfProperty.class).value();
if ("http://asu.edu/sharpc2b/ops#opCode".equals(propIri)) {
continue;
}
if (Collection.class.isAssignableFrom(m.getReturnType())) {
Collection coll = (Collection) m.invoke(expr);
int j = 0;
for (Object o : coll) {
if (o instanceof SharpExpression) {
visit((SharpExpression) o, oldName, newName);
}
}
} else {
Object o = m.invoke(expr);
if (o instanceof SharpExpression) {
visit((SharpExpression) o, oldName, newName);
}
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
public static void process(Object obj) {
if (obj == null) {
return;
}
Class cl = obj.getClass();
Method[] methods = cl.getMethods();
for (int i = 0; i < methods.length; i++) {
Method method = methods[i];
EventSubscriber classAnnotation = method.getAnnotation(EventSubscriber.class);
if (classAnnotation != null) {
process(classAnnotation, obj, method);
}
EventTopicSubscriber topicAnnotation =
(EventTopicSubscriber) method.getAnnotation(EventTopicSubscriber.class);
if (topicAnnotation != null) {
process(topicAnnotation, obj, method);
}
EventTopicPatternSubscriber topicPatternAnnotation =
(EventTopicPatternSubscriber) method.getAnnotation(EventTopicPatternSubscriber.class);
if (topicPatternAnnotation != null) {
process(topicPatternAnnotation, obj, method);
}
// Publisher publisherAnnotation = (Publisher) method.getAnnotation(Publisher.class);
// if (publisherAnnotation != null) {
// process(publisherAnnotation, obj);
// }
}
}
/**
* Create a SagaMethodMessageHandler for the given <code>methodHandler</code>. The
* SagaMethodMessageHandler add information specific to the behavior of Sagas, such as the
* association value and creation policy.
*
* @param methodHandler The handler for incoming events
* @return a SagaMethodMessageHandler for the handler
*/
public static SagaMethodMessageHandler getInstance(MethodMessageHandler methodHandler) {
Method handlerMethod = methodHandler.getMethod();
SagaEventHandler handlerAnnotation = handlerMethod.getAnnotation(SagaEventHandler.class);
String associationPropertyName = handlerAnnotation.associationProperty();
Method associationProperty;
try {
associationProperty =
methodHandler.getPayloadType().getMethod(methodForProperty(associationPropertyName));
} catch (NoSuchMethodException e) {
throw new AxonConfigurationException(
format(
"SagaEventHandler %s.%s defines a property %s that is not "
+ "defined on the Event it declares to handle (%s)",
methodHandler.getMethod().getDeclaringClass().getName(),
methodHandler.getMethodName(),
associationPropertyName,
methodHandler.getPayloadType().getName()),
e);
}
String associationKey =
handlerAnnotation.keyName().isEmpty()
? associationPropertyName
: handlerAnnotation.keyName();
StartSaga startAnnotation = handlerMethod.getAnnotation(StartSaga.class);
SagaCreationPolicy sagaCreationPolicy;
if (startAnnotation == null) {
sagaCreationPolicy = SagaCreationPolicy.NONE;
} else if (startAnnotation.forceNew()) {
sagaCreationPolicy = SagaCreationPolicy.ALWAYS;
} else {
sagaCreationPolicy = SagaCreationPolicy.IF_NONE_FOUND;
}
return new SagaMethodMessageHandler(
sagaCreationPolicy, methodHandler, associationKey, associationProperty);
}
@Override
public void beforeInvocation(
IInvokedMethod method, ITestResult testResult, ITestContext context) {
int failed = findFailed(context);
if (failed > 0) {
LOG.error("Masking will not proceed. {} Configurations have failed", failed);
return;
}
Method rmethod = method.getTestMethod().getConstructorOrMethod().getMethod();
if (rmethod.getAnnotation(Test.class) != null
|| rmethod.getAnnotation(BeforeClass.class) != null
|| rmethod.getAnnotation(BeforeTest.class) != null) {
if (rmethod.getAnnotation(RunsWithController.class) != null
|| rmethod.getDeclaringClass().getAnnotation(RunsWithController.class) != null) {
LOG.warn("Method or Class of {} asks Controller to be masked", rmethod.getName());
AnnotationsHelper p = SteviaContext.getSpringContext().getBean(AnnotationsHelper.class);
try {
p.maskExistingController(rmethod);
masked = true;
} catch (Throwable e) {
throw new IllegalStateException("failed to replace controller", e);
}
}
}
}
private void processValueRangeAnnotation() {
Method propertyGetter = variablePropertyAccessor.getReadMethod();
ValueRange valueRangeAnnotation = propertyGetter.getAnnotation(ValueRange.class);
ValueRanges valueRangesAnnotation = propertyGetter.getAnnotation(ValueRanges.class);
if (valueRangeAnnotation != null) {
if (valueRangesAnnotation != null) {
throw new IllegalArgumentException(
"The planningEntityClass ("
+ planningEntityDescriptor.getPlanningEntityClass()
+ ") has a PlanningVariable annotated property ("
+ variablePropertyAccessor.getName()
+ ") that has a @ValueRange and @ValueRanges annotation: fold them into 1 @ValueRanges.");
}
valueRangeDescriptor = buildValueRangeDescriptor(valueRangeAnnotation);
} else {
if (valueRangesAnnotation == null) {
throw new IllegalArgumentException(
"The planningEntityClass ("
+ planningEntityDescriptor.getPlanningEntityClass()
+ ") has a PlanningVariable annotated property ("
+ variablePropertyAccessor.getName()
+ ") that has no @ValueRange or @ValueRanges annotation.");
}
List<PlanningValueRangeDescriptor> valueRangeDescriptorList =
new ArrayList<PlanningValueRangeDescriptor>(valueRangesAnnotation.value().length);
for (ValueRange partialValueRangeAnnotation : valueRangesAnnotation.value()) {
valueRangeDescriptorList.add(buildValueRangeDescriptor(partialValueRangeAnnotation));
}
valueRangeDescriptor =
new CompositePlanningValueRangeDescriptor(this, valueRangeDescriptorList);
}
}
/**
* Gets the specified method from a query module.
*
* @param mod query module object
* @param path path of the module
* @param name method name
* @param arity number of arguments
* @param qc query context
* @param ii input info
* @return method if found, {@code null} otherwise
* @throws QueryException query exception
*/
private static Method getModMethod(
final Object mod,
final String path,
final String name,
final long arity,
final QueryContext qc,
final InputInfo ii)
throws QueryException {
// find method with identical name and arity
Method meth = null;
for (final Method m : mod.getClass().getMethods()) {
if (m.getName().equals(name) && m.getParameterTypes().length == arity) {
if (meth != null) throw JAVAAMBIG_X.get(ii, "Q{" + path + '}' + name + '#' + arity);
meth = m;
}
}
if (meth == null) throw FUNCJAVA_X.get(ii, path + ':' + name);
// check if user has sufficient permissions to call the function
Perm perm = Perm.ADMIN;
final QueryModule.Requires req = meth.getAnnotation(QueryModule.Requires.class);
if (req != null) perm = Perm.get(req.value().name());
if (!qc.context.user.has(perm)) return null;
// Add module locks to QueryContext.
final QueryModule.Lock lock = meth.getAnnotation(QueryModule.Lock.class);
if (lock != null) {
for (final String read : lock.read()) qc.readLocks.add(DBLocking.MODULE_PREFIX + read);
for (final String write : lock.write()) qc.writeLocks.add(DBLocking.MODULE_PREFIX + write);
}
return meth;
}
