1.
package common;
import java.lang.reflect.Method;
import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.UUID;
import model.BaseEntity;
public abstract class FillFields {
private static String id = null;
private static Integer deleteFlag = null;
private static Date date = null;
private static final Integer DELETE_FLAG_1 = new Integer(1);
private static final Integer DELETE_FLAG_0 = new Integer(0);
public static <T extends BaseEntity> T fillCreateFields(T t, String user) {
id = UUID.randomUUID().toString();
deleteFlag = DELETE_FLAG_0;
date = new Date();
fillId(t);
fillDeleteFlag(t);
fillCreateDate(t);
fillCreator(t, user);
fillUpdateDate(t);
fillUpdater(t, user);
fillOptimisticLock(t);
return t;
}
public static <T extends BaseEntity> T fillUpdateFields(T t, String user) {
date = new Date();
fillUpdateDate(t);
fillUpdater(t, user);
fillOptimisticLock(t);
return t;
}
public static <T extends BaseEntity> T fillDeleteFields(T t, String user) {
deleteFlag = DELETE_FLAG_1;
date = new Date();
fillDeleteFlag(t);
fillUpdateDate(t);
fillUpdater(t, user);
fillOptimisticLock(t);
return t;
}
public static <T extends BaseEntity> T fillCancelDeleteFields(T t, String user) {
deleteFlag = DELETE_FLAG_0;
date = new Date();
fillDeleteFlag(t);
fillUpdateDate(t);
fillUpdater(t, user);
fillOptimisticLock(t);
return t;
}
public static <T extends BaseEntity> T fillOptimisticLockFields(T t) {
date = new Date();
fillOptimisticLock(t);
return t;
}
private static <T extends BaseEntity> T fillField(T t, String methodName, Class<?> fieldClass,
Object value) {
try {
Class<?> clazz = t.getClass();
Method method = clazz.getMethod(methodName, fieldClass);
method.invoke(t, value);
return t;
} catch (Exception e) {
throw new RuntimeException(e);
}
}
private static <T extends BaseEntity> T fillId(T t) throws RuntimeException {
t = fillField(t, "setId", String.class, id);
return t;
}
private static <T extends BaseEntity> T fillDeleteFlag(T t) {
t = fillField(t, "setDeleteFlag", Integer.class, deleteFlag);
return t;
}
private static <T extends BaseEntity> T fillCreateDate(T t) {
t = fillField(t, "setCreateTime", Date.class, date);
return t;
}
private static <T extends BaseEntity> T fillCreator(T t, String user) {
t = fillField(t, "setCreator", String.class, user);
return t;
}
private static <T extends BaseEntity> T fillUpdateDate(T t) {
t = fillField(t, "setUpdateTime", Date.class, date);
return t;
}
private static <T extends BaseEntity> T fillUpdater(T t, String user) {
t = fillField(t, "setUpdater", String.class, user);
return t;
}
private static <T extends BaseEntity> T fillOptimisticLock(T t) {
SimpleDateFormat df = new SimpleDateFormat("yyyyMMddHHmmssSSS");
df.format(date);
t = fillField(t, "setOptimisticLock", String.class, df.format(date));
return t;
}
}
2.
package common;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import javax.persistence.Column;
import javax.servlet.http.HttpServletRequest;
import org.apache.commons.lang.StringUtils;
import org.codehaus.jackson.JsonFactory;
import org.codehaus.jackson.JsonParser;
import org.codehaus.jackson.JsonToken;
import org.codehaus.jackson.map.ObjectMapper;
import org.hibernate.criterion.Criterion;
import org.hibernate.criterion.MatchMode;
import org.hibernate.criterion.Order;
import org.hibernate.criterion.Restrictions;
import entity.Condition;
import entity.Conditions;
import entity.Page;
import entity.Sort;
public class Building {
public static Page page(HttpServletRequest request) {
int start = Integer.parseInt(request.getParameter("start"));
int limit = Integer.parseInt(request.getParameter("limit"));
Page page = new Page(start, limit);
return page;
}
public static List<Order> sortOne(HttpServletRequest request) {
Map<String, String> orderMap = getOrder(request);
List<Order> orderList = null;
if (orderMap != null) {
orderList = new ArrayList<Order>();
if (orderMap.get("direction").equalsIgnoreCase("asc")) {
orderList.add(Order.asc(orderMap.get("property")));
} else if (orderMap.get("direction").equalsIgnoreCase("desc")) {
orderList.add(Order.desc(orderMap.get("property")));
} else {
orderList = null;
}
}
return orderList;
}
public static Map<String, String> getOrder(HttpServletRequest request) {
Map<String, String> orderMap = null;
try {
String sortStr = request.getParameter("sort");
if (sortStr != null) {
ObjectMapper objectMapper = new ObjectMapper();
Sort sort = objectMapper.readValue(sortStr.replaceAll("\\[", "").replaceAll("\\]", ""), Sort.class);
String property = sort.getProperty() != null ? sort.getProperty().trim() : "";
String direction = sort.getDirection() != null ? sort.getDirection().trim() : "";
if (!property.equals("")) {
orderMap = new HashMap<String, String>();
if (direction.equals("") || direction.equalsIgnoreCase("asc")) {
orderMap.put("property", property);
orderMap.put("direction", "asc");
} else if (direction.equalsIgnoreCase("desc")) {
orderMap.put("property", property);
orderMap.put("direction", "desc");
} else {
orderMap = null;
}
}
return orderMap;
} else {
return null;
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public static <T> T entity(HttpServletRequest request, Class<T> clazz, String parameter) {
try {
String parameterStr = request.getParameter(parameter);
if (parameterStr != null && !parameterStr.equals("") && !parameterStr.equals("{}")) {
ObjectMapper objectMapper = new ObjectMapper();
T t = objectMapper.readValue(parameterStr, clazz);
return t;
} else {
return null;
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public static <T> List<T> entityList(String parameterStr, Class<T> clazz) {
try {
if (parameterStr != null && !parameterStr.equals("") && !parameterStr.equals("[]")) {
List<T> list = null;
ObjectMapper objectMapper = new ObjectMapper();
list = new ArrayList<T>();
JsonFactory f = new JsonFactory();
JsonParser jp = f.createJsonParser(parameterStr);
jp.nextToken();
while (jp.nextToken() == JsonToken.START_OBJECT) {
T t = objectMapper.readValue(jp, clazz);
list.add(t);
}
return list;
} else {
return null;
}
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public static List<Criterion> criterionList(HttpServletRequest request, Object obj) {
List<Criterion> criterionList = null;
try {
String parameterStr = request.getParameter("queryConditions");
List<Conditions> list = entityList(parameterStr, Conditions.class);
if (list != null) {
criterionList = new ArrayList<Criterion>();
Iterator<Conditions> it = list.iterator();
while (it.hasNext()) {
Conditions conds = it.next();
Condition cond = new Condition(conds.getCondition());
String propertyName = cond.getPropertyName();
Object value = buildGetMethod(obj, cond.getValueProperty()).invoke(obj, new Object[0]);
MatchMode matchMode = null;
if (cond.getType().equalsIgnoreCase("like") || cond.getType().equalsIgnoreCase("ilike")) {
if (cond.getLikeType() != null) {
if (cond.getLikeType().equalsIgnoreCase("left")) {
matchMode = MatchMode.START;
} else if (cond.getLikeType().equalsIgnoreCase("right")) {
matchMode = MatchMode.END;
} else {
matchMode = MatchMode.ANYWHERE;
}
} else {
matchMode = MatchMode.ANYWHERE;
}
if (cond.getType().equalsIgnoreCase("like")) {
criterionList.add(Restrictions.like(propertyName, value.toString(), matchMode));
} else {
criterionList.add(Restrictions.ilike(propertyName, value.toString(), matchMode));
}
} else if (cond.getType().equalsIgnoreCase("between")) {
Object betweenValue = buildGetMethod(obj, cond.getBetweenProperty()).invoke(obj, new Object[0]);
criterionList.add(Restrictions.between(propertyName, value, betweenValue));
} else {
criterionList.add(Restrictions.eq(propertyName, value));
}
}
}
return criterionList;
} catch (Exception e) {
throw new RuntimeException(e);
}
}
public static String buildGetMethodName(String propertyName) {
return "get" + StringUtils.capitalize(propertyName);
}
public static String buildGetMethodField(String methodName) {
return StringUtils.uncapitalize(methodName.substring(3));
}
public static <T> Method buildGetMethod(T entity, String propertyName) throws SecurityException, NoSuchMethodException {
String get = buildGetMethodName(propertyName);
Method getMethod = entity.getClass().getMethod(get, new Class[0]);
return getMethod;
}
public static Map<String, Object> buildParameters(HttpServletRequest request, Object entity, Page page) {
Map<String, Object> paramMap = new HashMap<String, Object>();
Map<String, String> orderMap = getOrder(request);
try {
String parameterStr = request.getParameter("queryConditions");
List<Conditions> list = entityList(parameterStr, Conditions.class);
if (list != null) {
Iterator<Conditions> it = list.iterator();
while (it.hasNext()) {
Conditions conds = it.next();
Condition cond = new Condition(conds.getCondition());
Method getMethod = buildGetMethod(entity, cond.getValueProperty());
Object value = getMethod.invoke(entity, new Object[0]);
String columnName = getMethod.getAnnotation(Column.class).name();
if (cond.getType().equalsIgnoreCase("like") || cond.getType().equalsIgnoreCase("ilike")) {
paramMap.put(cond.getPropertyName(), "and " + cond.getTableAlias() + "." + columnName + " like '%" + value.toString() + "%'");
} else {
paramMap.put(cond.getPropertyName(), "and " + cond.getTableAlias() + "." + columnName + " = '" + value.toString() + "'");
}
}
}
if (orderMap != null) {
paramMap.put("order_property", orderMap.get("property"));
paramMap.put("order_direction", orderMap.get("direction"));
}
String nopage = request.getParameter("nopage") == null ? "" : request.getParameter("nopage");
if (page != null && !nopage.equals("yes")) {
paramMap.put("page_start", page.getStart());
paramMap.put("page_limit", page.getLimit());
}
} catch (Exception e) {
throw new RuntimeException(e);
}
return paramMap;
}
}
相关推荐
考虑到这是一个简单的反射例子，`ReflectTest.java`可能包含以下内容： ```java public class ReflectTest { public String echo(String msg) { return "Echo: " + msg; } public static void main(String[] ...
Java反射是Java编程语言中的一个强大特性，它允许运行中的Java程序对自身进行检查并且可以直接操作程序的内部属性。...通过分析这些例子，你可以更深入地理解Java反射的使用方式及其在实际开发中的应用。
JAVA反射机制及应用例子.。。Reflection API
Java反射是Java编程语言中的一个强大特性，它允许运行中的Java程序对自身进行检查并且可以直接操作程序的内部属性。在Spring框架中，反射扮演着核心角色，...希望这个简单的反射例子能帮助你更好地理解和运用Java反射。
java.lang.reflect.Constructor; java.lang.reflect.Field; java.lang.reflect.Method; java.lang.reflect.Modifier;
虽然Java反射机制带来了极大的灵活性，但它也有一些潜在的问题需要注意： 1. **性能开销**：反射操作通常比直接调用慢得多，因为它涉及到类的解析和方法的查找。 2. **安全性问题**：反射可以访问私有成员，这可能...
在标题和描述中提到的“java反射例子，封装了一个反射帮助类”，这表明我们有一个实用工具类，可以帮助简化使用反射的复杂过程。 首先，让我们理解Java反射的基本概念。当我们的程序运行时，我们可以通过Class类来...
Java反射是Java编程语言中的一个强大特性，它允许运行时检查类、接口、字段和方法的信息，甚至可以动态地创建对象并调用其方法。在Java中，`java.lang.reflect`包提供了对反射的支持，包括`Class`、`Constructor`、`...
这个案例将深入探讨如何使用Java反射来实现一些实用的功能。 1. **获取类信息**： 反射机制首先从Class对象开始，它是所有Java类的元数据。通过`Class.forName()`方法或`类名.class`可以获取到Class对象。一旦有了...
标题“java反射小例子”暗示这是一个关于如何在实际项目中应用反射的小型示例。通常，这样的示例会展示如何使用反射来实现以下功能： 1. **获取类信息**：通过`Class.forName()`方法，我们可以根据类名动态加载类...
"java反射机制详解" Java 反射机制是 Java 语言中的一种功能，它允许程序员在运行时检查和修改一个类的结构和行为。 Java 反射机制提供了一种获取类的信息、创建对象、调用方法和获取字段值的方式。 在 Java 中，...
Java反射是Java编程语言中的一个强大工具，它允许运行中的Java程序对自身进行检查并且可以直接操作程序的内部属性。在Java 8中，虽然没有引入重大的反射新特性，但原有的反射API仍然提供了丰富的功能，使得开发者...
Java 反射概念及例子 Java 反射机制是一种让框架能够根据 "以字符串形式存在的信息" 来调用对象的属性和函数的技术。这种技术在框架编程中特别有用，因为框架编程中很多类是要根据配置文件来配置确定的，没办法预先...
标题"java反射机制例子"暗示我们将探讨如何在实际应用中使用Java反射。以下是一些关键知识点： 1. **Class对象**：每个类在Java中都有一个对应的Class对象，可以通过`Class.forName("类全名")`获取。Class对象包含...
"用java写的一些小例子"这个标题和描述暗示了我们将会探讨一些基础到进阶的Java编程示例。这些小例子通常用于教学目的，帮助初学者理解和掌握Java编程的核心概念。 在Java的学习过程中，我们可以从以下几个方面进行...
### Java反射机制简介 Java反射机制是Java编程语言的一个强大特性，它允许程序在运行时检查自身，并且能够“看”到类的信息（字段、方法等），甚至可以在运行时调用这些方法或修改这些字段的值。这为开发带来了很大...
Java反射和泛型是Java编程中的两个重要特性，它们各自为开发者提供了强大的功能，并且在特定情况下可以相互结合使用。本文将深入探讨这两个概念，并通过一个具体的`Testrefl.java`示例来阐述它们的应用。 Java反射...
代码主要实现了Java反射应用实例, 包含利用反射方法创建对象(使用默认构造函数和自定义构造函数),访问对应对象的方法(包括带参数的和不带参数的),访问对应对象的域(Field). 从这里可以看到代码的详细解说:...