小菜鸟

java菜鸟号正在起航

0%

发表于 更新于 分类于 阅读次数： Valine：
本文字数： 252 阅读时长 ≈ 1 分钟

linux交换分区swap

swap交换分区是一块特殊的硬盘空间，当实际内存不够用的时候，操作系统会从内存中取出一部分暂时不用的数据，放到交换分区中，从而为当前运行的程序腾出足够的内存空间，这样就使得应用程序实际可以使用的内存空间将远远超过系统的物理内存。

内核通过硬盘上的存储空间来实现虚拟内存，这块区域称为交换空间。内核不断地在交换空间和实际的物理内存之间反复交换虚拟内存中的内容，使得系统以为它拥有比物理内存更多的可用内存。内核会维护一个内存页面表，指明哪些页面位于物理内存内，哪些页面被换到了磁盘上。

发表于 更新于 分类于 阅读次数： Valine：
本文字数： 154 阅读时长 ≈ 1 分钟

架构演进过程

  • 最一开始使用单一应用架构

    所有功能都在一个服务器上，包含了多个模块和功能

  • 后来演进为垂直应用架构

    由于代码量越来越大，业务越来越复杂，使用垂直应用架构将各个功能分别部署，流量分散到各个子系统

  • 分布式应用架构

    垂直应用相同的代码逻辑在不同的应用中进行复制，而分布式应用架构是将公共的业务逻辑提取出来，形成服务

发表于 更新于 分类于 阅读次数： Valine：
本文字数： 7.2k 阅读时长 ≈ 7 分钟

参数解析

说到参数解析，springmvc中处理参数的是HandlerMethodArgumentResolver接口

1
2
3
4
5
6
7
8
9
10
public interface HandlerMethodArgumentResolver {

   // 判断是否支持该类型参数
   boolean supportsParameter(MethodParameter parameter);

   // 进行参数解析
   Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
         NativeWebRequest webRequest, WebDataBinderFactory binderFactory) throws Exception;

}

其有一个抽象实现类AbstractNamedValueMethodArgumentResolver，有很多有用的子类

  • MapMethodProcessor

    这个用来处理 Map/ModelMap 类型的参数，解析完成后返回 model。

  • PathVariableMethodArgumentResolver

    这个用来处理使用了 @PathVariable 注解并且参数类型不为 Map 的参数，参数类型为 Map 则使用 PathVariableMapMethodArgumentResolver 来处理。

  • PathVariableMapMethodArgumentResolver

    见上。

  • ErrorsMethodArgumentResolver

    这个用来处理 Error 参数，例如我们做参数校验时的 BindingResult。

  • AbstractNamedValueMethodArgumentResolver

    这个用来处理 key/value 类型的参数，如请求头参数、使用了 @PathVariable 注解的参数以及 Cookie 等。

阅读全文 »

发表于 更新于 分类于 阅读次数： Valine：
本文字数： 501 阅读时长 ≈ 1 分钟

tomcat项目部署

tomcat项目部署有三种方式

  • 直接将web项目放在webapps下，tomcat会自动将其部署

  • 在server.xml文件配置<Context>节点，设置相关属性

    1
    2
    <Context path="/test" docBase="/Users/zhanghe/Desktop/user/myself/GitProject/springmvc/target/springmvc-1.0-SNAPSHOT/WEB-INF">
            </Context>

  • 通过Catalina来进行配置，在conf/Catalina/localhost下创建一个对应的xml文件(文件名称为对应的项目站点名字)

    1
    2
    <Context path="/test" docBase="/Users/zhanghe/Desktop/user/myself/GitProject/springmvc/target/springmvc-1.0-SNAPSHOT/WEB-INF">
            </Context>

发表于 更新于 分类于 阅读次数： Valine：
本文字数： 14k 阅读时长 ≈ 12 分钟

HystrixCommand如何执行

有一个HystrixCommandAspect是专门用来处理@HystrixCommand注解的

1
2
3
@Pointcut("@annotation(com.netflix.hystrix.contrib.javanica.annotation.HystrixCommand)")
public void hystrixCommandAnnotationPointcut() {
}

是不是感觉很熟悉，就是一个AOP切面，然后会使用@Around环绕来进行处理 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
@Around("hystrixCommandAnnotationPointcut() || hystrixCollapserAnnotationPointcut()")
public Object methodsAnnotatedWithHystrixCommand(final ProceedingJoinPoint joinPoint) throws Throwable {
  // 获取到对应的执行方法
    Method method = getMethodFromTarget(joinPoint);
    Validate.notNull(method, "failed to get method from joinPoint: %s", joinPoint);
    if (method.isAnnotationPresent(HystrixCommand.class) && method.isAnnotationPresent(HystrixCollapser.class)) {
        throw new IllegalStateException("method cannot be annotated with HystrixCommand and HystrixCollapser " +
                "annotations at the same time");
    }
  // 使用@HystrixCommand注解的话这里的type就是HystrixPointcutType.COMMAND，即得到的CommandMetaHolderFactory
    MetaHolderFactory metaHolderFactory = META_HOLDER_FACTORY_MAP.get(HystrixPointcutType.of(method));
      // 1.创建MetaHolder
    MetaHolder metaHolder = metaHolderFactory.create(joinPoint);
  // 2.创建HystrixInvokable
    HystrixInvokable invokable = HystrixCommandFactory.getInstance().create(metaHolder);
    ExecutionType executionType = metaHolder.isCollapserAnnotationPresent() ?
            metaHolder.getCollapserExecutionType() : metaHolder.getExecutionType();

    Object result;
    try {
      // 这里我就先按照 普通的方式来进行分析了，所以就!metaHolder.isObservable()为true
      // 3.执行
        if (!metaHolder.isObservable()) {
            result = CommandExecutor.execute(invokable, executionType, metaHolder);
        } else {
            result = executeObservable(invokable, executionType, metaHolder);
        }
    } catch (HystrixBadRequestException e) {
        throw e.getCause();
    } catch (HystrixRuntimeException e) {
        throw hystrixRuntimeExceptionToThrowable(metaHolder, e);
    }
    return result;
}

private Observable executeObservable(HystrixInvokable invokable, ExecutionType executionType, final MetaHolder metaHolder) {
    return ((Observable) CommandExecutor.execute(invokable, executionType, metaHolder))
            .onErrorResumeNext(new Func1<Throwable, Observable>() {
                @Override
                public Observable call(Throwable throwable) {
                    if (throwable instanceof HystrixBadRequestException) {
                        return Observable.error(throwable.getCause());
                    } else if (throwable instanceof HystrixRuntimeException) {
                        HystrixRuntimeException hystrixRuntimeException = (HystrixRuntimeException) throwable;
                        return Observable.error(hystrixRuntimeExceptionToThrowable(metaHolder, hystrixRuntimeException));
                    }
                    return Observable.error(throwable);
                }
            });
}
阅读全文 »