java 生态

Author: biancheng

java生态学习三.md

@@ -0,0 +1,92 @@
+# 初识Spring Boot
+> 没用过任何java的框架做过web开发，因此要问Sping Boot的优劣到底在哪，我也说不上，自己封装了`tomcat`，开箱即用？
+
+## 入口
+`Spring Boot`程序的入口并非业务代码中的定义了`main函数`的类，而是`Spring Boot`自己定义的`JarLauncher`类，这个也就是`MANIFEST.MF`中的`Main-Class`。而业务中的`main函数`则是通过`getMainClass()`在`MANIFEST.MF`查找`Start-Class`找到然后通过反射调用的。
+```
+    public void run() throws Exception {
+        Class mainClass = Thread.currentThread().getContextClassLoader().loadClass(this.mainClassName);
+        Method mainMethod = mainClass.getDeclaredMethod("main", new Class[]{String[].class});
+        mainMethod.invoke((Object)null, new Object[]{this.args});
+    }
+```
+用`IDEA`创建`Spring Boot`项目会默认生成一个入口类
+```
+@SpringBootApplication
+public class DemoApplication {
+ public static void main(String[] args) {
+  SpringApplication.run(DemoApplication.class, args);
+ }
+}
+```
+其中`Spring Boot`被人喜欢的就是自动化配置，而这点光是从入口类上就可见一斑。
+`@SpringBootApplication`注解类中会调用到`Sping Boot`的核心注解类`@EnableAutoConfiguration`，此类可以帮助`Spring Boot`应用将所有符合条件的`@Configuration`都加载到当前应用创建并使用的`IoC`容器中。
+而`@EnableAutoConfiguration`依靠的也是`AutoConfigurationImportSelector`和`SpringFactoriesLoader`才能产生此效果。
+落实到具体的配置文件是如下代码，这会被`SpringFactoriesLoader.loadFactoryNames`调用。
+```
+public static final String
+    FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";
+```
+> 再通俗说就是把`spring.factories`中需要自动配置的类的全名全都放入了`ImportSelector`，然后用时即取。
+
+## 控制层
+怎么称呼呢？路由？大概就是这么个意思。
+```
+@RestController
+@EnableAutoConfiguration
+public class hello {
+    @RequestMapping(value = {"/hello","/say"},method = RequestMethod.GET)
+    public String say(){
+        return "hello,this is a demo";
+    }
+}
+```
+`@RestController`注解类负责格式化错误输出成`json`，其实还是封装了一层`@Controller`，而且默认的解析框架是`jackson`
+`@RequestMapping`是一个用来处理地址映射的注解类，有六个参数，常用其中三个。
+```
+@RequestMapping(value = {"/hello","/say"},method = {RequestMethod.GET},headers = {})
+```
+上面是比较标准的写法，实际如果是单独路径的话(多路径是或关系)，可以简化写法
+```
+@RequestMapping("/hello");
+```
+`@PathVariable`URL变量设置，这样访问`/hello/1`就可以得到结果了。
+```
+    @RequestMapping(value = {"/hello/{id}"},method = {RequestMethod.GET})
+    public String say(@PathVariable("id") Integer id){
+        if(id==1) {
+            return "hello,this is a demo";
+        }else {
+            return "id=1";
+        }
+    }
+```
+`@RequestParam`参数设置，就是`get`的传参
+```
+    @RequestMapping(value = {"/hello/{id}"},method = {RequestMethod.GET})
+    public String say(@PathVariable("id") Integer id, @RequestParam Integer aa,@RequestParam String name){
+        if(id==1) {
+            return "hello,this is a demo and id:"+aa+"and name:"+name;
+        }else {
+            return "id=1";
+        }
+    }
+```
+> 如果没传入的话可以使用`required=false`+`defaultValue=value`作为`@RequestParam`的参数来设置默认。
+
+## 模块
+如果说`auto-configuration`是亮点的话，那`actuator`就不逊于它，这是`Spring Boot`的自省和监控模块，可以对整个应用进行配置查看和相关功能统计等。
+开启所有的`endpoint`
+```
+management.endpoints.web.exposure.include=*
+```
+至于安全问题，看一圈，有但是很比较难说，还是配置不当吧。
+
+# 参考资料
+* [Spring Boot项目的真实程序入口](https://blog.csdn.net/Fly2Leo/article/details/78612604)
+* [看源码，我为什么建议你先从 SpringBoot 开始](https://www.xttblog.com/?p=4016)
+* [@Controller和@RestController的区别？](https://blog.csdn.net/gg12365gg/article/details/51345601)
+* [springboot之@RequestMapping](https://blog.csdn.net/weixin_36775115/article/details/79541981)
+* [顶(0) 踩(0)
+SpringBoot应用监控Actuator使用的安全隐患](https://xz.aliyun.com/t/2233)
+

java生态学习二.md

@@ -0,0 +1,109 @@
+# MQ中间件 -- kafka
+* 为什么要用到MQ中间件
+* kafka的优劣
+## 为什么要用到MQ中间件
+> `Message Queuing`消息队列
+
+1. 解耦
+
+传统模式下，一个系统接入到另一个系统中，都是通过代码耦合来解决，因此每多一个新系统接入，就要修改一下代码，在这个基础上，产生了api的概念，对接的系统之间商量出相同的数据格式对接即可，同时还可以采用中间件的模式，也就是主系统将所有的数据都写入到一个消息队列中去，需要消息的系统则自己去消息队列中订阅，就像报刊发布一样。
+
+2. 异步
+
+在不同的服务之间有可能会出现处理相同消息的情况，但是由于服务迭代的问题，消息传递的情况很有可能是`A-B-C`这样的，因此如果`C`想要处理数据就必须要等待`B`先处理完把消息传过来，这无疑是低效的，因此`A`完全可以把消息写入一个中间件中，需要处理相同消息的系统主动来消费从而打到异步运行。
+
+3. 削峰
+
+请求并发过大时候，所有的请求都是直接查询的数据库，很容易导致数据库的连接异常，因此可以将所有的请求都写入消息队列里，然后系统根据数据库的并发限制来拉取请求，以此达到短暂的高峰期积压。
+
+然而消息队列带来的负面影响也是存在的，比如系统可用性的问题，多增加一个服务就是多增加一份风险，如果系统之间都通过消息队列来传输数据，如果消息队列挂了，那么所有的系统都将异常。同时还提高了系统复杂性，因为消费消息就要考虑到一致性问题以及如何保证消息不被重复消费，如何保证消息传输可靠，如何做消息丢失的召回。
+
+## 消息队列模式
+现在的消息队列主要应用有三种模式：
+1. `pub/sub模式`，也就是包含了`Topic(主题)`，`Publisher(发布者)`，`Subscriber(订阅者)`，以`topic`为节点，可以有多个`发布者`，同时也可以有多个`订阅者`
+2. `p2p模式`，包含`发送者`，`消息队列`和`接收者`，一个消息只有一个消费者。
+3. `push/pull模式`，也就是现在常用的模式，服务端主动推送消息/客户端主动发起消息请求。
+
+## kafka
+`MQ中间件`有多种，比如`ActiveMQ`，`RabbitMQ`，`kafka`等，展示一个性能对比表
+
+![55734022.png](java生态学习二_files/55734022.png)
+
+就以`kafka`为例子，看下`kafka`的架构。
+
+![56512760.png](java生态学习二_files/56512760.png)
+
+一个`kafka`节点就是一个`broker`，多个组成一个`kafka`集群，`Topic`是消息归类的标识，任何一条消息都要指定`topic`，`producer`和`consumer`是从`broker`中`push/pull`的数据，一条消息可以发送到多个不同的`ConsumerGroup`，但是一个`group`中只有一个`Consumer`可以消费该条信息，而一个`topic`可以分成多个`partition`，其中每个`partition`内部有序。
+
+具体表现是什么呢？
+1. 相同`group`的不同`consumer`获取的数据加起来是一个`topic`发布的数据
+2. 如果`consumer`数量大于`partition`的话，就会有`consumer`收不到信息
+
+一个`producer`发布数据
+```
+kafka-console-producer.sh --broker-list kafka.domain.com:9092 --topic TOPIC_NAME
+```
+而一个`consumer`消费数据
+```
+kafka-console-consumer.sh --bootstrap-server kafka.domain.com:9092 --topic TOPIC_NAME --consumer-property group.id=kafka
+```
+
+# 实时分析器 -- flink
+> 这段时间一直在做这个，坑点太多，不如简明扼要
+
+## 可以处理的数据
+1. `DataStream`
+2. `Table&sql`
+
+层级结构上如图：
+
+![58523413.png](java生态学习二_files/58523413.png)
+
+越上层越慢，但是封装的不错，因此也就越简单。但是坑点也在，就是`SQL`是在`流`的基础上封装的，因此表是实时表，因此就算你用了虚表，那么原来的字段也还是没有的。
+> 最常见的问题就是`SQL`中的`group by`如果后面没有分组的字段，那么这个字段就会丢失无法`select`。
+
+## 窗口
+最常用的聚合，坑点在于得自己处理`窗口数据`，而且更大的坑点在于`时间窗口`默认是`ProcessingTime`，因此需要手动设置`EventTime`的标志位，这就需要用到`waterMark`
+```
+env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);
+```
+处理时间
+```
+        DataStream<Tuple5<Long,String,String,String,String>> waterMarkStream = dataStream.assignTimestampsAndWatermarks(new AssignerWithPeriodicWatermarks<T>() {
+            Long currentMaxTimestamp = 0L;
+            //允许最大乱序时间:10s
+            final Long maxOutofOrderness = 10000L;
+            @Nullable
+            @Override
+            public Watermark getCurrentWatermark() {
+                return new Watermark(currentMaxTimestamp-maxOutofOrderness);
+            }
+            @Override
+            public long extractTimestamp(element, long previousElementTimestamp) {
+                long timestamp = element.f0;
+                currentMaxTimestamp = Math.max(timestamp,currentMaxTimestamp);
+                return timestamp;
+            }
+        });
+```
+提前聚合的`keyby()`，这个个人感觉并不实用，但是涉及到`window`和`No-Key-Window`，最常见的区别在于
+```
+window()和windowAll()
+```
+一个是先分组再聚合，另一个是全量聚合。
+## `map()`和`flatMap()`
+`map()`能做的`flatMap()`都可以，因此用`flatMap()`就行了，作用就是把基础的`DataStream`再清洗一遍。
+## 执行和输出
+输出流的信息的话只需要选取要输出的`流`后面加`print`，如`dataStream.print()`，而整个实时分析器的触发则是在`env.excute()`
+
+## 作用
+如名实时分析处理消息，不同于`hadoop`这样的定时全量分析，能够做到实时分析。具体案例就是实时推荐。
+比如在淘宝搜索食品，此时的推荐商品是电器，如果是全量分析，很有可能在第二天才会推荐食品，而如果是实时分析，则会在第一时间把推荐换成食品。
+
+能处理流就尽量处理流，不要搞`Table&Sql`，虽然更简单，但是坑也多。
+
+# 结语
+刚接触不久，坑很多，还在填。
+
+# 参考资料
+* [flink api](http://flink.iteblog.com/index.html)

java生态学习二_files/55734022.png

@@ -0,0 +1,76 @@
+public class SimpleConsumer {
+    //set get
+    private static String BOOTSTRAP_SERVER="kafka.domain.com:9092";
+    private static String TOPIC_NAME="topic";
+    private static String GROUP_ID="group_id";
+
+    public static void main(String[] args) throws Exception{
+        StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
+        env.enableCheckpointing(3000);
+
+
+        //set EventTime,the default is ProcessingTime
+        env.setStreamTimeCharacteristic(TimeCharacteristic.EventTime);
+
+        //get
+        Properties sourceKafkaProperties = new Properties();
+        sourceKafkaProperties.setProperty("bootstrap.servers",BOOTSTRAP_SERVER);
+        sourceKafkaProperties.setProperty("group.id",GROUP_ID);
+
+        //compress data
+        sourceKafkaProperties.put("compression.type", "gzip");
+        String jaasTemplate = "org.apache.kafka.common.security.plain.PlainLoginModule required username=\"username\" password=\"password\";";
+        sourceKafkaProperties.put("security.protocol", "SASL_PLAINTEXT");
+        sourceKafkaProperties.put("sasl.mechanism", "PLAIN");
+        sourceKafkaProperties.put("sasl.jaas.config", jaasTemplate);
+
+
+        FlinkKafkaConsumer010<String> consumer010 = new FlinkKafkaConsumer010(TOPIC_NAME,new SimpleStringSchema(),sourceKafkaProperties);
+
+
+
+        //解析数据
+        DataStream<T> dataStream=env
+        //DataStream<Long> dataStream=env
+                .addSource(consumer010)
+                .flatMap(new myFunction());
+
+        //抽取timestamp设置watermark
+        DataStream<T> waterMarkStream = dataStream.assignTimestampsAndWatermarks(new AssignerWithPeriodicWatermarks<T>() {
+
+            Long currentMaxTimestamp = 0L;
+            //允许最大乱序时间:10s
+            final Long maxOutofOrderness = 10000L;
+
+            @Nullable
+            @Override
+            public Watermark getCurrentWatermark() {
+                return new Watermark(currentMaxTimestamp-maxOutofOrderness);
+            }
+
+            @Override
+            public long extractTimestamp(T element, long previousElementTimestamp) {
+                long timestamp = element.f0;
+                currentMaxTimestamp = Math.max(timestamp,currentMaxTimestamp);
+
+                return timestamp;
+            }
+        });
+
+
+        
+        DataStream<T> windowDatta = waterMarkStream
+                .timeWindowAll(Time.minutes(1))
+                .apply(new AllWindowFunction<T>, T, TimeWindow>() {
+                    @Override
+                    public void apply(TimeWindow window, Iterable<T> values, Collector<T> out) throws Exception {
+			     T l;
+                        out.collect(l);
+                    }
+                });
+
+        windowDatta.print();
+
+        env.execute("kafka start");
+    }
+}

java生态学习二_files/56512760.png

@@ -0,0 +1,87 @@
+# Spring Boot连接mysql
+`Spring Boot`连接`mysql`可以用`jdbcTemplate`，这是整合好的工具包，特别的方便。不过也踩了个坑。
+
+## 配置
+想要用到连接，就先配置好，就和python的导入模块一样
+```
+  <dependency>
+   <groupId>mysql</groupId>
+   <artifactId>mysql-connector-java</artifactId>
+  </dependency>
+  <dependency>
+   <groupId>org.springframework.boot</groupId>
+   <artifactId>spring-boot-starter-jdbc</artifactId>
+  </dependency>
+```
+`application.properties`中添加连接`mysql`的配置
+```
+spring.datasource.url=jdbc:mysql://127.0.0.1:3306/test
+spring.datasource.username=root
+spring.datasource.password=password
+spring.datasource.driver-class-name=com.mysql.jdbc.Driver
+spring.datasource.max-idle=10
+spring.datasource.max-wait=10000
+spring.datasource.min-idle=5
+spring.datasource.initial-size=5
+```
+用`jdbc`连接到具体的某一个库名。
+> 运行起来可能会爆个小错误，Loading class `com.mysql.jdbc.Driver'. This is deprecated. The new driver class is `com.mysql.cj.jdbc.Driver'. The driver is automatically registered via the SPI and manual loading of the driver class is generally unnecessary.这个不影响项目的运行，就是说`com.mysql.jdbc.Driver`不用了，改用`com.mysql.cj.jdbc.Driver`了，自己改了也行
+
+这就结束了，其余什么都不用配，然而代码里面，还是需要有个注意的。因为是使用的`JdbcTemplate`，不是直接就能用的，要先预定义下
+```
+@Resource
+    private JdbcTemplate jdbcTemplate;
+```
+我一开始直接就调用`JdbcTemplate.queryForList`疯狂出错。查询函数有多个，我选用的是`queryForList`因为会返回一个`LIst`。当然也可以写`query`，然后需要传入自定义的函数。
+## demo
+一个demo
+```
+package com.example.demo;
+
+import org.springframework.boot.autoconfigure.EnableAutoConfiguration;
+import org.springframework.jdbc.core.JdbcTemplate;
+import org.springframework.web.bind.annotation.*;
+
+import javax.annotation.Resource;
+import java.util.List;
+import java.util.Map;
+
+@RestController
+@EnableAutoConfiguration
+public class hello {
+
+    @Resource
+    private JdbcTemplate jdbcTemplate;
+    //输出指定年份所有的信息
+    @RequestMapping(value = {"/hello"},method = {RequestMethod.GET})
+    public String say(@RequestParam(value = "year",required = false,defaultValue = "0") Integer year){
+        if(year==0) {
+            return "请输入正确的年份";
+        }else {
+            String sql = "select * from sales where year="+year;
+            List<Map<String,Object>> list =jdbcTemplate.queryForList(sql);
+
+            return list.toString();
+        }
+    }
+}
+```
+`mybatis`本质上还是对`jdbc`的封装，它的优势在于：
+1. 集中管理
+所有的`sql`都在同一个`xml`文件中，方便管理
+2. 动态生成sql
+可以在`xml`中写条件判断，从而生成不同的`sql语句`
+```
+<select id="getCountByInfo" parameterType="User" resultType="int">
+        select count(*) from user
+        <where>
+            <if test="nickname!=null">
+                and nickname = #{nickname} 
+            </if>
+            <if test="email!=null">
+                and email = #{email} 
+            </if>
+        </where>
+</select>
+```
+劣势在于相比于`jdbc`更慢，因为`jdbc`更底层。