上下文

对文件操作完成后应该立即关闭它们，一种比较古老的方法是 try_finally块 ，但Python提供了一种更为简单的解决方案： with语句 。 with语句的语法为： with 表达式 [as 目标]： 代码块 with语句支持嵌套，支持多个with子句，它们两者可以相互转换。 # 多个with子句 with expr1 as e1 , expr2 as e2 : pass # 嵌套形式 with expr1 as e1 : with expr2 as e2 : pass with语句可以在代码块执行完毕后还原进入代码块时的现场。包含有with语句的代码块的执行过程如下： 计算表达式的值，返回一个上下文管理器对象。 加载上下文管理器对象的__exit__()方法以备后用。 调用上下文管理器对象的__enter__()方法。 如果with语句中设置了目标对象，则将__enter__()方法的返回值赋值给目标对象。 执行with中的代码块。 如果代码正常结束，调用上下文管理器对象的__exit__()方法，其返回值直接忽略。 如果代码执行过程中发生异常，调用上下文管理器对象的__exit__()方法，并将异常类型、值及trackback信息作为参数传递给__exit__()方法。如果__exit__()返回值为false，则异常会被重新抛出；如果其返回值为true，异常被挂起

在 Spring 应用中，所有的对象都在 Spring 容器(container) 里，容器负责对象的创建、配置、装配并管理它们的整个生命周期。 Spring 容器 Spring 容器 并不是只有一个, Spring 自带了多个容器的实现，可以归为两种不同的类型： bean 工厂(org.springframework.beans.factory.eanFactory) 应用上下文(org.springframework.context.ApplicationContext) 虽然两者都可以使用，但是 bean 工厂 对大多数应用来说太低级了，因此我们通常会选择 应用上下文 的形式。 应用上下文 Spring 自带了多种类型的应用上下文： 类型 含义 AnnotationConfigApplicationContext 从一个或多个基于Java配置类中加载 Spring 应用上下文 AnnotationConfigWebApplicationContext 从一个或多个基于Java的配置类中加载Spring Web 应用上下文 ClassPathXmlApplicationContext 从类路径下的一个或多个XML配置文件中加载上下文定义，把应用上下文的定义文件作为类资源 FileSystemXmlapplicationcontext

上下文组织和集成模式的定义 合作关系： 如果两个限界上下文的团队要么一起成功，要么一起失败，那么他们就需要建立起合作关系。两个团队应该在接口的演化上进行合作以同时满足两个系统的需求。应该为相互关联的的软件功能制订好计划表，这样可以确保这些功能在同一个发布中完成。 共享内核： 对模型和代码的共享将产生一种紧密的依赖性。我们需要为共享的的部分模型指定一个显示的边界，并保持共享内核的小型化。共享内核具有特殊的状态，在没有与另一个团队的协商的情况下，这种状态是不能改变的。 客户方-供应方开发： 当两个团队处于一种上游-下游关系时，上游团队的计划中应该顾及到下游团队的需求。 尊奉者： 在存在上游-下游的两个团队中，如果上游团队已经没有动力提供下游团队之所需，下游团队便孤立无援了，只能盲目使用上游团队的模型。 防腐层： 就是上下游之间的翻译层，放在下游上。对于下游客户来说，你需要根据自己的领域模型创建一个单独的层，该层作为上游系统的委派向你的系统提供功能。防腐层通过已有的接口与其他系统交互，而尽量使其他系统无需修改。在防腐层内部，它在你自己的木星和他方模型之间进行翻译转换。 开放主机服务： 定义一种协议，让你的子系统通过该协议来访问你的服务。 发布语言： 在两个限界上下文之间翻译模型需要一种共享的公用的语言。发布语言通常和开放主机系统一起用。 大泥球： 当我们检查已有系统时

Flask之上下文管理 知识储备之问题情境： request中的参数： 单进程单线程 单进程多线程-->reqeust 会因为多个请求，数据发生错乱.--->可以基于threading.local对象 单进程单线程（多协程）threading.local对象做不到（因为一个线程下多个协程同享一个线程的资源） 解决办法： ​ 自定义类似threading.local对象（支持协程）---保证多协程下数据的安全 先来看一下下面这段代码（支持多线程）： # -*- coding: utf-8 -*- """ 1288::{} """ from _thread import get_ident import threading class Local(object): def __init__(self): self.storage = {} self.get_ident = get_ident # 设置值 def set(self, k, v): # 获取线程的唯一标识 ident = self.get_ident() # 通过唯一标识去字典里面取值 origin = self.storage.get(ident) if not origin: origin = {k: v} else: origin[k] = v # 将k,v 保存到 storage中 形式如下 # { # 1023:

