syntax = "proto3";
//以外部类模式生成
option java_multiple_files = true;
//所在包名
option java_package = "cn.dxh.practice";
//最外层类名称
option java_outer_classname = "PracticeService";
// 定义服务
service UserService {
//按id查询数据
rpc FindById (FindByIdRequest) returns (FindByIdResponse) {
}
//服务器端流式 RPC
// 客户端发送一个请求给服务端，可获取一个数据流用来读取一系列消息。客户端从返回的数据流里一直读取直到没有更多消息为止。
// 通过在 响应 类型前插入 stream 关键字，可以指定一个服务器端的流方法。
//查询所有符合条件的数据
rpc FindByAge (FindByAgeRequest) returns (stream UserEntity) {
}
//客户端流式 RPC
// 即客户端用提供的一个数据流写入并发送一系列消息给服务端。
// 客户端写入一个消息序列并将其发送到服务器，同样也是使用流。一旦客户端完成消息写入，就等待服务端读取这些消息并返回应答。
// 通过在 请求 类型前指定 stream 关键字来指定一个客户端的流方法。
//删除数据
rpc DeleteById (DeletedByIdRequest) returns (DeletedByIdResponse) {
}
//双向流式 RPC
// 即两边都可以分别通过一个读写数据流来发送一系列消息。这两个数据流操作是相互独立的，所以客户端和服务端能按其希望的任意顺序读写，
// 例如：服务端可以在写应答前等待所有的客户端消息，或者它可以先读一个消息再写一个消息，或者是读写相结合的其他方式。每个数据流里消息的顺序会被保持。
//通过在请求和响应前加 stream 关键字去制定方法的类型。
rpc FindByName (stream FindByNameRequest) returns (stream UserEntity) {
}
}
//按id查询数据参数
message FindByIdRequest {
int64 id = 1;
}
//按id查询数据返回结果
message FindByIdResponse {
string name = 2;
int32 age = 3;
}
//查询语句的条件参数
message FindByAgeRequest {
int32 age = 1;
}
//删除数据的参数
message DeletedByIdRequest {
int64 id = 1;
}
//删除数据的返回结果
message DeletedByIdResponse {
}
//参数
message FindByNameRequest {
}
//实例
message UserEntity {
int64 id = 1;
string name = 2;
int32 age = 3;
string from = 4;
string pwd = 5;
}
此类需要继承 UserServiceGrpc.UserServiceImplBase ,这个类提供了我们定义的接口，继承后并覆盖需要实现的方法。
@Slf4j
@Service
public class UserServiceImpl extends UserServiceGrpc.UserServiceImplBase {
@Resource
private UserMapper userMapper;
/**
* 简单rpc
* 其中StreamObserver是一个应答观察者,用于封装返回的信息,服务器把该信息传给客户端.请求结束要调用onCompleted()方法.
* @param request
* @param responseObserver
*/
@Override
public void findById(FindByIdRequest request, StreamObserver responseObserver) {
try {
long id = request.getId();
userMapper.findById(id)
responseObserver.onNext(UserEntity.newBuilder().build());
// 请求结束
responseObserver.onCompleted();
} catch (Exception e) {
log.error("findById is error");
}
}
/**
* 服务器端流式 RPC
*
* @param request
* @param responseObserver
*/
@Override
public void findByAge(FindByAgeRequest request, StreamObserver responseObserver) {
try {
int age = request.getAge();
List userEntities = userMapper.findByAgs(age);
userEntities.forEach(userEntity -> responseObserver.onNext(UserEntity.newBuilder().build()));
responseObserver.onCompleted();
} catch (Exception e) {
log.error("");
}
}
/**
* 客户端流式 RPC
* 服务端就需要一直监控客户端写入情况,因此需要一个StreamObserver接口,其中onNext方法会在客户端每次写入时调用,当写入完毕时调用onCompleted()方法
* @param responseObserver
* @return
*/
@Override
public StreamObserver deleteById(StreamObserver responseObserver) {
return new StreamObserver() {
@Override
public void onNext(DeletedByIdRequest deletedByIdRequest) {
userMapper.deletedById(deletedByIdRequest.getId());
}
@Override
public void onError(Throwable throwable) {
throwable.printStackTrace();
}
@Override
public void onCompleted() {
responseObserver.onNext(DeletedByIdResponse.newBuilder().build());
responseObserver.onCompleted();
}
};
}
/**
* 双向流式 RPC
*
* @param responseObserver
* @return
*/
@Override
public StreamObserver findByName(StreamObserver responseObserver) {
return new StreamObserver() {
@Override
public void onNext(FindByNameRequest findByNameRequest) {
userMapper.findByName(findByNameRequest.getName());
}
@Override
public void onError(Throwable throwable) {
throwable.printStackTrace();
}
@Override
public void onCompleted() {
responseObserver.onNext(UserEntity.newBuilder().build());
responseObserver.onCompleted();
}
};
}
}
@Component
public class GrpcService {
private int port = 19090;
private Server server;
@Resource
private UserServiceGrpc.UserServiceImplBase userService;
@PostConstruct
public void init() throws IOException {
ThreadFactory threadFactory = new ThreadFactoryBuilder().setDaemon(true)
.setNameFormat("grpc-server-thread-%d")
.build();
ThreadPoolExecutor executor = new ThreadPoolExecutor(10,
100,
60L,
TimeUnit.SECONDS,
new LinkedBlockingQueue<>(),
threadFactory,
new ThreadPoolExecutor.CallerRunsPolicy());
server = ServerBuilder.forPort(port)
.addService(userService)
.executor(executor).build();
server.start();
}
@PreDestroy
public void destroy() {
if (server != null) {
server.shutdown();
}
}
}
psql -h [ip] -U [username] -d [databases]
查询pg库的所有表名称
select tablename from pg_tables where schemaname=’public’;
获取pg表的字段
select column_name from information_schema.columns
where table_name = ‘db_job’;
–查看当前活动的客户端连接数
SELECT count(*) FROM pg_stat_activity WHERE NOT pid=pg_backend_pid();
–查看PostgreSQL正在执行的SQL
SELECT
procpid,
start,
now() - start AS lap,
current_query
FROM
(SELECT
backendid,
pg_stat_get_backend_pid(S.backendid) AS procpid,
pg_stat_get_backend_activity_start(S.backendid) AS start,
pg_stat_get_backend_activity(S.backendid) AS current_query
FROM
(SELECT pg_stat_get_backend_idset() AS backendid) AS S
) AS S ,pg_stat_activity pa
WHERE
current_query <> ‘
ORDER BY
lap DESC;
–查看当前库表和索引的的大小并排序显示前20条
SELECT
nspname,
relname,
relkind as “type”,
pg_size_pretty(pg_table_size(C.oid)) AS size,
pg_size_pretty(pg_indexes_size(C.oid)) AS idxsize,
pg_size_pretty(pg_total_relation_size(C.oid)) as “total”
FROM pg_class C
LEFT JOIN pg_namespace N ON (N.oid = C.relnamespace)
WHERE nspname NOT IN (‘pg_catalog’, ‘information_schema’) AND
nspname !~ ‘^pg_toast’ AND
relkind IN (‘r’,’i’)
ORDER BY pg_total_relation_size(C.oid) DESC
LIMIT 20;
排序：ORDER BY 字段 DESC
模糊不区分大小写查询：UPPER(字段) LIKE UPPER(‘%${search}%’)
查指定条数：LIMIT 长度 OFFSET 起始位置
关联查询：
SELECT fail_count
FROM test_report AS f
INNER JOIN(SELECT MAX(id) AS b_id FROM test_build WHERE job_id = #{jobId}) r
ON f.build_id = r.b_id
去重返回
SELECT DISTINCT
T.parent_id
FROM
db_task AS T
INNER JOIN db_job AS j ON T.status IN (
‘running’,
‘initComplete’,
‘fail’
)
AND j.status IN (‘created’, ‘dispatched’)
1 | > \w /txt |
1 | > \o /txt |
定义
也叫做自查询部分，可以定义一个SQL片断，该SQL片断会被整个SQL语句用到。可以使SQL语句的可读性更高，也可以在UNION ALL的不同部分，作为提供数据的部分。
对于UNION ALL，使用WITH AS定义了一个UNION ALL语句，当该片断被调用2次以上，优化器会自动将该WITH AS短语所获取的数据放入一个Temp表中。而提示meterialize则是强制将WITH AS短语的数据放入一个全局临时表中。很多查询通过该方式都可以提高速度。
用法
1 | WITH cte AS (SELECT * FROM task WHERE status = 1) //相当于创建了一个cte临时表 |
1 | WITH |
1 | WITH cte AS ( |
优点
特性
注意
用法
场景是获取指定任务，但需要修改状态
1 | WITH cte AS ( |
作用： 想用一个表的字段也更新另一个表
用法
场景1： 修改学生表中某学生姓名的同时也修改年级表中此同学姓名，根据学号
1 | UPDATE student AS s SET name = 'aa' FROM grade AS g WHERE s.s_id = g.s_ids |
场景2: 按年级表中某学生姓名修改学生表中某学生姓名，根据学号
1 | UPDATE student AS s SET s.name = g.name FROM grade AS g WHERE s.s_id = g.s_ids |
1 | WITH cte AS ( |
Annotation其实是代码里的特殊标记，这些标记可以在编译、类加载、运行时被读取，并执行相应的处理。通过使用Annotation，程序开发人员可以在不改变原有逻辑的情况下，在源文件嵌入一些补充信息。代码分析工具、开发工具和部署工具可以通过这些补充信息进行验证或者进行部署。
Annotation提供了一条为程序元素设置元数据的方法，从某些方面来看，Annotation就像修饰符一样被使用，可用于修饰包、类、构造器、方法、成员变量、参数、局部变量的声明，这些信息被存储在Annotation的“name=value”对中。
Annotation能被用来为程序元素(类、方法、成员变量等)设置元数据。值得指出的是：Annotation不能影响程序代码的执行，无论增加、删除Annotation，代码都始终如一地执行。如果希望让程序中的Annotation能在运行时起一定的作用，只有通过某种配套的工具对Annotation中的信息进行访问的处理，访问和处理Annotation的工具统称APT（Annotation Processing Tool）
Annotation必须使用工具来处理，工具负责提取Annotation里包含的元数据，工具还会根据这些元数据增加额外的功能。
三个基本的Annotation：
@Override 限定重写父类的方法
@Deprecated 标示已过时
@SuppressWarnings 抑制编译器警告
自定义Annotation
定义新的Annotation类型使用@interface关键字，它用于定义新的Annotation类型。定义一个新的Annotation类型与定义一个接口非常像
定义一个简单的注解：
public @interface GetLog {
}
带成员变量的Annotation，Annotation的成员变量在Annotation定义中以无参数方法的形式声明。其方法名和返回值定义了该成员的名字和类型
同时使用时也要指定相应的变量值
public @interface GetLog {
//定义成员变量
String name();
}
@GetLog(name = "log")
public void getName(){}
我们还可以在定义Annotation的成员变量时为其指定初始值，指定成员变量的初始值可使用default关键字;
public @interface GetLog {
//定义成员变量
String description() default "${description}";
}
根据我们介绍的Annotation是否可以包含成员变量，我们可以把Annotation分为如下两类：
标记Annotation： 一个没有成员定义的Annotation类型被称为标记。这种Annotation仅使用自身的存在与否来为我们提供信息。如前面介绍的@Override。
元数据Annotation：那些包含成员变量的Annotation，因为它们可接受更多元数据，所以也被称为元数据Annotation。
提取Annotation信息
Java使用Annotation接口来代表程序元素前面的注释（反射的时候用它来接收注解对象），该接口是所有Annotation类型的父接口;
Java在java.lang.reflect包下新增了AnnotateElement接口，该接口代表程序中可以接受注释的程序元素，该接口主要有如下几个实现类（注意以下是类:
Class：类定义。
Constructor：构造器定义。
Field：类的成员变量定义。
Method：类的方法定义。
Package：类的包定义。
java.lang.reflect包下主要包含一些实现反射功能工具类，实际上，java.lang.reflect包提供的反射API扩充了读取运行时Annotation的能力。当一个Annotation类型被定义为运行时Annotation后，该注解才是运行时可见，当class文件被装载时被保存在class文件中的Annotation才会被虚拟机读取。
AnnotatedElement接口是所有程序元素（如Class、Method、Constructor）的父接口，所以程序通过反射获取了某个类的AnnotatedElement对象（如Class、Method、Constructor）之后，程序就可以调用该对象的如下三个方法来访问Annotation信息：
getAnnotation(Class
Annotation[] getAnnotations(); //返回该程序元素上存在的所有注释。
boolean isAnnotationPresent(Class<? extends Annotation> annotationClass); //判断该程序元素上是否包含指定类型的注解，存在则返回true，否则返回false。
//@Retention注解指定GetLog注解保留多久
@Retention(RetentionPolicy.RUNTIME)
//@Target注解指定注解能修饰的目标(只能是方法)
@Target(ElementType.METHOD)
public @interface GetLog {
String description() default "${description}";
}
定义Annotation时使用了@Retention和@Target两个系统元注释，其中@Retention注释指定Test注释可以保留多久，@Target注释指定Test注释能修饰的目标（）.
仅仅使用注释来标识程序元素对程序是不会有任何影响的，这也是Java注释的一条重要原则。
@Retention
@Retention只能用于修饰一个Annotation定义，用于指定该Annotation可以保留多长时间，@Retention包含一个RetentionPolicy类型的value成员变量，所以使用@Retention时必须为该value成员变量指定值。
value成员变量的值只能是如下三个：
RetentionPolicy.CLASS: 编译器将把注释记录在class文件中。当运行Java程序时，JVM不在保留注释，这是默认值。
RetentionPolicy.RUNTIME: 编译器将把注释记录在class文件中。当运行Java程序时，JVM也会保留注释，程序可以通过反射获取该注释。
RetentionPolicy.SOURCE: 注解仅存在于源码中，在class字节码文件中不包含。
@Target
@Target也是用于修饰一个Annotation定义，它用于指定被修饰Annotation能用于修饰那些程序元素。@Target Annotation也包含一个名为value的成员变量，该成员变量只能是如下几个：
ElementType.ANNOTATION_TYPE: 指定该策略的Annotation只能修饰Annotation。
ElementType.CONSTRUCTOR: 指定该策略的Annotation能修饰构造器。
ElementType.FIELD: 指定该策略的Annotation只能修饰成员变量。
ElementType.LOCAL_VARIABLE: 指定该策略的Annotation只能修饰局部变量。
ElementType.METHOD: 指定该策略的Annotation只能修饰方法。
ElementType.PACKAGE: 指定该策略的Annotation只能修饰包定义。
ElementType.PARAMETER: 指定该策略的Annotation可以修饰参数。
ElementType.TYPE: 指定该策略的Annotation可以修饰类、接口（包括注释类型）或枚举定义。
@Documented
@Documented用于指定该元Annotation修饰的Annotation类将被javadoc工具提取成文档，如果定义Annotation类时使用了@Documented修饰，则所有使用该Annotation修饰的程序元素的API文档中将会包含该Annotation说明。
@Inherited
@Inherited 元 Annotation指定被它修饰的Annotation将具有继承性：如果某个类使用了A Annotation（定义该Annotation时使用了@Inherited修饰）修饰，则其子类将自动具有A注释.
### AOP
### 动态代理
在线Cron表达式生成器 : http://cron.qqe2.com/
（1）*：表示匹配该域的任意值。假如在Minutes域使用, 即表示每分钟都会触发事件。
（2）?：只能用在DayofMonth和DayofWeek两个域。它也匹配域的任意值，但实际不会。因为DayofMonth和DayofWeek会相互影响。例如想在每月的20日触发调度，不管20日到底是星期几，则只能使用如下写法： 13 13 15 20 * ?, 其中最后一位只能用？，而不能使用，如果使用*表示不管星期几都会触发，实际上并不是这样。
（3）-：表示范围。例如在Minutes域使用5-20，表示从5分到20分钟每分钟触发一次
（4）/：表示起始时间开始触发，然后每隔固定时间触发一次。例如在Minutes域使用5/20,则意味着5分钟触发一次，而25，45等分别触发一次.
（5）,：表示列出枚举值。例如：在Minutes域使用5,20，则意味着在5和20分每分钟触发一次。
（6）L：表示最后，只能出现在DayofWeek和DayofMonth域。如果在DayofWeek域使用5L,意味着在最后的一个星期四触发。
（7）W:表示有效工作日(周一到周五),只能出现在DayofMonth域，系统将在离指定日期的最近的有效工作日触发事件。例如：在 DayofMonth使用5W，如果5日是星期六，则将在最近的工作日：星期五，即4日触发。如果5日是星期天，则在6日(周一)触发；如果5日在星期一到星期五中的一天，则就在5日触发。另外一点，W的最近寻找不会跨过月份 。
（8）LW:这两个字符可以连用，表示在某个月最后一个工作日，即最后一个星期五。
（9）# :用于确定每个月第几个星期几，只能出现在DayofMonth域。例如在4#2，表示某月的第二个星期三。
一
RestClient实例可以通过相应的建立 RestClientBuilder的类，通过创建RestClient#builder(HttpHost…) 静态方法。唯一必需的参数是客户端将与之通信的一个或多个主机，作为HttpHost的实例提供
RestClient restClient = RestClient.builder(
new HttpHost("localhost", 9200, "http"),
new HttpHost("localhost", 9201, "http")).build();
该RestClient班是线程安全的，理想情况下具有相同的生命周期为使用它的应用程序。重要的是它在不再需要时关闭，以便它使用的所有资源得到正确释放，以及底层的http客户端实例及其线程：
restClient.close();
二
RestClientBuilder还允许在构建RestClient实例时可选地设置以下配置参数：
RestClientBuilder builder = RestClient.builder(
new HttpHost("localhost", 9200, "http"));
Header[] defaultHeaders = new Header[]{new BasicHeader("header", "value")};
builder.setDefaultHeaders(defaultHeaders);
设置需要随每个请求一起发送的默认标头，以防止必须为每个请求指定它们
RestClientBuilder builder = RestClient.builder(
new HttpHost("localhost", 9200, "http"));
builder.setMaxRetryTimeoutMillis(10000);
设置在多次尝试同一请求时应该遵守的超时。默认值为30秒，与默认套接字超时相同。如果自定义套接字超时，则应相应地调整最大重试超时
RestClientBuilder builder = RestClient.builder(
new HttpHost("localhost", 9200, "http"));
builder.setFailureListener(new RestClient.FailureListener() {
@Override
public void onFailure(Node node) {
}
});
设置一个侦听器，每次节点出现故障时都会收到通知，以防需要采取措施。启用嗅探失败时在内部使用。
RestClientBuilder builder = RestClient.builder(
new HttpHost("localhost", 9200, "http"));
builder.setNodeSelector(NodeSelector.SKIP_DEDICATED_MASTERS);
设置节点选择器以用于过滤客户端将请求发送到客户端本身的节点之间的节点。这有助于防止在启用嗅探时向专用主节点发送请求。默认情况下，客户端向每个配置的节点发送请求。
RestClientBuilder builder = RestClient.builder(
new HttpHost("localhost", 9200, "http"));
builder.setRequestConfigCallback(
new RestClientBuilder.RequestConfigCallback() {
@Override
public RequestConfig.Builder customizeRequestConfig(
RequestConfig.Builder requestConfigBuilder) {
return requestConfigBuilder.setSocketTimeout(10000);
}
});
设置允许修改默认请求配置的回调（例如，请求超时，身份验证或org.apache.http.client.config.RequestConfig.Builder 允许设置的任何内容 ）
RestClientBuilder builder = RestClient.builder（
new HttpHost（“localhost”，9200，“http”））;
builder.setHttpClientConfigCallback（new HttpClientConfigCallback（）{
@
Override public HttpAsyncClientBuilder customizeHttpClient（
HttpAsyncClientBuilder httpClientBuilder）{
return httpClientBuilder.setProxy（
new HttpHost（“proxy”，9000，“http”））;
}
};
SearchSourceBuilder ssb = new SearchSourceBuilder() ssb.size(100) //构建搜索的query语句 ssb.query(createQuery()) //设置返回字段包含和不包含哪些字段，可为null ssb.fetchSource(new String[],new String[]) //设置超时时间 ssb.timeout(new TimeValue(15,TimeUnit.SECONDS)) //定义参数 SearchRequest sr = new SearchRequest(getIndex()).routing(queryParam.tenantId) sr.source(ssb) //执行获取结果 SearchResponse resp = client.search(sr, RequestOptions.DEFAULT)
index（索引）
相当于mysql中的数据库
type（类型）
相当于mysql中的一张表 (7.x后只有_doc)
document（文档）
相当于mysql中的一行（一条记录）
field（域）
相当于mysql中的一列（一个字段）
节点
一个服务器，由一个名字来标识
集群
一个或多个节点组织在一起
分片
将一份数据划分为多小份的能力，允许水平分割和扩展容量。多个分片可以响应请求，提高性能和吞吐量
创建一个索引（即创建数据库）：（index_name为索引的名称）
PUT index_name
{
“settings” : {
“number_of_shards” : 5,
“number_of_replicas” : 1
}
}
查看索引信息：（即查看数据库）
GET index_name
GET index_name/_settings
查看映射
GET index_name/_mapping
设置映射：(即设置字段类型)
PUT index_name
{
“mappings” : {
“type_name” : {
“properties” : {
“field_name1” : {
“type” : “keyword”
},
“field_name2” : {
“type” : “integet”
},
“field_name3” : {
“type” : “text”,
“analyzer” : “ik_max_word”
}
}
}
}
}
插入文档：（即插入一条数据）
可以指定文档id
PUT index_name/type_name/id （相当于PUT 数据库名/表名/id）
也可以不指定id
POST index_name/type_name
查看文档：
GET index_name/type_name/id
查看_source中的部分字段：
GET index_name/type_name/id?_source=field1,field2
修改文档：
1.一种是通过PUT的全覆盖方式，旧数据将被删除，以新的代替
PUT index_name/type_name/id
2.另一种是通过POST方式，只对部分字段进行修改.
POST index_name/type_name/id/_update
{
“doc” : {
“field_name” : “ “
}
}
删除文档：
DELETE index_name/type_name/id
###安装es
gitHub:
https://github.com/elastic/elasticsearch
@PostConstruct和@PreDestroy这两个作用于Servlet生命周期的注解，实现Bean初始化之前和销毁之前的自定义操作
下载并解压
$ wget https://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-5.5.1.zip
$ unzip elasticsearch-5.5.1.zip
$ cd elasticsearch-5.5.1/
启动 ./bin/elasticsearch
第一次启动时内存不够，将config中jvm.options中的
-Xms512M
-Xmx512M
由于需要修改磁盘，所以不能用root用户启动，需要新建用户
创建新用户并赋权限
第一步：liunx创建新用户 adduser XXX 然后给创建的用户加密码 passwd XXX 输入两次密码。
第二步：切换刚才创建的用户 su XXX 然后执行elasticsearch 会显示Permission denied 权限不足。
第四步：root给XXX赋权限，chown -R XXX /你的elasticsearch安装目录。
查看当前节点的所有索引(index)
curl -X GET ‘http://localhost:9200/_cat/indices?v
列出每个 Index 所包含的 Type
curl ‘localhost:9200/_mapping?pretty=true’
curl -
创建索引：
curl -XPUT ‘localhost:9200/dxh?pretty’
将一个信息索引到dxh下的ljf类型中，这个文档的id为1：
curl -XPUT ‘localhost:9200/dxh/ljf/1?pretty’ -d ‘{ “name”:”dongxiaohua” }’
获取文档：
按文档数量降序列出所有文档信息
GET /_cat/indices?v&s=docs.count:desc
按文档大小降序列出index
GET /_cat/indices?v&h=i,tm&s=tm:desc