+ * // Static import all reflection methods to decrease verbosity
+ * import static org.joor.Reflect.*;
+ *
+ * // Wrap an Object / Class / class name with the on() method:
+ * on("java.lang.String")
+ * // Invoke constructors using the create() method:
+ * .create("Hello World")
+ * // Invoke methods using the call() method:
+ * .call("toString")
+ * // Retrieve the wrapped object
+ *
+ * @author Lukas Eder
+ * @author Irek Matysiewicz
+ * @author Thomas Darimont
+ */
+public class Reflect {
+
+ // ---------------------------------------------------------------------
+ // Static API used as entrance points to the fluent API
+ // ---------------------------------------------------------------------
+
+ /**
+ * Wrap a class name.
+ *
+ * This is the same as calling on(Class.forName(name))
+ *
+ * @param name A fully qualified class name
+ * @return A wrapped class object, to be used for further reflection.
+ * @throws ReflectException If any reflection exception occurred.
+ * @see #on(Class)
+ */
+ public static Reflect on(String name) throws ReflectException {
+ return on(forName(name));
+ }
+
+ /**
+ * Wrap a class name, loading it via a given class loader.
+ *
+ * This is the same as calling
+ * on(Class.forName(name, classLoader))
+ *
+ * @param name A fully qualified class name.
+ * @param classLoader The class loader in whose context the class should be
+ * loaded.
+ * @return A wrapped class object, to be used for further reflection.
+ * @throws ReflectException If any reflection exception occurred.
+ * @see #on(Class)
+ */
+ public static Reflect on(String name, ClassLoader classLoader) throws ReflectException {
+ return on(forName(name, classLoader));
+ }
+
+ /**
+ * Wrap a class.
+ *
+ * Use this when you want to access static fields and methods on a
+ * {@link Class} object, or as a basis for constructing objects of that
+ * class using {@link #create(Object...)}
+ *
+ * @param clazz The class to be wrapped
+ * @return A wrapped class object, to be used for further reflection.
+ */
+ public static Reflect on(Class clazz) {
+ return new Reflect(clazz);
+ }
+
+ /**
+ * Wrap an object.
+ *
+ * Use this when you want to access instance fields and methods on any
+ * {@link Object}
+ *
+ * @param object The object to be wrapped
+ * @return A wrapped object, to be used for further reflection.
+ */
+ public static Reflect on(Object object) {
+ return new Reflect(object);
+ }
+
+ /**
+ * Conveniently render an {@link AccessibleObject} accessible.
+ *
+ * To prevent {@link SecurityException}, this is only done if the argument
+ * object and its declaring class are non-public.
+ *
+ * @param accessible The object to render accessible
+ * @return The argument object rendered accessible
+ */
+ public static T accessible(T accessible) {
+ if (accessible == null) {
+ return null;
+ }
+
+ if (accessible instanceof Member) {
+ Member member = (Member) accessible;
+
+ if (Modifier.isPublic(member.getModifiers()) &&
+ Modifier.isPublic(member.getDeclaringClass().getModifiers())) {
+
+ return accessible;
+ }
+ }
+
+ // [jOOQ #3392] The accessible flag is set to false by default, also for public members.
+ if (!accessible.isAccessible()) {
+ accessible.setAccessible(true);
+ }
+
+ return accessible;
+ }
+
+ // ---------------------------------------------------------------------
+ // Members
+ // ---------------------------------------------------------------------
+
+ /* [java-8] */
+ private static final Constructor CACHED_LOOKUP_CONSTRUCTOR;
+
+ static {
+ try {
+ CACHED_LOOKUP_CONSTRUCTOR = MethodHandles.Lookup.class.getDeclaredConstructor(Class.class);
+
+ if (!CACHED_LOOKUP_CONSTRUCTOR.isAccessible())
+ CACHED_LOOKUP_CONSTRUCTOR.setAccessible(true);
+ }
+ catch (Exception e) {
+ throw new IllegalStateException(e);
+ }
+ }
+ /* [/java-8] */
+
+ /**
+ * The wrapped object
+ */
+ private final Object object;
+
+ /**
+ * A flag indicating whether the wrapped object is a {@link Class} (for
+ * accessing static fields and methods), or any other type of {@link Object}
+ * (for accessing instance fields and methods).
+ */
+ private final boolean isClass;
+
+ // ---------------------------------------------------------------------
+ // Constructors
+ // ---------------------------------------------------------------------
+
+ private Reflect(Class type) {
+ this.object = type;
+ this.isClass = true;
+ }
+
+ private Reflect(Object object) {
+ this.object = object;
+ this.isClass = false;
+ }
+
+ // ---------------------------------------------------------------------
+ // Fluent Reflection API
+ // ---------------------------------------------------------------------
+
+ /**
+ * Get the wrapped object
+ *
+ * @param A convenience generic parameter for automatic unsafe casting
+ */
+ @SuppressWarnings("unchecked")
+ public T get() {
+ return (T) object;
+ }
+
+ /**
+ * Set a field value.
+ *
+ * This is roughly equivalent to {@link Field#set(Object, Object)}. If the
+ * wrapped object is a {@link Class}, then this will set a value to a static
+ * member field. If the wrapped object is any other {@link Object}, then
+ * this will set a value to an instance member field.
+ *
+ * This method is also capable of setting the value of (static) final
+ * fields. This may be convenient in situations where no
+ * {@link SecurityManager} is expected to prevent this, but do note that
+ * (especially static) final fields may already have been inlined by the
+ * javac and/or JIT and relevant code deleted from the runtime verison of
+ * your program, so setting these fields might not have any effect on your
+ * execution.
+ *
+ * For restrictions of usage regarding setting values on final fields check:
+ * http://stackoverflow.com/questions/3301635/change-private-static-final-field-using-java-reflection
+ * ... and http://pveentjer.blogspot.co.at/2017/01/final-static-boolean-jit.html
+ *
+ * @param name The field name
+ * @param value The new field value
+ * @return The same wrapped object, to be used for further reflection.
+ * @throws ReflectException If any reflection exception occurred.
+ */
+ public Reflect set(String name, Object value) throws ReflectException {
+ try {
+ Field field = field0(name);
+ if ((field.getModifiers() & Modifier.FINAL) == Modifier.FINAL) {
+ Field modifiersField = Field.class.getDeclaredField("modifiers");
+ modifiersField.setAccessible(true);
+ modifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL);
+ }
+ field.set(object, unwrap(value));
+ return this;
+ }
+ catch (Exception e) {
+ throw new ReflectException(e);
+ }
+ }
+
+ /**
+ * Get a field value.
+ *
+ * This is roughly equivalent to {@link Field#get(Object)}. If the wrapped
+ * object is a {@link Class}, then this will get a value from a static
+ * member field. If the wrapped object is any other {@link Object}, then
+ * this will get a value from an instance member field.
+ *
+ * If you want to "navigate" to a wrapped version of the field, use
+ * {@link #field(String)} instead.
+ *
+ * @param name The field name
+ * @return The field value
+ * @throws ReflectException If any reflection exception occurred.
+ * @see #field(String)
+ */
+ public T get(String name) throws ReflectException {
+ return field(name).get();
+ }
+
+ /**
+ * Get a wrapped field.
+ *
+ * This is roughly equivalent to {@link Field#get(Object)}. If the wrapped
+ * object is a {@link Class}, then this will wrap a static member field. If
+ * the wrapped object is any other {@link Object}, then this wrap an
+ * instance member field.
+ *
+ * @param name The field name
+ * @return The wrapped field
+ * @throws ReflectException If any reflection exception occurred.
+ */
+ public Reflect field(String name) throws ReflectException {
+ try {
+ Field field = field0(name);
+ Object obj = field.get(object);
+
+ return on(field.get(object));
+ }
+ catch (Exception e) {
+ throw new ReflectException(e);
+ }
+ }
+
+ private Field field0(String name) throws ReflectException {
+ Class type = type();
+
+ // Try getting a public field
+ try {
+ return accessible(type.getField(name));
+ }
+
+ // Try again, getting a non-public field
+ catch (NoSuchFieldException e) {
+ do {
+ try {
+ return accessible(type.getDeclaredField(name));
+ }
+ catch (NoSuchFieldException ignore) {}
+
+ type = type.getSuperclass();
+ }
+ while (type != null);
+
+ throw new ReflectException(e);
+ }
+ }
+
+ /**
+ * Get a Map containing field names and wrapped values for the fields'
+ * values.
+ *
+ * If the wrapped object is a {@link Class}, then this will return static
+ * fields. If the wrapped object is any other {@link Object}, then this will
+ * return instance fields.
+ *
+ * These two calls are equivalent
+ * on(object).field("myField");
+ * on(object).fields().get("myField");
+ *
+ * This is a convenience method for calling
+ * call(name, new Object[0])
+ *
+ * @param name The method name
+ * @return The wrapped method result or the same wrapped object if the
+ * method returns void, to be used for further
+ * reflection.
+ * @throws ReflectException If any reflection exception occurred.
+ * @see #call(String, Object...)
+ */
+ public Reflect call(String name) throws ReflectException {
+ return call(name, new Object[0]);
+ }
+
+ /**
+ * Call a method by its name.
+ *
+ * This is roughly equivalent to {@link Method#invoke(Object, Object...)}.
+ * If the wrapped object is a {@link Class}, then this will invoke a static
+ * method. If the wrapped object is any other {@link Object}, then this will
+ * invoke an instance method.
+ *
+ * Just like {@link Method#invoke(Object, Object...)}, this will try to wrap
+ * primitive types or unwrap primitive type wrappers if applicable. If
+ * several methods are applicable, by that rule, the first one encountered
+ * is called. i.e. when calling
+ * on(...).call("method", 1, 1);
+ *
+ * public void method(int param1, Integer param2);
+ * public void method(Integer param1, int param2);
+ * public void method(Number param1, Number param2);
+ * public void method(Number param1, Object param2);
+ * public void method(int param1, Object param2);
+ *
+ * The best matching method is searched for with the following strategy:
+ *
+ * - public method with exact signature match in class hierarchy
+ * - non-public method with exact signature match on declaring class
+ * - public method with similar signature in class hierarchy
+ * - non-public method with similar signature on declaring class
+ *
+ *
+ * @param name The method name
+ * @param args The method arguments
+ * @return The wrapped method result or the same wrapped object if the
+ * method returns void, to be used for further
+ * reflection.
+ * @throws ReflectException If any reflection exception occurred.
+ */
+ public Reflect call(String name, Object... args) throws ReflectException {
+ Class[] types = types(args);
+
+ // Try invoking the "canonical" method, i.e. the one with exact
+ // matching argument types
+ try {
+ Method method = exactMethod(name, types);
+ return on(method, object, args);
+ }
+
+ // If there is no exact match, try to find a method that has a "similar"
+ // signature if primitive argument types are converted to their wrappers
+ catch (NoSuchMethodException e) {
+ try {
+ Method method = similarMethod(name, types);
+ return on(method, object, args);
+ } catch (NoSuchMethodException e1) {
+ throw new ReflectException(e1);
+ }
+ }
+ }
+
+ /**
+ * Searches a method with the exact same signature as desired.
+ *
+ * If a public method is found in the class hierarchy, this method is returned.
+ * Otherwise a private method with the exact same signature is returned.
+ * If no exact match could be found, we let the {@code NoSuchMethodException} pass through.
+ */
+ private Method exactMethod(String name, Class[] types) throws NoSuchMethodException {
+ Class type = type();
+
+ // first priority: find a public method with exact signature match in class hierarchy
+ try {
+ return type.getMethod(name, types);
+ }
+
+ // second priority: find a private method with exact signature match on declaring class
+ catch (NoSuchMethodException e) {
+ do {
+ try {
+ return type.getDeclaredMethod(name, types);
+ }
+ catch (NoSuchMethodException ignore) {}
+
+ type = type.getSuperclass();
+ }
+ while (type != null);
+
+ throw new NoSuchMethodException();
+ }
+ }
+
+ /**
+ * Searches a method with a similar signature as desired using
+ * {@link #isSimilarSignature(Method, String, Class[])}.
+ *
+ * First public methods are searched in the class hierarchy, then private
+ * methods on the declaring class. If a method could be found, it is
+ * returned, otherwise a {@code NoSuchMethodException} is thrown.
+ */
+ private Method similarMethod(String name, Class[] types) throws NoSuchMethodException {
+ Class type = type();
+
+ // first priority: find a public method with a "similar" signature in class hierarchy
+ // similar interpreted in when primitive argument types are converted to their wrappers
+ for (Method method : type.getMethods()) {
+ if (isSimilarSignature(method, name, types)) {
+ return method;
+ }
+ }
+
+ // second priority: find a non-public method with a "similar" signature on declaring class
+ do {
+ for (Method method : type.getDeclaredMethods()) {
+ if (isSimilarSignature(method, name, types)) {
+ return method;
+ }
+ }
+
+ type = type.getSuperclass();
+ }
+ while (type != null);
+
+ throw new NoSuchMethodException("No similar method " + name + " with params " + Arrays.toString(types) + " could be found on type " + type() + ".");
+ }
+
+ /**
+ * Determines if a method has a "similar" signature, especially if wrapping
+ * primitive argument types would result in an exactly matching signature.
+ */
+ private boolean isSimilarSignature(Method possiblyMatchingMethod, String desiredMethodName, Class[] desiredParamTypes) {
+ return possiblyMatchingMethod.getName().equals(desiredMethodName) && match(possiblyMatchingMethod.getParameterTypes(), desiredParamTypes);
+ }
+
+ /**
+ * Call a constructor.
+ *
+ * This is a convenience method for calling
+ * create(new Object[0])
+ *
+ * @return The wrapped new object, to be used for further reflection.
+ * @throws ReflectException If any reflection exception occurred.
+ * @see #create(Object...)
+ */
+ public Reflect create() throws ReflectException {
+ return create(new Object[0]);
+ }
+
+ /**
+ * Call a constructor.
+ *
+ * This is roughly equivalent to {@link Constructor#newInstance(Object...)}.
+ * If the wrapped object is a {@link Class}, then this will create a new
+ * object of that class. If the wrapped object is any other {@link Object},
+ * then this will create a new object of the same type.
+ *
+ * Just like {@link Constructor#newInstance(Object...)}, this will try to
+ * wrap primitive types or unwrap primitive type wrappers if applicable. If
+ * several constructors are applicable, by that rule, the first one
+ * encountered is called. i.e. when calling
+ * on(C.class).create(1, 1);
+ *
+ * public C(int param1, Integer param2);
+ * public C(Integer param1, int param2);
+ * public C(Number param1, Number param2);
+ * public C(Number param1, Object param2);
+ * public C(int param1, Object param2);
+ *
P as(final Class
proxyType) {
+ final boolean isMap = (object instanceof Map);
+ final InvocationHandler handler = new InvocationHandler() {
+ @SuppressWarnings("null")
+ @Override
+ public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
+ String name = method.getName();
+
+ // Actual method name matches always come first
+ try {
+ return on(object).call(name, args).get();
+ }
+
+ // [#14] Emulate POJO behaviour on wrapped map objects
+ catch (ReflectException e) {
+ if (isMap) {
+ Map map = (Map) object;
+ int length = (args == null ? 0 : args.length);
+
+ if (length == 0 && name.startsWith("get")) {
+ return map.get(property(name.substring(3)));
+ }
+ else if (length == 0 && name.startsWith("is")) {
+ return map.get(property(name.substring(2)));
+ }
+ else if (length == 1 && name.startsWith("set")) {
+ map.put(property(name.substring(3)), args[0]);
+ return null;
+ }
+ }
+
+ /* [java-8] */
+ if (method.isDefault()) {
+ return CACHED_LOOKUP_CONSTRUCTOR
+ .newInstance(proxyType)
+ .unreflectSpecial(method, proxyType)
+ .bindTo(proxy)
+ .invokeWithArguments(args);
+ }
+ /* [/java-8] */
+
+ throw e;
+ }
+ }
+ };
+
+ return (P) Proxy.newProxyInstance(proxyType.getClassLoader(), new Class[] { proxyType }, handler);
+ }
+
+ /**
+ * Get the POJO property name of an getter/setter
+ */
+ private static String property(String string) {
+ int length = string.length();
+
+ if (length == 0) {
+ return "";
+ }
+ else if (length == 1) {
+ return string.toLowerCase();
+ }
+ else {
+ return string.substring(0, 1).toLowerCase() + string.substring(1);
+ }
+ }
+
+ // ---------------------------------------------------------------------
+ // Object API
+ // ---------------------------------------------------------------------
+
+ /**
+ * Check whether two arrays of types match, converting primitive types to
+ * their corresponding wrappers.
+ */
+ private boolean match(Class[] declaredTypes, Class[] actualTypes) {
+ if (declaredTypes.length == actualTypes.length) {
+ for (int i = 0; i < actualTypes.length; i++) {
+ if (actualTypes[i] == NULL.class)
+ continue;
+
+ if (wrapper(declaredTypes[i]).isAssignableFrom(wrapper(actualTypes[i])))
+ continue;
+
+ return false;
+ }
+
+ return true;
+ }
+ else {
+ return false;
+ }
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public int hashCode() {
+ return object.hashCode();
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public boolean equals(Object obj) {
+ if (obj instanceof Reflect) {
+ return object.equals(((Reflect) obj).get());
+ }
+
+ return false;
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public String toString() {
+ return object.toString();
+ }
+
+ // ---------------------------------------------------------------------
+ // Utility methods
+ // ---------------------------------------------------------------------
+
+ /**
+ * Wrap an object created from a constructor
+ */
+ private static Reflect on(Constructor constructor, Object... args) throws ReflectException {
+ try {
+ return on(accessible(constructor).newInstance(args));
+ }
+ catch (Exception e) {
+ throw new ReflectException(e);
+ }
+ }
+
+ /**
+ * Wrap an object returned from a method
+ */
+ private static Reflect on(Method method, Object object, Object... args) throws ReflectException {
+ try {
+ accessible(method);
+
+ if (method.getReturnType() == void.class) {
+ method.invoke(object, args);
+ return on(object);
+ }
+ else {
+ return on(method.invoke(object, args));
+ }
+ }
+ catch (Exception e) {
+ throw new ReflectException(e);
+ }
+ }
+
+ /**
+ * Unwrap an object
+ */
+ private static Object unwrap(Object object) {
+ if (object instanceof Reflect) {
+ return ((Reflect) object).get();
+ }
+
+ return object;
+ }
+
+ /**
+ * Get an array of types for an array of objects
+ *
+ * @see Object#getClass()
+ */
+ private static Class[] types(Object... values) {
+ if (values == null) {
+ return new Class[0];
+ }
+
+ Class[] result = new Class[values.length];
+
+ for (int i = 0; i < values.length; i++) {
+ Object value = values[i];
+ result[i] = value == null ? NULL.class : value.getClass();
+ }
+
+ return result;
+ }
+
+ /**
+ * Load a class
+ *
+ * @see Class#forName(String)
+ */
+ private static Class forName(String name) throws ReflectException {
+ try {
+ return Class.forName(name);
+ }
+ catch (Exception e) {
+ throw new ReflectException(e);
+ }
+ }
+
+ private static Class forName(String name, ClassLoader classLoader) throws ReflectException {
+ try {
+ return Class.forName(name, true, classLoader);
+ }
+ catch (Exception e) {
+ throw new ReflectException(e);
+ }
+ }
+
+ /**
+ * Get the type of the wrapped object.
+ *
+ * @see Object#getClass()
+ */
+ public Class type() {
+ if (isClass) {
+ return (Class) object;
+ }
+ else {
+ return object.getClass();
+ }
+ }
+
+ /**
+ * Get a wrapper type for a primitive type, or the argument type itself, if
+ * it is not a primitive type.
+ */
+ public static Class wrapper(Class type) {
+ if (type == null) {
+ return null;
+ }
+ else if (type.isPrimitive()) {
+ if (boolean.class == type) {
+ return Boolean.class;
+ }
+ else if (int.class == type) {
+ return Integer.class;
+ }
+ else if (long.class == type) {
+ return Long.class;
+ }
+ else if (short.class == type) {
+ return Short.class;
+ }
+ else if (byte.class == type) {
+ return Byte.class;
+ }
+ else if (double.class == type) {
+ return Double.class;
+ }
+ else if (float.class == type) {
+ return Float.class;
+ }
+ else if (char.class == type) {
+ return Character.class;
+ }
+ else if (void.class == type) {
+ return Void.class;
+ }
+ }
+
+ return type;
+ }
+
+ private static class NULL {}
+
+}
diff --git a/dove-config-admin/src/main/java/com/licc/dove/util/ReflectException.java b/dove-config-admin/src/main/java/com/licc/dove/util/ReflectException.java
new file mode 100644
index 0000000..d39714e
--- /dev/null
+++ b/dove-config-admin/src/main/java/com/licc/dove/util/ReflectException.java
@@ -0,0 +1,41 @@
+package com.licc.dove.util;
+
+/**
+ * A unchecked wrapper for any of Java's checked reflection exceptions:
+ *
+ * These exceptions are
+ *
+ * - {@link ClassNotFoundException}
+ * - {@link IllegalAccessException}
+ * - {@link IllegalArgumentException}
+ * - {@link InstantiationException}
+ * - {@link NoSuchMethodException}
+ * - {@link NoSuchFieldException}
+ * - {@link SecurityException}
+ *
+ *
+ * @author Lukas Eder
+ */
+public class ReflectException extends RuntimeException {
+
+ /**
+ * Generated UID
+ */
+ private static final long serialVersionUID = -6213149635297151442L;
+
+ public ReflectException(String message) {
+ super(message);
+ }
+
+ public ReflectException(String message, Throwable cause) {
+ super(message, cause);
+ }
+
+ public ReflectException() {
+ super();
+ }
+
+ public ReflectException(Throwable cause) {
+ super(cause);
+ }
+}
\ No newline at end of file
diff --git a/dove-config-admin/src/main/java/com/licc/dove/util/ResponseVo.java b/dove-config-admin/src/main/java/com/licc/dove/util/ResponseVo.java
new file mode 100644
index 0000000..3b0b2c8
--- /dev/null
+++ b/dove-config-admin/src/main/java/com/licc/dove/util/ResponseVo.java
@@ -0,0 +1,57 @@
+package com.licc.dove.util;
+
+/**
+ * @author lichangchao
+ * @功能 返回json格式数据
+ *
+ */
+public class ResponseVo {
+ private static final long serialVersionUID = -3819569459544701549L;
+ private Integer code;
+ private Integer draw;
+ private String desc;
+ private Object data;
+
+ private ResponseVo() {
+ }
+
+ public Integer getCode() {
+ return this.code;
+ }
+
+ public ResponseVo setCode(Integer code) {
+ this.code = code;
+ return this;
+ }
+
+ public String getDesc() {
+ return this.desc;
+ }
+
+ public ResponseVo setDesc(String desc) {
+ this.desc = desc;
+ return this;
+ }
+
+ public Object getData() {
+ return this.data;
+ }
+
+ public ResponseVo setData(Object data) {
+ this.data = data;
+ return this;
+ }
+
+ public Integer getDraw() {
+ return draw;
+ }
+
+ public ResponseVo setDraw(Integer draw) {
+ this.draw = draw;
+ return this;
+ }
+
+ static ResponseVo BUILDER() {
+ return new ResponseVo();
+ }
+}
diff --git a/dove-config-admin/src/main/java/com/licc/dove/util/ResponseVoUtil.java b/dove-config-admin/src/main/java/com/licc/dove/util/ResponseVoUtil.java
new file mode 100644
index 0000000..904904e
--- /dev/null
+++ b/dove-config-admin/src/main/java/com/licc/dove/util/ResponseVoUtil.java
@@ -0,0 +1,31 @@
+package com.licc.dove.util;
+
+
+import com.licc.dove.enums.EResultCode;
+
+/**
+ * @author lichangchao
+ * @功能 返回json格式数据
+ *
+ */
+public class ResponseVoUtil {
+ public static ResponseVo failResult(String message) {
+ return ResponseVo.BUILDER().setCode(EResultCode.FAIL.getKey()).setDesc(message);
+ }
+
+ public static ResponseVo failResult(String Message, Object b) {
+ return ResponseVo.BUILDER().setCode(EResultCode.FAIL.getKey()).setDesc(Message).setData(b);
+ }
+
+ public static ResponseVo successMsg(String Message) {
+ return ResponseVo.BUILDER().setCode(EResultCode.SUCCESS.getKey()).setDesc(Message);
+ }
+
+ public static ResponseVo successData(Object data) {
+ return ResponseVo.BUILDER().setCode(EResultCode.SUCCESS.getKey()).setData(data);
+ }
+
+ public static ResponseVo successResult(String Message, Object data) {
+ return ResponseVo.BUILDER().setCode(EResultCode.SUCCESS.getKey()).setData(data).setDesc(Message);
+ }
+}
diff --git a/dove-config-admin/src/main/java/com/licc/dove/vo/DoveConfigEnvIpVO.java b/dove-config-admin/src/main/java/com/licc/dove/vo/DoveConfigEnvIpVO.java
new file mode 100644
index 0000000..03adae6
--- /dev/null
+++ b/dove-config-admin/src/main/java/com/licc/dove/vo/DoveConfigEnvIpVO.java
@@ -0,0 +1,25 @@
+package com.licc.dove.vo;
+
+import com.licc.dove.dao.anno.Table;
+
+import lombok.Data;
+
+/**
+ *
+ * @author lichangchao
+ * @version 1.0.0
+ * @date 2017/12/29 15:24
+ * @see
+ */
+@Table(name = "dove_config_env_ip")
+@Data
+public class DoveConfigEnvIpVO {
+ private Long id;
+ private Long configEnvId;
+ String ip;
+ String envName;
+
+ String envProfile;
+
+
+}
diff --git a/dove-config-admin/src/main/java/com/licc/dove/vo/DoveConfigPropertiesVO.java b/dove-config-admin/src/main/java/com/licc/dove/vo/DoveConfigPropertiesVO.java
new file mode 100644
index 0000000..7fe6d5a
--- /dev/null
+++ b/dove-config-admin/src/main/java/com/licc/dove/vo/DoveConfigPropertiesVO.java
@@ -0,0 +1,27 @@
+package com.licc.dove.vo;
+
+import com.licc.dove.dao.anno.Table;
+import lombok.Data;
+
+/**
+ *
+ * @author lichangchao
+ * @version 1.0.0
+ * @date 2017/12/29 15:24
+ * @see
+ */
+@Table(name = "dove_config_propertie")
+@Data
+public class DoveConfigPropertiesVO {
+ private Long id;
+
+ Long configAppId;
+ String name;
+ String proKey;
+
+ String proValue;
+
+ String appName;
+ String appProfile;
+
+}
diff --git a/dove-config-admin/src/main/java/com/licc/dove/vo/MenuVO.java b/dove-config-admin/src/main/java/com/licc/dove/vo/MenuVO.java
new file mode 100644
index 0000000..3f07737
--- /dev/null
+++ b/dove-config-admin/src/main/java/com/licc/dove/vo/MenuVO.java
@@ -0,0 +1,36 @@
+package com.licc.dove.vo;
+
+import java.util.Collections;
+import java.util.Date;
+import java.util.List;
+
+import com.licc.dove.dao.anno.Table;
+import com.licc.dove.domain.Menu;
+
+import lombok.Data;
+
+@Data
+@Table(name = "dove_menu")
+public class MenuVO {
+
+ String parentName;
+ List