本文链接： https://blog.csdn.net/yangcheng33/article/details/52631940 #前言 此前我对线程上下文类加载器（ThreadContextClassLoader，下文使用TCCL表示）的理解仅仅局限于下面这段话： Java 提供了很多服务提供者接口（Service Provider Interface，SPI），允许第三方为这些接口提供实现。常见的 SPI 有 JDBC、JCE、JNDI、JAXP 和 JBI 等。 这些 SPI 的接口由 Java 核心库来提供，而这些 SPI 的实现代码则是作为 Java 应用所依赖的 jar 包被包含进类路径（CLASSPATH）里。SPI接口中的代码经常需要加载具体的实现类。那么问题来了，SPI的接口是Java核心库的一部分，是由**启动类加载器(Bootstrap Classloader)来加载的；SPI的实现类是由系统类加载器(System ClassLoader)**来加载的。引导类加载器是无法找到 SPI 的实现类的，因为依照双亲委派模型，BootstrapClassloader无法委派AppClassLoader来加载类。 而线程上下文类加载器破坏了“双亲委派模型”，可以在执行线程中抛弃双亲委派加载链模式，使程序可以逆向使用类加载器。 一直困恼我的问题就是

前言 年初面试时接触到一道面试题，在聊到SpringMVC时提到了SpringMVC的开发者为何要设计父子容器呢，又或者说是父子容器的设计有什么更实际的作用呢？ 首先要理解对于一个web应用，当期部署在web容器上时，容器会为其提供一个全局上下文环境ServletContext，这个上下文环境将为后续的Spring提供宿主环境。 SpringMVC工作流程 DispatcherServlet上下文继承关系 SpringMVC设计的父子容器 父子容器配置文件 --在web.xml中配置，两个重要的xml:applicationContext.xml和SpringMVC-conf.xml <context-param> <param-name>contextConfigLocation</param-name> <param-value>classpath*:applictionContext.xml</param-value> </context-param> <listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener> <servlet> <servlet-name>dispatcher-servlet</servlet

Spring源码解读之执行流程 1、加载resources下面的context.xml配置文件 public static void main(String[] args){ ClassPathXmlApplicationContext application = new ClassPathXmlApplicationContext("classpath:context.xml"); Test test = application.getBean(Test.class); } 2、context.xml的配置内容为： <?xml version="1.0" encoding="UTF-8"?> <beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans.xsd"> <bean id = "test" class="com.reus.Test" /> </beans> 3、执行流程为

整体概念上：进程是操作系统资源分配的基本单位，而线程是任务调度和执行的基本单位 本质上：进程和线程都是一个时间段的描述，是CPU工作时间段的描述，不过是颗粒大小不同。 　　先说进程： 　　　　背景： 　　　　　　①关于计算机系统：CPU+RAM+各种资源（比如显卡，光驱，键盘，GPS, 等等外设）构成我们的电脑，但是电脑的运行，实际就是CPU和相关寄存器以及RAM之间的事情。 　　　　　　②事实1：CPU太快了，寄存器仅仅能够追的上他的脚步，RAM和别的挂在各总线上的设备完全是望其项背。在多任务执行的时候，CPU总是轮流执行那些任务。 　　　　　　③事实2：CPU在执行某个任务的时候，需要先加载这个任务的程序上下文，然后执行，最后再保存该程序上下文（方便下次继续执行该任务的时候加载）。 　　　　综上：进程就是包括上下文切换的程序执行时间总和 = CPU加载程序上下文+CPU执行该程序+CPU保存程序上下文 　　再说线程： 　　　　一个形象的比喻：进程的颗粒度太大，每次都要有上下文的调入，保存，调出。如果我们把进程比喻为一个运行在电脑上的软件，那么一个软件的执行不可能是一条逻辑执行的，必定有多个分支和多个程序段，就好比要实现程序A，实际分成 a，b，c等多个块组合而成。那么这里具体的执行就可能变成：程序A得到CPU =》CPU加载上下文，开始执行程序A的a小段，然后执行A的b小段

flask的request和session设置方式比较新颖，如果没有这种方式，那么就只能通过参数的传递。 flask是如何做的呢？ 本地线程，保证即使是多个线程，自己的值也是互相隔离。 !/usr/bin/env python # -*- coding:utf-8 -*- import threading local_values = threading.local() def func(num): local_values.name = num import time time.sleep(1) print(local_values.name, threading.current_thread().name) for i in range(20): th = threading.Thread(target=func, args=(i,), name='线程%s' % i) th.start() 上下文原理 !/usr/bin/env python # -*- coding:utf-8 -*- from functools import partial from flask.globals import LocalStack, LocalProxy ls = LocalStack() class RequestContext(object): def __init__(self,

介绍 JavaScript编程的时候总避免不了声明函数和变量，以成功构建我们的系统，但是解释器是如何并且在什么地方去查找这些函数和变量呢？我们引用这些对象的时候究竟发生了什么？ 原始发布：Dmitry A. Soshnikov发布时间：2009-06-27俄文地址：http://dmitrysoshnikov.com/ecmascript/ru-chapter-2-variable-object/英文翻译：Dmitry A. Soshnikov发布时间：2010-03-15英文地址：http://dmitrysoshnikov.com/ecmascript/chapter-2-variable-object/部分难以翻译的句子参考了justinw的中文翻译 大多数ECMAScript程序员应该都知道变量与执行上下文有密切关系： var a = 10; // 全局上下文中的变量 (function () { var b = 20; // function上下文中的局部变量})(); alert(a); // 10alert(b); // 全局变量 "b" 没有声明 并且，很多程序员也都知道，当前ECMAScript规范指出独立作用域只能通过“函数(function)”代码类型的执行上下文创建。也就是说，相对于C/C++来说，ECMAScript里的for循环并不能创建一个局部的上下文