Fork me on GitHub
行锋

低头走路,抬头思考


  • 首页

  • 分类

  • 归档

  • 标签

  • 关于

  • 搜索

未命名

发表于 2019-04-15

title: DNS
tags:

  • DNS
    copyright: true
    comments: true
    toc: true
    date: 2019-04-15 22:10:23
    categories: 环境搭建
    password:

BIND服务

  • 开源、稳定、应用广泛的DNS服务
  • 提供服务:1、 域名解析服务;2、权威域名服务;3、DNS工具

image

DNS解析记录分析

  • A记录
  • CNAME
  • MX记录
  • NS记录
    image

未命名

发表于 2019-04-10

title: Maven详解
tags:

  • java
    copyright: true
    comments: true
    toc: true
    date: 2019-04-07 14:41:51
    categories: Java
    password:

http://maven.apache.org/

4.0.0

maven实战 许晓斌
https://juvenshun.iteye.com/category/34725

依赖:依赖是会被传递的(依赖是基于compile依赖,test的就不会依赖过来),scope没写,默认就是compile范围

作用域:

聚合项目:打包方式为pom 聚合、继承

mirrors 私服安装 索引更新 快照开放

区分:maven中的配置文件和maven工厂中的配置文件

profile

设置允许发布

仓库
生命周期和插件

https://www.cnblogs.com/wxgblogs/p/6696229.html

https://blog.csdn.net/u014238498/article/details/82729084

未命名

发表于 2019-04-10

title: JUnit
tags:

  • java
    copyright: true
    comments: true
    toc: true
    date: 2019-03-29 14:41:51
    categories: java
    password:

1.@Test: 测试方法

a)(expected=XXException.class)如果程序的异常和XXException.class一样,则测试通过
    b)(timeout=100)如果程序的执行能在100毫秒之内完成,则测试通过

2.@Ignore: 被忽略的测试方法:加上之后,暂时不运行此段代码

3.@Before: 每一个测试方法之前运行

4.@After: 每一个测试方法之后运行

5.@BeforeClass: 方法必须必须要是静态方法(static 声明),所有测试开始之前运行,注意区分before,是所有测试方法

6.@AfterClass: 方法必须要是静态方法(static 声明),所有测试结束之后运行,注意区分 @After

https://blog.csdn.net/ryo1060732496/article/details/80812395

注意:编写测试类的原则:

①测试方法上必须使用@Test进行修饰

    ②测试方法必须使用public void 进行修饰,不能带任何的参数

    ③新建一个源代码目录来存放我们的测试代码,即将测试代码和项目业务代码分开

    ④测试类所在的包名应该和被测试类所在的包名保持一致

    ⑤测试单元中的每个方法必须可以独立测试,测试方法间不能有任何的依赖

    ⑥测试类使用Test作为类名的后缀(不是必须)

    ⑦测试方法使用test作为方法名的前缀(不是必须)

Redis入门

发表于 2019-04-05 | 分类于 数据库

简介

  • https://redis.io/
  • Lettuce和Jedis的都是连接Redis Server的客户端程序
  • Jedis在实现上是直连redis server,多线程环境下非线程安全,除非使用连接池,为每个Jedis实例增加物理连接
  • Lettuce基于Netty的连接实例(StatefulRedisConnection),可以在多个线程间并发访问,且线程安全,满足多线程环境下的并发访问,同时它是可伸缩的设计,一个连接实例不够的情况也可以按需增加连接实例。

安装配置

macOS

1
2
3
4
5
6
brew install redis
brew services start redis //后台服务方式
redis-server /usr/local/etc/redis.conf //控制台方式
brew services stop redis //关闭redis
redis-cli
redis-cli -h 127.0.0.1 -p

Linux

1
2
3
4
5
解压:tar zxvf redis-4.0.9.tar.gz
移动到: mv redis-4.0.9 /usr/local/
切换到:cd /usr/local/redis-4.0.9/
编译测试 sudo make test
编译安装 sudo make install

配置

配置详解: https://www.cnblogs.com/joshua317/p/5635297.html

插件及破解

https://blog.csdn.net/qq_15071263/article/details/79759973
https://www.cnblogs.com/happyday56/p/3916388.html

https://www.cnblogs.com/it-cen/p/4295984.html

Spring Webflux

发表于 2019-04-01 | 分类于 Spring

SpringFramework5.0添加的新功能,WebFlux本身追随当下最火的Reactive Programming而诞生的框架

参考文章

  • https://www.jianshu.com/p/c029de45d23b
  • https://www.cnblogs.com/niechen/p/9303451.html

https://waylau.gitbooks.io/servlet-3-1-specification/
https://blog.csdn.net/wangyangzhizhou/article/details/52753696

https://www.cnblogs.com/tenglongwentian/p/6219233.html

https://www.oschina.net/news/94804/flux-replace-web-mvc

https://blog.csdn.net/qiyueqinglian/article/details/50619556

https://blog.csdn.net/BiuBiuBiu___/article/details/82347399

