架构探险--框架初始化

最新推荐文章于 2024-04-05 06:55:13 发布
最新推荐文章于 2024-04-05 06:55:13 发布
阅读量1.1k 收藏
点赞数
分类专栏： 架构探险 文章标签： 架构探险
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013285335/article/details/50365182
版权

MVC框架搭建初始化

定义框架配置项

smart.framework.jdbc.driver = com.mysql.jdbc.Driver

smart.framework.jdbc.url = jdbc:mysql://localhost:3306/smarttest

smart.framework.jdbc.username = root

smart.framework.jdbc.password = 123456

#   基础包名
smart.framework.jdbc.app.base_package = com.tutechan.smart4j

#   jsp的基础路径
smart.framework.jdbc.app.jsp_path = /WEB-INF/view/

#   静态资源文件，js或css或图片
smart.framework.jdbc.app.assert_path = /assert/

加载配置项

/**
 * 提供配置项常量
 */
public interface ConfigContent {

    String CONFIG_FILE = "smart.properties";

    String JDBC_DRIVER = "smart.framework.jdbc.driver";

    String JDBC_URL = "smart.framework.jdbc.url";

    String JDBC_USERNAME = "smart.framework.jdbc.username";

    String JDBC_PASSWORD = "smart.framework.jdbc.password";

    String BASE_PACKAGE = "smart.framework.jdbc.app.base_package";

    String ASSERT_PATH = "smart.framework.jdbc.app.jsp_path";

    String JSP_PATH = "smart.framework.jdbc.app.assert_path";

}

package util;

/**
 * Created by benny on 2015/12/20.
 */

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

/**
 * 属性文件工具类
 */
public final class PropertiesUtils {

    private static final Logger LOGGER = LoggerFactory.getLogger(PropertiesUtils.class);

