架构探险读书笔记——自己搭建轻量级javaWeb框架之MVC和IOC

原創 GokusJQK 2018-09-04 22:55

首先安利一波"架构探险——从零开始写JavaWeb框架"这本书，想要学习的朋友可以到这里下载，https://pan.baidu.com/s/1eSEaE10

源码下载:http://download.csdn.net/detail/qq_31957747/9842676,我的是IDEA项目，顺便在给用myeclipse的同志们安利一波IDEA吧:IDEA强无敌！

好，回到主题首先先说说Ioc(控制反转，又称依赖注入)，

Ioc这个部分定义三个注解:Autowire、Controller以及Service，注解的定义代码如下：

package org.smart4j.framework.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 依赖注入注解
 */
@Target({ElementType.TYPE,ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
public @interface Autowired {
}
package org.smart4j.framework.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 控制器注解
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Controller {
}

package org.smart4j.framework.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * 服务类注解
 */
@Target(ElementType.TYPE)
@Retention(RetentionPolicy.RUNTIME)
public @interface Service {
}
Controller注解用来标识控制器，学过springMVC的想必很熟悉这个注解,而我们这个Ioc实现的就是在Controller中的被Autowired注解标识的Service依赖注入进去。如下 

/**
 * 控制层
 */
@Controller
public class XxController {

    @Autowired
    private XxService xxService;
}
我们这个框架只用到了Controller和Service这两个Bean，若你想要更多的Bean类型，比如Service中再注入Dao，也可以进行改进，道理都一样。

   Ioc实现思路:我们先在一个properties文件中定义controller层和service层的基础包名，通过Resource定位获取到这个包的绝对路径然后进行扫描，扫描之后将这些Bean类的Class存到一个Set<Class<?>>中(Set中的元素不会重复，所以不必担心有重复Class进入)，然后再根据这个Set集合通过反射构造一个Map<Class<?>,Object>，这个Map的key也就是Set的值，而Map的value是Set的key(也就是Class)执行newInstance出来的对象，这样预先创建对象并存储在Map中也就保证了单例，最后就是依赖注入的操作，通过遍历上面产生的Map集合对key(也就是Class)的判断其中是否有Autowired注解的字段，然后进行注入。
主要代码:

package org.smart4j.framework.helper;

import org.smart4j.framework.annotation.Controller;
import org.smart4j.framework.annotation.Service;
import org.smart4j.framework.util.ClassUtil;

import java.util.HashSet;
import java.util.Set;

/**
 * 类操作助手类
 */
public final class ClassHelper {
    /**
     * 定义类集合(用于存放所加载的类)
     */
    private static final Set<Class<?>> CLASS_SET;

    static{
        String basePackage = ConfigHelper.getAppControllerBasePackage();
        CLASS_SET = ClassUtil.getClassSet(basePackage);           //将Controller包下面的类的Class保存到Set集合
        basePackage = ConfigHelper.getAppServiceBasePackage();
        CLASS_SET.addAll(ClassUtil.getClassSet(basePackage));     //将Service包下面的类的Class保存到Set集合
    }

    /**
     *获取应用包名下的所有类
     */
    public static Set<Class<?>> getClassSet(){
        return null;
    }

    /**
     * 获取应用包名下所有Service类
     */
    public static Set<Class<?>> getServiceClassSet(){
        Set<Class<?>> classSet = new HashSet<Class<?>>();
        for(Class<?> cls : CLASS_SET){
            if (cls.isAnnotationPresent(Service.class)){
                classSet.add(cls);
            }
        }
        return classSet;
    }

    /**
     * 获取应用包名下所有Controller类
     */
    public static Set<Class<?>> getControllerClassSet(){
        Set<Class<?>> classSet = new HashSet<Class<?>>();
        for (Class<?> cls : CLASS_SET){
            if(cls.isAnnotationPresent(Controller.class)){
                classSet.add(cls);
            }
        }
        return classSet;
    }

    /**
     * 获取应用包名下所有的Bean类(包括:Service、Controller等)
     */
    public static Set<Class<?>> getBeanClassSet(){
        Set<Class<?>> beanClassSet = new HashSet<Class<?>>();
        beanClassSet.addAll(getServiceClassSet());
        beanClassSet.addAll(getControllerClassSet());
        return beanClassSet;
    }
}


package org.smart4j.framework.helper;

import org.smart4j.framework.util.ReflectionUtil;

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

/**
 * Bean助手类
 */
public final class BeanHelper {
    /***
     * 定义Bean映射(用于存放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);           //根据存放Class的Set集合构造出Map
        }
    }

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

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

package org.smart4j.framework.helper;

import org.smart4j.framework.annotation.Autowired;
import org.smart4j.framework.util.ArrayUtil;
import org.smart4j.framework.util.CollectionUtil;
import org.smart4j.framework.util.ReflectionUtil;

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)){
            //遍历Bean Map
            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(ArrayUtil.isNotEmpty(beanFields)){
                    //遍历Bean Field
                    for(Field beanField : beanFields){
                        //判断当前Bean Field是否代用Autowired注解
                        if(beanField.isAnnotationPresent(Autowired.class)){
                            Class<?> beanFieldClass = beanField.getType();
                            Object beanFieldInstance = beanMap.get(beanFieldClass);
                            if(beanFieldInstance != null){
                                //通过反射初始化BeanField的值
                                ReflectionUtil.setField(beanInstance,beanField,beanFieldInstance);
                            }
                        }
                    }
                }
            }
        }
    }
}

接下来说说Controller层mvc的实现:

我们要实现的控制层是这个样子的:

package org.smart4j.framework.controller;

import org.smart4j.framework.annotation.Action;
import org.smart4j.framework.annotation.Controller;
import org.smart4j.framework.annotation.Autowired;
import org.smart4j.framework.bean.Data;
import org.smart4j.framework.bean.Param;
import org.smart4j.framework.bean.View;
import org.smart4j.framework.service.HelloService;

import java.util.Date;
import java.util.HashMap;
import java.util.Map;

/**
 * 控制层
 */
@Controller
public class HelloController {

    @Autowired
    private HelloService helloService;

    @Action("get:/hello")
    public View hello(Param param){
        View view = new View("hello.jsp");
        view.addModel("currentTime",new Date());
        helloService.sout();
        return view;
    }

    @Action("post:/getNum")
    public Data getNum(Param param){
        Map map = new HashMap();
        map.put("name","jqk");
        map.put("age",11);
        return new Data(map);
    }
}
学过struts2和springMVC的同学，应该会感觉很熟悉，这个Controller的service在Ioc那块已经被我们注入了，所以我们现在关心的就是里面的Action注解修饰的方法。

这个Controller有hello和getNum两个方法，其中hello是返回页面的action，我们用View来表示返回的页面对象；getNum是返回json数据的action，我们用Data来表示返回的数据对象，还有可以封装的点在于，Action这个注解的值由“:”分为左右两侧，左侧为请求方法，右侧为请求路径，可以封装为Request类表示请求信息，请求信息对应的方法也进行封装由Handler类表示，最后是请求的参数封装到Param这个类中。

Action注解以及javaBean的代码如下:

package org.smart4j.framework.annotation;

import java.lang.annotation.ElementType;
import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.lang.annotation.Target;

/**
 * Action 方法注解
 */
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface Action {
    /**
     * 请求类型与路径
     */
    String value();
}

package org.smart4j.framework.bean;

import org.apache.commons.lang3.builder.EqualsBuilder;
import org.apache.commons.lang3.builder.HashCodeBuilder;

/**
 *封装请求信息
 */
public class Request {
    /**
     * 请求方法
     */
    private String requestMethod;

    /**
     * 请求路径
     */
    private String requestPath;

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

    public String getRequestMethod(){
        return requestMethod;
    }

    public String getRequestPath(){
        return requestPath;
    }

    @Override
    public boolean equals(Object obj) {
        return EqualsBuilder.reflectionEquals(this,obj);
    }
    @Override
    public int hashCode() {
        return HashCodeBuilder.reflectionHashCode(this);
    }
}

package org.smart4j.framework.bean;

import java.lang.reflect.*;

/**
 * 封装Action的信息
 */
public class Handler {
    /**
     * Controller类
     */
    private Class<?> controllerClass;

    /**
     * Action方法
     */
    private Method actionMethod;

    public Handler(Class<?> controllerClass,Method actionMethod){
        this.controllerClass = controllerClass;
        this.actionMethod = actionMethod;
    }

    public Class<?> getControllerClass(){
        return controllerClass;
    }

    public Method getActionMethod(){
        return actionMethod;
    }
}


package org.smart4j.framework.bean;

import org.smart4j.framework.util.CastUtil;

import java.util.Map;

/**
 * 请求参数信息
 */
public class Param {
    private Map<String,Object> paramMap;

    public Param(Map<String,Object> paramMap){
        this.paramMap = paramMap;
    }

    /**
     * 根据参数名获取long型参数值
     */
    public long getLong(String name){
        return CastUtil.castLong(paramMap.get(name));
    }

    /**
     * 获取所有字段信息
     */
    public Map<String,Object> getMap(){
        return paramMap;
    }
}

package org.smart4j.framework.bean;

import org.apache.commons.lang3.builder.EqualsBuilder;
import org.apache.commons.lang3.builder.HashCodeBuilder;

/**
 *封装请求信息
 */
public class Request {
    /**
     * 请求方法
     */
    private String requestMethod;

    /**
     * 请求路径
     */
    private String requestPath;

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

    public String getRequestMethod(){
        return requestMethod;
    }

    public String getRequestPath(){
        return requestPath;
    }

    @Override
    public boolean equals(Object obj) {
        return EqualsBuilder.reflectionEquals(this,obj);
    }
    @Override
    public int hashCode() {
        return HashCodeBuilder.reflectionHashCode(this);
    }
}

package org.smart4j.framework.bean;

/**
 * 返回数据对象
 */
public class Data {
    /**
     * 模型数据
     */
    private Object model;

    public Data(Object model){
        this.model = model;
    }

    public Object getModel(){
        return model;
    }
}
接下来说说Controller的mvc实现思路:在存放类的Class的Set集合中，取出含有Controller注解的Class并对其中含有的方法进行遍历,判断是否含有Action注解，对含有Action注解并且注解值(也就是请求方法:请求路径)满足格式要求的方法，我们用一个Map<Request,Handler>来存放，map的key表示请求信息，map的value表示请求的方法。再定义一个DispatherServlet，这个Servlet用来请求转发，将用户的请求转发给对应的Controller的对应方法，将用户的请求参数封装到Param中，然后通过反射调用controller的对应方法，并对其返回值进行判断，返回值为View对象的返回jsp页面，返回值为Data对象的，返回JSON数据。

主要代码如下:

package org.smart4j.framework.helper;

import org.smart4j.framework.annotation.Action;
import org.smart4j.framework.bean.Handler;
import org.smart4j.framework.bean.Request;
import org.smart4j.framework.util.ArrayUtil;
import org.smart4j.framework.util.CollectionUtil;

import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.lang.reflect.*;

/**
 * 控制器助手类
 */
public final class ControllerHelper {
    /**
     * 用于存放请求与处理器的映射关系(简称Action Map)
     */
    private static final Map<Request,Handler> ACTION_MAP = new HashMap<Request,Handler>();

    static{
        //获取所有的Controller类
        Set<Class<?>> controllerClassSet = ClassHelper.getControllerClassSet();
        if(CollectionUtil.isNotEmpty(controllerClassSet)){
            //遍历这些Controller类
            for(Class<?> controllerClass : controllerClassSet){
                //获取Cntroller类中定义的方法
                Method[] methods = controllerClass.getDeclaredMethods();
                if(ArrayUtil.isNotEmpty(methods)){
                    //遍历这些Controller类中的方法
                    for(Method method : methods){
                        //判断当前方法是否带有Action注解
                        if(method.isAnnotationPresent(Action.class)){
                            //从Action注解中获取URL映射规则
                            Action action = method.getAnnotation(Action.class);
                            String mapping = action.value();
                            //验证URL映射规则
                            if(mapping.matches("\\w+:/\\w*")){
                                String[] array = mapping.split(":");
                                if(ArrayUtil.isNotEmpty(array)&&array.length == 2){
                                    //获取请求方法与请求路径
                                    String requestMethod = array[0];
                                    String requestPath = array[1];
                                    Request request = new Request(requestMethod,requestPath);
                                    Handler handler = new Handler(controllerClass,method);
                                    //初始化Action Map
                                    ACTION_MAP.put(request,handler);
                                }
                            }
                        }
                    }
                }
            }
        }
    }

    /**
     * 获取Handler
     */
    public static Handler getHandler(String requestMethod,String requestPath){
        Request request = new Request(requestMethod,requestPath);
        return ACTION_MAP.get(request);
    }
}

package org.smart4j.framework;

import org.smart4j.framework.bean.Data;
import org.smart4j.framework.bean.Handler;
import org.smart4j.framework.bean.Param;
import org.smart4j.framework.bean.View;
import org.smart4j.framework.helper.BeanHelper;
import org.smart4j.framework.helper.ConfigHelper;
import org.smart4j.framework.helper.ControllerHelper;
import org.smart4j.framework.util.*;

import javax.servlet.*;
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对象(用于注册Servlet)
        ServletContext servletContext = servletConfig.getServletContext();
        //注册处理JSP的Servlet
        ServletRegistration jspServlet = servletContext.getServletRegistration("jsp");
        jspServlet.addMapping(ConfigHelper.getAppJspPath()+"*");
        //注册处理静态资源的默认Servlet
        ServletRegistration defaultServlet = servletContext.getServletRegistration("default");
        defaultServlet.addMapping(ConfigHelper.getAppAssetPath()+"*");
    }

    @Override
    public void service(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        //获取请求方法与请求路径
        String requestMethod = request.getMethod().toLowerCase();
        String requestPath = request.getPathInfo();
        //获取Action处理器
        Handler handler = ControllerHelper.getHandler(requestMethod,requestPath);
        if(handler != null){
            //获取Controller类及其Bean实例
            Class<?> controllerClass = handler.getControllerClass();
            Object controllerBean = BeanHelper.getBean(controllerClass);
            //创建请求参数对象
            Map<String,Object> paramMap = new HashMap<String,Object>();
            Enumeration<String> paramNames = request.getParameterNames();
            while(paramNames.hasMoreElements()){
                String paramName = paramNames.nextElement();
                String paramValue = request.getParameter(paramName);
                paramMap.put(paramName,paramValue);
            }
            String body = CodecUtil.decodeURL(StreamUtil.getString(request.getInputStream()));
            if(StringUtil.isNotEmpty(body)){
                String[] params = 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("/")){
                        response.sendRedirect(request.getContextPath()+path);
                    }else{
                        Map<String,Object> model = view.getModel();
                        for(Map.Entry<String,Object> entry : model.entrySet()){
                            request.setAttribute(entry.getKey(),entry.getValue());
                        }
                        request.getRequestDispatcher(ConfigHelper.getAppJspPath()+path).forward(request,response);
                    }
                }
            }else if(result instanceof Data){
                //返回JSON数据
                Data data = (Data)result;
                Object model = data.getModel();
                if(model != null){
                    response.setContentType("application/json");
                    response.setCharacterEncoding("UTF-8");
                    PrintWriter writer = response.getWriter();
                    String json = JsonUtil.toJson(model);
                    writer.write(json);
                    writer.flush();
                    writer.close();
                }
            }
        }
    }
}
这个类提供加载的统一入口: 

