因为hibernate枚举类型实在配置繁琐,所以直接用枚举换掉,以下是方法:
首先要2个工具类:
import java.beans.Introspector;
import java.lang.reflect.Array;
import java.lang.reflect.Constructor;
import java.lang.reflect.Field;
import java.lang.reflect.Member;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.HashSet;
import java.util.Set;
import java.util.logging.Logger;
import org.apache.commons.lang.ArrayUtils;
/**
*
* 反射的工具类
*
*
*/
public abstract class ClassUtils {
private static Logger logger = Logger.getLogger(ClassUtils.class.getName());
public ClassUtils() {
}
/**
* 通过类加载机制返回类对象
*
* @param name
* @param classLoader
* @return
* @throws ClassNotFoundException
*/
@SuppressWarnings("unchecked")
public static Class forName(String name, ClassLoader classLoader)
throws ClassNotFoundException {
Class clazz = resolvePrimitiveClassName(name);
if (clazz != null)
return clazz;
if (name.endsWith("[]")) {
String elementClassName = name.substring(0, name.length()
- "[]".length());
Class elementClass = forName(elementClassName, classLoader);
return Array.newInstance(elementClass, 0).getClass();
} else {
return Class.forName(name, true, classLoader);
}
}
/**
* 解析原始数据类型
*
* @param name
* @return
*/
@SuppressWarnings("unchecked")
public static Class resolvePrimitiveClassName(String name) {
if (name.length() <= 8) {
for (int i = 0; i < PRIMITIVE_CLASSES.length; i++) {
Class clazz = PRIMITIVE_CLASSES[i];
if (clazz.getName().equals(name))
return clazz;
}
}
return null;
}
/**
*
* @param clazz
* @return
*/
@SuppressWarnings("unchecked")
public static String getShortNameAsProperty(Class clazz) {
return Introspector.decapitalize(getShortName(clazz));
}
public static String getShortNameForField(Field field) {
return Introspector.decapitalize(field.getName());
}
/**
* 获取方法的名称
*
* @param method
* @return
*/
public static String getShortNameForMethod(Method method) {
String name = method.getName();
if (name.startsWith("is"))
name = name.substring("is".length());
else if (name.startsWith("get"))
name = name.substring("get".length());
else
throw new IllegalArgumentException((new StringBuilder()).append(
"Method [").append(method.getName()).append(
"] is not formed as a JavaBean property").toString());
return Introspector.decapitalize(name);
}
/**
* 获取一个类的ShortName 如:com.easyway.A 返回 A
*
* @param clazz
* @return
*/
@SuppressWarnings("unchecked")
public static String getShortName(Class clazz) {
return getShortName(clazz.getName());
}
/**
* 判断一个类是否为内部类并获取一个类的ShortName
*
* @param className
* @return
*/
public static String getShortName(String className) {
int lastDotIndex = className.lastIndexOf('.');
int nameEndIndex = className.indexOf("$$");
if (nameEndIndex == -1)
nameEndIndex = className.length();
String shortName = className.substring(lastDotIndex + 1, nameEndIndex);
shortName = shortName.replace('$', '.');
return shortName;
}
/**
* 获取一个方法所在类的全名
*
* @param method
* 方法名称
* @return
*/
public static String getQualifiedMethodName(Method method) {
return (new StringBuilder()).append(
method.getDeclaringClass().getName()).append(".").append(
method.getName()).toString();
}
/**
* 根据类,方法名称和参数查找方法
*
* @param clazz
* 类名
* @param methodName
* 方法名称
* @param paramTypes
* 参数类型
* @return
*/
@SuppressWarnings("unchecked")
public static boolean hasMethod(Class clazz, String methodName,
Class paramTypes[]) {
try {
clazz.getMethod(methodName, paramTypes);
return true;
} catch (NoSuchMethodException ex) {
return false;
}
}
/**
* 根据类和方法名返回方法的个数
*
* @param clazz
* @param methodName
* @return
*/
@SuppressWarnings("unchecked")
public static int getMethodCountForName(Class clazz, String methodName) {
int count = 0;
do {
for (int i = 0; i < clazz.getDeclaredMethods().length; i++) {
Method method = clazz.getDeclaredMethods()[i];
if (methodName.equals(method.getName()))
count++;
}
clazz = clazz.getSuperclass();
} while (clazz != null);
return count;
}
/**
*
* @param clazz
* @param methodName
* @return
*/
@SuppressWarnings("unchecked")
public static boolean hasAtLeastOneMethodWithName(Class clazz,
String methodName) {
do {
for (int i = 0; i < clazz.getDeclaredMethods().length; i++) {
Method method = clazz.getDeclaredMethods()[i];
if (methodName.equals(method.getName()))
return true;
}
clazz = clazz.getSuperclass();
} while (clazz != null);
return false;
}
/**
* 获取静态的方法的
*
* @param clazz
* @param methodName
* @param args
* @return
*/
@SuppressWarnings("unchecked")
public static Method getStaticMethod(Class clazz, String methodName,
Class args[]) {
try {
Method method = clazz.getDeclaredMethod(methodName, args);
if ((method.getModifiers() & Modifier.STATIC) != 0)
return method;
} catch (NoSuchMethodException ex) {
}
return null;
}
@SuppressWarnings("unchecked")
public static String addResourcePathToPackagePath(Class clazz,
String resourceName) {
if (!resourceName.startsWith("/"))
return (new StringBuilder()).append(
classPackageAsResourcePath(clazz)).append("/").append(
resourceName).toString();
else
return (new StringBuilder()).append(
classPackageAsResourcePath(clazz)).append(resourceName)
.toString();
}
@SuppressWarnings("unchecked")
public static String classPackageAsResourcePath(Class clazz) {
if (clazz == null || clazz.getPackage() == null)
return "";
else
return clazz.getPackage().getName().replace('.', '/');
}
/**
* 根据对象获取所有的接口
*
* @param object
* @return
*/
@SuppressWarnings("unchecked")
public static Class[] getAllInterfaces(Object object) {
Set interfaces = getAllInterfacesAsSet(object);
return (Class[]) (Class[]) interfaces.toArray(new Class[interfaces
.size()]);
}
/**
* 根据类获取所有的接口
*
* @param clazz
* @return
*/
@SuppressWarnings("unchecked")
public static Class[] getAllInterfacesForClass(Class clazz) {
Set interfaces = getAllInterfacesForClassAsSet(clazz);
return (Class[]) (Class[]) interfaces.toArray(new Class[interfaces
.size()]);
}
/**
* 根据对象获取所有的接口
*
* @param object
* @return
*/
@SuppressWarnings("unchecked")
public static Set getAllInterfacesAsSet(Object object) {
return getAllInterfacesForClassAsSet(object.getClass());
}
/**
* 根据类获取所有的接口
*
* @param clazz
* @return
*/
@SuppressWarnings("unchecked")
public static Set getAllInterfacesForClassAsSet(Class clazz) {
Set interfaces = new HashSet();
for (; clazz != null; clazz = clazz.getSuperclass()) {
for (int i = 0; i < clazz.getInterfaces().length; i++) {
Class ifc = clazz.getInterfaces()[i];
interfaces.add(ifc);
}
}
return interfaces;
}
/**
* 检测一个方法或者一个属性是否为Public 修饰
*
* @param object
* @return
*/
@SuppressWarnings("unchecked")
public static boolean isPublic(Class clazz, Member member) {
return Modifier.isPublic(member.getModifiers())
&& Modifier.isPublic(clazz.getModifiers());
}
/**
* 检测一个Class是否为Abstract 修饰
*
* @param object
* @return
*/
@SuppressWarnings("unchecked")
public static boolean isAbstractClass(Class clazz) {
int modifier = clazz.getModifiers();
return Modifier.isAbstract(modifier) || Modifier.isInterface(modifier);
}
/**
* 根据一个类获取一个默认的无参数的构造函数
*
* @param object
* @return
*/
@SuppressWarnings("unchecked")
public static Constructor getDefaultConstructor(Class clazz) {
if (isAbstractClass(clazz))
return null;
try {
Constructor constructor = clazz
.getDeclaredConstructor(EMPTY_CLASS_ARRAY);
if (!isPublic(clazz, constructor))
constructor.setAccessible(true);
return constructor;
} catch (NoSuchMethodException nme) {
return null;
}
}
/**
* 根据一个类和对应输入参数,获取一个对应参数的构造函数
*
* @param object
* @return
*/
@SuppressWarnings("unchecked")
public static Constructor getConstructor(Class clazz,
Class parameterTypes[]) {
if (isAbstractClass(clazz))
return null;
try {
Constructor constructor = clazz.getConstructor(parameterTypes);
if (!isPublic(clazz, constructor))
constructor.setAccessible(true);
return constructor;
} catch (NoSuchMethodException nme) {
return null;
}
}
/**
* 将一个完整的类名装换为资源名称路径
*
* @param resourcePath
* @return
*/
public static String convertResourcePathToClassName(String resourcePath) {
return resourcePath.replace('/', '.');
}
public static String convertClassNameToResourcePath(String className) {
return className.replace('.', '/');
}
/**
* 获取一个对象的属性
*
* @param <T>
* @param object
* @param propertyName
* @return
* @throws NoSuchFieldException
*/
@SuppressWarnings("unchecked")
public static <T> T getDeclaredFieldValue(Object object, String propertyName)
throws NoSuchFieldException {
Field field = getDeclaredField(object.getClass(), propertyName);
boolean accessible = field.isAccessible();
Object result = null;
synchronized (field) {
field.setAccessible(true);
try {
result = field.get(object);
} catch (IllegalAccessException e) {
throw new NoSuchFieldException("No such field: "
+ object.getClass() + '.' + propertyName);
} finally {
field.setAccessible(accessible);
}
}
return (T) result;
}
/**
* 查找对应类的属性字段
*
* @param clazz
* @param propertyName
* @return
* @throws NoSuchFieldException
*/
public static Field getDeclaredField(Class<?> clazz, String propertyName)
throws NoSuchFieldException {
for (Class<?> superClass = clazz; superClass != Object.class; superClass = superClass
.getSuperclass()) {
try {
return superClass.getDeclaredField(propertyName);
} catch (NoSuchFieldException e) {
// Field不在当前类定义,继续向上转型
e.printStackTrace();
}
}
throw new NoSuchFieldException("No such field: " + clazz.getName()
+ '.' + propertyName);
}
/**
* 获取一个类的所有的属性
*
* @param clazz
* @return
*/
public static Field[] getDeclaredFields(Class<?> clazz) {
Field[] fields = clazz.getDeclaredFields();
for (Class<?> superClass = clazz; superClass != Object.class; superClass = superClass
.getSuperclass()) {
fields = (Field[]) ArrayUtils.addAll(fields, superClass
.getDeclaredFields());
}
return fields;
}
public static final String ARRAY_SUFFIX = "[]";
private static Class PRIMITIVE_CLASSES[];
private static final Class EMPTY_CLASS_ARRAY[] = new Class[0];
static {
PRIMITIVE_CLASSES = (new Class[] { Boolean.TYPE, Byte.TYPE,
Character.TYPE, Short.TYPE, Integer.TYPE, Long.TYPE,
Float.TYPE, Double.TYPE });
}
}
import org.apache.commons.lang.ObjectUtils;
/**
*
* 枚举工具类
*/
public abstract class EnumUtils {
public synchronized static <T extends Enum<T>> T getEnumFromValue(Class<T> enumClass,Object value){
return fromEnumProperty(enumClass, "value", value);
}
/**
* 从指定的枚举类中根据property搜寻匹配指定值的枚举实例
*
* @param <T>
* @param enumClass
* @param property
* @param propValue
* @return
*/
private static <T extends Enum<T>> T fromEnumProperty(Class<T> enumClass,
String property, Object propValue) {
T[] enumConstants = enumClass.getEnumConstants();
for (T t : enumConstants) {
Object constantPropValue;
try {
constantPropValue = ClassUtils.getDeclaredFieldValue(t,
property);
if (ObjectUtils.equals(constantPropValue, propValue)) {
return t;
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
return null;
}
/**
* 从指定的枚举类中根据名称匹配指定值
*
* @param <T>
* @param enumClass
* @param constantName
* @return
*/
private static <T extends Enum<T>> T fromEnumConstantName(
Class<T> enumClass, String constantName) {
T[] enumConstants = enumClass.getEnumConstants();
for (T t : enumConstants) {
if (((Enum<?>) t).name().equals(constantName)) {
return t;
}
}
return null;
}
}
然后一个测试枚举:
public enum SexEnum {
外星人(0) , 男(1) , 女(2);
private int value;
SexEnum(final int value){
this.value = value;
}
public int getValue() {
return value;
}
public String getName(){
return this.name();
}
}
测试类:
import junit.framework.TestCase;
import com.myweb.util.EnumUtils;
public class MainTest extends TestCase{
public void testEnum() throws Exception{
SexEnum sexEnum = EnumUtils.getEnumFromValue(SexEnum.class,1);
System.out.println(sexEnum.name());
System.out.println(sexEnum.getName());
System.out.println(SexEnum.男.getValue());
System.out.println(SexEnum.valueOf("男").getValue());
}
}
最后如何运用到hibernate呢?只需要如下改动hibernate即可:
改动方式以前的POJO中sex的get方法:
public int getSex(
return this.sex;
)
现在改为:
public SexEnum getSex(){
return EnumUtils.getEnumFromValue(SexEnum.class,this.sex);
}
页面获取为:
${sex.name}和${sex.value}