https://blog.csdn.net/liumiaocn/article/details/83991147
https://blog.csdn.net/kaige8312/article/details/84334343
https://blog.csdn.net/alinyua/article/details/81103570

http://www.cnblogs.com/ahaii/p/6868003.html

SpringMVC入门

发表于 2019-03-28 | 分类于 Spring

https://www.imooc.com/learn/47

缓存技术与Jetcache

发表于 2019-03-27 | 分类于 Spring

https://github.com/alibaba/jetcache/wiki/Home_CN

1、Cache是高速缓冲存储器 一种特殊的存储器子系统,其中复制了频繁使用的数据以利于快速访问
2、凡是位于速度相差较大的两种硬件/软件之间的,用于协调两者数据传输速度差异的结构,均可称之为 Cache

1、FIFO(First In First Out):
先入先出,很好理解,就和队列一样,先进队列的先出队列。

2、LRU(Least Recently Used):
最近最少使用,意思就是最近读取的数据放在最前面,最早读取的数据放在最后面,如果这个时候有新的数据进来,那么最后面存储的数据淘汰。

3、LFU(Least Frequently Used):
最不常使用,意思就是对存储的数据都会有一个计数引用,然后队列按数据引用次数排序,引用数多的排在最前面,引用数少的排在后面。如果这个时候有新的数据进来,把最后面的数据删除,把新进数据排在最后面,且引用次数为1

https://blog.csdn.net/baidu_33497625/article/details/50801571
https://blog.csdn.net/fouy_yun/article/details/81075344

ttl缓存:https://www.dns.com/supports/594.html

进程内缓存就是我们常用的存储在java虚拟机内存的缓存数据;进程外缓存就是有专门的缓存服务器(缓存数据也是存储在内存中),对外提供统一的缓存
根据缓存数据的存储位置,把缓存分为:进程内缓存、进程外缓存,也可以看做一级缓存、二级缓存。

  • JetCache支持本地TTL、两级缓存和分布式缓存自动刷新
  • 共有4个组件可以使用:RedisCache、TairCache(未在github开源)、CaffeineCache(内存)和简单的LinkedHashMapCache(内存)

SpringCloud入门

发表于 2019-03-26 | 分类于 Spring

http://www.ityouknow.com/springcloud/2016/12/30/springcloud-collect.html

未命名

发表于 2019-03-26

title: Java注解
tags:

  • java
    copyright: true
    comments: true
    toc: true
    date: 2019-03-24 18:41:51
    categories: java
    password:

https://www.imooc.com/learn/456

Java中的常见注解

JDK自带注解

  1. @Override
  2. @Deprecated
  3. @SuppressWarnings(“deprecation”)

常见第三方注解

Spring(@Autowired,@Service,@Repository…),Mybatis(@InsetProvider,@UpdateProvide…)…

自定义注解

Description.java

1
2
3
4
5
6
7
8
9
10
import java.lang.annotation.*;