package org.smart4j.framework;

import org.smart4j.framework.helper.BeanHelper;
import org.smart4j.framework.helper.ClassHelper;
import org.smart4j.framework.helper.ControllerHelper;
import org.smart4j.framework.helper.IocHelper;
import org.smart4j.framework.util.ClassUtil;

/**
 * 加载相应的类
 */
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(),true);
        }

    }
}
运行项目查看下结果: 

<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Hello</title>
    <script src="/asset/jquery.js"></script>
    <script src="/asset/hello.js"></script>
</head>
<body>
<h1>Hello!</h1>
<h2>当前时间:${currentTime}</h2>
</body>
</html>
$(function(){
   var url="/getNum";
   var params =  {
      timestamp : new Date()
   }
    $.post(url, params, function(data) {
         alert(data.name+" "+data.age);
    });
});
可以看到MVC以及IOC都已经实现了。

开发过程中遇到的小BUG:

1、 java.lang.NoClassDefFoundError:这个是遇到的最大的麻烦，这个错误不同于java.lang.ClassNotFoundException，这个错误发生只在运行时需要加载对应的类不成功，而不是编译时发生，例如在运行时我们想调用某个类的方法或者访问这个类的静态成员的时候，发现这个类不可用，此时Java虚拟机就会抛出NoClassDefFoundError错误。在开发过程中，我们给特定的几个类都加上了静态成员变量slf4j进行异常日志的打印。