    /**
     * 加载属性文件
     *
     * @param fileName
     * @return
     */
    public static Properties loadProperties(String fileName) {

        Properties prop = null;
        InputStream is = null;
        try {
            is = Thread.currentThread().getContextClassLoader().getResourceAsStream(fileName);
            if (is == null) {
                LOGGER.error("inputstream is null");
                throw new FileNotFoundException("file does not exists");
            }
        } catch (FileNotFoundException e) {
            LOGGER.error("file does not exists");
            e.printStackTrace();
        } finally {
            if (is != null) {
                try {
                    is.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
        return prop;
    }

    public static String getString(Properties prop, String key) {
        return getString(prop, key, "");
    }

    public static String getString(Properties prop, String key, String defaultValue) {
        String value = defaultValue;
        if (prop.containsKey(key)) {
            value = prop.getProperty(key);
        }
        return value;
    }

}

package util;

/**
 * Created by benny on 2015/12/20.
 */

import com.tutechan.smartframework.util.PropUtils;

import java.util.Properties;

/**
 * 属性文件的助手类
 */
public final class ConfigHelper {

    private static final Properties CONFIG_PROPERTIES = PropUtils.loadProperties(ConfigContent.CONFIG_FILE);

    /**
     * 获得jdbc驱动
     *
     * @return
     */
    public static String getJdbcDriver() {
        return PropUtils.getString(CONFIG_PROPERTIES, ConfigContent.JDBC_DRIVER);
    }

    /**
     * 获得url
     *
     * @return
     */
    public static String getUrl() {
        return PropUtils.getString(CONFIG_PROPERTIES, ConfigContent.JDBC_URL);
    }

    /**
     * 获得用户名
     *
     * @return
     */
    public static String getUsername() {
        return PropUtils.getString(CONFIG_PROPERTIES, ConfigContent.JDBC_USERNAME);
    }

    /**
     * 获取密码
     *
     * @return
     */
    public static String getPassword() {
        return PropUtils.getString(CONFIG_PROPERTIES, ConfigContent.JDBC_PASSWORD);
    }

    /**
     * 基础包名
     *
     * @return
     */
    public static String getBasePackage() {
        return PropUtils.getString(CONFIG_PROPERTIES, ConfigContent.BASE_PACKAGE);
    }

    /**
     * jsp文件的路径
     *
     * @return
     */
    public static String getJspPath() {
        return PropUtils.getString(CONFIG_PROPERTIES, ConfigContent.JSP_PATH,"/WEB-INF/view/");
    }

    /**
     * 静态资源文件路径
     *
     * @return
     */
    public static String getAssertPath() {
        return PropUtils.getString(CONFIG_PROPERTIES, ConfigContent.ASSERT_PATH,"/assert/");
    }
}

总结：发现凡是工具类都有final修饰。

开发类加载器

目的：来加载基础包名下的所有类，比如使用了某注解的类或者实现了某接口的类，再或者继承了某弗雷德额所有子类。

ClassUtil： 提供与类操作相关的方法，比如获取类加载器，加载类，获取指定包名下的所有类。

package util;

import com.tutechan.smartframework.util.StringUtil;

import java.io.File;
import java.io.FileFilter;
import java.io.IOException;
import java.net.JarURLConnection;
import java.net.URL;
import java.util.Enumeration;
import java.util.HashSet;
import java.util.Set;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;

/**
 * Created by Administrator on 2015/12/20.
 */
public final class ClassUtil {

    /**
     * 获取类加载器
     *
     * @return
     */
    public static ClassLoader getClassLoader() {
        return Thread.currentThread().getContextClassLoader();
    }

    /**
     * 加载类
     *
     * @param className
     * @param isInitialized
     * @return
     */
    public static Class<?> loadClass(String className, boolean isInitialized) {

        Class<?> clazz = null;
        try {
            clazz = Class.forName(className, false, getClassLoader());
        } catch (ClassNotFoundException e) {
            throw new RuntimeException();
        }
        return clazz;
    }

    /**
     * 获取指定包下面的所有类
     * <p/>
     * 根据包名并将其转化为文件路径
     * 读取class文件或jar 包
     * 获取指定的雷鸣去加载类。
     *
     * @param packageName
     * @return
     */
    public static Set<Class<?>> getClassSet(String packageName) {

        Set<Class<?>> classSet = new HashSet<Class<?>>();

        Enumeration<URL> urls = (Enumeration<URL>) getClassLoader().getResourceAsStream(packageName.replace(".", "/"));
        while (urls.hasMoreElements()) {
            URL url = urls.nextElement();
            if (url != null) {
                String protocol = url.getProtocol();
                if (protocol.equals("file")) {
                    String packagePath = url.getPath().replace("%20", "");
                    addClass(classSet, packagePath, packageName);
                } else if (protocol.equals("jar")) {
                    try {
                        JarURLConnection jarURLConnection = (JarURLConnection) url.openConnection();
                        if (jarURLConnection != null) {
                            JarFile jarFile = jarURLConnection.getJarFile();
                            if (jarFile != null) {
                                Enumeration<JarEntry> jarEntryEnumeration = jarFile.entries();
                                while (jarEntryEnumeration.hasMoreElements()) {
                                    JarEntry jarEntry = jarEntryEnumeration.nextElement();
                                    String jarEntryName = jarEntry.getName();
                                    if (jarEntryName.endsWith(".class")) {
                                        String className = jarEntryName.substring(0, jarEntryName.lastIndexOf(".")).replaceAll("/", ".");
                                        doAddClass(classSet, className);
                                    }
                                }

                            }
                        }
                    } catch (IOException e) {
                        e.printStackTrace();
                    }
                }
            }
        }
        return classSet;
    }

    public static void addClass(Set<Class<?>> classSet, String packagePath, String packageName) {
        File[] files = new File(packageName).listFiles(new FileFilter() {
            public boolean accept(File file) {
                return (file.isFile() && file.getName().endsWith(".class")) || file.isDirectory();
            }
        });
        for (File file : files) {
            String fileName = file.getName();
            if (file.isFile()) {
                String className = fileName.substring(0, fileName.lastIndexOf("."));
                if (StringUtil.isNotEmpty(packageName)) {
                    className = packageName + "." + className;
                }
                doAddClass(classSet, className);
            } else {
                String subPackagePath = fileName;
                if (StringUtil.isNotEmpty(packageName)) {
                    subPackagePath = packagePath + "/" + subPackagePath;
                }
                String subPackageName = fileName;
                if (StringUtil.isNotEmpty(packageName)) {
                    subPackageName = packageName + "." + subPackageName;
                }
                addClass(classSet, subPackagePath, subPackageName);
            }
        }
    }

    private static void doAddClass(Set<Class<?>> classSet, String className) {
        Class<?> clazz = loadClass(className, false);
        classSet.add(clazz);
    }

}

实现Bean容器

package util;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

/**
 * Created by benny on 2015/12/22.
 */

/**
 * 反射工具类
 */
public class ReflectionUtil {

    private static final Logger LOGGER = LoggerFactory.getLogger(ReflectionUtil.class);

    /**
     * 创建实例
     *
     * @param cls
     * @return
     */
    public static Object newInstance(Class<?> cls) {

        Object instance = null;

        try {
            instance = cls.newInstance();
        } catch (InstantiationException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return instance;
    }

    /**
     * 调用方法
     *
     * @param obj
     * @param method
     * @param params
     * @return
     */
    public static Object invokeMethod(Object obj, Method method, Object... params) {
        Object result = null;
        method.setAccessible(true);
        try {
            result = method.invoke(obj, params);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        } catch (InvocationTargetException e) {
            e.printStackTrace();
        }
        return result;
    }

    /**
     * 设置成员变量的值
     * @param obj
     * @param field
     * @param value
     */
    public static void setField(Object obj, Field field, Object value) {

        field.setAccessible(true);
        try {
            field.set(obj, value);
        } catch (IllegalAccessException e) {
            e.printStackTrace();
            LOGGER.error("set field failure",e);
            throw new RuntimeException(e);
        }

    }
}

package util;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;

/**
 * Created by benny on 2015/12/22.
 */

/**
 * Bean 助手类
 */
public class BeanHelper {

    /**
     * 定义javabean的映射（用于存放bean类与bean实例的映射关系）
     */
    private static final Map<Class<?>, Object> BEAN_MAP = new HashMap<Class<?>,Object>();

    static {
        Set<Class<?>> beanClassSet = ClassHelper.getBeanClassSet();
        for (Class<?> beanClass : beanClassSet) {
            Object obj = ReflectionUtil.newInstance(beanClass);
            BEAN_MAP.put(beanClass, obj);
        }
    }

    /**
     * 获取bean映射
     * @return
     */
    public static Map<Class<?>,Object> getBeanMap() {
        return BEAN_MAP;
    }

    /**
     * 获取bean实例
     * @param cls
     * @param <T>
     * @return
     */
    public static <T> T getBean(Class<T> cls){
        if (!BEAN_MAP.containsKey(cls)) {
            throw new RuntimeException("can not get bean by class");
        }
        return (T) BEAN_MAP.get(cls);
    }
}

实现依赖注入

package util;

/**
 * Created by benny on 2015/12/22.
 */

import com.tutechan.smart4j.annotation.Inject;
import com.tutechan.smartframework.util.CollectionUtil;
import org.apache.commons.lang3.ArrayUtils;

import java.lang.reflect.Field;
import java.util.Map;

/**
 * 依赖注入助手类
 */
public final class IocHelper {

    static {
        //获取所有bean类与bean之间的映射关系（简称bean map）
        Map<Class<?>, Object> beanMap = BeanHelper.getBeanMap();
        if (CollectionUtil.isNotEmpty(beanMap)) {
            //遍历beanmap
            for (Map.Entry<Class<?>, Object> beanEntry : beanMap.entrySet()) {
                //从 beanMap 中获取bean 类与bean 实例
                Class<?> beanClass = beanEntry.getKey();
                Object beanInstance = beanEntry.getValue();
                //从 bean类定义的所有成员变量（简称 bean field）
                Field[] beanFields = beanClass.getDeclaredFields();
                if (ArrayUtils.isNotEmpty(beanFields)) {
                    //遍历bean field
                    for (Field beanField : beanFields) {
                        //判断当前bean field 是否带有Inject 注解
                        if (beanField.isAnnotationPresent(Inject.class)) {
                            //在bean map中获取bean field 对应的实例
                            Class<?> beanFieldClass = beanField.getType();
                            Object beanFieldInstance = beanMap.get(beanFieldClass);
                            if (beanFieldInstance != null) {
                                //通过反射初始化BeanField 的值
                                ReflectionUtil.setField(beanInstance, beanField, beanFieldInstance);
                            }

                        }
                    }
                }
            }
        }
    }
}
package util;

/**
 * Created by Administrator on 2015/12/22.
 */

import org.apache.commons.lang3.ArrayUtils;

/**
 * 数组助手类
 */
public final class ArrayUtil {

    /**
     * 判断数组是否非空
     * @param array
     * @return
     */
    public static boolean isNotEmpty(Object[] array) {
        return !ArrayUtils.isEmpty(array);
    }

    /**
     * 判断数组是否为空
     * @param array
     * @return
     */
    public static boolean isEmpty(Object[] array) {
        return ArrayUtils.isEmpty(array);

    }


}

加载Controller

package com.tutechan.smart4j.framework.bean;

/**
 * Created by benny on 2015/12/22.
 */

/**
 * 封装请求信息
 */
public class Request {

    /**
     * 请求方法
     */
    private String requestMethod;
    /**
     * 请求路径
     */
    private String requestPath;

    public Request(String requestPath, String requestMethod) {
        this.requestPath = requestPath;
        this.requestMethod = requestMethod;
    }

    public String getRequestMethod() {
        return requestMethod;
    }

    public String getRequestPath() {
        return requestPath;
    }

    @Override
    public int hashCode() {
        return super.hashCode();
    }

    @Override
    public boolean equals(Object obj) {
        return super.equals(obj);
    }
}

初始化框架

package util;
/**
 * Created by benny on 2015/12/22.
 */

/**
 * 加载对应的Helper类
 */
public final class HelperLoader {

    public static void init() {
        Class<?>[] classList = {
                ClassHelper.class,
                BeanHelper.class,
                IocHelper.class,
                ControllerHelper.class};
        for (Class<?> cls : classList) {
            ClassUtil.loadClass(cls.getName(), false);
        }
    }
}

请求转发器

字符串工具类

package util;

/**
 * Created by Administrator on 2015/12/26.
 */

import org.apache.commons.lang3.StringUtils;
import org.apache.commons.lang3.math.NumberUtils;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 字符串处理类
 */
public final class StringUtil {

    /**
     * 字符串分割符
     */
    public static final String SEPARATOR = String.valueOf((char) 29);

    /**
     * 判断字符串是否为空
     */
    public static boolean isNotEmpty(String str) {
        return StringUtils.isNotEmpty(str);
    }
    /**
     * 判断字符串是否为空
     */

    public static boolean isEmpty(String str) {
        return StringUtils.isEmpty(str);
    }
    /**
     * 若字符串为空，则取默认值
     */
    public static String defaultEmpty(String str,String defaultValue) {
        return StringUtils.defaultIfEmpty(str, defaultValue);
    }

    /**
     * 替换固定格式的
     */
    public static String replaceAll(String str, String regex, String replacement) {
        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(str);
        StringBuffer sb = new StringBuffer();
        if (matcher.find()) {
            matcher.appendReplacement(sb, replacement);
        }
        matcher.appendTail(sb);
        return sb.toString();
    }

    /**
     * 判断是否为数字
     * @param str
     * @return
     */
    public static boolean isNumber(String str) {
        return NumberUtils.isNumber(str);
    }

    /**
     * 判断是否为十进制整数
     */
    public static boolean isDigits(String str) {
        return NumberUtils.isDigits(str);
    }

    /**
     * 将驼峰风格替换为下划线风格
     */
    public static String camelhumpT0Unerline(String str) {
        Matcher matcher = Pattern.compile("[A-Z]").matcher(str);
        StringBuilder sb = new StringBuilder(str);
        for (int i = 0; matcher.find() ; i++) {
            sb.replace(matcher.start() + i, matcher.end() + i, "_" + matcher.group().toLowerCase());
        }
        if ('_' == sb.charAt(0)) {
            sb.deleteCharAt(0);
        }
        return sb.toString();

    }

    /**
     * 下划线替换为驼峰
     * @param str
     * @return
     */
    public static String unerlineToCamelhump(String str) {
        Matcher matcher = Pattern.compile("_[a-z]").matcher(str);
        StringBuilder builder = new StringBuilder(str);
        for (int i = 0; matcher.find(); i++) {
            builder.replace(matcher.start() - i, matcher.end() - i, matcher.group().substring(1).toUpperCase());
        }
        return builder.toString();
    }

    /**
     * 分割固定的字符串
     * @return
     */
    public static String[] splitString(String str,String separator) {
        return StringUtils.splitByWholeSeparator(str, separator);
    }
    /**
     * 将字符串首字母大写
     */
    public static String firstToUpper(String str) {
        return Character.toUpperCase(str.charAt(0)) + str.substring(1);
    }
    /**
     * 将首字母小写
     */
    public static String firstToLower(String str) {
        return Character.toLowerCase(str.charAt(0)) + str.substring(1);
    }
    /**
     * 转为帕斯卡命名方式（如：FooBar）
     */

    public static String toPascalStyle(String str ,String seperator) {
        return StringUtil.firstToUpper(toCamelhumpStyle(str, seperator));
    }
    /**
     * 转为驼峰命令方式（如：fooBar）
     */
    public static String toCamelhumpStyle(String str,String seperator) {
        return StringUtil.unerlineToCamelhump(toUnderlineStyle(str, seperator));
    }


    /**
     * 转为下划线命名方式（如：foo_bar）
     */
    public static String toUnderlineStyle(String str,String seperator) {
        str = str.trim().toLowerCase();
        if (str.contains(seperator)) {
            str = str.replace(seperator , "_");
        }
        return str;
    }

    /**
     * 转为现实命名方式
     */

    public static String toDisplayStyle(String str, String seperator) {
        String displayName = "";
        str = str.trim().toLowerCase();
        if (str.contains(seperator)) {
            String[] words = StringUtil.splitString(str, seperator);
            for (String word : words) {
                displayName += StringUtil.firstToUpper(word)+"";
            }
        }else {
            displayName = StringUtil.firstToUpper(str);
        }
        return displayName;
    }
}

流操作工具类

package util;

/**
 * Created by Administrator on 2015/12/26.
 */

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;

/**
 * 流操作工具类
 */
public class StreamUtil {

    private static final Logger LOGGER = LoggerFactory.getLogger(StreamUtil.class);

    /**
     * 从输入流中获取字符串
     */

    public static String getString(InputStream is) {

        StringBuilder sb = new StringBuilder();
        BufferedReader bf = new BufferedReader(new InputStreamReader(is));
        String line = null;
        try {
            while ((line = bf.readLine()) != null) {
                sb.append(line);

            }
        } catch (IOException e) {
            e.printStackTrace();
        }
        return sb.toString();
    }
}

编码解码工具类

package util;

/**
 * Created by Administrator on 2015/12/26.
 */

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.UnsupportedEncodingException;
import java.net.URLDecoder;
import java.net.URLEncoder;

/**
 * 编码与解码操作工具类
 */
public final class CodecUtil {

    private static final Logger LOGGER = LoggerFactory.getLogger(CodecUtil.class);

    /**
     * 将URL编码
     * @param source
     * @return
     */
    public static String encodeURL(String source){
        String target = null;
        try {
            target = URLEncoder.encode(source, "UTF-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return target;
    }

    /**
     * 将URL解码
     */

    public static String decodeURL(String source){
        String targer = null;

        try {
            targer = URLDecoder.decode(source, "UTF-8");
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return targer;
    }

}

JSON与POJO转换的工具类

package util;

import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;

/**
 * Created by Administrator on 2015/12/26.
 */
public class JsonUtil {

    private static final Logger LOGGER = LoggerFactory.getLogger(JsonUtil.class);

    private static final ObjectMapper OBJECT_MAPPER = new ObjectMapper();

    /**
     * 将POJO转为 JSON
     */
    public static <T> String toJson(T obj){
        String json = null;
        try {
            json = OBJECT_MAPPER.writeValueAsString(obj);
        } catch (JsonProcessingException e) {
            LOGGER.error("convert POJO to JSON faliure", e);
            e.printStackTrace();
        }
        return json;

    }

    /**
     * 将json转为String
     * @param json
     * @param type
     * @param <T>
     * @return
     */
    public static <T> T fromJson(String json, Class<T> type) {
        T pojo = null;
        try {
            pojo = OBJECT_MAPPER.readValue(json, type);
        } catch (IOException e) {
            LOGGER.error("convert JSON to POJO failure", e);
            throw new RuntimeException(e);
        }
        return pojo;
    }
}

请求转发

package controllerutils;

/**
 * Created by Administrator on 2015/12/26.
 */

import com.tutechan.smart4j.framework.bean.Handler;
import org.apache.commons.lang3.StringUtils;
import util.*;

import javax.servlet.ServletConfig;
import javax.servlet.ServletContext;
import javax.servlet.ServletException;
import javax.servlet.ServletRegistration;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.io.PrintWriter;
import java.lang.reflect.Method;
import java.util.Enumeration;
import java.util.HashMap;
import java.util.Map;

/**
 * 请求转发器
 */
@WebServlet(urlPatterns = "/*", loadOnStartup = 0)
public class DispatcherServlet extends HttpServlet {

    @Override
    public void init(ServletConfig servletConfig) throws ServletException {
        // 初始化相关helper类
        HelperLoader.init();
        // 获取ServletContext对象
        ServletContext servletContext = servletConfig.getServletContext();
        //注册处理的jsp的servlet
        ServletRegistration jspServlet = servletContext.getServletRegistration("jsp");
        jspServlet.addMapping(ConfigHelper.getJspPath() + "*");
        //处理静态资源的默认servlet
        ServletRegistration defaultServlet = servletContext.getServletRegistration("default");
        defaultServlet.addMapping(ConfigHelper.getAssertPath() + "*");
    }

    @Override
    protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {

        //获取请求方法与请求路径
        String requestMethod = req.getMethod().toLowerCase();
        String requestPath = req.getPathInfo();

        //获取action处理器
        Handler handler = ControllerHelper.gethandler(requestMethod, requestPath);

        if (null != handler) {

//            获取Controller 类与其Bean实例
            Class<?> controllerClass = handler.getControllerClass();
            Object controllerBean = BeanHelper.getBean(controllerClass);
            //创建请求对象
            Map<String, Object> paramMap = new HashMap<String, Object>();
            Enumeration<String> paramNames = req.getParameterNames();
            if (paramNames.hasMoreElements()) {

                String paramName = paramNames.nextElement();
                String paramValue = req.getParameter(paramName);
                paramMap.put(paramName, paramValue);
            }

            String body = CodecUtil.decodeURL(StreamUtil.getString(req.getInputStream()));

            if (StringUtils.isNotEmpty(body)) {
                String[] params = util.StringUtil.splitString(body, "&");
                if (ArrayUtil.isNotEmpty(params)) {
                    for (String param : params) {
                        String[] array = StringUtil.splitString(param, "=");
                        if (ArrayUtil.isNotEmpty(array) && array.length == 2) {
                            String paramName = array[0];
                            String paramValue = array[1];
                            paramMap.put(paramName, paramValue);
                        }
                    }

                }
            }

            Param param = new Param(paramMap);
            //调用action方法
            Method actionMethod = handler.getActionMethod();
            Object result = ReflectionUtil.invokeMethod(controllerBean, actionMethod, param);
            //处理Action 方法返回值
            if (result instanceof View) {
                //返回jsp页面
                View view = (View) result;
                String path = view.getPath();
                if (StringUtil.isNotEmpty(path)) {
                    if (path.startsWith("/")) {
                        resp.sendRedirect(req.getContextPath() + path);
                    } else {
                        Map<String, Object> model = view.getModel();
                        for (Map.Entry<String, Object> stringObjectEntry : model.entrySet()) {
                            req.setAttribute(stringObjectEntry.getKey(), stringObjectEntry.getValue());
                        }
                        req.getRequestDispatcher(ConfigHelper.getJspPath() + path).forward(req, resp);
                    }
                } else if (result instanceof Data) {
                    //返回JSON数据
                    Data data = (Data) result;
                    Object model = data.getModel();
                    if (null != model) {
                        resp.setContentType("application/json");
                        resp.setCharacterEncoding("UTF-8");
                        PrintWriter writer = resp.getWriter();
                        String json = JsonUtil.toJson(model);
                        writer.write(json);
                        writer.flush();
                        writer.close();
                    }
                }
            }
        }
    }
}
谈情亲个嘴
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
架构探险 原书源码
08-21
本书首先从一个简单的 Web 应用开始，让读者学会如何使用 IDEA、Maven、Git 等开发工具搭建 Java Web 应用；接着通过一个简单的应用场景，为该 Web 应用添加若干业务功能，从需求分析与系统设计开始，带领读者动手完成该 Web 应用，完善相关细节，并对已有代码进行优化；然后基于传统 Servlet 框架搭建一款轻量级 Java Web 框架，一切都是从零开始，逐个实现类加载器、Bean 容器、IoC 框架、MVC 框架，所涉及的代码也是整个框架的核心基础。为了使框架具备 AOP 特性，从代理技术讲到 AOP 技术，从 ThreadLocal 技术讲到事务控制技术。最后对框架进行优化与扩展，通过对现有框架的优化，使其可以提供更加完备的功能，并以扩展 Web 服务插件与安全控制插件为例，教会读者如何设计一款可扩展的Web应用框架。
框架初始化
技术人生
09-22 2148
//MTF基础模块初始化 rvIppSipSystemInit() //RV基础支撑模块初始化（如时间戳、信号量、内存管理等系统抽象层对象的初始化） RvCBaseInit(); //获取内存对象信息，默认的内存对象构造详见RvCBaseInit中的RvMemoryInit RvMemoryGetInfo(NULL, NULL, &memInfo); initialAl
框架初始化流程
技术人生
09-22 1605
RvBool mgStartup() mgLogInit(); logMgr = rvMegacoLogGet(); //获取日志句柄 //设置所有源日志句柄的掩码 RvLogSetGlobalMask(logMgr, RV_LOGLEVEL_ERROR | RV_LOGLEVEL_EXCEP | RV_LOGLEVEL_WARNING | RV_LOGLEVEL_INFO); RvL
Flutter框架分析（二）-- 初始化(1)
最新发布
2401_84123201的博客
04-05 661
那我们该怎么做才能做到年薪60万+呢，对于程序员来说，只有不断学习，不断提升自己的实力。我之前有篇文章提到过，感兴趣的可以看看，到底要学习哪些知识才能达到年薪60万+。通过职友集数据可以查看，以北京 Android 相关岗位为例，其中 【20k-30k】 薪酬的 Android 工程师，占到了整体从业者的 30.8%！北京 Android 工程师「工资收入水平 」今天重点内容是怎么去学，怎么提高自己的技术。1.合理安排时间2.找对好的系统的学习资料3.有老师带，可以随时解决问题。
【从零写javaweb框架】(七)初始化框架
KK_GKD的博客
01-28 417
在上一篇【从零写javaweb框架】(六)加载Controller，我封装了请求对象(Request)与处理对象(Handler)，并写了ControllerHelper来维护维护Request与Handler之间的映射关系。 集合上几篇编写的ClassHelper/BeanHelper/IocHelper/ControllerHelper,我们现在需要做的是在项目启动时把他们都加载进来。 p
架构探险-从零开始写Java Web 框架
01-02
《架构探险-从零开始写Java Web框架》是一本深入探讨Java Web开发的书籍，作者黄勇通过实际的代码示例带领读者从无到有构建一个完整的Java Web框架。在这个过程中，读者不仅可以学习到Java Web的基础知识，还能了解...
架构探险-从零开始写javaweb框架
10-27
《架构探险：从零开始写Java Web框架》首先从一个简单的 Web 应用开始，让读者学会如何使用 IDEA、Maven、Git 等开发工具搭建 Java Web 应用；接着通过一个简单的应用场景，为该 Web 应用添加若干业务功能，从需求...
learn-smart-code:《架构探险--从零开始写java web框架》读书笔记
04-30
《架构探险--从零开始写Java Web框架》是一本深入探讨Java Web开发的书籍，旨在帮助读者理解并构建自己的Web框架。这本书通过实践的方式引导读者探索MVC（Model-View-Controller）架构模式，深入了解Java Web开发的...
架构探险-----从零开始写javaweb框架.pdf
08-03
然后基于传统 Servlet 框架搭建一款轻量级 Java Web 框架，一切都是从零开始，逐个实现类加载器、Bean 容器、IoC 框架、MVC 框架，所涉及的代码也是整个框架的核心基础。为了使框架具备 AOP 特性，从代理技术讲到 ...
架构探险-从零开始写Java Web框架-全书源码
01-02
《架构探险-从零开始写Java Web框架》是一本深入探讨Java Web开发的书籍，作者黄勇通过本书向读者展示了如何从零构建一个完整的Web框架。全书源码的提供，使得读者能够更加直观地理解并实践书中的理论知识，这对于...
架构探险javaweb
02-23
架构探险javaweb 架构探险javaweb 架构探险javaweb 架构探险javaweb
架构探险,从零开始写javaweb框架-源码
08-11
架构探险,从零开始写javaweb框架 huangyong-smart-framework-master.zip
架构探险 从零开始写javaweb框架Pdf及书上源码
11-27
架构探险 从零开始写javaweb框架 pdf 及书上源码。 资源来自于互联网，方便大家下载。
wpa_supplicant软件架构分析（初始化流程）
09-07 1661
wpa_supplicant的初始化流程 evans1987 收藏于 2012-04-18 阅读数： 公众公开 原文来源  转藏到我的图书馆 wpa_supplicant软件架构分析 分类
一个简单的初始化框架，提供数据初始化的简单加载。适用方便。
06-17 81
一个简单的初始化框架，提供数据初始化的简单加载。适用方便。 我们在项目开发中，常常会用到初始化数据的工作。每次写了要初始化的数据，都要写到初始化方法里面。个人感觉比较麻烦，呵呵，因为我比较懒惰。 我这里的做法是，首先写一个接口。包括一个execute() 方法，那么要初始化的类，都继承这个接口，来实现execute()方法。 然后把这些类放到一个包下面，这样的话。我就可以在一个启动方法里面...
Atlas框架源码简要分析(上)--框架的初始化
M075097的博客
02-01 2847
Atlas框架源码简要分析–框架的初始化(上) 内容根据阿里发布到github官网上的源码整理，版本号：v5.0.7.55，官方源码github地址https://github.com/alibaba/atlas；官方文档地址：https://alibaba.github.io/atlas/ 一、关于Atlas应该大致知道的 1.1.这个框架都能做到什么？ 1.1.1、首先这是
架构探险-从零开始写Javaweb框架读书笔记（4）
wuhulala的休息室
08-09 1912
请求转发器 用于处理用户发送给的请求。 我们需要一个Servlet来处理所有的请求 这是HttpServlet的处理请求的service函数源码protected void service(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException { String
[笔记]架构探险-从零开始写JavaWeb框架-1. 之搭建轻量级mvc框架
代码有毒的博客
10-20 4227
ヽ(ˋ▽ˊ)ノヽ(ˋ▽ˊ)ノ 终于到了不会的地步了,该书的前面两章节都是从零开始讲解怎么使用 idea搭建项目,从servlet开始讲解怎么使用. (idea的使用目录)把思维过度到了 下面这样一个局面: 最简单的servlet 我们都知道是一个servlet处理一个种请求,那么弊端大家都知道. 那么这章要学习的应该就是 怎么实现下面这样的理想的状态,处理customer的action 那么相
亲手打造Java Web框架：架构探险之旅
"《架构探险：从零开始写Java Web框架》是一本引导读者逐步构建自己的Java Web框架的书籍，适合有一定Java基础知识和Web相关理论经验的程序员，特别是那些希望成为架构师的读者。作者从实际操作出发，通过使用IDEA、...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值