+ *
* It would be nice if you provide credit to me if you use this class in a published project
- *
+ *
* @author DarkBlade12
* @version 1.1
*/
public final class ReflectionUtils {
- // Prevent accidental construction
- private ReflectionUtils() {}
+ // Prevent accidental construction
+ private ReflectionUtils() {
+ }
- /**
- * Returns the constructor of a given class with the given parameter types
- *
- * @param clazz Target class
- * @param parameterTypes Parameter types of the desired constructor
- * @return The constructor of the target class with the specified parameter types
- * @throws NoSuchMethodException If the desired constructor with the specified parameter types cannot be found
- * @see DataType
- * @see DataType#getPrimitive(Class[])
- * @see DataType#compare(Class[], Class[])
- */
- public static Constructor getConstructor(Class clazz, Class... parameterTypes) throws NoSuchMethodException {
- Class[] primitiveTypes = DataType.getPrimitive(parameterTypes);
- for (Constructor constructor : clazz.getConstructors()) {
- if (!DataType.compare(DataType.getPrimitive(constructor.getParameterTypes()), primitiveTypes)) {
- continue;
- }
- return constructor;
- }
- throw new NoSuchMethodException("There is no such constructor in this class with the specified parameter types");
- }
+ /**
+ * Returns the constructor of a given class with the given parameter types
+ *
+ * @param clazz Target class
+ * @param parameterTypes Parameter types of the desired constructor
+ * @return The constructor of the target class with the specified parameter types
+ * @throws NoSuchMethodException If the desired constructor with the specified parameter types cannot be found
+ * @see DataType
+ * @see DataType#getPrimitive(Class[])
+ * @see DataType#compare(Class[], Class[])
+ */
+ public static Constructor getConstructor(Class clazz, Class... parameterTypes) throws NoSuchMethodException {
+ Class[] primitiveTypes = DataType.getPrimitive(parameterTypes);
+ for (Constructor constructor : clazz.getDeclaredConstructors()) {
+ if (!DataType.compare(DataType.getPrimitive(constructor.getParameterTypes()), primitiveTypes)) {
+ continue;
+ }
+ constructor.setAccessible(true);
+ return constructor;
+ }
+ throw new NoSuchMethodException("There is no such constructor in this class with the specified parameter types");
+ }
- /**
- * Returns the constructor of a desired class with the given parameter types
- *
- * @param className Name of the desired target class
- * @param packageType Package where the desired target class is located
- * @param parameterTypes Parameter types of the desired constructor
- * @return The constructor of the desired target class with the specified parameter types
- * @throws NoSuchMethodException If the desired constructor with the specified parameter types cannot be found
- * @throws ClassNotFoundException ClassNotFoundException If the desired target class with the specified name and package cannot be found
- * @see #getConstructor(Class, Class...)
- */
- public static Constructor getConstructor(String className, PackageType packageType, Class... parameterTypes) throws NoSuchMethodException, ClassNotFoundException {
- return getConstructor(packageType.getClass(className), parameterTypes);
- }
+ /**
+ * Returns the constructor of a desired class with the given parameter types
+ *
+ * @param className Name of the desired target class
+ * @param packageType Package where the desired target class is located
+ * @param parameterTypes Parameter types of the desired constructor
+ * @return The constructor of the desired target class with the specified parameter types
+ * @throws NoSuchMethodException If the desired constructor with the specified parameter types cannot be found
+ * @throws ClassNotFoundException ClassNotFoundException If the desired target class with the specified name and package cannot be found
+ * @see #getConstructor(Class, Class...)
+ */
+ public static Constructor getConstructor(String className, PackageType packageType, Class... parameterTypes) throws NoSuchMethodException, ClassNotFoundException {
+ return getConstructor(packageType.getClass(className), parameterTypes);
+ }
- /**
- * Returns an instance of a class with the given arguments
- *
- * @param clazz Target class
- * @param arguments Arguments which are used to construct an object of the target class
- * @return The instance of the target class with the specified arguments
- * @throws InstantiationException If you cannot create an instance of the target class due to certain circumstances
- * @throws IllegalAccessException If the desired constructor cannot be accessed due to certain circumstances
- * @throws IllegalArgumentException If the types of the arguments do not match the parameter types of the constructor (this should not occur since it searches for a constructor with the types of the arguments)
- * @throws InvocationTargetException If the desired constructor cannot be invoked
- * @throws NoSuchMethodException If the desired constructor with the specified arguments cannot be found
- */
- public static Object instantiateObject(Class clazz, Object... arguments) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException {
- return getConstructor(clazz, DataType.getPrimitive(arguments)).newInstance(arguments);
- }
+ /**
+ * Returns an instance of a class with the given arguments
+ *
+ * @param clazz Target class
+ * @param arguments Arguments which are used to construct an object of the target class
+ * @return The instance of the target class with the specified arguments
+ * @throws InstantiationException If you cannot create an instance of the target class due to certain circumstances
+ * @throws IllegalAccessException If the desired constructor cannot be accessed due to certain circumstances
+ * @throws IllegalArgumentException If the types of the arguments do not match the parameter types of the constructor (this should not occur since it searches for a constructor with the types of the arguments)
+ * @throws InvocationTargetException If the desired constructor cannot be invoked
+ * @throws NoSuchMethodException If the desired constructor with the specified arguments cannot be found
+ */
+ public static Object instantiateObject(Class clazz, Object... arguments) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException {
+ return getConstructor(clazz, DataType.getPrimitive(arguments)).newInstance(arguments);
+ }
- /**
- * Returns an instance of a desired class with the given arguments
- *
- * @param className Name of the desired target class
- * @param packageType Package where the desired target class is located
- * @param arguments Arguments which are used to construct an object of the desired target class
- * @return The instance of the desired target class with the specified arguments
- * @throws InstantiationException If you cannot create an instance of the desired target class due to certain circumstances
- * @throws IllegalAccessException If the desired constructor cannot be accessed due to certain circumstances
- * @throws IllegalArgumentException If the types of the arguments do not match the parameter types of the constructor (this should not occur since it searches for a constructor with the types of the arguments)
- * @throws InvocationTargetException If the desired constructor cannot be invoked
- * @throws NoSuchMethodException If the desired constructor with the specified arguments cannot be found
- * @throws ClassNotFoundException If the desired target class with the specified name and package cannot be found
- * @see #instantiateObject(Class, Object...)
- */
- public static Object instantiateObject(String className, PackageType packageType, Object... arguments) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, ClassNotFoundException {
- return instantiateObject(packageType.getClass(className), arguments);
- }
+ /**
+ * Returns an instance of a desired class with the given arguments
+ *
+ * @param className Name of the desired target class
+ * @param packageType Package where the desired target class is located
+ * @param arguments Arguments which are used to construct an object of the desired target class
+ * @return The instance of the desired target class with the specified arguments
+ * @throws InstantiationException If you cannot create an instance of the desired target class due to certain circumstances
+ * @throws IllegalAccessException If the desired constructor cannot be accessed due to certain circumstances
+ * @throws IllegalArgumentException If the types of the arguments do not match the parameter types of the constructor (this should not occur since it searches for a constructor with the types of the arguments)
+ * @throws InvocationTargetException If the desired constructor cannot be invoked
+ * @throws NoSuchMethodException If the desired constructor with the specified arguments cannot be found
+ * @throws ClassNotFoundException If the desired target class with the specified name and package cannot be found
+ * @see #instantiateObject(Class, Object...)
+ */
+ public static Object instantiateObject(String className, PackageType packageType, Object... arguments) throws InstantiationException, IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, ClassNotFoundException {
+ return instantiateObject(packageType.getClass(className), arguments);
+ }
- /**
- * Returns a method of a class with the given parameter types
- *
- * @param clazz Target class
- * @param methodName Name of the desired method
- * @param parameterTypes Parameter types of the desired method
- * @return The method of the target class with the specified name and parameter types
- * @throws NoSuchMethodException If the desired method of the target class with the specified name and parameter types cannot be found
- * @see DataType#getPrimitive(Class[])
- * @see DataType#compare(Class[], Class[])
- */
- public static Method getMethod(Class clazz, String methodName, Class... parameterTypes) throws NoSuchMethodException {
- Class[] primitiveTypes = DataType.getPrimitive(parameterTypes);
- for (Method method : clazz.getMethods()) {
- if (!method.getName().equals(methodName) || !DataType.compare(DataType.getPrimitive(method.getParameterTypes()), primitiveTypes)) {
- continue;
- }
- return method;
- }
- throw new NoSuchMethodException("There is no such method in this class with the specified name and parameter types");
- }
+ /**
+ * Returns a method of a class with the given parameter types
+ *
+ * @param clazz Target class
+ * @param methodName Name of the desired method
+ * @param parameterTypes Parameter types of the desired method
+ * @return The method of the target class with the specified name and parameter types
+ * @throws NoSuchMethodException If the desired method of the target class with the specified name and parameter types cannot be found
+ * @see DataType#getPrimitive(Class[])
+ * @see DataType#compare(Class[], Class[])
+ */
+ public static Method getMethod(Class clazz, String methodName, Class... parameterTypes) throws NoSuchMethodException {
+ Class[] primitiveTypes = DataType.getPrimitive(parameterTypes);
+ for (Method method : clazz.getDeclaredMethods()) {
+ if (!method.getName().equals(methodName) || !DataType.compare(DataType.getPrimitive(method.getParameterTypes()), primitiveTypes)) {
+ continue;
+ }
+ method.setAccessible(true);
+ return method;
+ }
+ throw new NoSuchMethodException("There is no such method in this class with the specified name and parameter types");
+ }
- /**
- * Returns a method of a desired class with the given parameter types
- *
- * @param className Name of the desired target class
- * @param packageType Package where the desired target class is located
- * @param methodName Name of the desired method
- * @param parameterTypes Parameter types of the desired method
- * @return The method of the desired target class with the specified name and parameter types
- * @throws NoSuchMethodException If the desired method of the desired target class with the specified name and parameter types cannot be found
- * @throws ClassNotFoundException If the desired target class with the specified name and package cannot be found
- * @see #getMethod(Class, String, Class...)
- */
- public static Method getMethod(String className, PackageType packageType, String methodName, Class... parameterTypes) throws NoSuchMethodException, ClassNotFoundException {
- return getMethod(packageType.getClass(className), methodName, parameterTypes);
- }
+ /**
+ * Returns a method of a desired class with the given parameter types
+ *
+ * @param className Name of the desired target class
+ * @param packageType Package where the desired target class is located
+ * @param methodName Name of the desired method
+ * @param parameterTypes Parameter types of the desired method
+ * @return The method of the desired target class with the specified name and parameter types
+ * @throws NoSuchMethodException If the desired method of the desired target class with the specified name and parameter types cannot be found
+ * @throws ClassNotFoundException If the desired target class with the specified name and package cannot be found
+ * @see #getMethod(Class, String, Class...)
+ */
+ public static Method getMethod(String className, PackageType packageType, String methodName, Class... parameterTypes) throws NoSuchMethodException, ClassNotFoundException {
+ return getMethod(packageType.getClass(className), methodName, parameterTypes);
+ }
- /**
- * Invokes a method on an object with the given arguments
- *
- * @param instance Target object
- * @param methodName Name of the desired method
- * @param arguments Arguments which are used to invoke the desired method
- * @return The result of invoking the desired method on the target object
- * @throws IllegalAccessException If the desired method cannot be accessed due to certain circumstances
- * @throws IllegalArgumentException If the types of the arguments do not match the parameter types of the method (this should not occur since it searches for a method with the types of the arguments)
- * @throws InvocationTargetException If the desired method cannot be invoked on the target object
- * @throws NoSuchMethodException If the desired method of the class of the target object with the specified name and arguments cannot be found
- * @see #getMethod(Class, String, Class...)
- * @see DataType#getPrimitive(Object[])
- */
- public static Object invokeMethod(Object instance, String methodName, Object... arguments) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException {
- return getMethod(instance.getClass(), methodName, DataType.getPrimitive(arguments)).invoke(instance, arguments);
- }
+ /**
+ * Invokes a method on an object with the given arguments
+ *
+ * @param instance Target object
+ * @param methodName Name of the desired method
+ * @param arguments Arguments which are used to invoke the desired method
+ * @return The result of invoking the desired method on the target object
+ * @throws IllegalAccessException If the desired method cannot be accessed due to certain circumstances
+ * @throws IllegalArgumentException If the types of the arguments do not match the parameter types of the method (this should not occur since it searches for a method with the types of the arguments)
+ * @throws InvocationTargetException If the desired method cannot be invoked on the target object
+ * @throws NoSuchMethodException If the desired method of the class of the target object with the specified name and arguments cannot be found
+ * @see #getMethod(Class, String, Class...)
+ * @see DataType#getPrimitive(Object[])
+ */
+ public static Object invokeMethod(Object instance, String methodName, Object... arguments) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException {
+ return getMethod(instance.getClass(), methodName, DataType.getPrimitive(arguments)).invoke(instance, arguments);
+ }
- /**
- * Invokes a method of the target class on an object with the given arguments
- *
- * @param instance Target object
- * @param clazz Target class
- * @param methodName Name of the desired method
- * @param arguments Arguments which are used to invoke the desired method
- * @return The result of invoking the desired method on the target object
- * @throws IllegalAccessException If the desired method cannot be accessed due to certain circumstances
- * @throws IllegalArgumentException If the types of the arguments do not match the parameter types of the method (this should not occur since it searches for a method with the types of the arguments)
- * @throws InvocationTargetException If the desired method cannot be invoked on the target object
- * @throws NoSuchMethodException If the desired method of the target class with the specified name and arguments cannot be found
- * @see #getMethod(Class, String, Class...)
- * @see DataType#getPrimitive(Object[])
- */
- public static Object invokeMethod(Object instance, Class clazz, String methodName, Object... arguments) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException {
- return getMethod(clazz, methodName, DataType.getPrimitive(arguments)).invoke(instance, arguments);
- }
+ /**
+ * Invokes a method of the target class on an object with the given arguments
+ *
+ * @param instance Target object
+ * @param clazz Target class
+ * @param methodName Name of the desired method
+ * @param arguments Arguments which are used to invoke the desired method
+ * @return The result of invoking the desired method on the target object
+ * @throws IllegalAccessException If the desired method cannot be accessed due to certain circumstances
+ * @throws IllegalArgumentException If the types of the arguments do not match the parameter types of the method (this should not occur since it searches for a method with the types of the arguments)
+ * @throws InvocationTargetException If the desired method cannot be invoked on the target object
+ * @throws NoSuchMethodException If the desired method of the target class with the specified name and arguments cannot be found
+ * @see #getMethod(Class, String, Class...)
+ * @see DataType#getPrimitive(Object[])
+ */
+ public static Object invokeMethod(Object instance, Class clazz, String methodName, Object... arguments) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException {
+ return getMethod(clazz, methodName, DataType.getPrimitive(arguments)).invoke(instance, arguments);
+ }
- /**
- * Invokes a method of a desired class on an object with the given arguments
- *
- * @param instance Target object
- * @param className Name of the desired target class
- * @param packageType Package where the desired target class is located
- * @param methodName Name of the desired method
- * @param arguments Arguments which are used to invoke the desired method
- * @return The result of invoking the desired method on the target object
- * @throws IllegalAccessException If the desired method cannot be accessed due to certain circumstances
- * @throws IllegalArgumentException If the types of the arguments do not match the parameter types of the method (this should not occur since it searches for a method with the types of the arguments)
- * @throws InvocationTargetException If the desired method cannot be invoked on the target object
- * @throws NoSuchMethodException If the desired method of the desired target class with the specified name and arguments cannot be found
- * @throws ClassNotFoundException If the desired target class with the specified name and package cannot be found
- * @see #invokeMethod(Object, Class, String, Object...)
- */
- public static Object invokeMethod(Object instance, String className, PackageType packageType, String methodName, Object... arguments) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, ClassNotFoundException {
- return invokeMethod(instance, packageType.getClass(className), methodName, arguments);
- }
+ /**
+ * Invokes a method of a desired class on an object with the given arguments
+ *
+ * @param instance Target object
+ * @param className Name of the desired target class
+ * @param packageType Package where the desired target class is located
+ * @param methodName Name of the desired method
+ * @param arguments Arguments which are used to invoke the desired method
+ * @return The result of invoking the desired method on the target object
+ * @throws IllegalAccessException If the desired method cannot be accessed due to certain circumstances
+ * @throws IllegalArgumentException If the types of the arguments do not match the parameter types of the method (this should not occur since it searches for a method with the types of the arguments)
+ * @throws InvocationTargetException If the desired method cannot be invoked on the target object
+ * @throws NoSuchMethodException If the desired method of the desired target class with the specified name and arguments cannot be found
+ * @throws ClassNotFoundException If the desired target class with the specified name and package cannot be found
+ * @see #invokeMethod(Object, Class, String, Object...)
+ */
+ public static Object invokeMethod(Object instance, String className, PackageType packageType, String methodName, Object... arguments) throws IllegalAccessException, IllegalArgumentException, InvocationTargetException, NoSuchMethodException, ClassNotFoundException {
+ return invokeMethod(instance, packageType.getClass(className), methodName, arguments);
+ }
- /**
- * Returns a field of the target class with the given name
- *
- * @param clazz Target class
- * @param declared Whether the desired field is declared or not
- * @param fieldName Name of the desired field
- * @return The field of the target class with the specified name
- * @throws NoSuchFieldException If the desired field of the given class cannot be found
- * @throws SecurityException If the desired field cannot be made accessible
- */
- public static Field getField(Class clazz, boolean declared, String fieldName) throws NoSuchFieldException, SecurityException {
- Field field = declared ? clazz.getDeclaredField(fieldName) : clazz.getField(fieldName);
- field.setAccessible(true);
- return field;
- }
+ /**
+ * Returns a field of the target class with the given name
+ *
+ * @param clazz Target class
+ * @param declared Whether the desired field is declared or not
+ * @param fieldName Name of the desired field
+ * @return The field of the target class with the specified name
+ * @throws NoSuchFieldException If the desired field of the given class cannot be found
+ * @throws SecurityException If the desired field cannot be made accessible
+ */
+ public static Field getField(Class clazz, boolean declared, String fieldName) throws NoSuchFieldException, SecurityException {
+ Field field = declared ? clazz.getDeclaredField(fieldName) : clazz.getField(fieldName);
+ field.setAccessible(true);
+ return field;
+ }
- /**
- * Returns a field of a desired class with the given name
- *
- * @param className Name of the desired target class
- * @param packageType Package where the desired target class is located
- * @param declared Whether the desired field is declared or not
- * @param fieldName Name of the desired field
- * @return The field of the desired target class with the specified name
- * @throws NoSuchFieldException If the desired field of the desired class cannot be found
- * @throws SecurityException If the desired field cannot be made accessible
- * @throws ClassNotFoundException If the desired target class with the specified name and package cannot be found
- * @see #getField(Class, boolean, String)
- */
- public static Field getField(String className, PackageType packageType, boolean declared, String fieldName) throws NoSuchFieldException, SecurityException, ClassNotFoundException {
- return getField(packageType.getClass(className), declared, fieldName);
- }
+ /**
+ * Returns a field of a desired class with the given name
+ *
+ * @param className Name of the desired target class
+ * @param packageType Package where the desired target class is located
+ * @param declared Whether the desired field is declared or not
+ * @param fieldName Name of the desired field
+ * @return The field of the desired target class with the specified name
+ * @throws NoSuchFieldException If the desired field of the desired class cannot be found
+ * @throws SecurityException If the desired field cannot be made accessible
+ * @throws ClassNotFoundException If the desired target class with the specified name and package cannot be found
+ * @see #getField(Class, boolean, String)
+ */
+ public static Field getField(String className, PackageType packageType, boolean declared, String fieldName) throws NoSuchFieldException, SecurityException, ClassNotFoundException {
+ return getField(packageType.getClass(className), declared, fieldName);
+ }
- /**
- * Returns the value of a field of the given class of an object
- *
- * @param instance Target object
- * @param clazz Target class
- * @param declared Whether the desired field is declared or not
- * @param fieldName Name of the desired field
- * @return The value of field of the target object
- * @throws IllegalArgumentException If the target object does not feature the desired field
- * @throws IllegalAccessException If the desired field cannot be accessed
- * @throws NoSuchFieldException If the desired field of the target class cannot be found
- * @throws SecurityException If the desired field cannot be made accessible
- * @see #getField(Class, boolean, String)
- */
- public static Object getValue(Object instance, Class clazz, boolean declared, String fieldName) throws IllegalArgumentException, IllegalAccessException, NoSuchFieldException, SecurityException {
- return getField(clazz, declared, fieldName).get(instance);
- }
+ /**
+ * Returns the value of a field of the given class of an object
+ *
+ * @param instance Target object
+ * @param clazz Target class
+ * @param declared Whether the desired field is declared or not
+ * @param fieldName Name of the desired field
+ * @return The value of field of the target object
+ * @throws IllegalArgumentException If the target object does not feature the desired field
+ * @throws IllegalAccessException If the desired field cannot be accessed
+ * @throws NoSuchFieldException If the desired field of the target class cannot be found
+ * @throws SecurityException If the desired field cannot be made accessible
+ * @see #getField(Class, boolean, String)
+ */
+ public static Object getValue(Object instance, Class clazz, boolean declared, String fieldName) throws IllegalArgumentException, IllegalAccessException, NoSuchFieldException, SecurityException {
+ return getField(clazz, declared, fieldName).get(instance);
+ }
- /**
- * Returns the value of a field of a desired class of an object
- *
- * @param instance Target object
- * @param className Name of the desired target class
- * @param packageType Package where the desired target class is located
- * @param declared Whether the desired field is declared or not
- * @param fieldName Name of the desired field
- * @return The value of field of the target object
- * @throws IllegalArgumentException If the target object does not feature the desired field
- * @throws IllegalAccessException If the desired field cannot be accessed
- * @throws NoSuchFieldException If the desired field of the desired class cannot be found
- * @throws SecurityException If the desired field cannot be made accessible
- * @throws ClassNotFoundException If the desired target class with the specified name and package cannot be found
- * @see #getValue(Object, Class, boolean, String)
- */
- public static Object getValue(Object instance, String className, PackageType packageType, boolean declared, String fieldName) throws IllegalArgumentException, IllegalAccessException, NoSuchFieldException, SecurityException, ClassNotFoundException {
- return getValue(instance, packageType.getClass(className), declared, fieldName);
- }
+ /**
+ * Returns the value of a field of a desired class of an object
+ *
+ * @param instance Target object
+ * @param className Name of the desired target class
+ * @param packageType Package where the desired target class is located
+ * @param declared Whether the desired field is declared or not
+ * @param fieldName Name of the desired field
+ * @return The value of field of the target object
+ * @throws IllegalArgumentException If the target object does not feature the desired field
+ * @throws IllegalAccessException If the desired field cannot be accessed
+ * @throws NoSuchFieldException If the desired field of the desired class cannot be found
+ * @throws SecurityException If the desired field cannot be made accessible
+ * @throws ClassNotFoundException If the desired target class with the specified name and package cannot be found
+ * @see #getValue(Object, Class, boolean, String)
+ */
+ public static Object getValue(Object instance, String className, PackageType packageType, boolean declared, String fieldName) throws IllegalArgumentException, IllegalAccessException, NoSuchFieldException, SecurityException, ClassNotFoundException {
+ return getValue(instance, packageType.getClass(className), declared, fieldName);
+ }
- /**
- * Returns the value of a field with the given name of an object
- *
- * @param instance Target object
- * @param declared Whether the desired field is declared or not
- * @param fieldName Name of the desired field
- * @return The value of field of the target object
- * @throws IllegalArgumentException If the target object does not feature the desired field (should not occur since it searches for a field with the given name in the class of the object)
- * @throws IllegalAccessException If the desired field cannot be accessed
- * @throws NoSuchFieldException If the desired field of the target object cannot be found
- * @throws SecurityException If the desired field cannot be made accessible
- * @see #getValue(Object, Class, boolean, String)
- */
- public static Object getValue(Object instance, boolean declared, String fieldName) throws IllegalArgumentException, IllegalAccessException, NoSuchFieldException, SecurityException {
- return getValue(instance, instance.getClass(), declared, fieldName);
- }
+ /**
+ * Returns the value of a field with the given name of an object
+ *
+ * @param instance Target object
+ * @param declared Whether the desired field is declared or not
+ * @param fieldName Name of the desired field
+ * @return The value of field of the target object
+ * @throws IllegalArgumentException If the target object does not feature the desired field (should not occur since it searches for a field with the given name in the class of the object)
+ * @throws IllegalAccessException If the desired field cannot be accessed
+ * @throws NoSuchFieldException If the desired field of the target object cannot be found
+ * @throws SecurityException If the desired field cannot be made accessible
+ * @see #getValue(Object, Class, boolean, String)
+ */
+ public static Object getValue(Object instance, boolean declared, String fieldName) throws IllegalArgumentException, IllegalAccessException, NoSuchFieldException, SecurityException {
+ return getValue(instance, instance.getClass(), declared, fieldName);
+ }
- /**
- * Sets the value of a field of the given class of an object
- *
- * @param instance Target object
- * @param clazz Target class
- * @param declared Whether the desired field is declared or not
- * @param fieldName Name of the desired field
- * @param value New value
- * @throws IllegalArgumentException If the type of the value does not match the type of the desired field
- * @throws IllegalAccessException If the desired field cannot be accessed
- * @throws NoSuchFieldException If the desired field of the target class cannot be found
- * @throws SecurityException If the desired field cannot be made accessible
- * @see #getField(Class, boolean, String)
- */
- public static void setValue(Object instance, Class clazz, boolean declared, String fieldName, Object value) throws IllegalArgumentException, IllegalAccessException, NoSuchFieldException, SecurityException {
- getField(clazz, declared, fieldName).set(instance, value);
- }
+ /**
+ * Sets the value of a field of the given class of an object
+ *
+ * @param instance Target object
+ * @param clazz Target class
+ * @param declared Whether the desired field is declared or not
+ * @param fieldName Name of the desired field
+ * @param value New value
+ * @throws IllegalArgumentException If the type of the value does not match the type of the desired field
+ * @throws IllegalAccessException If the desired field cannot be accessed
+ * @throws NoSuchFieldException If the desired field of the target class cannot be found
+ * @throws SecurityException If the desired field cannot be made accessible
+ * @see #getField(Class, boolean, String)
+ */
+ public static void setValue(Object instance, Class clazz, boolean declared, String fieldName, Object value) throws IllegalArgumentException, IllegalAccessException, NoSuchFieldException, SecurityException {
+ getField(clazz, declared, fieldName).set(instance, value);
+ }
- /**
- * Sets the value of a field of a desired class of an object
- *
- * @param instance Target object
- * @param className Name of the desired target class
- * @param packageType Package where the desired target class is located
- * @param declared Whether the desired field is declared or not
- * @param fieldName Name of the desired field
- * @param value New value
- * @throws IllegalArgumentException If the type of the value does not match the type of the desired field
- * @throws IllegalAccessException If the desired field cannot be accessed
- * @throws NoSuchFieldException If the desired field of the desired class cannot be found
- * @throws SecurityException If the desired field cannot be made accessible
- * @throws ClassNotFoundException If the desired target class with the specified name and package cannot be found
- * @see #setValue(Object, Class, boolean, String, Object)
- */
- public static void setValue(Object instance, String className, PackageType packageType, boolean declared, String fieldName, Object value) throws IllegalArgumentException, IllegalAccessException, NoSuchFieldException, SecurityException, ClassNotFoundException {
- setValue(instance, packageType.getClass(className), declared, fieldName, value);
- }
+ /**
+ * Sets the value of a field of a desired class of an object
+ *
+ * @param instance Target object
+ * @param className Name of the desired target class
+ * @param packageType Package where the desired target class is located
+ * @param declared Whether the desired field is declared or not
+ * @param fieldName Name of the desired field
+ * @param value New value
+ * @throws IllegalArgumentException If the type of the value does not match the type of the desired field
+ * @throws IllegalAccessException If the desired field cannot be accessed
+ * @throws NoSuchFieldException If the desired field of the desired class cannot be found
+ * @throws SecurityException If the desired field cannot be made accessible
+ * @throws ClassNotFoundException If the desired target class with the specified name and package cannot be found
+ * @see #setValue(Object, Class, boolean, String, Object)
+ */
+ public static void setValue(Object instance, String className, PackageType packageType, boolean declared, String fieldName, Object value) throws IllegalArgumentException, IllegalAccessException, NoSuchFieldException, SecurityException, ClassNotFoundException {
+ setValue(instance, packageType.getClass(className), declared, fieldName, value);
+ }
- /**
- * Sets the value of a field with the given name of an object
- *
- * @param instance Target object
- * @param declared Whether the desired field is declared or not
- * @param fieldName Name of the desired field
- * @param value New value
- * @throws IllegalArgumentException If the type of the value does not match the type of the desired field
- * @throws IllegalAccessException If the desired field cannot be accessed
- * @throws NoSuchFieldException If the desired field of the target object cannot be found
- * @throws SecurityException If the desired field cannot be made accessible
- * @see #setValue(Object, Class, boolean, String, Object)
- */
- public static void setValue(Object instance, boolean declared, String fieldName, Object value) throws IllegalArgumentException, IllegalAccessException, NoSuchFieldException, SecurityException {
- setValue(instance, instance.getClass(), declared, fieldName, value);
- }
+ /**
+ * Sets the value of a field with the given name of an object
+ *
+ * @param instance Target object
+ * @param declared Whether the desired field is declared or not
+ * @param fieldName Name of the desired field
+ * @param value New value
+ * @throws IllegalArgumentException If the type of the value does not match the type of the desired field
+ * @throws IllegalAccessException If the desired field cannot be accessed
+ * @throws NoSuchFieldException If the desired field of the target object cannot be found
+ * @throws SecurityException If the desired field cannot be made accessible
+ * @see #setValue(Object, Class, boolean, String, Object)
+ */
+ public static void setValue(Object instance, boolean declared, String fieldName, Object value) throws IllegalArgumentException, IllegalAccessException, NoSuchFieldException, SecurityException {
+ setValue(instance, instance.getClass(), declared, fieldName, value);
+ }
- /**
- * Represents an enumeration of dynamic packages of NMS and CraftBukkit
- *
- * This class is part of the ReflectionUtils and follows the same usage conditions
- *
- * @author DarkBlade12
- * @since 1.0
- */
- public enum PackageType {
- MINECRAFT_SERVER("net.minecraft.server." + getServerVersion()),
- CRAFTBUKKIT("org.bukkit.craftbukkit." + getServerVersion()),
- CRAFTBUKKIT_BLOCK(CRAFTBUKKIT, "block"),
- CRAFTBUKKIT_CHUNKIO(CRAFTBUKKIT, "chunkio"),
- CRAFTBUKKIT_COMMAND(CRAFTBUKKIT, "command"),
- CRAFTBUKKIT_CONVERSATIONS(CRAFTBUKKIT, "conversations"),
- CRAFTBUKKIT_ENCHANTMENS(CRAFTBUKKIT, "enchantments"),
- CRAFTBUKKIT_ENTITY(CRAFTBUKKIT, "entity"),
- CRAFTBUKKIT_EVENT(CRAFTBUKKIT, "event"),
- CRAFTBUKKIT_GENERATOR(CRAFTBUKKIT, "generator"),
- CRAFTBUKKIT_HELP(CRAFTBUKKIT, "help"),
- CRAFTBUKKIT_INVENTORY(CRAFTBUKKIT, "inventory"),
- CRAFTBUKKIT_MAP(CRAFTBUKKIT, "map"),
- CRAFTBUKKIT_METADATA(CRAFTBUKKIT, "metadata"),
- CRAFTBUKKIT_POTION(CRAFTBUKKIT, "potion"),
- CRAFTBUKKIT_PROJECTILES(CRAFTBUKKIT, "projectiles"),
- CRAFTBUKKIT_SCHEDULER(CRAFTBUKKIT, "scheduler"),
- CRAFTBUKKIT_SCOREBOARD(CRAFTBUKKIT, "scoreboard"),
- CRAFTBUKKIT_UPDATER(CRAFTBUKKIT, "updater"),
- CRAFTBUKKIT_UTIL(CRAFTBUKKIT, "util");
+ /**
+ * Represents an enumeration of dynamic packages of NMS and CraftBukkit
+ *
+ * This class is part of the ReflectionUtils and follows the same usage conditions
+ *
+ * @author DarkBlade12
+ * @since 1.0
+ */
+ public enum PackageType {
+ MINECRAFT_SERVER("net.minecraft.server." + getServerVersion()),
+ CRAFTBUKKIT("org.bukkit.craftbukkit." + getServerVersion()),
+ CRAFTBUKKIT_BLOCK(CRAFTBUKKIT, "block"),
+ CRAFTBUKKIT_CHUNKIO(CRAFTBUKKIT, "chunkio"),
+ CRAFTBUKKIT_COMMAND(CRAFTBUKKIT, "command"),
+ CRAFTBUKKIT_CONVERSATIONS(CRAFTBUKKIT, "conversations"),
+ CRAFTBUKKIT_ENCHANTMENS(CRAFTBUKKIT, "enchantments"),
+ CRAFTBUKKIT_ENTITY(CRAFTBUKKIT, "entity"),
+ CRAFTBUKKIT_EVENT(CRAFTBUKKIT, "event"),
+ CRAFTBUKKIT_GENERATOR(CRAFTBUKKIT, "generator"),
+ CRAFTBUKKIT_HELP(CRAFTBUKKIT, "help"),
+ CRAFTBUKKIT_INVENTORY(CRAFTBUKKIT, "inventory"),
+ CRAFTBUKKIT_MAP(CRAFTBUKKIT, "map"),
+ CRAFTBUKKIT_METADATA(CRAFTBUKKIT, "metadata"),
+ CRAFTBUKKIT_POTION(CRAFTBUKKIT, "potion"),
+ CRAFTBUKKIT_PROJECTILES(CRAFTBUKKIT, "projectiles"),
+ CRAFTBUKKIT_SCHEDULER(CRAFTBUKKIT, "scheduler"),
+ CRAFTBUKKIT_SCOREBOARD(CRAFTBUKKIT, "scoreboard"),
+ CRAFTBUKKIT_UPDATER(CRAFTBUKKIT, "updater"),
+ CRAFTBUKKIT_UTIL(CRAFTBUKKIT, "util");
- private final String path;
+ private final String path;
- /**
- * Construct a new package type
- *
- * @param path Path of the package
- */
- PackageType(String path) {
- this.path = path;
- }
+ /**
+ * Construct a new package type
+ *
+ * @param path Path of the package
+ */
+ PackageType(String path) {
+ this.path = path;
+ }
- /**
- * Construct a new package type
- *
- * @param parent Parent package of the package
- * @param path Path of the package
- */
- PackageType(PackageType parent, String path) {
- this(parent + "." + path);
- }
+ /**
+ * Construct a new package type
+ *
+ * @param parent Parent package of the package
+ * @param path Path of the package
+ */
+ PackageType(PackageType parent, String path) {
+ this(parent + "." + path);
+ }
- /**
- * Returns the path of this package type
- *
- * @return The path
- */
- public String getPath() {
- return path;
- }
+ /**
+ * Returns the path of this package type
+ *
+ * @return The path
+ */
+ public String getPath() {
+ return path;
+ }
- /**
- * Returns the class with the given name
- *
- * @param className Name of the desired class
- * @return The class with the specified name
- * @throws ClassNotFoundException If the desired class with the specified name and package cannot be found
- */
- public Class getClass(String className) throws ClassNotFoundException {
- return Class.forName(this + "." + className);
- }
+ /**
+ * Returns the class with the given name
+ *
+ * @param className Name of the desired class
+ * @return The class with the specified name
+ * @throws ClassNotFoundException If the desired class with the specified name and package cannot be found
+ */
+ public Class getClass(String className) throws ClassNotFoundException {
+ return Class.forName(this + "." + className);
+ }
- // Override for convenience
- @Override
- public String toString() {
- return path;
- }
+ // Override for convenience
+ @Override
+ public String toString() {
+ return path;
+ }
- /**
- * Returns the version of your server
- *
- * @return The server version
- */
- public static String getServerVersion() {
- return Bukkit.getServer().getClass().getPackage().getName().substring(23);
- }
- }
+ /**
+ * Returns the version of your server
+ *
+ * @return The server version
+ */
+ public static String getServerVersion() {
+ return Bukkit.getServer().getClass().getPackage().getName().substring(23);
+ }
+ }
- /**
- * Represents an enumeration of Java data types with corresponding classes
- *
- * This class is part of the ReflectionUtils and follows the same usage conditions
- *
- * @author DarkBlade12
- * @since 1.0
- */
- public enum DataType {
- BYTE(byte.class, Byte.class),
- SHORT(short.class, Short.class),
- INTEGER(int.class, Integer.class),
- LONG(long.class, Long.class),
- CHARACTER(char.class, Character.class),
- FLOAT(float.class, Float.class),
- DOUBLE(double.class, Double.class),
- BOOLEAN(boolean.class, Boolean.class);
+ /**
+ * Represents an enumeration of Java data types with corresponding classes
+ *
+ * This class is part of the ReflectionUtils and follows the same usage conditions
+ *
+ * @author DarkBlade12
+ * @since 1.0
+ */
+ public enum DataType {
+ BYTE(byte.class, Byte.class),
+ SHORT(short.class, Short.class),
+ INTEGER(int.class, Integer.class),
+ LONG(long.class, Long.class),
+ CHARACTER(char.class, Character.class),
+ FLOAT(float.class, Float.class),
+ DOUBLE(double.class, Double.class),
+ BOOLEAN(boolean.class, Boolean.class);
- private static final Map, DataType> CLASS_MAP = new HashMap<>();
- private final Class primitive;
- private final Class reference;
+ private static final Map, DataType> CLASS_MAP = new HashMap<>();
+ private final Class primitive;
+ private final Class reference;
- // Initialize map for quick class lookup
- static {
- for (DataType type : values()) {
- CLASS_MAP.put(type.primitive, type);
- CLASS_MAP.put(type.reference, type);
- }
- }
+ // Initialize map for quick class lookup
+ static {
+ for (DataType type : values()) {
+ CLASS_MAP.put(type.primitive, type);
+ CLASS_MAP.put(type.reference, type);
+ }
+ }
- /**
- * Construct a new data type
- *
- * @param primitive Primitive class of this data type
- * @param reference Reference class of this data type
- */
- DataType(Class primitive, Class reference) {
- this.primitive = primitive;
- this.reference = reference;
- }
+ /**
+ * Construct a new data type
+ *
+ * @param primitive Primitive class of this data type
+ * @param reference Reference class of this data type
+ */
+ DataType(Class primitive, Class reference) {
+ this.primitive = primitive;
+ this.reference = reference;
+ }
- /**
- * Returns the primitive class of this data type
- *
- * @return The primitive class
- */
- public Class getPrimitive() {
- return primitive;
- }
+ /**
+ * Returns the primitive class of this data type
+ *
+ * @return The primitive class
+ */
+ public Class getPrimitive() {
+ return primitive;
+ }
- /**
- * Returns the reference class of this data type
- *
- * @return The reference class
- */
- public Class getReference() {
- return reference;
- }
+ /**
+ * Returns the reference class of this data type
+ *
+ * @return The reference class
+ */
+ public Class getReference() {
+ return reference;
+ }
- /**
- * Returns the data type with the given primitive/reference class
- *
- * @param clazz Primitive/Reference class of the data type
- * @return The data type
- */
- public static DataType fromClass(Class clazz) {
- return CLASS_MAP.get(clazz);
- }
+ /**
+ * Returns the data type with the given primitive/reference class
+ *
+ * @param clazz Primitive/Reference class of the data type
+ * @return The data type
+ */
+ public static DataType fromClass(Class clazz) {
+ return CLASS_MAP.get(clazz);
+ }
- /**
- * Returns the primitive class of the data type with the given reference class
- *
- * @param clazz Reference class of the data type
- * @return The primitive class
- */
- public static Class getPrimitive(Class clazz) {
- DataType type = fromClass(clazz);
- return type == null ? clazz : type.getPrimitive();
- }
+ /**
+ * Returns the primitive class of the data type with the given reference class
+ *
+ * @param clazz Reference class of the data type
+ * @return The primitive class
+ */
+ public static Class getPrimitive(Class clazz) {
+ DataType type = fromClass(clazz);
+ return type == null ? clazz : type.getPrimitive();
+ }
- /**
- * Returns the reference class of the data type with the given primitive class
- *
- * @param clazz Primitive class of the data type
- * @return The reference class
- */
- public static Class getReference(Class clazz) {
- DataType type = fromClass(clazz);
- return type == null ? clazz : type.getReference();
- }
+ /**
+ * Returns the reference class of the data type with the given primitive class
+ *
+ * @param clazz Primitive class of the data type
+ * @return The reference class
+ */
+ public static Class getReference(Class clazz) {
+ DataType type = fromClass(clazz);
+ return type == null ? clazz : type.getReference();
+ }
- /**
- * Returns the primitive class array of the given class array
- *
- * @param classes Given class array
- * @return The primitive class array
- */
- public static Class[] getPrimitive(Class[] classes) {
- int length = classes == null ? 0 : classes.length;
- Class[] types = new Class[length];
- for (int index = 0; index < length; index++) {
- types[index] = getPrimitive(classes[index]);
- }
- return types;
- }
+ /**
+ * Returns the primitive class array of the given class array
+ *
+ * @param classes Given class array
+ * @return The primitive class array
+ */
+ public static Class[] getPrimitive(Class[] classes) {
+ int length = classes == null ? 0 : classes.length;
+ Class[] types = new Class[length];
+ for (int index = 0; index < length; index++) {
+ types[index] = getPrimitive(classes[index]);
+ }
+ return types;
+ }
- /**
- * Returns the reference class array of the given class array
- *
- * @param classes Given class array
- * @return The reference class array
- */
- public static Class[] getReference(Class[] classes) {
- int length = classes == null ? 0 : classes.length;
- Class[] types = new Class[length];
- for (int index = 0; index < length; index++) {
- types[index] = getReference(classes[index]);
- }
- return types;
- }
+ /**
+ * Returns the reference class array of the given class array
+ *
+ * @param classes Given class array
+ * @return The reference class array
+ */
+ public static Class[] getReference(Class[] classes) {
+ int length = classes == null ? 0 : classes.length;
+ Class[] types = new Class[length];
+ for (int index = 0; index < length; index++) {
+ types[index] = getReference(classes[index]);
+ }
+ return types;
+ }
- /**
- * Returns the primitive class array of the given object array
- *
- * @return The primitive class array
- */
- public static Class[] getPrimitive(Object[] objects) {
- int length = objects == null ? 0 : objects.length;
- Class[] types = new Class[length];
- for (int index = 0; index < length; index++) {
- types[index] = getPrimitive(objects[index].getClass());
- }
- return types;
- }
+ /**
+ * Returns the primitive class array of the given object array
+ *
+ * @return The primitive class array
+ */
+ public static Class[] getPrimitive(Object[] objects) {
+ int length = objects == null ? 0 : objects.length;
+ Class[] types = new Class[length];
+ for (int index = 0; index < length; index++) {
+ types[index] = getPrimitive(objects[index].getClass());
+ }
+ return types;
+ }
- /**
- * Returns the reference class array of the given object array
- *
- * @return The reference class array
- */
- public static Class[] getReference(Object[] objects) {
- int length = objects == null ? 0 : objects.length;
- Class[] types = new Class[length];
- for (int index = 0; index < length; index++) {
- types[index] = getReference(objects[index].getClass());
- }
- return types;
- }
+ /**
+ * Returns the reference class array of the given object array
+ *
+ * @return The reference class array
+ */
+ public static Class[] getReference(Object[] objects) {
+ int length = objects == null ? 0 : objects.length;
+ Class[] types = new Class[length];
+ for (int index = 0; index < length; index++) {
+ types[index] = getReference(objects[index].getClass());
+ }
+ return types;
+ }
- /**
- * Compares two class arrays on equivalence
- *
- * @param primary Primary class array
- * @param secondary Class array which is compared to the primary array
- * @return Whether these arrays are equal or not
- */
- public static boolean compare(Class[] primary, Class[] secondary) {
- if (primary == null || secondary == null || primary.length != secondary.length) {
- return false;
- }
- for (int index = 0; index < primary.length; index++) {
- Class primaryClass = primary[index];
- Class secondaryClass = secondary[index];
- if (primaryClass.equals(secondaryClass) || primaryClass.isAssignableFrom(secondaryClass)) {
- continue;
- }
- return false;
- }
- return true;
- }
- }
+ /**
+ * Compares two class arrays on equivalence
+ *
+ * @param primary Primary class array
+ * @param secondary Class array which is compared to the primary array
+ * @return Whether these arrays are equal or not
+ */
+ public static boolean compare(Class[] primary, Class[] secondary) {
+ if (primary == null || secondary == null || primary.length != secondary.length) {
+ return false;
+ }
+ for (int index = 0; index < primary.length; index++) {
+ Class primaryClass = primary[index];
+ Class secondaryClass = secondary[index];
+ if (primaryClass.equals(secondaryClass) || primaryClass.isAssignableFrom(secondaryClass)) {
+ continue;
+ }
+ return false;
+ }
+ return true;
+ }
+ }
}
\ No newline at end of file
diff --git a/src/main/java/me/skymc/taboolib/mysql/builder/SQLColumn.java b/src/main/java/me/skymc/taboolib/mysql/builder/SQLColumn.java
index cf7ce3f..dd6463f 100644
--- a/src/main/java/me/skymc/taboolib/mysql/builder/SQLColumn.java
+++ b/src/main/java/me/skymc/taboolib/mysql/builder/SQLColumn.java
@@ -22,7 +22,7 @@ public class SQLColumn {
private SQLColumnOption[] columnOptions;
/**
- * 文本类型常用构造器
+ * 文本 类型常用构造器
* new SQLColumn(SQLColumnType.TEXT, "username");
*/
public SQLColumn(SQLColumnType columnType, String columnName) {
@@ -30,7 +30,17 @@ public class SQLColumn {
}
/**
- * 主键类型常用构造器
+ * CHAR 类型常用构造器
+ *
+ * @param columnType
+ * @param columnName
+ */
+ public SQLColumn(SQLColumnType columnType, int m, String columnName) {
+ this(columnType, m, 0, columnName, null);
+ }
+
+ /**
+ * 主键 类型常用构造器
* new SQLColumn(SQLColumnType.TEXT, "username", SQLColumnOption.PRIMARY_KEY, SQLColumnOption.AUTO_INCREMENT);
*/
public SQLColumn(SQLColumnType columnType, String columnName, SQLColumnOption... columnOptions) {
@@ -38,7 +48,7 @@ public class SQLColumn {
}
/**
- * 数据类型常用构造器
+ * 数据 类型常用构造器
* new SQLColumn(SQLColumnType.TEXT, "player_group", "PLAYER");
*/
public SQLColumn(SQLColumnType columnType, String columnName, Object defaultValue) {
@@ -99,25 +109,25 @@ public class SQLColumn {
for (SQLColumnOption options : columnOptions) {
switch (options) {
case NOTNULL:
- builder.append(" not null");
+ builder.append(" NOT NULL");
break;
case PRIMARY_KEY:
- builder.append(" primary key");
+ builder.append(" PRIMARY KEY");
break;
case AUTO_INCREMENT:
- builder.append(" auto_increment");
+ builder.append(" AUTO_INCREMENT");
break;
case UNIQUE_KEY:
- builder.append(" unique key");
+ builder.append(" UNIQUE KEY");
break;
default:
}
}
if (defaultValue != null) {
if (defaultValue instanceof String) {
- builder.append(" default '").append(defaultValue).append("'");
+ builder.append(" DEFAULT '").append(defaultValue).append("'");
} else {
- builder.append(" default ").append(defaultValue);
+ builder.append(" DEFAULT ").append(defaultValue);
}
}
return builder.toString();
diff --git a/src/main/java/me/skymc/taboolib/mysql/builder/SQLExample.java b/src/main/java/me/skymc/taboolib/mysql/builder/SQLExample.java
deleted file mode 100644
index e6dc79a..0000000
--- a/src/main/java/me/skymc/taboolib/mysql/builder/SQLExample.java
+++ /dev/null
@@ -1,31 +0,0 @@
-package me.skymc.taboolib.mysql.builder;
-
-import com.zaxxer.hikari.HikariDataSource;
-import org.bukkit.plugin.java.JavaPlugin;
-
-/**
- * @Author sky
- * @Since 2018-07-02 23:43
- */
-public class SQLExample extends JavaPlugin {
-
- private SQLHost sqlHost;
- private SQLTable sqlTable;
- private HikariDataSource dataSource;
-
- @Override
- public void onEnable() {
- int value = sqlTable.executeQuery("select * from table where username = ?")
- .dataSource(dataSource)
- .statement(statement -> statement.setString(1, "BlackSKY"))
- .resultNext(result -> result.getInt("value"))
- .run(0, 0);
-
- sqlTable.executeUpdate("statement table set value = ? where username = ?")
- .dataSource(dataSource)
- .statement(statement -> {
- statement.setInt(1, 999);
- statement.setString(2, "BlackSKY");
- }).run();
- }
-}
diff --git a/src/main/java/me/skymc/taboolib/mysql/builder/SQLHost.java b/src/main/java/me/skymc/taboolib/mysql/builder/SQLHost.java
index 13e9c15..a0195bb 100644
--- a/src/main/java/me/skymc/taboolib/mysql/builder/SQLHost.java
+++ b/src/main/java/me/skymc/taboolib/mysql/builder/SQLHost.java
@@ -4,7 +4,6 @@ import com.ilummc.tlib.util.Strings;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.plugin.Plugin;
-import java.text.MessageFormat;
import java.util.Objects;
/**
@@ -19,18 +18,28 @@ public class SQLHost {
private String password;
private String database;
private Plugin plugin;
+ private boolean autoClose;
public SQLHost(ConfigurationSection section, Plugin plugin) {
+ this(section, plugin, false);
+ }
+
+ public SQLHost(ConfigurationSection section, Plugin plugin, boolean autoClose) {
this(section.getString("host", "localhost"), section.getString("user", "root"), section.getString("port", "3306"), section.getString("password", ""), section.getString("database", "test"), plugin);
}
public SQLHost(String host, String user, String port, String password, String database, Plugin plugin) {
+ this(host, user, port, password, database, plugin, false);
+ }
+
+ public SQLHost(String host, String user, String port, String password, String database, Plugin plugin, boolean autoClose) {
this.host = host;
this.user = user;
this.port = port;
this.password = password;
this.database = database;
this.plugin = plugin;
+ this.autoClose = false;
}
public String getHost() {
@@ -57,6 +66,10 @@ public class SQLHost {
return plugin;
}
+ public boolean isAutoClose() {
+ return autoClose;
+ }
+
public String getConnectionUrl() {
return Strings.replaceWithOrder("jdbc:mysql://{0}:{1}/{2}?characterEncoding=utf-8&useSSL=false", this.host, this.port, this.database);
}
@@ -74,16 +87,18 @@ public class SQLHost {
return false;
}
SQLHost sqlHost = (SQLHost) o;
- return Objects.equals(getHost(), sqlHost.getHost()) &&
+ return autoClose == sqlHost.autoClose &&
+ Objects.equals(getHost(), sqlHost.getHost()) &&
Objects.equals(getUser(), sqlHost.getUser()) &&
Objects.equals(getPort(), sqlHost.getPort()) &&
Objects.equals(getPassword(), sqlHost.getPassword()) &&
- Objects.equals(getDatabase(), sqlHost.getDatabase());
+ Objects.equals(getDatabase(), sqlHost.getDatabase()) &&
+ Objects.equals(getPlugin(), sqlHost.getPlugin());
}
@Override
public int hashCode() {
- return Objects.hash(getHost(), getUser(), getPort(), getPassword(), getDatabase());
+ return Objects.hash(getHost(), getUser(), getPort(), getPassword(), getDatabase(), getPlugin(), autoClose);
}
@Override
@@ -95,6 +110,7 @@ public class SQLHost {
", password='" + password + '\'' +
", database='" + database + '\'' +
", plugin=" + plugin +
+ ", autoClose=" + autoClose +
'}';
}
}
diff --git a/src/main/java/me/skymc/taboolib/mysql/builder/SQLTable.java b/src/main/java/me/skymc/taboolib/mysql/builder/SQLTable.java
index ed2e5f5..d61e5fd 100644
--- a/src/main/java/me/skymc/taboolib/mysql/builder/SQLTable.java
+++ b/src/main/java/me/skymc/taboolib/mysql/builder/SQLTable.java
@@ -26,11 +26,7 @@ public class SQLTable {
}
public SQLTable addColumn(SQLColumn sqlColumn) {
- if (columns == null) {
- columns = new SQLColumn[] {sqlColumn};
- } else {
- columns = ArrayUtils.arrayAppend(columns, sqlColumn);
- }
+ columns = columns == null ? new SQLColumn[] {sqlColumn} : ArrayUtils.arrayAppend(columns, sqlColumn);
return this;
}
@@ -52,6 +48,22 @@ public class SQLTable {
return Strings.replaceWithOrder("truncate table `{0}`", tableName);
}
+ public RunnableUpdate executeInsert(String values) {
+ return executeUpdate("insert into " + tableName + " values(" + values + ")");
+ }
+
+ public RunnableQuery executeSelect(String where) {
+ return executeQuery("select * from " + tableName + " where " + where);
+ }
+
+ public RunnableQuery executeSelect() {
+ return executeQuery("select * from " + tableName);
+ }
+
+ public RunnableUpdate executeUpdate(String update, String where) {
+ return executeUpdate("update " + tableName + " set " + update + " where " + where);
+ }
+
public RunnableUpdate executeUpdate(String query) {
return new RunnableUpdate(query);
}
diff --git a/src/main/java/me/skymc/taboolib/mysql/hikari/HikariHandler.java b/src/main/java/me/skymc/taboolib/mysql/hikari/HikariHandler.java
index 410c3f5..a422313 100644
--- a/src/main/java/me/skymc/taboolib/mysql/hikari/HikariHandler.java
+++ b/src/main/java/me/skymc/taboolib/mysql/hikari/HikariHandler.java
@@ -6,10 +6,8 @@ import com.zaxxer.hikari.HikariConfig;
import com.zaxxer.hikari.HikariDataSource;
import me.skymc.taboolib.Main;
import me.skymc.taboolib.fileutils.ConfigUtils;
-import me.skymc.taboolib.fileutils.FileUtils;
import me.skymc.taboolib.mysql.builder.SQLHost;
import org.bukkit.configuration.file.FileConfiguration;
-import org.bukkit.configuration.file.YamlConfiguration;
import javax.sql.DataSource;
import java.util.concurrent.ConcurrentHashMap;
@@ -91,4 +89,18 @@ public class HikariHandler {
}
return config;
}
+
+ // *********************************
+ //
+ // Getter and Setter
+ //
+ // *********************************
+
+ public static ConcurrentHashMap getDataSource() {
+ return dataSource;
+ }
+
+ public static FileConfiguration getSettings() {
+ return settings;
+ }
}
diff --git a/src/main/java/me/skymc/taboolib/object/Instantiable.java b/src/main/java/me/skymc/taboolib/object/Instantiable.java
new file mode 100644
index 0000000..fb7e32e
--- /dev/null
+++ b/src/main/java/me/skymc/taboolib/object/Instantiable.java
@@ -0,0 +1,18 @@
+package me.skymc.taboolib.object;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * @Author sky
+ * @Since 2018-08-27 10:04
+ */
+@Target(ElementType.TYPE)
+@Retention(RetentionPolicy.RUNTIME)
+public @interface Instantiable {
+
+ String value();
+
+}
diff --git a/src/main/java/me/skymc/taboolib/object/InstantiableLoader.java b/src/main/java/me/skymc/taboolib/object/InstantiableLoader.java
new file mode 100644
index 0000000..45e7c0d
--- /dev/null
+++ b/src/main/java/me/skymc/taboolib/object/InstantiableLoader.java
@@ -0,0 +1,82 @@
+package me.skymc.taboolib.object;
+
+import com.ilummc.tlib.util.Ref;
+import me.skymc.taboolib.TabooLibLoader;
+import me.skymc.taboolib.listener.TListener;
+import me.skymc.taboolib.methods.ReflectionUtils;
+import org.bukkit.Bukkit;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.server.PluginDisableEvent;
+import org.bukkit.event.server.PluginEnableEvent;
+import org.bukkit.plugin.Plugin;
+
+import java.util.Optional;
+import java.util.concurrent.ConcurrentHashMap;
+
+/**
+ * @Author sky
+ * @Since 2018-08-27 10:04
+ */
+@TListener
+public class InstantiableLoader implements Listener {
+
+ private static ConcurrentHashMap instance = new ConcurrentHashMap<>();
+
+ public InstantiableLoader() {
+ loadInstantiable();
+ }
+
+ @EventHandler
+ public void onEnable(PluginEnableEvent e) {
+ loadInstantiable(e.getPlugin());
+ }
+
+ @EventHandler
+ public void onDisable(PluginDisableEvent e) {
+ clear(e.getPlugin());
+ }
+
+ public static void clear(Plugin plugin) {
+ instance.entrySet().stream().filter(entry -> Ref.getCallerPlugin(entry.getValue().getClass()).equals(plugin)).forEach(entry -> instance.remove(entry.getKey()));
+ }
+
+ public static void loadInstantiable() {
+ for (Plugin plugin : Bukkit.getPluginManager().getPlugins()) {
+ try {
+ loadInstantiable(plugin);
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+ }
+
+ public static void loadInstantiable(Plugin plugin) {
+ TabooLibLoader.getPluginClasses(plugin).ifPresent(classes -> {
+ for (Class pluginClass : classes) {
+ if (pluginClass.isAnnotationPresent(Instantiable.class)) {
+ Instantiable instantiable = (Instantiable) pluginClass.getAnnotation(Instantiable.class);
+ try {
+ instance.put(instantiable.value(), ReflectionUtils.instantiateObject(pluginClass));
+ } catch (Exception e) {
+ e.printStackTrace();
+ }
+ }
+ }
+ });
+ }
+
+ // *********************************
+ //
+ // Getter and Setter
+ //
+ // *********************************
+
+ public static ConcurrentHashMap getInstance() {
+ return instance;
+ }
+
+ public static Optional