private static final Logger LOGGER = LoggerFactory.getLogger(ClassUtil.class);
但是这个类在动态加载的时候就报出了java.lang.NoClassDefFoundError，当时有点不知所措，经过和同学一下午的排查，并且明确了这个错误发生的条件，最终发现问题出在这个成员变量上，出错的原因，也就是我们的maven少配了slf4j对应的两个logback的依赖，然后在项目的资源文件目录加上logback.xml，这个错误才算解决。

2、Class.forName(className,isInitialized,getClassLoader()):书上的isInitialized设置为false，我也就跟着敲了，但是实际运行当中却发现加载的四个类有一个类并没有被初始化，查阅资料发现，class.forName(className)调用的上述方法设置的isInitialized参数为true，所以class.forName(className)动态加载的类是一定会被初始化的，而inInitialized为false虽然整个加载的执行速度会变快，但是类不一定会被初始化，比如上面提到的IocHelper，若设置为false他就会初始化失败，但是给他增加一个没有用的成员方法，他又会初始化成功。















發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

01-Django REST framwork 板块( 01-REST规范)

文章目錄一、RESTFUL API 設計二、知識點1. 10個restfull規範，分析記憶2. 常見重點分析a. 用過rest framework，那麼寫視圖的時候，都繼承過哪些類？b. 用過比較接近原生的類，還可以繼承原生的其

