Reflect is
20 | * // Static import all reflection methods to decrease verbosity
21 | * import static org.joor.Reflect.*;
22 | *
23 | * // Wrap an Object / Class / class name with the on() method:
24 | * on("java.lang.String")
25 | * // Invoke constructors using the create() method:
26 | * .create("Hello World")
27 | * // Invoke methods using the call() method:
28 | * .call("toString")
29 | * // Retrieve the wrapped object
30 | */
31 | public final class Reflect {
32 |
33 | /**
34 | * 获取外部类的引用
35 | */
36 | public T getOuterObject() throws ReflectException {
37 | return get("this$0");
38 | }
39 |
40 | // ---------------------------------------------------------------------
41 | // Static API used as entrance points to the fluent API
42 | // ---------------------------------------------------------------------
43 |
44 | /**
45 | * Wrap a class name.
46 | *
47 | * This is the same as calling on(Class.forName(name))
48 | *
49 | * @param name A fully qualified class name
50 | * @return A wrapped class object, to be used for further reflection.
51 | * @throws ReflectException If any reflection exception occurred.
52 | * @see #on(Class)
53 | */
54 | public static Reflect on(String name) throws ReflectException {
55 | return on(forName(name));
56 | }
57 |
58 | /**
59 | * Wrap a class name, loading it via a given class loader.
60 | *
61 | * This is the same as calling
62 | * on(Class.forName(name, classLoader))
63 | *
64 | * @param name A fully qualified class name.
65 | * @param classLoader The class loader in whose context the class should be
66 | * loaded.
67 | * @return A wrapped class object, to be used for further reflection.
68 | * @throws ReflectException If any reflection exception occurred.
69 | * @see #on(Class)
70 | */
71 | public static Reflect on(String name, ClassLoader classLoader) throws ReflectException {
72 | return on(forName(name, classLoader));
73 | }
74 |
75 | /**
76 | * Wrap a class.
77 | *
78 | * Use this when you want to access static fields and methods on a
79 | * {@link Class} object, or as a basis for constructing objects of that
80 | * class using {@link #create(Object...)}
81 | *
82 | * @param clazz The class to be wrapped
83 | * @return A wrapped class object, to be used for further reflection.
84 | */
85 | public static Reflect on(Class clazz) {
86 | return new Reflect(clazz);
87 | }
88 |
89 | /**
90 | * Wrap an object.
91 | *
92 | * Use this when you want to access instance fields and methods on any
93 | * {@link Object}
94 | *
95 | * @param object The object to be wrapped
96 | * @return A wrapped object, to be used for further reflection.
97 | */
98 | public static Reflect on(Object object) {
99 | return new Reflect(object);
100 | }
101 |
102 | /**
103 | * Conveniently render an {@link AccessibleObject} accessible.
104 | *
105 | * To prevent {@link SecurityException}, this is only done if the argument
106 | * object and its declaring class are non-public.
107 | *
108 | * @param accessible The object to render accessible
109 | * @return The argument object rendered accessible
110 | */
111 | public static T accessible(T accessible) {
112 | if (accessible == null) {
113 | return null;
114 | }
115 |
116 | if (accessible instanceof Member) {
117 | Member member = (Member) accessible;
118 |
119 | if (Modifier.isPublic(member.getModifiers()) &&
120 | Modifier.isPublic(member.getDeclaringClass().getModifiers())) {
121 |
122 | return accessible;
123 | }
124 | }
125 |
126 | // [jOOQ #3392] The accessible flag is set to false by default, also for public members.
127 | if (!accessible.isAccessible()) {
128 | accessible.setAccessible(true);
129 | }
130 |
131 | return accessible;
132 | }
133 |
134 | // ---------------------------------------------------------------------
135 | // Members
136 | // ---------------------------------------------------------------------
137 |
138 | /**
139 | * The wrapped object
140 | */
141 | private final Object object;
142 |
143 | /**
144 | * A flag indicating whether the wrapped object is a {@link Class} (for
145 | * accessing static fields and methods), or any other type of {@link Object}
146 | * (for accessing instance fields and methods).
147 | */
148 | private final boolean isClass;
149 |
150 | // ---------------------------------------------------------------------
151 | // Constructors
152 | // ---------------------------------------------------------------------
153 |
154 | private Reflect(Class type) {
155 | this.object = type;
156 | this.isClass = true;
157 | }
158 |
159 | private Reflect(Object object) {
160 | this.object = object;
161 | this.isClass = false;
162 | }
163 |
164 | // ---------------------------------------------------------------------
165 | // Fluent Reflection API
166 | // ---------------------------------------------------------------------
167 |
168 | /**
169 | * Get the wrapped object
170 | *
171 | * @param A convenience generic parameter for automatic unsafe casting
172 | */
173 | @SuppressWarnings("unchecked")
174 | public T get() {
175 | return (T) object;
176 | }
177 |
178 | /**
179 | * Set a field value.
180 | *
181 | * This is roughly equivalent to {@link Field#set(Object, Object)}. If the
182 | * wrapped object is a {@link Class}, then this will set a value to a static
183 | * member field. If the wrapped object is any other {@link Object}, then
184 | * this will set a value to an instance member field.
185 | *
186 | * @param name The field name
187 | * @param value The new field value
188 | * @return The same wrapped object, to be used for further reflection.
189 | * @throws ReflectException If any reflection exception occurred.
190 | */
191 | public Reflect set(String name, Object value) throws ReflectException {
192 | try {
193 | Field field = field0(name);
194 | field.set(object, unwrap(value));
195 | return this;
196 | } catch (Exception e) {
197 | throw new ReflectException(e);
198 | }
199 | }
200 |
201 | /**
202 | * Get a field value.
203 | *
204 | * This is roughly equivalent to {@link Field#get(Object)}. If the wrapped
205 | * object is a {@link Class}, then this will get a value from a static
206 | * member field. If the wrapped object is any other {@link Object}, then
207 | * this will get a value from an instance member field.
208 | *
209 | * If you want to "navigate" to a wrapped version of the field, use
210 | * {@link #field(String)} instead.
211 | *
212 | * @param name The field name
213 | * @return The field value
214 | * @throws ReflectException If any reflection exception occurred.
215 | * @see #field(String)
216 | */
217 | public T get(String name) throws ReflectException {
218 | return field(name).get();
219 | }
220 |
221 | /**
222 | * Get a wrapped field.
223 | *
224 | * This is roughly equivalent to {@link Field#get(Object)}. If the wrapped
225 | * object is a {@link Class}, then this will wrap a static member field. If
226 | * the wrapped object is any other {@link Object}, then this wrap an
227 | * instance member field.
228 | *
229 | * @param name The field name
230 | * @return The wrapped field
231 | * @throws ReflectException If any reflection exception occurred.
232 | */
233 | public Reflect field(String name) throws ReflectException {
234 | try {
235 | Field field = field0(name);
236 | return on(field.get(object));
237 | } catch (Exception e) {
238 | throw new ReflectException(e);
239 | }
240 | }
241 |
242 | private Field field0(String name) throws ReflectException {
243 | Class type = type();
244 |
245 | // Try getting a public field
246 | try {
247 | return type.getField(name);
248 | } catch (NoSuchFieldException e) {
249 | do {
250 | try {
251 | return accessible(type.getDeclaredField(name));
252 | } catch (NoSuchFieldException ignore) {
253 | }
254 |
255 | type = type.getSuperclass();
256 | }
257 | while (type != null);
258 |
259 | throw new ReflectException(e);
260 | }
261 | }
262 |
263 | /**
264 | * Get a Map containing field names and wrapped values for the fields'
265 | * values.
266 | *
267 | * If the wrapped object is a {@link Class}, then this will return static
268 | * fields. If the wrapped object is any other {@link Object}, then this will
269 | * return instance fields.
270 | *
271 | * These two calls are equivalent
272 | * on(object).field("myField");
273 | * on(object).fields().get("myField");
274 | * fields() throws ReflectException {
279 | Map result = new LinkedHashMap();
280 | Class type = type();
281 |
282 | do {
283 | for (Field field : type.getDeclaredFields()) {
284 | if (!isClass ^ Modifier.isStatic(field.getModifiers())) {
285 | String name = field.getName();
286 |
287 | if (!result.containsKey(name)) {
288 | result.put(name, field(name));
289 | }
290 | }
291 | }
292 |
293 | type = type.getSuperclass();
294 | } while (type != null);
295 |
296 | return result;
297 | }
298 |
299 | /**
300 | * Call a method by its name.
301 | *
302 | * This is a convenience method for calling
303 | * call(name, new Object[0])
304 | *
305 | * @param name The method name
306 | * @return The wrapped method result or the same wrapped object if the
307 | * method returns void, to be used for further
308 | * reflection.
309 | * @throws ReflectException If any reflection exception occurred.
310 | * @see #call(String, Object...)
311 | */
312 | public Reflect call(String name) throws ReflectException {
313 | return call(name, new Object[0]);
314 | }
315 |
316 | /**
317 | * Call a method by its name.
318 | *
319 | * This is roughly equivalent to {@link Method#invoke(Object, Object...)}.
320 | * If the wrapped object is a {@link Class}, then this will invoke a static
321 | * method. If the wrapped object is any other {@link Object}, then this will
322 | * invoke an instance method.
323 | *
324 | * Just like {@link Method#invoke(Object, Object...)}, this will try to wrap
325 | * primitive types or unwrap primitive type wrappers if applicable. If
326 | * several methods are applicable, by that rule, the first one encountered
327 | * is called. i.e. when calling
328 | * on(...).call("method", 1, 1);
329 | *
331 | * public void method(int param1, Integer param2);
332 | * public void method(Integer param1, int param2);
333 | * public void method(Number param1, Number param2);
334 | * public void method(Number param1, Object param2);
335 | * public void method(int param1, Object param2);
336 | *
340 | * - public method with exact signature match in class hierarchy
341 | * - non-public method with exact signature match on declaring class
342 | * - public method with similar signature in class hierarchy
343 | * - non-public method with similar signature on declaring class
344 | *
345 | *
346 | * @param name The method name
347 | * @param args The method arguments
348 | * @return The wrapped method result or the same wrapped object if the
349 | * method returns void, to be used for further
350 | * reflection.
351 | * @throws ReflectException If any reflection exception occurred.
352 | */
353 | public Reflect call(String name, Object... args) throws ReflectException {
354 | Class[] types = types(args);
355 |
356 | // Try invoking the "canonical" method, i.e. the one with exact
357 | // matching argument types
358 | try {
359 | Method method = exactMethod(name, types);
360 | return on(method, object, args);
361 | } catch (NoSuchMethodException e) {
362 | try {
363 | Method method = similarMethod(name, types);
364 | return on(method, object, args);
365 | } catch (NoSuchMethodException e1) {
366 | throw new ReflectException(e1);
367 | }
368 | }
369 | }
370 |
371 | /**
372 | * Searches a method with the exact same signature as desired.
373 | *
374 | * If a public method is found in the class hierarchy, this method is returned.
375 | * Otherwise a private method with the exact same signature is returned.
376 | * If no exact match could be found, we let the {@code NoSuchMethodException} pass through.
377 | */
378 | private Method exactMethod(String name, Class[] types) throws NoSuchMethodException {
379 | Class type = type();
380 |
381 | // first priority: find a public method with exact signature match in class hierarchy
382 | try {
383 | return type.getMethod(name, types);
384 | } catch (NoSuchMethodException e) {
385 | do {
386 | try {
387 | return type.getDeclaredMethod(name, types);
388 | } catch (NoSuchMethodException ignore) {
389 | }
390 |
391 | type = type.getSuperclass();
392 | } while (type != null);
393 |
394 | throw new NoSuchMethodException();
395 | }
396 | }
397 |
398 | /**
399 | * Searches a method with a similar signature as desired using
400 | * {@link #isSimilarSignature(Method, String, Class[])}.
401 | *
402 | * First public methods are searched in the class hierarchy, then private
403 | * methods on the declaring class. If a method could be found, it is
404 | * returned, otherwise a {@code NoSuchMethodException} is thrown.
405 | */
406 | private Method similarMethod(String name, Class[] types) throws NoSuchMethodException {
407 | Class type = type();
408 |
409 | // first priority: find a public method with a "similar" signature in class hierarchy
410 | // similar interpreted in when primitive argument types are converted to their wrappers
411 | for (Method method : type.getMethods()) {
412 | if (isSimilarSignature(method, name, types)) {
413 | return method;
414 | }
415 | }
416 |
417 | // second priority: find a non-public method with a "similar" signature on declaring class
418 | do {
419 | for (Method method : type.getDeclaredMethods()) {
420 | if (isSimilarSignature(method, name, types)) {
421 | return method;
422 | }
423 | }
424 |
425 | type = type.getSuperclass();
426 | }
427 | while (type != null);
428 |
429 | throw new NoSuchMethodException("No similar method " + name + " with params " + Arrays
430 | .toString(types) + " could be found on type " + type() + ".");
431 | }
432 |
433 | /**
434 | * Determines if a method has a "similar" signature, especially if wrapping
435 | * primitive argument types would result in an exactly matching signature.
436 | */
437 | private boolean isSimilarSignature(Method possiblyMatchingMethod, String desiredMethodName,
438 | Class[] desiredParamTypes) {
439 | return possiblyMatchingMethod.getName().equals(desiredMethodName) && match
440 | (possiblyMatchingMethod.getParameterTypes(), desiredParamTypes);
441 | }
442 |
443 | /**
444 | * Call a constructor.
445 | *
446 | * This is a convenience method for calling
447 | * create(new Object[0])
448 | *
449 | * @return The wrapped new object, to be used for further reflection.
450 | * @throws ReflectException If any reflection exception occurred.
451 | * @see #create(Object...)
452 | */
453 | public Reflect create() throws ReflectException {
454 | return create(new Object[0]);
455 | }
456 |
457 | /**
458 | * Call a constructor.
459 | *
460 | * This is roughly equivalent to {@link Constructor#newInstance(Object...)}.
461 | * If the wrapped object is a {@link Class}, then this will create a new
462 | * object of that class. If the wrapped object is any other {@link Object},
463 | * then this will create a new object of the same type.
464 | *
465 | * Just like {@link Constructor#newInstance(Object...)}, this will try to
466 | * wrap primitive types or unwrap primitive type wrappers if applicable. If
467 | * several constructors are applicable, by that rule, the first one
468 | * encountered is called. i.e. when calling
469 | * on(C.class).create(1, 1);
470 | *
472 | * public C(int param1, Integer param2);
473 | * public C(Integer param1, int param2);
474 | * public C(Number param1, Number param2);
475 | * public C(Number param1, Object param2);
476 | * public C(int param1, Object param2);
477 | *
P as(Class
proxyType) {
511 | final boolean isMap = (object instanceof Map);
512 | final InvocationHandler handler = new InvocationHandler() {
513 | @SuppressWarnings("null")
514 | @Override
515 | public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
516 | String name = method.getName();
517 |
518 | // Actual method name matches always come first
519 | try {
520 | return on(object).call(name, args).get();
521 | } catch (ReflectException e) {
522 | if (isMap) {
523 | Map map = (Map) object;
524 | int length = (args == null ? 0 : args.length);
525 |
526 | if (length == 0 && name.startsWith("get")) {
527 | return map.get(property(name.substring(3)));
528 | } else if (length == 0 && name.startsWith("is")) {
529 | return map.get(property(name.substring(2)));
530 | } else if (length == 1 && name.startsWith("set")) {
531 | map.put(property(name.substring(3)), args[0]);
532 | return null;
533 | }
534 | }
535 |
536 | throw e;
537 | }
538 | }
539 | };
540 |
541 | return (P) Proxy.newProxyInstance(proxyType.getClassLoader(), new Class[]{proxyType},
542 | handler);
543 | }
544 |
545 | /**
546 | * Get the POJO property name of an getter/setter
547 | */
548 | private static String property(String string) {
549 | int length = string.length();
550 |
551 | if (length == 0) {
552 | return "";
553 | } else if (length == 1) {
554 | return string.toLowerCase();
555 | } else {
556 | return string.substring(0, 1).toLowerCase() + string.substring(1);
557 | }
558 | }
559 |
560 | // ---------------------------------------------------------------------
561 | // Object API
562 | // ---------------------------------------------------------------------
563 |
564 | /**
565 | * Check whether two arrays of types match, converting primitive types to
566 | * their corresponding wrappers.
567 | */
568 | private boolean match(Class[] declaredTypes, Class[] actualTypes) {
569 | if (declaredTypes.length == actualTypes.length) {
570 | for (int i = 0; i < actualTypes.length; i++) {
571 | if (actualTypes[i] == NULL.class) {
572 | continue;
573 | }
574 |
575 | if (wrapper(declaredTypes[i]).isAssignableFrom(wrapper(actualTypes[i]))) {
576 | continue;
577 | }
578 |
579 | return false;
580 | }
581 |
582 | return true;
583 | } else {
584 | return false;
585 | }
586 | }
587 |
588 | /**
589 | * {@inheritDoc}
590 | */
591 | @Override
592 | public int hashCode() {
593 | return object.hashCode();
594 | }
595 |
596 | /**
597 | * {@inheritDoc}
598 | */
599 | @Override
600 | public boolean equals(Object obj) {
601 | return obj instanceof Reflect && object.equals(((Reflect) obj).get());
602 |
603 | }
604 |
605 | /**
606 | * {@inheritDoc}
607 | */
608 | @Override
609 | public String toString() {
610 | return object.toString();
611 | }
612 |
613 | // ---------------------------------------------------------------------
614 | // Utility methods
615 | // ---------------------------------------------------------------------
616 |
617 | /**
618 | * Wrap an object created from a constructor
619 | */
620 | private static Reflect on(Constructor constructor, Object... args) throws ReflectException {
621 | try {
622 | return on(accessible(constructor).newInstance(args));
623 | } catch (Exception e) {
624 | throw new ReflectException(e);
625 | }
626 | }
627 |
628 | /**
629 | * Wrap an object returned from a method
630 | */
631 | private static Reflect on(Method method, Object object, Object... args) throws
632 | ReflectException {
633 | try {
634 | accessible(method);
635 |
636 | if (method.getReturnType() == void.class) {
637 | method.invoke(object, args);
638 | return on(object);
639 | } else {
640 | return on(method.invoke(object, args));
641 | }
642 | } catch (Exception e) {
643 | throw new ReflectException(e);
644 | }
645 | }
646 |
647 | /**
648 | * Unwrap an object
649 | */
650 | private static Object unwrap(Object object) {
651 | if (object instanceof Reflect) {
652 | return ((Reflect) object).get();
653 | }
654 |
655 | return object;
656 | }
657 |
658 | /**
659 | * Get an array of types for an array of objects
660 | *
661 | * @see Object#getClass()
662 | */
663 | private static Class[] types(Object... values) {
664 | if (values == null) {
665 | return new Class[0];
666 | }
667 |
668 | Class[] result = new Class[values.length];
669 |
670 | for (int i = 0; i < values.length; i++) {
671 | Object value = values[i];
672 | result[i] = value == null ? NULL.class : value.getClass();
673 | }
674 |
675 | return result;
676 | }
677 |
678 | /**
679 | * Load a class
680 | *
681 | * @see Class#forName(String)
682 | */
683 | private static Class forName(String name) throws ReflectException {
684 | try {
685 | return Class.forName(name);
686 | } catch (Exception e) {
687 | throw new ReflectException(e);
688 | }
689 | }
690 |
691 | private static Class forName(String name, ClassLoader classLoader) throws ReflectException {
692 | try {
693 | return Class.forName(name, true, classLoader);
694 | } catch (Exception e) {
695 | throw new ReflectException(e);
696 | }
697 | }
698 |
699 | /**
700 | * Get the type of the wrapped object.
701 | *
702 | * @see Object#getClass()
703 | */
704 | public Class type() {
705 | if (isClass) {
706 | return (Class) object;
707 | } else {
708 | return object.getClass();
709 | }
710 | }
711 |
712 | /**
713 | * Get a wrapper type for a primitive type, or the argument type itself, if
714 | * it is not a primitive type.
715 | */
716 | public static Class wrapper(Class type) {
717 | if (type == null) {
718 | return null;
719 | } else if (type.isPrimitive()) {
720 | if (boolean.class == type) {
721 | return Boolean.class;
722 | } else if (int.class == type) {
723 | return Integer.class;
724 | } else if (long.class == type) {
725 | return Long.class;
726 | } else if (short.class == type) {
727 | return Short.class;
728 | } else if (byte.class == type) {
729 | return Byte.class;
730 | } else if (double.class == type) {
731 | return Double.class;
732 | } else if (float.class == type) {
733 | return Float.class;
734 | } else if (char.class == type) {
735 | return Character.class;
736 | } else if (void.class == type) {
737 | return Void.class;
738 | }
739 | }
740 |
741 | return type;
742 | }
743 |
744 | private static class NULL {
745 | }
746 | }
747 |
--------------------------------------------------------------------------------
/android-modular/modular-tool/modular-manager/src/main/java/com/jeremyliao/modular/utils/ReflectException.java:
--------------------------------------------------------------------------------
1 | package com.jeremyliao.modular.utils;
2 |
3 |
4 | /**
5 | * A unchecked wrapper for any of Java's checked reflection exceptions:
6 | *
7 | * These exceptions are
8 | *
9 | * - {@link ClassNotFoundException}
10 | * - {@link IllegalAccessException}
11 | * - {@link IllegalArgumentException}
12 | * - {@link InstantiationException}
13 | * - {@link java.lang.reflect.InvocationTargetException}
14 | * - {@link NoSuchMethodException}
15 | * - {@link NoSuchFieldException}
16 | * - {@link SecurityException}
17 | *
18 | */
19 | public class ReflectException extends Exception {
20 |
21 | /**
22 | * Generated UID
23 | */
24 | private static final long serialVersionUID = -6213149635297151442L;
25 |
26 | public ReflectException(String message) {
27 | super(message);
28 | }
29 |
30 | public ReflectException(String message, Throwable cause) {
31 | super(message, cause);
32 | }
33 |
34 | public ReflectException() {
35 | super();
36 | }
37 |
38 | public ReflectException(Throwable cause) {
39 | super(cause);
40 | }
41 | }
42 |
--------------------------------------------------------------------------------
/android-modular/modular-tool/modular-manager/src/main/res/values/strings.xml:
--------------------------------------------------------------------------------
1 |
2 | modular
3 |
4 |
--------------------------------------------------------------------------------
/android-modular/modular-tool/modular-plugin/.gitignore:
--------------------------------------------------------------------------------
1 | /build
2 |
--------------------------------------------------------------------------------
/android-modular/modular-tool/modular-plugin/build.gradle:
--------------------------------------------------------------------------------
1 | apply plugin: 'groovy'
2 | apply plugin: 'java'
3 | apply plugin: 'maven'
4 |
5 | repositories {
6 | maven {
7 | url uri('../../repo')
8 | }
9 | mavenLocal()
10 | jcenter()
11 | }
12 |
13 | sourceSets {
14 | main {
15 | groovy {
16 | srcDir 'src/main/groovy'
17 | }
18 |
19 | java {
20 | srcDir 'src/main/java'
21 | }
22 | }
23 | }
24 |
25 |
26 | dependencies {
27 | implementation gradleApi()
28 | implementation localGroovy()
29 | implementation 'com.squareup:javapoet:1.11.1'
30 | implementation 'com.android.tools.build:gradle:3.2.1'
31 | implementation 'com.android.tools.build:transform-api:1.5.0'
32 | if (USE_LOCAL_LIB.toBoolean()) {
33 | implementation 'com.jeremyliao:modular-base:0.0.1'
34 | // implementation project(':modular-tool:modular-base')
35 | } else {
36 | implementation 'com.jeremyliao.modular-tools:base:0.0.1'
37 | }
38 | }
39 |
40 | apply from: '../../upload.gradle'
--------------------------------------------------------------------------------
/android-modular/modular-tool/modular-plugin/src/main/groovy/com/jeremyliao/plugin/ModularPlugin.groovy:
--------------------------------------------------------------------------------
1 | package com.jeremyliao.plugin
2 |
3 | import com.android.build.gradle.AppExtension
4 | import org.gradle.api.Plugin
5 | import org.gradle.api.Project
6 |
7 | /**
8 | * Created by liaohailiang on 2018/12/26.
9 | */
10 | class ModularPlugin implements Plugin {
11 |
12 | final String TAG = "[ModularPlugin]"
13 |
14 | @Override
15 | void apply(Project project) {
16 | System.out.println(TAG + project)
17 | addTransform(project)
18 | }
19 |
20 | private void addTransform(Project project) {
21 | def extension = project.extensions.findByType(AppExtension.class)
22 | System.out.println(TAG + extension)
23 | extension.registerTransform(new ModularTransform(project))
24 | }
25 | }
26 |
--------------------------------------------------------------------------------
/android-modular/modular-tool/modular-plugin/src/main/groovy/com/jeremyliao/plugin/ModularTransform.groovy:
--------------------------------------------------------------------------------
1 | package com.jeremyliao.plugin
2 |
3 | import com.android.build.api.transform.*
4 | import com.android.build.gradle.internal.pipeline.TransformManager
5 | import com.google.gson.reflect.TypeToken
6 | import com.jeremyliao.asm.ModularManagerVisitor
7 | import com.jeremyliao.base.inner.bean.ModuleServiceInfo
8 | import com.jeremyliao.base.inner.utils.GsonUtil
9 | import org.apache.commons.io.FileUtils
10 | import org.apache.commons.io.IOUtils
11 | import org.gradle.api.Project
12 | import org.objectweb.asm.ClassReader
13 | import org.objectweb.asm.ClassVisitor
14 | import org.objectweb.asm.ClassWriter
15 |
16 | import java.lang.reflect.Type
17 | import java.util.jar.JarEntry
18 | import java.util.jar.JarFile
19 | import java.util.jar.JarOutputStream
20 | import java.util.stream.Collectors
21 | import java.util.zip.ZipEntry
22 |
23 | import static org.objectweb.asm.ClassReader.EXPAND_FRAMES
24 |
25 | /**
26 | * Created by liaohailiang on 2018/12/26.
27 | */
28 | class ModularTransform extends Transform {
29 |
30 | static final String TAG = "[[ModularTransform]]"
31 | static final String MODULAR_PATH = "META-INF/modules/module_info/"
32 | static final String MODULE_MANAGER_CLASS_NAME = "ModuleRpcManager.class"
33 |
34 | private final Project project
35 |
36 | private List moduleServiceInfos = new ArrayList<>();
37 | //输出的目标jar
38 | private JarInput outPutJarInput
39 |
40 | ModularTransform(Project project) {
41 | this.project = project
42 | }
43 |
44 | @Override
45 | void transform(TransformInvocation transformInvocation) throws TransformException, InterruptedException, IOException {
46 | super.transform(transformInvocation)
47 | traversal(transformInvocation)
48 | handleOutputJarInputs(transformInvocation.outputProvider)
49 | }
50 |
51 | /**
52 | * 处理输入
53 | * @param transformInvocation
54 | */
55 | private void traversal(TransformInvocation transformInvocation) {
56 | printLog("处理输入")
57 | Collection inputs = transformInvocation.inputs
58 | TransformOutputProvider outputProvider = transformInvocation.outputProvider
59 | //遍历inputs
60 | inputs.each { TransformInput input ->
61 | input.directoryInputs.each { DirectoryInput directoryInput ->
62 | handleDirectoryInput(directoryInput, outputProvider)
63 | }
64 |
65 | input.jarInputs.each { JarInput jarInput ->
66 | handleJarInputs(jarInput, outputProvider)
67 | }
68 | }
69 | }
70 |
71 | @Override
72 | String getName() {
73 | return ModularTransform.simpleName
74 | }
75 |
76 | @Override
77 | Set getInputTypes() {
78 | return TransformManager.CONTENT_CLASS
79 | }
80 |
81 | @Override
82 | Set getScopes() {
83 | return TransformManager.SCOPE_FULL_PROJECT
84 | }
85 |
86 | @Override
87 | boolean isIncremental() {
88 | return false
89 | }
90 |
91 | private void handleJarInputs(JarInput jarInput, TransformOutputProvider outputProvider) {
92 | boolean copyAfterProcess = true
93 | File file = jarInput.getFile()
94 | JarFile jarFile = new JarFile(file)
95 | Enumeration entries = jarFile.entries()
96 | while (entries.hasMoreElements()) {
97 | JarEntry entry = entries.nextElement()
98 | def name = entry.getName()
99 | if (name.contains(MODULE_MANAGER_CLASS_NAME)) {
100 | printLog("ModuleRpcManager JarEntry name: " + name)
101 | printLog("ModuleRpcManager path: " + file.getAbsolutePath())
102 | outPutJarInput = jarInput
103 | copyAfterProcess = false
104 | }
105 | if (name.contains(MODULAR_PATH)) {
106 | printLog("JarEntry: " + entry)
107 | try {
108 | InputStream inputStream = jarFile.getInputStream(entry)
109 | String json = new BufferedReader(new InputStreamReader(inputStream))
110 | .lines().parallel().collect(Collectors.joining(System.lineSeparator()))
111 | Type type = new TypeToken>() {
112 | }.getType()
113 | ArrayList serviceInfos = GsonUtil.fromJson(json, type)
114 | if (serviceInfos != null && serviceInfos.size() > 0) {
115 | moduleServiceInfos.addAll(serviceInfos)
116 | }
117 | inputStream.close()
118 | } catch (IOException e) {
119 | e.printStackTrace()
120 | }
121 | }
122 | }
123 | //处理完输入文件之后，要把输出给下一个任务
124 | if (copyAfterProcess) {
125 | File dest = outputProvider.getContentLocation(jarInput.name, jarInput.contentTypes,
126 | jarInput.scopes, Format.JAR)
127 | FileUtils.copyFile(file, dest)
128 | }
129 | }
130 |
131 | private void handleDirectoryInput(DirectoryInput directoryInput, TransformOutputProvider outputProvider) {
132 | //是否是目录
133 | if (directoryInput.file.isDirectory()) {
134 | //列出目录所有文件（包含子文件夹，子文件夹内文件）
135 | directoryInput.file.eachFileRecurse { File file ->
136 | def name = file.name
137 | if (name.contains(MODULAR_PATH)) {
138 | printLog('filename: ' + name)
139 | try {
140 | InputStream inputStream = new FileInputStream(file)
141 | String json = new BufferedReader(new InputStreamReader(inputStream))
142 | .lines().parallel().collect(Collectors.joining(System.lineSeparator()))
143 | Type type = new TypeToken>() {
144 | }.getType()
145 | ArrayList serviceInfos = GsonUtil.fromJson(json, type)
146 | if (serviceInfos != null && serviceInfos.size() > 0) {
147 | moduleServiceInfos.addAll(serviceInfos)
148 | }
149 | inputStream.close()
150 | } catch (IOException e) {
151 | e.printStackTrace()
152 | }
153 | }
154 | }
155 | }
156 | //处理完输入文件之后，要把输出给下一个任务
157 | def dest = outputProvider.getContentLocation(directoryInput.name,
158 | directoryInput.contentTypes, directoryInput.scopes,
159 | Format.DIRECTORY)
160 | FileUtils.copyDirectory(directoryInput.file, dest)
161 | }
162 |
163 | private void handleOutputJarInputs(TransformOutputProvider outputProvider) {
164 | if (outPutJarInput == null) {
165 | return
166 | }
167 | if (moduleServiceInfos == null || moduleServiceInfos.size() == 0) {
168 | return
169 | }
170 | JarFile jarFile = new JarFile(outPutJarInput.file)
171 | Enumeration enumeration = jarFile.entries()
172 | File tmpFile = new File(outPutJarInput.file.getParent() + File.separator + "classes_temp.jar")
173 | JarOutputStream jarOutputStream = new JarOutputStream(new FileOutputStream(tmpFile))
174 | //用于保存
175 | while (enumeration.hasMoreElements()) {
176 | JarEntry jarEntry = (JarEntry) enumeration.nextElement()
177 | String entryName = jarEntry.getName()
178 | ZipEntry zipEntry = new ZipEntry(entryName)
179 | InputStream inputStream = jarFile.getInputStream(jarEntry)
180 | if (entryName.contains(MODULE_MANAGER_CLASS_NAME)) {
181 | //class文件处理
182 | jarOutputStream.putNextEntry(zipEntry)
183 | ClassReader classReader = new ClassReader(IOUtils.toByteArray(inputStream))
184 | ClassWriter classWriter = new ClassWriter(classReader, ClassWriter.COMPUTE_MAXS)
185 | ClassVisitor cv = new ModularManagerVisitor(classWriter, GsonUtil.toJson(moduleServiceInfos))
186 | classReader.accept(cv, EXPAND_FRAMES)
187 | byte[] code = classWriter.toByteArray()
188 | jarOutputStream.write(code)
189 | } else {
190 | jarOutputStream.putNextEntry(zipEntry)
191 | jarOutputStream.write(IOUtils.toByteArray(inputStream))
192 | }
193 | jarOutputStream.closeEntry()
194 | }
195 | //结束
196 | jarOutputStream.close()
197 | jarFile.close()
198 | File dest = outputProvider.getContentLocation(outPutJarInput.name,
199 | outPutJarInput.contentTypes, outPutJarInput.scopes, Format.JAR)
200 | printLog("src path: " + outPutJarInput.file.absolutePath)
201 | printLog("copy dest: " + dest.absolutePath)
202 | FileUtils.copyFile(tmpFile, dest)
203 | tmpFile.delete()
204 | }
205 |
206 | private static void printLog(String log) {
207 | println TAG + log
208 | }
209 | }
210 |
--------------------------------------------------------------------------------
/android-modular/modular-tool/modular-plugin/src/main/java/com/jeremyliao/asm/ModularManagerVisitor.java:
--------------------------------------------------------------------------------
1 | package com.jeremyliao.asm;
2 |
3 | import org.objectweb.asm.ClassVisitor;
4 | import org.objectweb.asm.Label;
5 | import org.objectweb.asm.MethodVisitor;
6 | import org.objectweb.asm.Opcodes;
7 |
8 | /**
9 | * Created by liaohailiang on 2019-09-30.
10 | */
11 | public class ModularManagerVisitor extends ClassVisitor implements Opcodes {
12 |
13 | private static final String INJECT_METHOD_NAME = "getModuleJson";
14 | private final String outputJson;
15 |
16 | public ModularManagerVisitor(ClassVisitor cv, String json) {
17 | super(Opcodes.ASM5, cv);
18 | outputJson = json;
19 | }
20 |
21 | @Override
22 | public MethodVisitor visitMethod(int access, String name, String desc, String signature, String[] exceptions) {
23 | MethodVisitor mv = cv.visitMethod(access, name, desc, signature, exceptions);
24 | if (!INJECT_METHOD_NAME.equals(name)) {
25 | return mv;
26 | }
27 | return new MethodVisitor(Opcodes.ASM5, mv) {
28 | @Override
29 | public void visitCode() {
30 | super.visitCode();
31 | mv.visitCode();
32 | Label l0 = new Label();
33 | mv.visitLabel(l0);
34 | mv.visitLineNumber(66, l0);
35 | mv.visitLdcInsn(outputJson);
36 | mv.visitInsn(ARETURN);
37 | mv.visitMaxs(1, 0);
38 | mv.visitEnd();
39 | }
40 | };
41 | }
42 |
43 | @Override
44 | public void visitEnd() {
45 | super.visitEnd();
46 | }
47 | }
48 |
--------------------------------------------------------------------------------
/android-modular/modular-tool/modular-plugin/src/main/resources/META-INF/gradle-plugins/modular-plugin.properties:
--------------------------------------------------------------------------------
1 | implementation-class=com.jeremyliao.plugin.ModularPlugin
--------------------------------------------------------------------------------
/android-modular/settings.gradle:
--------------------------------------------------------------------------------
1 | include ':app'
2 | include 'modular-demo:module-a'
3 | include 'modular-demo:common'
4 | include 'modular-demo:module-a-interface'
5 | include 'modular-demo:module-b'
6 | include 'modular-demo:module-b-interface'
7 | include 'modular-tool:modular-manager'
8 | include 'modular-tool:modular-base'
9 | include 'modular-tool:modular-plugin'
10 | include 'modular-tool:modular-compiler'
--------------------------------------------------------------------------------
/android-modular/upload.gradle:
--------------------------------------------------------------------------------
1 | apply plugin: 'maven'
2 |
3 | //group和version
4 | group = 'com.jeremyliao'
5 | version = '0.0.1'
6 |
7 | //打包到本地或者远程Maven库
8 | uploadArchives {
9 | repositories {
10 | mavenDeployer {
11 | repository(url: uri('../../repo'))
12 | }
13 | }
14 | }
--------------------------------------------------------------------------------