@Target({ElementType.METHOD,ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Description {
String desc();
int age() default 18;
}
  • @interface表示是定义注解
  • 成员必须以无参无异常方式声明;可通过defalut给出默认值
  • 成员的类型是受限制的,只能是基本类型、String、Class、Annotaion、Enumeration
  • 如果注解只有一个成员,成员名称必须为value(),在使用时可忽略成员名和赋值号
  • 注解类可以没有成员,没有成员的注解称为标识注解

元注解:注解的注解

  • @Target:表示注解的作用域,如ElementType.METHOD-方法,ElementType.TYPE-类,接口
  • @Retention:生命周期,如:SOURCE(只在源码显示)、CLASS(编译时记录到class中,运行时忽略)、RUNTIME(运行时存在,可通过反射读取)
  • @Inherited:表示允许子注解继承,此继承表示子类如果没有自定义此注解的话会继承父类的注解信息(类注解信息)
  • @Documented:表示生成Javadoc时包含注解的信息

使用自定义注解的语法:

1
2
3
4
5
6
@注解名(成员名1=成员值1,成员名2=成员值2,...)
==========================================
@Description(desc="annotation test",age=20)
public String test(){
return "test my annotation"
}

注解的分类

按照运行机制

  • 源码注解:注解只在源码存在,编译成.class文件就没有了
  • 编译时注解:注解在源码和.class文件中都存在,上面JDK自带注解就属于这一类
  • 运行时注解:在运行阶段还起作用,设置会影响程序的运行逻辑,如@Autowired

解析注解

通过反射获取类、函数或成员上的运行时注解信息,从而实现动态控制程序运行的逻辑

1
2
3
4
5
6
7
8
9
package com.anno.test.demo;

@Description(desc="TestAnno class annotaion desc",age=10)
public class TestAnno {
@Description(desc="TestAnno class method annotaion desc",age=1)
public String test(){
return "Hello";
}
}

解析

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
try {
//1 使用类加载器加载类
Class clazz = Class.forName("com.anno.test.demo.TestAnno");
//2 找到类上面的注解
boolean isExistAnno = clazz.isAnnotationPresent(Description.class);
if(isExistAnno){
//2.1 拿到注解实例
Description description = (Description) clazz.getAnnotation(Description.class);
//2.2 获取注解值
System.out.println(description.desc()+" "+ description.age());
}

//3 找到方法上的注解
Method[] methods = clazz.getMethods();
for (Method method:methods) {
boolean isMethodExistAnno = method.isAnnotationPresent(Description.class);
if(isMethodExistAnno){
//3.1 拿到注解实例
Description description = (Description) method.getAnnotation(Description.class);
//3.2 获取注解值
System.out.println(description.desc()+" "+ description.age());
}
}

//4 另一中方式获取方法上的注解
for(Method method :methods){
Annotation[] ans = method.getAnnotations();
for(Annotation an:ans){
if(an instanceof Description){
Description description = (Description)an;
System.out.println(description.desc()+" "+ description.age());
}
}
}
} catch (ClassNotFoundException e) {
e.printStackTrace();
}

项目实战

Hibernate注解生成sql的模仿:

  • 表注解
1
2
3
4
5
6
7
8
9
package com.anno.test.demo;
import java.lang.annotation.*;
@Target({ElementType.TYPE})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Table {
String value();
}
  • 字段注解
1
2
3
4
5
6
7
8
9
package com.anno.test.demo;
import java.lang.annotation.*;
@Target({ElementType.FIELD})
@Retention(RetentionPolicy.RUNTIME)
@Inherited
@Documented
public @interface Column {
String value();
}
  • 实体类
1
2
3
4
5
6
7
8
9
10
11
12
package com.anno.test.demo;
import lombok.Data;
@Data
@Table("User")
public class UserFilter {
@Column("id")
private long id;
@Column("name")
private String name;
@Column("email")
private String email;
}
  • 调用
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
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
public static void testAnno()  throws Exception {
UserFilter filter1 = new UserFilter();
filter1.setId(100);

UserFilter filter2 = new UserFilter();
filter2.setName("jack");

UserFilter filter3 = new UserFilter();
filter3.setEmail("abc@163.com,111@qq.com");

String sql1 = query(filter1);
String sql2 = query(filter2);
String sql3 = query(filter3);

System.out.println(sql1); //select * from User where 1=1 and id=100
System.out.println(sql2); //select * from User where 1=1 and id=0 and name='jack'
System.out.println(sql3); //select * from User where 1=1 and id=0 and email in('abc@163.com','111@qq.com')
}

public static String query(UserFilter filter) throws Exception {
StringBuffer sb = new StringBuffer();
//1 获取UserFilter类类型
Class clazz = Class.forName("com.anno.test.demo.UserFilter");
//2 获取table的名称
boolean isExistTableAnno = clazz.isAnnotationPresent(Table.class);
if(isExistTableAnno){
Table table = (Table)clazz.getAnnotation(Table.class);
String tableName = table.value();
sb.append("select * from ").append(tableName).append(" where 1=1 ");
}
//3 遍历所有字段
Field[] fields = clazz.getDeclaredFields();
for(Field field:fields){
//获取字段名称及值
boolean isExistColumnAnno = field.isAnnotationPresent(Column.class);
if(isExistColumnAnno){
Column column = field.getAnnotation(Column.class);
String columnName = column.value();
//拼装get属性方法
String fieldName = field.getName();
String getMethodName = "get"+fieldName.substring(0,1).toUpperCase() + fieldName.substring(1);
Method getMethod = clazz.getMethod(getMethodName);
Object fieldValueObj = getMethod.invoke(filter);
if(fieldValueObj == null || (fieldValueObj instanceof Long && (Long)fieldValueObj==0))
continue;
sb.append(" and ").append(columnName);
if(fieldValueObj instanceof String) {
if(((String) fieldValueObj).contains(",")){
String[] values = ((String) fieldValueObj).split(",");
sb.append(" in(");
for(String v:values){
sb.append("'").append(v).append("'").append(",");
}
sb.deleteCharAt(sb.length()-1);
sb.append(")");
}else{
sb.append("='").append(fieldValueObj).append("'");
}
}else if(fieldValueObj instanceof Long){
sb.append("=").append(fieldValueObj);
}
}
}
return sb.toString();
}

测试代码路径:https://gitee.com/chetaofeng/myannotation.git

未命名

发表于 2019-03-25

title: 网络协议
tags:

  • java
    copyright: true
    comments: true
    toc: true
    date: 2019-03-29 14:41:51
    categories: Spring
    password:

https://www.cnblogs.com/qishui/p/5428938.html
http://www.cnblogs.com/tsingke/p/8604871.html
https://www.cnblogs.com/lemo-/p/6391095.html

12…50
行锋

行锋

496 日志
15 分类
74 标签
GitHub E-Mail
自古写字楼如青楼,不许楼里见白头
© 2015 — 2019 行锋
博客全站共229.9k字