AggressionStorm 2020-07-08 04:15:54

03-Django REST framwork 板块(03-认证、权限、节流)

文章目錄1. 用戶登錄認證認證梳理：1. 使用2. 源碼流程2. 權限3.訪問頻率控制（節流/限流）源碼流程梳理 1. 用戶登錄認證 a. 有些API需要用戶登錄成功之後，才能訪問；有些無需登錄就能訪問。 b. 基本使用認

AggressionStorm 2020-07-08 04:15:54

Django中models字段含义、用法

Model 文章目錄Model一、model基本結構1.字段名稱、含義2.參數含義3.元信息Meta（干預數據庫建表名等操作）4.擴展二、連表結構 *****1.字段以及參數三、表的操作(正向查詢按字段，反向查詢按表名)1.基本操

AggressionStorm 2020-07-08 04:15:54

02-Django REST framwork 板块(02-CBV、FBV详解)

文章目錄一、CBV / FBV處理請求的實現方式二、CBV詳解1.原理：2.流程3.CBV對csrf的實現三、注意點1. CSRF基於Django的中間件的實現2. CSRF兩種配置方式 一、CBV / FBV處理請求的實現方式

AggressionStorm 2020-07-08 04:15:54

a2.sqlalchemy-操作

文章目錄一、sqlalchemy中的==查詢==分析1、基本查詢filter和filter_by的區別：如何查看sqlalchemey的sql語句表中單個字段查詢first()==one()==get 根據主鍵查詢limit 限制

