Skip to content

Commit 35d37fa

Browse files
moyadamoyada
committed
fix jar implement
1 parent 555936f commit 35d37fa

5 files changed

Lines changed: 161 additions & 38 deletions

File tree

‎pom.xml‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -6,7 +6,7 @@
66

77
<groupId>io.github.moyada</groupId>
88
<artifactId>feign-help</artifactId>
9-
<version>1.0.0-RELEASE</version>
9+
<version>1.0.1-SNAPSHOT</version>
1010

1111
<name>feign help</name>
1212
<description>a simple plugin for automatic create feign fallback factory.</description>

‎src/main/java/io/moyada/feign/help/processor/FeignHelpProcessor.java‎

Lines changed: 7 additions & 10 deletions
Original file line numberDiff line numberDiff line change
@@ -16,9 +16,8 @@
1616
import javax.annotation.processing.*;
1717
import javax.lang.model.SourceVersion;
1818
import javax.lang.model.element.TypeElement;
19-
import javax.tools.Diagnostic;
2019
import java.lang.reflect.Method;
21-
import java.util.List;
20+
import java.util.Collection;
2221
import java.util.Set;
2322

2423
/**
@@ -72,22 +71,20 @@ private static <T> T jbUnwrap(Class<? extends T> iface, T wrapper) {
7271

7372
@Override
7473
public boolean process(Set<? extends TypeElement> annotations, RoundEnvironment roundEnv) {
75-
List<JCTree.JCClassDecl> factoryEles = ElementUtil.getFallbackFactory(trees, roundEnv);
76-
List<JCTree.JCClassDecl> fallbackEles = ElementUtil.getFallback(trees, roundEnv, factoryEles);
74+
Collection<JCTree.JCClassDecl> factoryEles = ElementUtil.getFallbackFactory(trees, roundEnv);
75+
Collection<JCTree.JCClassDecl> fallbackEles = ElementUtil.getFallback(trees, roundEnv, factoryEles);
7776
if (factoryEles.isEmpty() && fallbackEles.isEmpty()) {
7877
return true;
7978
}
8079

8180
SyntaxTreeMaker syntaxTreeMaker = SyntaxTreeMaker.newInstance(context);
82-
8381
TreeTranslator translator = new FallbackTranslator(trees, syntaxTreeMaker, printer);
84-
for (JCTree.JCClassDecl fallbackEle : fallbackEles) {
85-
fallbackEle.accept(translator);
82+
for (JCTree.JCClassDecl ele : fallbackEles) {
83+
ele.accept(translator);
8684
}
87-
8885
translator = new FallbackFactoryTranslator(trees, syntaxTreeMaker, printer);
89-
for (JCTree.JCClassDecl factoryEle: factoryEles) {
90-
factoryEle.accept(translator);
86+
for (JCTree.JCClassDecl ele: factoryEles) {
87+
ele.accept(translator);
9188
}
9289
return true;
9390
}

‎src/main/java/io/moyada/feign/help/util/ElementUtil.java‎

Lines changed: 95 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -2,7 +2,13 @@
22

33
import com.sun.source.tree.Tree;
44
import com.sun.source.util.Trees;
5+
import com.sun.tools.javac.code.Flags;
6+
import com.sun.tools.javac.code.Symbol;
7+
import com.sun.tools.javac.code.Type;
58
import com.sun.tools.javac.tree.JCTree;
9+
import com.sun.tools.javac.tree.TreeMaker;
10+
import com.sun.tools.javac.util.List;
11+
import com.sun.tools.javac.util.Name;
612
import io.moyada.feign.help.annotation.FallbackBuild;
713
import io.moyada.feign.help.annotation.FallbackFactoryBuild;
814
import io.moyada.feign.help.support.SyntaxTreeMaker;
@@ -11,8 +17,8 @@
1117
import javax.lang.model.element.Element;
1218
import javax.lang.model.element.ElementKind;
1319
import java.util.ArrayList;
20+
import java.util.Collection;
1421
import java.util.Collections;
15-
import java.util.List;
1622
import java.util.Set;
1723

1824
/**
@@ -25,12 +31,12 @@ public final class ElementUtil {
2531
private ElementUtil() {
2632
}
2733

28-
public static List<JCTree.JCClassDecl> getFallbackFactory(Trees trees, RoundEnvironment roundEnv) {
34+
public static Collection<JCTree.JCClassDecl> getFallbackFactory(Trees trees, RoundEnvironment roundEnv) {
2935
Set<? extends Element> factoryEles = roundEnv.getElementsAnnotatedWith(FallbackFactoryBuild.class);
3036
if (factoryEles.isEmpty()) {
3137
return Collections.emptyList();
3238
}
33-
List<JCTree.JCClassDecl> list = new ArrayList<JCTree.JCClassDecl>(factoryEles.size());
39+
java.util.List<JCTree.JCClassDecl> list = new java.util.ArrayList<JCTree.JCClassDecl>(factoryEles.size());
3440
for (Element element : factoryEles) {
3541
if (element.getKind() == ElementKind.INTERFACE) {
3642
JCTree.JCClassDecl classDecl = (JCTree.JCClassDecl) trees.getTree(element);
@@ -40,13 +46,13 @@ public static List<JCTree.JCClassDecl> getFallbackFactory(Trees trees, RoundEnvi
4046
return list;
4147
}
4248

43-
public static List<JCTree.JCClassDecl> getFallback(Trees trees, RoundEnvironment roundEnv, List<JCTree.JCClassDecl> factoryEles) {
49+
public static Collection<JCTree.JCClassDecl> getFallback(Trees trees, RoundEnvironment roundEnv, Collection<JCTree.JCClassDecl> factoryEles) {
4450
Set<? extends Element> fallbackEles = roundEnv.getElementsAnnotatedWith(FallbackBuild.class);
4551
if (fallbackEles.isEmpty()) {
4652
return factoryEles;
4753
}
4854

49-
List<JCTree.JCClassDecl> list = new ArrayList<JCTree.JCClassDecl>(fallbackEles.size());
55+
Collection<JCTree.JCClassDecl> list = new java.util.ArrayList<JCTree.JCClassDecl>(fallbackEles.size());
5056

5157
for (Element element : fallbackEles) {
5258
if (element.getKind() == ElementKind.INTERFACE) {
@@ -62,40 +68,114 @@ public static List<JCTree.JCClassDecl> getFallback(Trees trees, RoundEnvironment
6268
return list;
6369
}
6470

65-
public static List<JCTree.JCMethodDecl> getStaticMethod(Trees trees, SyntaxTreeMaker treeMaker, JCTree.JCClassDecl element) {
66-
List<JCTree.JCMethodDecl> list = new ArrayList<JCTree.JCMethodDecl>();
67-
71+
public static Collection<JCTree.JCMethodDecl> getStaticMethod(Trees trees, SyntaxTreeMaker treeMaker, JCTree.JCClassDecl element) {
72+
Collection<JCTree.JCMethodDecl> list = new ArrayList<JCTree.JCMethodDecl>();
73+
// 获取目标类中方法
6874
if (element.defs != null) {
6975
for (JCTree tree : element.defs) {
7076
if (tree.getKind() == Tree.Kind.METHOD) {
7177
list.add((JCTree.JCMethodDecl) tree);
7278
}
7379
}
7480
}
75-
81+
// 注入父类方法
7682
addSuperStaticMethod(list, trees, treeMaker, element);
7783
return list;
7884
}
7985

80-
private static void addSuperStaticMethod(List<JCTree.JCMethodDecl> list, Trees trees, SyntaxTreeMaker treeMaker, JCTree.JCClassDecl element) {
86+
private static void addSuperStaticMethod(Collection<JCTree.JCMethodDecl> list, Trees trees, SyntaxTreeMaker treeMaker, JCTree.JCClassDecl element) {
8187
if (element.implementing == null) {
8288
return;
8389
}
8490

91+
// 遍历继承接口
8592
for (JCTree.JCExpression imple : element.implementing) {
8693
JCTree.JCIdent ident = (JCTree.JCIdent) imple.getTree();
94+
95+
// 获取当前类节点
8796
JCTree.JCClassDecl sup = (JCTree.JCClassDecl) trees.getTree(ident.sym);
97+
if (sup == null) {
98+
// 当前类中方法
99+
for (Symbol symbol : ident.sym.getEnclosedElements()) {
100+
if (symbol.getKind() == ElementKind.METHOD) {
101+
Symbol.MethodSymbol methodSymbol = (Symbol.MethodSymbol) symbol;
102+
JCTree.JCMethodDecl methodDecl = buildFHMethodDecl(treeMaker, methodSymbol);
103+
list.add(methodDecl);
104+
}
105+
}
106+
continue;
107+
}
108+
109+
// 获取节点属性
110+
if (sup.defs != null) {
111+
for (JCTree tree : sup.defs) {
112+
if (tree.getKind() == Tree.Kind.METHOD) {
113+
list.add((JCTree.JCMethodDecl) tree);
114+
}
115+
}
116+
}
88117

89118
// get super method
90119
addSuperStaticMethod(list, trees, treeMaker, sup);
91-
if (sup.defs == null) {
92-
continue;
120+
}
121+
}
122+
123+
private static JCTree.JCMethodDecl buildFHMethodDecl(SyntaxTreeMaker syntaxTreeMaker, Symbol.MethodSymbol symbol) {
124+
TreeMaker treeMaker = syntaxTreeMaker.getTreeMaker();
125+
126+
JCTree.JCModifiers mod = treeMaker.Modifiers(Flags.PUBLIC);
127+
128+
Name name = symbol.name;
129+
130+
Type returnType = symbol.getReturnType();
131+
JCTree.JCIdent restype = treeMaker.Ident(returnType.tsym);
132+
133+
List<JCTree.JCTypeParameter> typarams = null;
134+
List<Symbol.TypeVariableSymbol> typeParameters = symbol.getTypeParameters();
135+
if (typeParameters == null || typeParameters.isEmpty()) {
136+
typarams = List.nil();
137+
} else {
138+
for (Symbol.TypeVariableSymbol typeParameter : typeParameters) {
139+
JCTree.JCTypeParameter jcTypeParameter = treeMaker.TypeParam(typeParameter.name, (Type.TypeVar) typeParameter.type);
140+
141+
if (typarams == null) {
142+
typarams = List.of(jcTypeParameter);
143+
} else {
144+
typarams = typarams.append(jcTypeParameter);
145+
}
93146
}
94-
for (JCTree tree : sup.defs) {
95-
if (tree.getKind() == Tree.Kind.METHOD) {
96-
list.add((JCTree.JCMethodDecl) tree);
147+
}
148+
149+
List<JCTree.JCVariableDecl> params = null;
150+
List<Symbol.VarSymbol> parameters = symbol.getParameters();
151+
if (parameters == null || parameters.isEmpty()) {
152+
params = List.nil();
153+
} else {
154+
for (Symbol.VarSymbol parameter : parameters) {
155+
JCTree.JCVariableDecl param = treeMaker.Param(parameter.name, parameter.type, parameter.owner);
156+
if (params == null) {
157+
params = List.of(param);
158+
} else {
159+
params = params.append(param);
97160
}
98161
}
99162
}
163+
164+
List<JCTree.JCExpression> thrown = null;
165+
List<Type> thrownTypes = symbol.getThrownTypes();
166+
if (thrownTypes == null || thrownTypes.isEmpty()) {
167+
thrown = List.nil();
168+
} else {
169+
for (Type thrownType : thrownTypes) {
170+
JCTree.JCIdent ident = treeMaker.Ident(thrownType.tsym);
171+
if (thrown == null) {
172+
thrown = List.of((JCTree.JCExpression) ident);
173+
} else {
174+
thrown = thrown.append(ident);
175+
}
176+
}
177+
}
178+
179+
return treeMaker.MethodDef(mod, name, restype, typarams, params, thrown, null, null);
100180
}
101181
}

‎src/main/java/io/moyada/feign/help/visitor/BaseTranslator.java‎

Lines changed: 19 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -49,6 +49,25 @@ protected Name importClass(JCTree.JCClassDecl classDecl, String pkg, String claa
4949
return simplename;
5050
}
5151

52+
/**
53+
* 创建类
54+
* @param classDecl 接口
55+
*/
56+
protected void addImport(JCTree.JCClassDecl classDecl, String pkg, String claaName) {
57+
Name fullname = syntaxTreeMaker.getName(pkg);
58+
Name simplename = syntaxTreeMaker.getName(claaName);
59+
60+
JCTree.JCIdent fullbean = treeMaker.Ident(fullname);
61+
JCTree.JCFieldAccess select = treeMaker.Select(fullbean, simplename);
62+
JCTree.JCImport anImport = treeMaker.Import(select, false);
63+
64+
TreePath treePath = trees.getPath(classDecl.sym);
65+
JCTree.JCCompilationUnit jccu = (JCTree.JCCompilationUnit) treePath.getCompilationUnit();
66+
if (!jccu.defs.contains(select)) {
67+
jccu.defs = jccu.defs.append(anImport);
68+
}
69+
}
70+
5271
/**
5372
* 创建类
5473
* @param interClass 接口

‎src/main/java/io/moyada/feign/help/visitor/FallbackTranslator.java‎

Lines changed: 39 additions & 12 deletions
Original file line numberDiff line numberDiff line change
@@ -13,15 +13,15 @@
1313
import io.moyada.feign.help.util.ElementUtil;
1414
import io.moyada.feign.help.util.TreeUtil;
1515

16-
import javax.annotation.processing.Messager;
16+
import java.util.Collection;
1717

1818
/**
1919
* @author xueyikang
2020
* @since 1.0
2121
**/
2222
public class FallbackTranslator extends BaseTranslator {
2323

24-
private Name name;
24+
private final Name name;
2525

2626
public FallbackTranslator(Trees trees, SyntaxTreeMaker syntaxTreeMaker, Printer printer) {
2727
super(trees, syntaxTreeMaker, printer);
@@ -41,7 +41,6 @@ public void visitClassDef(JCTree.JCClassDecl jcClassDecl) {
4141
if (!localClass.equals(name)) {
4242
return;
4343
}
44-
4544
JCTree.JCClassDecl classDecl = createClass(jcClassDecl);
4645
super.appendClass(jcClassDecl, classDecl);
4746
}
@@ -78,15 +77,15 @@ private JCTree.JCClassDecl createClass(JCTree.JCClassDecl interClass) {
7877
}
7978

8079
private List<JCTree> buildMethod(JCTree.JCClassDecl interClass) {
81-
java.util.List<JCTree.JCMethodDecl> methodList = ElementUtil.getStaticMethod(trees, syntaxTreeMaker, interClass);
80+
Collection<JCTree.JCMethodDecl> methodList = ElementUtil.getStaticMethod(trees, syntaxTreeMaker, interClass);
8281
if (methodList.isEmpty()) {
8382
return List.<JCTree>nil();
8483
}
8584

8685
List<JCTree> list = null;
8786
for (JCTree.JCMethodDecl methodDecl : methodList) {
87+
addImport(interClass, methodDecl);
8888
JCTree.JCMethodDecl jcMethod = createJCMethod(methodDecl);
89-
9089
if (list == null) {
9190
list = List.of((JCTree) jcMethod);
9291
} else {
@@ -96,20 +95,48 @@ private List<JCTree> buildMethod(JCTree.JCClassDecl interClass) {
9695
return list;
9796
}
9897

98+
private void addImport(JCTree.JCClassDecl thisClass, JCTree.JCMethodDecl methodDecl) {
99+
JCTree.JCIdent restype;
100+
if (methodDecl.restype instanceof JCTree.JCTypeApply) {
101+
JCTree.JCTypeApply typeApply = (JCTree.JCTypeApply) methodDecl.restype;
102+
restype = (JCTree.JCIdent) typeApply.clazz;
103+
} else {
104+
restype = (JCTree.JCIdent) methodDecl.restype;
105+
}
106+
addImport(thisClass, restype.sym.packge().toString(), restype.name.toString());
107+
108+
for (JCTree.JCVariableDecl param : methodDecl.params) {
109+
if (param.vartype instanceof JCTree.JCFieldAccess) {
110+
JCTree.JCFieldAccess paramtype = (JCTree.JCFieldAccess) param.vartype;
111+
addImport(thisClass, paramtype.sym.packge().toString(), paramtype.name.toString());
112+
} else {
113+
if (param.vartype instanceof JCTree.JCTypeApply) {
114+
JCTree.JCTypeApply typeApply = (JCTree.JCTypeApply) param.vartype;
115+
JCTree.JCFieldAccess paramtype = (JCTree.JCFieldAccess) typeApply.clazz;
116+
addImport(thisClass, paramtype.sym.packge().toString(), paramtype.name.toString());
117+
} else {
118+
JCTree.JCIdent paramtype = (JCTree.JCIdent) param.vartype;
119+
addImport(thisClass, paramtype.sym.packge().toString(), paramtype.name.toString());
120+
}
121+
}
122+
}
123+
124+
for (JCTree.JCExpression expression : methodDecl.thrown) {
125+
JCTree.JCIdent thro = (JCTree.JCIdent) expression;
126+
addImport(thisClass, thro.sym.packge().toString(), thro.name.toString());
127+
}
128+
}
129+
99130
/**
100131
* 实现空方法
101132
* @param jcMethodDecl 方法
102133
* @return 方法元素
103134
*/
104135
private JCTree.JCMethodDecl createJCMethod(JCTree.JCMethodDecl jcMethodDecl) {
105136
JCTree.JCModifiers mod = treeMaker.Modifiers(Flags.PUBLIC);
106-
107-
// if (jcMethodDecl.sym == null || jcMethodDecl.sym.getAnnotationMirrors().isEmpty()) {
108-
// mod = treeMaker.Modifiers(Flags.PUBLIC);
109-
// } else {
110-
// List<JCTree.JCAnnotation> annotations = treeMaker.Annotations(jcMethodDecl.sym.getAnnotationMirrors());
111-
// mod = treeMaker.Modifiers(Flags.PUBLIC, annotations);
112-
// }
137+
for (JCTree.JCVariableDecl param : jcMethodDecl.params) {
138+
param.mods.annotations = List.nil();
139+
}
113140

114141
return treeMaker.MethodDef(mod,
115142
jcMethodDecl.name,

0 commit comments

Comments
 (0)