Merge pull request #5 from JavaCourse00/main

019caoyu · web-flow · commit c46705d5ef3c · 2021-03-19T09:47:58.000+08:00
merge
diff --git a/04fx/java8/src/main/java/io/kimmking/java8/A.java b/04fx/java8/src/main/java/io/kimmking/java8/A.java
@@ -1,10 +1,19 @@
 package io.kimmking.java8;
 
-import lombok.Data;
+import lombok.*;
+import lombok.extern.slf4j.Slf4j;
 
-@Data
+@ToString
+@NoArgsConstructor
+@AllArgsConstructor
+@Slf4j
+@Builder
+@Getter
+@Setter
 public class A {
-    
+
     private int age;
-    
+
+    private String name;
+
 }
diff --git a/04fx/java8/src/main/java/io/kimmking/java8/GenericDemo.java b/04fx/java8/src/main/java/io/kimmking/java8/GenericDemo.java
@@ -1,9 +1,10 @@
 package io.kimmking.java8;
 
+import java.io.Serializable;
 import java.lang.reflect.ParameterizedType;
 import java.lang.reflect.Type;
 
-public class GenericDemo {
+public class GenericDemo implements Serializable {
     public static void main(String[] args) {
         Demo demo = new Demo();
         Class clazz = demo.getClass();
@@ -20,7 +21,7 @@ public static void main(String[] args) {
         System.out.println(c);
     }
     
-    public static class Person<T> {
+    public static class Person<T extends Serializable> {
         
     }
     
diff --git a/04fx/java8/src/main/java/io/kimmking/java8/GuavaDemo.java b/04fx/java8/src/main/java/io/kimmking/java8/GuavaDemo.java
@@ -48,7 +48,7 @@ private static void testEventBus() {
         // Callback/Listener
         // 
         Student student2 = new Student(2, "KK02");
-        System.out.println("I want " + student2 + " run now.");
+        System.out.println(Thread.currentThread().getName()+" I want " + student2 + " run now.");
         bus.post(new AEvent(student2));
     }
     
@@ -81,6 +81,7 @@ private static List<Integer> testList() {
         List<Integer> list = Lists.newArrayList(4,2,3,5,1,2,2,7,6);
         
         List<List<Integer>> list1 = Lists.partition(list,3);
+
         print(list1);
         return list;
     }
@@ -89,10 +90,11 @@ private static List<String> testString() {
         // 字符串处理
         // 
         List<String> lists = Lists.newArrayList("a","b","g","8","9");
+
         String result = Joiner.on(",").join(lists);
         System.out.println(result);
         
-        String test = "34344,34,34,哈哈";
+        String test = "34344,,,34,34,哈哈";
         lists = Splitter.on(",").splitToList(test);
         System.out.println(lists);
         return lists;
@@ -111,7 +113,7 @@ public static class AEvent{
     
     @Subscribe
     public void handle(AEvent ae){
-        System.out.println(ae.student + " is running.");
+        System.out.println(Thread.currentThread().getName()+" "+ae.student + " is running.");
     }
     
     
diff --git a/04fx/java8/src/main/java/io/kimmking/java8/LambdaDemo.java b/04fx/java8/src/main/java/io/kimmking/java8/LambdaDemo.java
@@ -17,12 +17,20 @@ public Integer operation(int a, int b) {
         };
         
         MathOperation op1 = (a, b) -> 1;
+
+
+        MathOperation op2 = new MathOperation<Integer>() {
+            @Override
+            public Integer operation(int a, int b) {
+                return a+b;
+            }
+        };
         
         // 类型声明
         MathOperation addition = (int a, int b) -> a + b;
     
                 // 不用类型声明
-        MathOperation subtraction = (a, b) -> a - b + 1.0;
+        MathOperation subtraction = (int a, int b) -> a - b + 1.0;
         
         // 大括号中的返回语句
         MathOperation multiplication = (int a, int b) -> { 
@@ -47,9 +55,10 @@ public Integer operation(int a, int b) {
                 System.out.println("Hello " + message);
         
         // 用括号
-        GreetingService greetService2 = (message) ->
-                System.out.println("Hello " + message);
-    
+        GreetingService greetService2 = (message) -> {
+            System.out.println(message);
+        };
+
         GreetingService greetService3 = System.out::println;
     
         Arrays.asList(1,2,3).forEach( x -> System.out.println(x+3));
diff --git a/04fx/java8/src/main/java/io/kimmking/java8/LombokDemo.java b/04fx/java8/src/main/java/io/kimmking/java8/LombokDemo.java
@@ -1,14 +1,19 @@
 package io.kimmking.java8;
 
 import lombok.extern.java.Log;
+import org.slf4j.LoggerFactory;
 
 import java.io.IOException;
 
 @Log
 public class LombokDemo {
-    
+
     public static void main(String[] args) throws IOException {
-        
+
+        A a = new A(1, "KK");
+        System.out.println(a.toString());
+        A.builder().age(1).name("KKK").build();
+
         new LombokDemo().demo();
         
         Student student1 = new Student();
@@ -17,6 +22,7 @@ public static void main(String[] args) throws IOException {
         System.out.println(student1.toString());
         
         Student student2 = new Student(2, "KK02");
+        //student2.init();
         System.out.println(student2.toString());
     }
     
diff --git a/04fx/java8/src/main/java/io/kimmking/java8/StreamDemo.java b/04fx/java8/src/main/java/io/kimmking/java8/StreamDemo.java
@@ -3,11 +3,7 @@
 import com.alibaba.fastjson.JSON;
 
 import java.io.IOException;
-import java.util.Arrays;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Optional;
+import java.util.*;
 import java.util.stream.Collectors;
 
 public class StreamDemo {
@@ -19,14 +15,14 @@ public static void main(String[] args) throws IOException {
         
         // Optional
         Optional<Integer> first = list.stream().findFirst();
-        
+
         System.out.println(first.map(i -> i * 100).orElse(100));
         
         int sum = list.stream().filter( i -> i<4).distinct().reduce(0,(a,b)->a+b);
         System.out.println("sum="+sum);
         
-        //Map map = list.stream().collect(Collectors.toMap(a->a,a->(a+1)));
-        Map<Integer,Integer> map = list.parallelStream().collect(Collectors.toMap(a->a,a->(a+1),(a,b)->a, LinkedHashMap::new));
+        //Map map1 = list.stream().collect(Collectors.toMap(a->a,a->(a+1)));
+        Map<Integer,Integer> map = list.stream().parallel().collect(Collectors.toMap(a->a,a->(a+1),(a,b)->a, LinkedHashMap::new));
         print(map);
         
         
diff --git a/04fx/springboot01/src/main/resources/application.yml b/04fx/springboot01/src/main/resources/application.yml
@@ -18,7 +18,7 @@ spring:
     enabled: true
     max-connections: 10   #连接池最大连接数
     idle-timeout: 30000   #空闲的连接过期时间，默认为30秒
-    
+
     
     
   data:
diff --git a/README.md b/README.md
@@ -1,2 +1,14 @@
 # JavaCourse
-JavaCourse
+Java进阶训练营示例代码。此处代码，一方面作为作业的基本版本，另一方面需要大家通过调整加深自己对技术点的认识。
+
+本课程的三个要素：
+
+1）40%是课程，包括预习、听课、复习总结，形成自己对知识体系的认识和经验，这是最基本的学习方法。
+
+2）30%是作业，作业包括基础版本的必做作业，补充的选做作业，高难度的挑战作业。基本上完成必做可以通过P6的技术面试，完成选做可以通过P7的技术面试，高难度的话可以达到P7+/P8的技术面试水平。这是通过练习，得到第一手的体验。
+
+3）30%是活动，包括且不限于源码分析学习小组，技术文章活动，读书活动，线下技术沙龙，线上技术分享等。通过一群愿意学习的人，在更好的学习氛围中，实现长期深入学习。
+
+## 挑战作业
+
+每个模块的挑战作业：[homework2.0.md](./homework2.0.md) , 能做出来70%的题目，直接联系我，给你推荐一线大厂工作。
diff --git a/homework2.0.md b/homework2.0.md
@@ -31,19 +31,167 @@
 
 #### 3.2-侧重应用：
 
-1. 10-根据课程提供的场景，实现一个订单处理Service，模拟处理100万订单：后面提供模拟数据。
+1. 10-根据课程提供的场景，实现一个订单处理Service，模拟处理100万订单：后面提供模拟数据
 2. 20-使用多线程方法优化订单处理，对比处理性能
 3. 30-使用并发工具和集合类改进订单Service，对比处理性能
-4. 30-使用分布式集群+分库分表方式处理拆分订单，对比处理性能：第6模块讲解分库分表。
-5. 30-使用读写分离和分布式缓存优化订单的读性能：第6、8模块讲解读写分离和缓存。
+4. 30-使用分布式集群+分库分表方式处理拆分订单，对比处理性能：第6模块讲解分库分表
+5. 30-使用读写分离和分布式缓存优化订单的读性能：第6、8模块讲解读写分离和缓存
 
 ### 4. 框架
 
 #### 4.1 Spring AOP
 
-1. 10-讲网关的frontend/backend/filter/router/线程池都改造成Spring配置方式；
-2. 20-基于AOP改造Netty网关，filter和router使用AOP方式实现；
-3. 30-基于前述改造，将网关请求前后端分离，中级使用JMS传递消息；
-4. 30-尝试使用ByteBuddy实现一个简单的基于类的AOP；
-5. 30-尝试使用ByteBuddy与Instrument实现一个简单JavaAgent实现无侵入下的AOP；
+1. 10-讲网关的frontend/backend/filter/router/线程池都改造成Spring配置方式
+2. 20-基于AOP改造Netty网关，filter和router使用AOP方式实现
+3. 30-基于前述改造，将网关请求前后端分离，中级使用JMS传递消息
+4. 30-尝试使用ByteBuddy实现一个简单的基于类的AOP
+5. 30-尝试使用ByteBuddy与Instrument实现一个简单JavaAgent实现无侵入下的AOP
 
+#### 4.2 Spring ORM
+
+1. 基于AOP和自定义注解，实现@MyCache(60)对于指定方法返回值缓存60秒
+2. 自定义实现一个数据库连接池，并整合Hibernate/Mybatis/Spring/SpringBoot
+3. 基于MyBatis实现一个简单的分库分表+读写分离+分布式ID生成方案
+
+### 5. 数据库与性能
+
+1. 模拟1000万订单数据，测试不同方式下导入导出（数据备份还原）MySQL的速度，包括jdbc程序处理和命令行处理，思考和实践，如何提升处理效率
+2. 对MySQL配置不同的数据库连接池（DBCP、C3P0、Druid、Hikari），测试增删改查100万次，对比性能，生成报告
+3. 尝试自己做一个ID生成器（可以模拟Seq或Snowflake）
+4. 尝试实现或改造一个非精确分页的组件，思考是否可以用于改造自己的业务系统
+5. 基于必做作业2.0版本，实现读写分离-数据库中间件版本3.0
+
+### 6. 分库分表
+
+1. 思考总结常用的数据拆分和数据迁移同步方案，以及它们的优势劣势，适用场景，考虑是否可以引入到自己的工作中
+2. 设计实现一个简单的XA分布式事务框架demo，只需要能管理和调用2个MySQL的本地事务即可，不需要考虑全局事务的持久化和恢复、高可用等
+3. 设计实现一个TCC分布式事务框架的简单Demo，需要实现事务管理器，不需要实现全局事务的持久化和恢复、高可用等
+4. 设计实现一个AT分布式事务框架的简单Demo，仅需要支持根据主键id进行的单个删改操作的SQL或插入操作的事务
+
+### 7. RPC与分布式服务化
+
+#### 7.1 RPC与Dubbo
+
+1. 升级作业中的自定义RPC程序：
+- 尝试使用压测并分析优化RPC性能
+- 尝试使用Netty+TCP作为两端传输方式
+- 尝试自定义二进制序列化或者使用kyro/fst等
+- 尝试压测改进后的RPC并分析优化，有问题欢迎群里讨论
+- 尝试将fastjson改成xstream
+- 尝试使用字节码生成方式代替服务端反射
+
+2. 尝试扩展Dubbo
+- 基于上次作业的自定义序列化，实现Dubbo的序列化扩展；
+- 基于上次作业的自定义RPC，实现Dubbo的RPC扩展；
+- 在Dubbo的filter机制上，实现REST权限控制，可参考dubbox；
+- 实现自定义Dubbo的Cluster/Loadbalance扩展，如果一分钟内调用某个服务/提供者超过10次，则拒绝提供服务直到下一分钟；
+- 整合Dubbo+Sentinel，实现限流功能；
+- 整合Dubbo与Skywalking，实现全链路性能监控。
+
+#### 7.2 自定义RPC
+
+1. rpcfx1.1: 给自定义RPC实现简单的分组(group)和版本(version)。
+
+2. rpcfx2.0: 给自定义RPC实现：
+ - 基于zookeeper的注册中心，消费者和生产者可以根据注册中心查找可用服务进行调用(直接选择列表里的最后一个)。
+ - 当有生产者启动或者下线时，通过zookeeper通知并更新各个消费者，使得各个消费者可以调用新生产者或者不调用下线生产者。
+
+3. 在2.0的基础上继续增强rpcfx实现：
+- 3.0: 实现基于zookeeper的配置中心，消费者和生产者可以根据配置中心配置参数（分组，版本，线程池大小等）。
+- 3.1：实现基于zookeeper的元数据中心，将服务描述元数据保存到元数据中心。
+- 3.2：实现基于etcd/nacos/apollo等基座的配置/注册/元数据中心。
+
+4. 在3.2的基础上继续增强rpcfx实现：
+- 4.0：实现基于tag的简单路由；
+- 4.1：实现基于Weight/ConsistentHash的负载均衡;
+- 4.2：实现基于IP黑名单的简单流控；
+- 4.3：完善RPC框架里的超时处理，增加重试参数；
+
+5. 在4.3的基础上继续增强rpcfx实现：
+- 5.0：实现利用HTTP头跨进程传递Context参数（隐式传参）；
+- 5.1：实现消费端mock一个指定对象的功能（Mock功能）；
+- 5.2：实现消费端可以通过一个泛化接口调用不同服务（泛化调用）；
+- 5.3：实现基于Weight/ConsistentHash的负载均衡;
+- 5.4：实现基于单位时间调用次数的流控，可以基于令牌桶等算法；
+
+6. 实现最终版本6.0：压测并分析调优5.4版本。
+
+### 8. 分布式缓存
+
+1. 基于其他各类场景，设计并在示例代码中实现简单demo：
+- 实现分数排名或者排行榜；
+- 实现全局ID生成；
+- 基于Bitmap实现id去重；
+- 基于HLL实现点击量计数。
+- 以redis作为数据库，模拟使用lua脚本实现前面课程的外汇交易事务。
+
+2. 升级改造项目：
+- 实现guava cache的spring cache适配；
+- 替换jackson序列化为fastjson或者fst，kryo；
+- 对项目进行分析和性能调优。
+
+3. 以redis作为基础实现上个模块的自定义rpc的注册中心；
+4. 练习redission的各种功能；
+5. 练习hazelcast的各种功能；
+6. 搭建hazelcast 3节点集群，写入100万数据到一个map，模拟和演示高可用，测试一下性能。
+
+### 9. 分布式消息
+
+#### 9.1 消息队列原理与应用
+
+1. 基于数据库的订单表，模拟消息队列处理订单：
+- 一个程序往表里写新订单，标记状态为未处理(status=0);
+- 另一个程序每隔100ms定时从表里读取所有status=0的订单，打印一下订单数据，然后改成完成status=1；
+- 考虑失败重试策略，考虑多个消费程序如何协作；
+- 将上述订单处理场景，改成使用ActiveMQ发送消息处理模式；
+- 使用java代码，创建一个ActiveMQ Broker Server，并测试它；
+
+2. ActiveMQ/RabbitMQ作业
+- 搭建ActiveMQ的network集群和master-slave主从结构；
+- 基于ActiveMQ的MQTT实现简单的聊天功能或者Android消息推送；
+- 创建一个RabbitMQ，用Java代码实现简单的AMQP协议操作；
+- 搭建RabbitMQ集群，重新实现前面的订单处理；
+- 使用Apache Camel打通上述ActiveMQ集群和RabbitMQ集群，实现所有写入到ActiveMQ上的一个队列q24的消息，自动转发到RabbitMQ；
+- 压测ActiveMQ和RabbitMQ的性能；
+
+3. 演练本课提及的各种生产者和消费者特性。
+
+4. Kafka金融领域实战：在证券或者外汇、数字货币类金融核心交易系统里，对于订单的处理，大概可以分为收单、定序、撮合、清算等步骤。其中我们一般可以用mq来实现订单定序，然后将订单发送给撮合模块。
+- 收单：请实现一个订单的rest接口，能够接收一个订单Order对象；
+- 定序：将Order对象写入到kafka集群的order.usd2cny队列，要求数据有序并且不丢失；
+- 撮合：模拟撮合程序（不需要实现撮合逻辑），从kafka获取order数据，并打印订单信息，要求可重放, 顺序消费, 消息仅处理一次。
+
+#### 9.2 自定义消息中间件
+
+1. v1.0-内存队列：基于内存Queue实现生产和消费API（示例代码已经完成）
+- 创建内存BlockingQueue，作为底层消息存储
+- 定义Topic，支持多个Topic
+- 定义Producer，支持Send消息
+- 定义Consumer，支持Poll消息
+
+2. v2.0-自定义队列：去掉内存Queue，设计自定义Queue，实现消息确认和消费offset
+- 自定义内存Message数组模拟Queue。
+- 使用指针记录当前消息写入位置。
+- 对于每个命名消费者，用指针记录消费位置。
+
+3. v3.0-基于SpringMVC实现MQServer：拆分broker和client(包括producer和consumer)，从单机走向服务器模式。
+- 将Queue保存到web server端
+- 设计消息读写API接口，确认接口，提交offset接口
+- producer和consumer通过httpclient访问Queue
+- 实现消息确认，offset提交
+- 实现consumer从offset增量拉取
+
+4. v4.0-功能全面：增加多种策略（各条之间没有关系，可以任意选择实现），基于TCP实现server->client，从而实现 PUSH模式
+- 考虑实现消息过期，消息重试，消息定时投递等策略
+- 考虑批量操作，包括读写，可以打包和压缩
+- 考虑消息清理策略，包括定时清理，按容量清理、LRU等
+- 考虑消息持久化，存入数据库，或WAL日志文件，或BookKeeper
+- 考虑将spring mvc替换成netty下的tcp传输协议，rsocket/websocket
+
+5. v5.0-优化完善：对接各种技术（各条之间没有关系，可以任意选择实现）
+- 考虑封装 JMS 1.1 接口规范
+- 考虑实现 STOMP 消息规范
+- 考虑实现消息事务机制与事务管理器
+- 对接Spring
+- 对接Camel或Spring Integration
+- 优化内存和磁盘的使用