AggressionStorm 2020-07-08 04:15:54

05-Django REST framwork 板块(06-序列化)

文章目錄6. 序列化一.序列化：**1.寫類****2.字段**重點：**獲取choice字段顯示**3. 自動序列化連表、深度depth4. 生成鏈接（反向解析）2.請求數據校驗： 6. 序列化 兩大功能： 1. 對請求數據

AggressionStorm 2020-07-08 04:15:54

数据库加锁，乐观锁、悲观锁

文章目錄一、概念悲觀鎖（Pessimistic Lock）樂觀鎖（Optimistic Lock）使用場景二、具體實現方式sql層面Django層面 一、概念 悲觀鎖（Pessimistic Lock） 每次獲取數據的時候，都會

AggressionStorm 2020-07-08 04:15:54

Django中间件Middleware

文章目錄django中間件一、中間件詳細分析1.django配置文件`settings.py`2.自定義中間件`middleware.py`3.注意事項：4.看圖分析二、簡化版，以及參數分析三、應用實例 django中間件 一、中

AggressionStorm 2020-07-08 04:15:54

04-Django REST framwork 板块(04-版本、05-解析器)

Django REST framework 板塊 文章目錄Django REST framework 板塊4. 版本a. URL中通過GET傳參()b. 在URL中傳參（推薦使用）總結使用5. 解析器總結使用 4. 版本 共三個

