1. 1
    2
    3
    		 
    Scanner input = new Scanner(System.in);
    String s = input.nextLine();
    input.close();
    		 

  2. 1
    2
    		 
    BufferedReader input = new BufferedReader(new InputStreamReader(System.in));
    String s = input.readLine();

IO模型
阻塞IO模型 同步阻塞
非阻塞IO模型 同步非阻塞
IO多路复用模型 同步阻塞
信号驱动IO模型 同步非阻塞
异步IO模型（AIO） 异步非阻塞 

1
 
arr[i] = baseAddress + i*dataTypeSize
 

1
 
array[1] = 10+i*4 =14
 

1
 
List<String> list = Arrays.asList(strs);
 

1
2
3
4
5
6
7
8
9
10
 
<!-- 配置 SpringMvc 的拦截器 -->
<mvc:interceptors> 
 <!-- 配置一个拦截器的 Bean 就可以了 默认是对所有请求都拦截 --> 
 <bean id="myInterceptor" class="com.et.action.MyHandlerInterceptor"></bean> 
 <!-- 只针对部分请求拦截 --> 
 <mvc:interceptor> 
 <mvc:mapping path="/modelMap.do" /> 
 <bean class="com.et.action.MyHandlerInterceptorAdapter" /> 
 </mvc:interceptor>
</mvc:interceptors>
 

1
2
3
4
5
6
7
8
9
10
11
12
 
<filter>
    <filter-name>CharacterEncodingFilter</filter-name>
    <filter-class>org.springframework.web.filter.CharacterEncodingFilter</filter-class>
    <init-param>
        <param-name>encoding</param-name>
        <param-value>utf-8</param-value>
    </init-param>
</filter>
<filter-mapping>
    <filter-name>CharacterEncodingFilter</filter-name>
    <url-pattern>/*</url-pattern>
</filter-mapping>
 

1
 
<bean class="com.exception.MyExceptionHandler" id="exceptionHandler"></bean>
 

  1. 1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    		 
    <beans> 
     <!-- JSON Support --> 
     <bean name="viewResolver"
    class="org.springframework.web.servlet.view.BeanNameViewResolver"/> 
     <bean name="jsonTemplate"
    class="org.springframework.web.servlet.view.json.MappingJackson2JsonV
    iew"/> 
     <bean id="restTemplate"
    class="org.springframework.web.client.RestTemplate"/> 
    </beans>
    		 

  2. 1
    2
    3
    		 
    <beans>
    	<context:annotation-config/>
    </beans>
    		 

  3. 1
    2
    3
    4
    5
    6
    7
    8
    9
    		 
    @Configuration//这个也会被Spring容器托管，注册到容器中，因为他本来就是一个@Component
    //@Configuration代表这是一个配置类就和我们之前看的beans.xml一样
    public class AppConfig{
        @Bean
       // @Bean—注册一个bean，就相当于我们之前写的一个bean标签，这个方法的名字就相当于bean标签中的id属性，这个方法的返回值就相当于bean标签中的class属性
        public MyService myService(){
            return new MyServiceImpl()
        }
    }
    		 

    1
    2
    3
    		 
    <beans>
    	<bean id="myService" class="com.xxx.xxx.MyserviceImpl"></bean>
    </beans>
    		 

    1
    2
    3
    4
    5
    		 
    public static void main(String[] args){
        ApplicationContext ctx = new AnnotationConfigApplicationContext(AppConfig.class);
        MyService myService = ctx.getBean(MyService.class);
        myService.doSomeThing();
    }
    		 

  1. 1
    2
    3
    4
    		 
    @Bean
    public IRule randomRule(){
        return new RandomRule();
    }
    		 

  2. 1
    2
    3
    4
    		 
    userservice:
    	ribbon:
    	NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RandomRule# 负载均衡规则 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
@FeignClient(value="leadnews-article",fallback=ArticleClientFallback.class)
public interface ArticleClient{
    
    @PostMapping("/api/v1/article/save")
    public ResponseReuslt saveArticle(@RequestBody ArticleDto dto);
}


@Compoent
public class ArticleClientFallback implements ArticleClient{
    @Override
    public ResponseResult saveArticle(ArticleDto dto){
        return ResponseResult.errorResult(AppHttpCodeEnum.SERVER_ERROR,"获取数据失败");
    }
}
 

  1. 1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    		 
    if(jedis.setnx(key.lockValue)==1){
        //加锁
        expire(key,100);//设置过期时间
        try{
            do something;
        }catch(){
            
        }finally{
            jedis.del(key);//释放锁
        }
    }
    		 

  2. 1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    		 
    long expires = System.currentTimeMillis()+expireTime;//系统时间+设置过期时间
    String expiresStr = String.valueOf(expires);
    //如果当前锁不存在就返回加锁成功
    if(jedis.setnx(key,expiresStr)==1){
        return true;
    }
    //如果所已经存在，获取锁的过期日期
    String currentValueStr = jedis.get(key);
    //如果获取到的过期时间，小于系统当前时间，表示已经过期
    if(currentValueStr!=null&&Long.parseLong(currentValueStr)<System.currentTImeMillis()){
        //锁已过期，获取上一个锁的过期时间，并设置现在锁的过期时间
        String oldValue = jedis.getSet(key_resource_id.expiresStr);
        if(oldValueStr!=null&&oldValueStr.equals(currentValueStr)){
            //考虑多线程并发的情况，只有一个线程的设置值和当前值相同，他才可以加锁
            return true;
        }
    }
    //其他情况，均返回加锁失败
    return false;
    }
    		 

  3. 1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    		 
    if(jedis.set(key,uni_request_id,"NX","EX",100s)==1){
        //加锁
        try{
            do something;
        }catch(){
            
        }finally{
            //判断是不是当前线程假的锁，是才释放
            if(uni_request_id.equals(jedis.get(key))){
                jedis.del(key);//释放锁
            }
        }
    }

Kafka RocketMQ RabbitMQ
单机吞吐量 17.3w/s 11.6w/s 2.62/s(消息做持久化)
开发语言 Scala/java java Erlang
主要维护者 Apache Alibaba Mozilla/Spring
订阅形式 基于topic，按照topic进行正则匹配的发布订阅模式 基于topic/messageTag，按照消息类型、属性进行正则匹配的发布订阅模式 提供了4种：direct，topic，Headers和fanout。fanout就是广播模式
持久化 支持大量堆积 支持大量堆积 支持少量堆积
顺序消息 支持 支持 不支持
集群方式 天然的Leader-Slave，无状态集群，每台服务器即是Master也是Slave 常用多对Master-Slave模式，开源版本需要手动切换Slave变成Master 支持简单集群，复制模式，对高级集群模式支持不好
性能稳定性 较差 一般 好