package org.mvc.framework.servlet;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.math.BigDecimal;
import java.net.URL;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Properties;
import java.util.regex.Pattern;
import javax.servlet.ServletConfig;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.apache.commons.lang3.StringUtils;
import org.mvc.framework.annotation.XCAutowired;
import org.mvc.framework.annotation.XCController;
import org.mvc.framework.annotation.XCRequestMapping;
import org.mvc.framework.annotation.XCRequestParam;
import org.mvc.framework.annotation.XCService;
import com.alibaba.fastjson.JSON;
import javassist.ClassClassPath;
import javassist.ClassPool;
import javassist.CtClass;
import javassist.CtMethod;
import javassist.bytecode.CodeAttribute;
import javassist.bytecode.LocalVariableAttribute;
import javassist.bytecode.MethodInfo;
import javassist.bytecode.annotation.AnnotationMemberValue;
@SuppressWarnings("serial")
public class XCDispatcherServlet extends HttpServlet {
private Properties properties = new Properties();
private Map<String, Object> iocBean = new HashMap<>();
private Map<String, Object> handerMap = new HashMap<>();
@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
this.doPost(request, response);
}
@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
System.out.println("收到用户请求");
response.setHeader("Content-type", "text/html;charset=UTF-8");
String reqPath = request.getRequestURL().toString();
String basePath = request.getScheme() + "://" + request.getServerName() + ":" + request.getServerPort()
+ request.getContextPath();
String url = reqPath.replace(basePath, "").replaceAll("/+", "/");
HanlerInner inner = (HanlerInner) handerMap.get(url);
if (null == inner) {
response.getWriter().write("404 not Fund reuest");
return;
}
Object object = iocBean.get(inner.getBeanName());
List<Object> invokeMethod = new ArrayList<>();
for (int i=0; i<inner.getParametersize(); i++) {
String paramName = inner.getParameterNames()[i];
Class<?> paramType = inner.getParameterTypes()[i];
if (paramType == HttpServletRequest.class) {
invokeMethod.add(request);
} else if (paramType == HttpServletResponse.class) {
invokeMethod.add(response);
} else {
String paramValue = "";
Annotation[][] annotationParam = inner.getMethod().getParameterAnnotations();
if (null != annotationParam[i] && annotationParam[i].length > 0) {
Annotation[] annotations = annotationParam[i];
Annotation annotation = annotations[0];
String annoParamVal = "";
Boolean annoParamRequire = true;
if (annotation instanceof XCRequestParam) {
annoParamVal = ((XCRequestParam) annotation).value();
annoParamRequire = ((XCRequestParam) annotation).required();
if (StringUtils.isNotBlank(annoParamVal)) {
paramName = annoParamVal;
}
paramValue = new String(request.getParameter(paramName).getBytes("ISO-8859-1"), "UTF-8");
if (annoParamRequire && StringUtils.isBlank(paramValue)) {
throw new RuntimeException(Thread.currentThread().getName() + " server exception parameter "
+ paramName + " can not empty or null.");
}
if (StringUtils.isBlank(paramValue) && annoParamRequire) {
throw new RuntimeException("500 exception parameter " + paramName + " is empty or null");
}
}
} else {
paramValue = new String(request.getParameter(paramName).getBytes("ISO-8859-1"), "UTF-8");
}
Object val = invokeMethodParamValue(request, response, paramType, paramValue);
invokeMethod.add(val);
}
}
try {
Object result = inner.getMethod().invoke(object, invokeMethod.toArray());
String ret = new String(JSON.toJSONString(result).getBytes("UTF-8"));
response.getWriter().write(ret);
} catch (IllegalAccessException | IllegalArgumentException | InvocationTargetException e) {
e.printStackTrace();
}
}
private Object invokeMethodParamValue(HttpServletRequest request , HttpServletResponse response,
Class<?> paramType, String paramValue) {
System.out.println("start convert request parameter." + JSON.toJSONString(paramType));
try {
if (paramType == String.class) {
return paramValue;
} else if (paramType == Integer.class || paramType == int.class) {
return Integer.valueOf(paramValue);
} else if (paramType == Long.class || paramType == long.class) {
return Long.valueOf(paramValue);
} else if (paramType == Boolean.class || paramType == boolean.class) {
return Boolean.valueOf(paramValue);
} else if (paramType == Short.class || paramType == short.class) {
return Short.valueOf(paramValue);
} else if (paramType == Float.class || paramType == float.class) {
return Float.valueOf(paramValue);
} else if (paramType == Double.class || paramType == double.class) {
return Double.valueOf(paramValue);
} else if (paramType == BigDecimal.class) {
return new BigDecimal(paramValue);
} else if (paramType == Character.class || paramType == char.class) {
char[] cs = paramValue.toCharArray();
if (cs.length > 1) {
throw new IllegalArgumentException("参数长度太大");
}
return paramValue;
}
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
private String[] methodParameterName(Class<?> clazz, String methodName) {
String nameParams[] = null;
try {
ClassPool classPool = ClassPool.getDefault();
classPool.insertClassPath(new ClassClassPath(clazz));
CtClass ctClass = classPool.get(clazz.getName());
CtMethod ctMethod = ctClass.getDeclaredMethod(methodName);
MethodInfo methodInfo = ctMethod.getMethodInfo();
CodeAttribute attribute = methodInfo.getCodeAttribute();
LocalVariableAttribute lAttribute = (LocalVariableAttribute) attribute.getAttribute(LocalVariableAttribute.tag);
if (null == lAttribute) {
throw new RuntimeException("500 get parameter");
}
nameParams = new String[ctMethod.getParameterTypes().length];
int pos = Modifier.isStatic(ctMethod.getModifiers())?0 : 1;
for (int i=0; i< nameParams.length; i++) {
nameParams[i] = lAttribute.variableName(i + pos);
}
} catch (Exception e) {
e.printStackTrace();
}
return nameParams;
}
@Override
public void init(ServletConfig config) throws ServletException {
System.out.println("-------------- init dispatcherServlet start ------------------");
// 1 加载xml
doinitContextConfig(config);
// 2 扫描包 初始化实例化bean IOC
String basePackage = properties.getProperty("basescan.pacakge");
doscanPacakge(basePackage);
// 4 依赖注入bean
doInitIDBean();
// 5. 初始化handlerMapping
doInitHandlerMapping();
System.out.println("-------------- init dispatcherServlet end ------------------");
}
private void doInitHandlerMapping() {
try {
if (iocBean.isEmpty()) {return;}
for (Map.Entry<String, Object> bean : iocBean.entrySet()) {
Class<?> clazz = bean.getValue().getClass();
if (clazz.isAnnotationPresent(XCController.class)) {
String basePath = clazz.getAnnotation(XCRequestMapping.class).value();
Method[] methods = clazz.getMethods();
if (methods.length <= 0) {continue;}
for (Method method : methods) {
String url = "";
HanlerInner inner = null;
if (method.isAnnotationPresent(XCRequestMapping.class)) {
inner = new HanlerInner();
String methodPath = method.getAnnotation(XCRequestMapping.class).value();
url = (basePath + "/" + methodPath).replaceAll("/+", "/");
inner.setUrl(url);
inner.setMethod(method);
inner.setBeanName(bean.getKey());
inner.setParameterTypes(method.getParameterTypes());
inner.setParametersize(method.getParameterTypes().length);
inner.setParameterNames(methodParameterName(clazz, method.getName()));
}
handerMap.put(url, inner);
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
private void doInitIDBean() {
try {
if (iocBean.isEmpty()) {return;}
for (Map.Entry<String, Object> entry : iocBean.entrySet()) {
Class<?> claxx = entry.getValue().getClass();
if (claxx.isAnnotationPresent(XCController.class)) {
System.out.println("controller 注入");
Field[] fields = claxx.getDeclaredFields();
for (Field field : fields) {
field.setAccessible(true);
if (field.isAnnotationPresent(XCAutowired.class)) {
String beanName = field.getAnnotation(XCAutowired.class).value();
if ("".equals(beanName)) {
beanName = field.getName();
}
System.out.println("controller 注入 名称 " + beanName + " " + field.getType().getName());
Object instatnce = iocBean.get(beanName);
field.set(entry.getValue(), instatnce);
}
}
} else if (claxx.isAnnotationPresent(XCService.class)) {
System.out.println("service 注入");
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
private void doscanPacakge(String basePackage) {
try {
if ("".equals(basePackage)) {
return;
}
String basePath = basePackage.replace(".", "/");
URL url = this.getClass().getClassLoader().getResource(basePath);
File file = new File(url.getFile());
File[] files = file.listFiles();
for (File pack : files) {
if (pack.isDirectory()) {
String nextPack = basePackage + "." + pack.getName();
doscanPacakge(nextPack);
} else {
String className = pack.getName().replace(".class", "");
Class<?> instance = Class.forName(basePackage + "." + className);
Object object = null;
if (instance.isAnnotationPresent(XCController.class)) {
object = instance.newInstance();
iocBean.put(lowerFirstCase(className), object);
} else if (instance.isAnnotationPresent(XCService.class)) {
object = instance.newInstance();
String beanName = instance.getAnnotation(XCService.class).value();
if ("".equals(beanName)) {
Class<?> instanceInter[] = instance.getInterfaces();
for (Class<?> inter : instanceInter) {
if (inter.isAssignableFrom(instance)) {
beanName = lowerFirstCase(inter.getSimpleName());
}
}
}
iocBean.put(beanName, object);
}
}
}
} catch (Exception e) {
e.printStackTrace();
}
}
private void doinitContextConfig(ServletConfig config) {
try {
String contextPath = config.getInitParameter("contextConfigLocation");
InputStream in = this.getClass().getClassLoader().getResourceAsStream(contextPath);
properties.load(in);
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 首字母小写
* @return
*/
private String lowerFirstCase (String claxxName) {
char[] chars = claxxName.toCharArray();
chars[0] = (char) (chars[0] + 32);
return String.valueOf(chars);
}
class HanlerInner {
private String url;
private String beanName;
private Pattern pattern;
private Method method;
private Integer parametersize;
private String[] parameterNames;
private Class<?>[] parameterTypes;
public String getUrl() {
return url;
}
public void setUrl(String url) {
this.url = url;
}
public String getBeanName() {
return beanName;
}
public void setBeanName(String beanName) {
this.beanName = beanName;
}
public Pattern getPattern() {
return pattern;
}
public void setPattern(Pattern pattern) {
this.pattern = pattern;
}
public Method getMethod() {
return method;
}
public void setMethod(Method method) {
this.method = method;
}
public String[] getParameterNames() {
return parameterNames;
}
public void setParameterNames(String[] parameterNames) {
this.parameterNames = parameterNames;
}
public Class<?>[] getParameterTypes() {
return parameterTypes;
}
public void setParameterTypes(Class<?>[] parameterTypes) {
this.parameterTypes = parameterTypes;
}
public Integer getParametersize() {
return parametersize;
}
public void setParametersize(Integer parametersize) {
this.parametersize = parametersize;
}
}
}
302
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