AggressionStorm 2020-07-08 04:15:54

sqlalchemy的QueuePool

文章目錄SQLAlchemy與數據庫連接的QueuePool1. 引入：從常見的一種連接錯誤說起2. 詳解：SQLAlchemy的連接池a.連接複用b.默認使用的[*QueuePool*](http://docs.sqlalche

AggressionStorm 2020-07-08 04:15:44

浅析 Django 处理流程 和 结构分析 django

  在Python 的Web 框架中，Django 是比較成功的。 它是一個高級Python web framework ，鼓勵快速開發和乾淨的

collin1211 2020-07-08 01:38:31

再叙AngularJS

上一篇講到AngularJS是在三月17號，已經過去整整3個月。 當時我也只是AngularJS的入門程序員，文章涉及的內容也只是針對框架的特性和Backbone進行簡單的對比。 在當時，我正在進行內部平臺從Backbone向A

aric_chen 2020-07-07 21:50:48

hibernate扩展原生查询集成spring

在一些應用以及複雜的SQL語句，有的時候我們需要用原生的SQL進行查詢，分享怎麼解決hibernate使用原生並集成到spring中 首先,新建類：MyJdbcTemplate.java 繼承hibernateTemplate

中国人叔叔 2020-07-07 11:08:25

JAVA MVC RSET

allowtransparency="true" frameborder="0" scrolling="no" src="http://hits.sinajs.cn/A1/weiboshare.html?url=http%3A%2F

JRect 2020-07-06 00:32:15

diy面向请求的java框架

這個框架也是爲google app engine準備的。當時感覺直接在gae上sevlet太煩人了，就封裝個簡易的框架。使用的時候只需要配置web.xml中DispacherSevlet和package.properties中的packa

lywybo 2020-07-05 19:40:05