java复制代码// 
int i = 10;
i++;
System.out.println(i); // 11

int k = 10;
++k;
System.out.println(k); // 11

++出现在变量前：
int i = 10;
int k = ++i;
System.out.println(); // 11
System.out.println(); // 11

++出现在变量后：
int i = 10;
int k = i++;
System.out.println(k); // 10
System.out.println(i); // 11

int i = 10;
System.out.println(i++); // 10
// 拆代码:
int temp = i++;
System.out.println(temp); // 10
System.out.println(i); // 11

int i = 10;
System.out.println(++i); // 11
// 拆代码:
int temp = ++i;
System.out.println(temp); // 11
System.out.println(i); // 11

// 原文出自: CSDN-请叫我阿ken

java复制代码byte x = 100; // byte 最大值127
x += 1000; // 编译可以通过，x变量还是byte类型，只不过损失精度了。

x += 1000; 等同于： x = (byte)(x + 1000);
int i = 10;
i += 10; // 等同于: i = i + 10; 累加。

// 原文出自: CSDN-请叫我阿ken

java复制代码String name = "jackson"；
System.out.println("登陆成功，欢迎"+name+"回来");

// 原文出自: CSDN-请叫我阿ken

bash复制代码00000000 00000000 00000000 00000111

bash复制代码正数的补码，原码，反码都是相同的。
＋8的补码，原码，反码，都是 0000 1000。

负数的补码，原码，反码都是用1放在符号位，后面7位有变化：
－8的原码：1000 1000；
－8的反码：1111 0111；
－8的补码：1111 1000。

// 原文出自: CSDN-请叫我阿ken

java复制代码switch(表达式){
case 常量值1;
若干个语句
break;

case 常量值2;
若干个语句
break;
......

case 常量值n;
若干个语句
break;

default;
若干语句
}

// switvh语句中表达式的值可以为byte、short、int、char型;常量值1到常量值n，也是byte、short、int、char型，而且要互不相同。

// 原文出自: CSDN-请叫我阿ken

java复制代码while(true){
System.out.println("死循环");
}

// 原文出自: CSDN-请叫我阿ken

java复制代码do {
循环体；
} while(布尔表达式);
/*最后这个分号很关键*/

// 原文出自: CSDN-请叫我阿ken

java复制代码int i = 0;
do{
System.out.println(i); // 0 1 2 3...8 9
i++;
// 也可直接把上两行代码等价替换为
// System.out.println(i++);
}while(i < 10);

int i = 0;
do{
System.out.println(++i); // 1 2 3 ... 8 9 10
}while(i < 10);

int k = 100;
System.out.println(++k); // 101
System.out.println(k);   // 101

int m = 10;
System.out.println(m++); // 10
System.out.println(m)    // 11

// 原文出自: CSDN-请叫我阿ken

java复制代码for(表达式1; 表达式2; 表达式3) {
循环语句;
}


// 原文出自: CSDN-请叫我阿ken

java复制代码// anli
public class Example_n {
public static void main(String args[]){
long sum = 0, a = 8, item = a, n = 12, i = 1;
for(i = 1; i <= n; i++) {
sum = sum + item;
item = item*10 + a;
}
System.out.println(sum);
}
}


// 原文出自: CSDN-请叫我阿ken

xml复制代码<dependency>
    <groupId>cn.afterturn</groupId>
    <artifactId>easypoi-spring-boot-starter</artifactId>
    <version>4.4.0</version>
</dependency>
复制代码

typescript复制代码/**
 * 购物会员
 * Created by macro on 2021/10/12.
 */
@Data
@EqualsAndHashCode(callSuper = false)
public class Member {
    @Excel(name = "ID", width = 10)
    private Long id;
    @Excel(name = "用户名", width = 20, needMerge = true)
    private String username;
    private String password;
    @Excel(name = "昵称", width = 20, needMerge = true)
    private String nickname;
    @Excel(name = "出生日期", width = 20, format = "yyyy-MM-dd")
    private Date birthday;
    @Excel(name = "手机号", width = 20, needMerge = true, desensitizationRule = "3_4")
    private String phone;
    private String icon;
    @Excel(name = "性别", width = 10, replace = {"男_0", "女_1"})
    private Integer gender;
}
复制代码

less复制代码/**
 * EasyPoi导入导出测试Controller
 * Created by macro on 2021/10/12.
 */
@Controller
@Api(tags = "EasyPoiController", description = "EasyPoi导入导出测试")
@RequestMapping("/easyPoi")
public class EasyPoiController {

    @ApiOperation(value = "导出会员列表Excel")
    @RequestMapping(value = "/exportMemberList", method = RequestMethod.GET)
    public void exportMemberList(ModelMap map,
                                 HttpServletRequest request,
                                 HttpServletResponse response) {
        List<Member> memberList = LocalJsonUtil.getListFromJson("json/members.json", Member.class);
        ExportParams params = new ExportParams("会员列表", "会员列表", ExcelType.XSSF);
        map.put(NormalExcelConstants.DATA_LIST, memberList);
        map.put(NormalExcelConstants.CLASS, Member.class);
        map.put(NormalExcelConstants.PARAMS, params);
        map.put(NormalExcelConstants.FILE_NAME, "memberList");
        PoiBaseView.render(map, request, response, NormalExcelConstants.EASYPOI_EXCEL_VIEW);
    }
}
复制代码

less复制代码/**
 * EasyPoi导入导出测试Controller
 * Created by macro on 2021/10/12.
 */
@Controller
@Api(tags = "EasyPoiController", description = "EasyPoi导入导出测试")
@RequestMapping("/easyPoi")
public class EasyPoiController {

    @ApiOperation("从Excel导入会员列表")
    @RequestMapping(value = "/importMemberList", method = RequestMethod.POST)
    @ResponseBody
    public CommonResult importMemberList(@RequestPart("file") MultipartFile file) {
        ImportParams params = new ImportParams();
        params.setTitleRows(1);
        params.setHeadRows(1);
        try {
            List<Member> list = ExcelImportUtil.importExcel(
                    file.getInputStream(),
                    Member.class, params);
            return CommonResult.success(list);
        } catch (Exception e) {
            e.printStackTrace();
            return CommonResult.failed("导入失败！");
        }
    }
}
复制代码

less复制代码/**
 * 商品
 * Created by macro on 2021/10/12.
 */
@Data
@EqualsAndHashCode(callSuper = false)
public class Product {
    @Excel(name = "ID", width = 10)
    private Long id;
    @Excel(name = "商品SN", width = 20)
    private String productSn;
    @Excel(name = "商品名称", width = 20)
    private String name;
    @Excel(name = "商品副标题", width = 30)
    private String subTitle;
    @Excel(name = "品牌名称", width = 20)
    private String brandName;
    @Excel(name = "商品价格", width = 10)
    private BigDecimal price;
    @Excel(name = "购买数量", width = 10, suffix = "件")
    private Integer count;
}
复制代码

less复制代码/**
 * 订单
 * Created by macro on 2021/10/12.
 */
@Data
@EqualsAndHashCode(callSuper = false)
public class Order {
    @Excel(name = "ID", width = 10,needMerge = true)
    private Long id;
    @Excel(name = "订单号", width = 20,needMerge = true)
    private String orderSn;
    @Excel(name = "创建时间", width = 20, format = "yyyy-MM-dd HH:mm:ss",needMerge = true)
    private Date createTime;
    @Excel(name = "收货地址", width = 20,needMerge = true )
    private String receiverAddress;
    @ExcelEntity(name = "会员信息")
    private Member member;
    @ExcelCollection(name = "商品列表")
    private List<Product> productList;
}
复制代码

less复制代码/**
 * EasyPoi导入导出测试Controller
 * Created by macro on 2021/10/12.
 */
@Controller
@Api(tags = "EasyPoiController", description = "EasyPoi导入导出测试")
@RequestMapping("/easyPoi")
public class EasyPoiController {

    @ApiOperation(value = "导出订单列表Excel")
    @RequestMapping(value = "/exportOrderList", method = RequestMethod.GET)
    public void exportOrderList(ModelMap map,
                                HttpServletRequest request,
                                HttpServletResponse response) {
        List<Order> orderList = getOrderList();
        ExportParams params = new ExportParams("订单列表", "订单列表", ExcelType.XSSF);
        //导出时排除一些字段
        params.setExclusions(new String[]{"ID", "出生日期", "性别"});
        map.put(NormalExcelConstants.DATA_LIST, orderList);
        map.put(NormalExcelConstants.CLASS, Order.class);
        map.put(NormalExcelConstants.PARAMS, params);
        map.put(NormalExcelConstants.FILE_NAME, "orderList");
        PoiBaseView.render(map, request, response, NormalExcelConstants.EASYPOI_EXCEL_VIEW);
    }
}
复制代码

typescript复制代码/**
 * 自定义字段处理
 * Created by macro on 2021/10/13.
 */
public class MemberExcelDataHandler extends ExcelDataHandlerDefaultImpl<Member> {

  @Override
  public Object exportHandler(Member obj, String name, Object value) {
    if("昵称".equals(name)){
      String emptyValue = "暂未设置";
      if(value==null){
        return super.exportHandler(obj,name,emptyValue);
      }
      if(value instanceof String&&StrUtil.isBlank((String) value)){
        return super.exportHandler(obj,name,emptyValue);
      }
    }
    return super.exportHandler(obj, name, value);
  }

  @Override
  public Object importHandler(Member obj, String name, Object value) {
    return super.importHandler(obj, name, value);
  }
}
复制代码

less复制代码/**
 * EasyPoi导入导出测试Controller
 * Created by macro on 2021/10/12.
 */
@Controller
@Api(tags = "EasyPoiController", description = "EasyPoi导入导出测试")
@RequestMapping("/easyPoi")
public class EasyPoiController {

    @ApiOperation(value = "导出会员列表Excel")
    @RequestMapping(value = "/exportMemberList", method = RequestMethod.GET)
    public void exportMemberList(ModelMap map,
                                 HttpServletRequest request,
                                 HttpServletResponse response) {
        List<Member> memberList = LocalJsonUtil.getListFromJson("json/members.json", Member.class);
        ExportParams params = new ExportParams("会员列表", "会员列表", ExcelType.XSSF);
        //对导出结果进行自定义处理
        MemberExcelDataHandler handler = new MemberExcelDataHandler();
        handler.setNeedHandlerFields(new String[]{"昵称"});
        params.setDataHandler(handler);
        map.put(NormalExcelConstants.DATA_LIST, memberList);
        map.put(NormalExcelConstants.CLASS, Member.class);
        map.put(NormalExcelConstants.PARAMS, params);
        map.put(NormalExcelConstants.FILE_NAME, "memberList");
        PoiBaseView.render(map, request, response, NormalExcelConstants.EASYPOI_EXCEL_VIEW);
    }
}
复制代码

lua复制代码--KEYS[1]: 锁key
--ARGV[1]: 锁value,随机字符串
--ARGV[2]: 过期时间
--判断锁key持有的value是否等于传入的value
--如果相等说明是再次获取锁并更新获取时间，防止重入时过期
--这里说明是“可重入锁”
if redis.call("GET", KEYS[1]) == ARGV[1] then
    --设置
    redis.call("SET", KEYS[1], ARGV[1], "PX", ARGV[2])
    return "OK"

else
    --锁key.value不等于传入的value则说明是第一次获取锁
    --SET key value NX PX timeout : 当key不存在时才设置key的值
    --设置成功会自动返回“OK”，设置失败返回“NULL Bulk Reply”
    --为什么这里要加“NX”呢，因为需要防止把别人的锁给覆盖了
    return redis.call("SET", KEYS[1], ARGV[1], "NX", "PX", ARGV[2])
end

lua复制代码--释放锁
--不可以释放别人的锁
if redis.call("GET", KEYS[1]) == ARGV[1] then
    --执行成功返回“1”
    return redis.call("DEL", KEYS[1])
else
    return 0
end

go复制代码package redis

import (
	"math/rand"
	"strconv"
	"sync/atomic"
	"time"

	red "github.com/go-redis/redis"
	"github.com/tal-tech/go-zero/core/logx"
)

const (
	letters     = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
	lockCommand = `if redis.call("GET", KEYS[1]) == ARGV[1] then
    redis.call("SET", KEYS[1], ARGV[1], "PX", ARGV[2])
    return "OK"
else
    return redis.call("SET", KEYS[1], ARGV[1], "NX", "PX", ARGV[2])
end`
	delCommand = `if redis.call("GET", KEYS[1]) == ARGV[1] then
    return redis.call("DEL", KEYS[1])
else
    return 0
end`
	randomLen = 16
	//默认超时时间，防止死锁
	tolerance       = 500 // milliseconds
	millisPerSecond = 1000
)

// A RedisLock is a redis lock.
type RedisLock struct {
	//redis客户端
	store *Redis
	//超时时间
	seconds uint32
	//锁key
	key string
	//锁value，防止锁被别人获取到
	id string
}

func init() {
	rand.Seed(time.Now().UnixNano())
}

// NewRedisLock returns a RedisLock.
func NewRedisLock(store *Redis, key string) *RedisLock {
	return &RedisLock{
		store: store,
		key:   key,
        //获取锁时，锁的值通过随机字符串生成
        //实际上go-zero提供更加高效的随机字符串生成方式
        //见core/stringx/random.go：Randn
		id:    randomStr(randomLen),
	}
}

// Acquire acquires the lock.
//加锁
func (rl *RedisLock) Acquire() (bool, error) {
	//获取过期时间
	seconds := atomic.LoadUint32(&rl.seconds)
	//默认锁过期时间为500ms，防止死锁
	resp, err := rl.store.Eval(lockCommand, []string{rl.key}, []string{
		rl.id, strconv.Itoa(int(seconds)*millisPerSecond + tolerance),
	})
	if err == red.Nil {
		return false, nil
	} else if err != nil {
		logx.Errorf("Error on acquiring lock for %s, %s", rl.key, err.Error())
		return false, err
	} else if resp == nil {
		return false, nil
	}

	reply, ok := resp.(string)
	if ok && reply == "OK" {
		return true, nil
	}

	logx.Errorf("Unknown reply when acquiring lock for %s: %v", rl.key, resp)
	return false, nil
}

// Release releases the lock.
//释放锁
func (rl *RedisLock) Release() (bool, error) {
	resp, err := rl.store.Eval(delCommand, []string{rl.key}, []string{rl.id})
	if err != nil {
		return false, err
	}

	reply, ok := resp.(int64)
	if !ok {
		return false, nil
	}

	return reply == 1, nil
}

// SetExpire sets the expire.
//需要注意的是需要在Acquire()之前调用
//不然默认为500ms自动释放
func (rl *RedisLock) SetExpire(seconds int) {
	atomic.StoreUint32(&rl.seconds, uint32(seconds))
}

func randomStr(n int) string {
	b := make([]byte, n)
	for i := range b {
		b[i] = letters[rand.Intn(len(letters))]
	}
	return string(b)
}

typescript复制代码/**
 * >1 引入，常规判断一个学生的学校是不是公立学校，判断是否成年
 */
public static boolean checkIsPublicV1(Student student) {
    if (student != null) {
        School school = student.getSchool();
        if (school != null) {
            return school.isPublicFlag();
        }
    }
    throw new RuntimeException("参数异常");
}

public static String getAdultV1(Student student) {
    if (student != null) {
        int age = student.getAge();
        if (age > 18) {
            return student.getName();
        }
    }
    return "无";
}
复制代码

csharp复制代码private final T value;

private Optional() {
    this.value = null;
}

private Optional(T var1) {
    this.value = Objects.requireNonNull(var1);
}
复制代码

csharp复制代码private static final Optional<?> EMPTY = new Optional();

private Optional() {
    this.value = null;
}

public static <T> Optional<T> empty() {
    Optional var0 = EMPTY;
    return var0;
}
复制代码

typescript复制代码public static <T> Optional<T> of(T var0) {
    return new Optional(var0);
}
复制代码

scss复制代码public static <T> Optional<T> ofNullable(T var0) {
    return var0 == null ? empty() : of(var0);
}
复制代码

ini复制代码public static void testOptionalBuild() {
    // 1. 无法直接new 'Optional()' has private access in 'java.util.Optional'
    // Optional<School> school = new Optional<>();

    // 2. of构建非空和空对象(NullPointerException)
    /*Optional<String> o1 = Optional.of("test");
    System.out.println(o1);
    Optional<Object> o2 = Optional.of(null);
    System.out.println(o2);*/

    // 3. ofNullable构建非空和空对象(Optional.empty)
    /*Optional<String> o3 = Optional.ofNullable("test");
    System.out.println(o3);
    Optional<Object> o4 = Optional.ofNullable(null);
    System.out.println(o4);*/
}
复制代码

typescript复制代码public <U> Optional<U> map(Function<? super T, ? extends U> var1) {
    Objects.requireNonNull(var1);
    return !this.isPresent() ? empty() : ofNullable(var1.apply(this.value));
}
复制代码

kotlin复制代码public <U> Optional<U> flatMap(Function<? super T, Optional<U>> var1) {
    Objects.requireNonNull(var1);
    return !this.isPresent() ? empty() : (Optional)Objects.requireNonNull(var1.apply(this.value));
}
复制代码

scss复制代码public static void testOptionalMap() {
    Student student1 = getDefaultStudent();
    Student student2 = getBackStudent();
    // map
    String school1 = Optional.ofNullable(student1).map(i -> i.getName()).orElse("无名");
    String school2 = Optional.ofNullable(student2).map(i -> i.getName()).orElse("无名");
    System.out.println("school1: " + school1 + "| school2: " + school2);
    // flapMap 链式
    String school3 = Optional.ofNullable(getOptionalStudent()).flatMap(i -> getOptionalStudent()).flatMap(i->i.getSchool()).map(i->i.getSchoolName()).orElse("没上大学");
    System.out.println("school3: " + school3);
}
复制代码

kotlin复制代码public T orElse(T var1) {
    return this.value != null ? this.value : var1;
}
复制代码

kotlin复制代码public T orElseGet(Supplier<? extends T> var1) {
    return this.value != null ? this.value : var1.get();
}
public T get() {
    if (this.value == null) {
        throw new NoSuchElementException("No value present");
    } else {
        return this.value;
    }
}
复制代码

kotlin复制代码public <X extends Throwable> T orElseThrow(Supplier<? extends X> var1) throws X {
    if (this.value != null) {
        return this.value;
    } else {
        throw (Throwable)var1.get();
    }
}
复制代码

scss复制代码public static void testOptionalOrElse() {
    // orElse
    Student stu = getDefaultStudent();
    Student backStudent = getBackStudent();
    Student realStu1 = Optional.ofNullable(stu).orElse(backStudent);
    System.out.println(realStu1);

    // orElseGet
    Student realStu2 = Optional.ofNullable(stu).orElseGet(()-> getBackStudent());
    System.out.println(realStu2);

    // orElseGet
    Student realStu3 = Optional.ofNullable(stu).orElseThrow(()-> new RuntimeException("学生不存在"));
    System.out.println(realStu3);
}
复制代码

typescript复制代码public boolean isPresent() {
    return this.value != null;
}
复制代码

typescript复制代码public void ifPresent(Consumer<? super T> var1) {
    if (this.value != null) {
        var1.accept(this.value);
    }
}
复制代码

scss复制代码public static void testOptionalIfPresent() {
    // isPresent()
    Student student1 = getDefaultStudent();
    Student student2 = getBackStudent();
    boolean b1 = Optional.ofNullable(student1).isPresent();
    boolean b2 = Optional.ofNullable(student2).isPresent();
    System.out.println("b1: " + b1 + "| b2: " + b2);

    // isPresent(Consumer)
    Optional.ofNullable(student2).ifPresent(i-> acceptStudent(i, LocalDate.now()));
}
复制代码

kotlin复制代码public Optional<T> filter(Predicate<? super T> var1) {
    Objects.requireNonNull(var1);
    if (!this.isPresent()) {
        return this;
    } else {
        return var1.test(this.value) ? this : empty();
    }
}
复制代码

scss复制代码public static void testOptionalFilter() {
    Student student1 = getDefaultStudent();
    Student student2 = getBackStudent();
    System.out.println(student1);
    System.out.println(student2);
    Student student3 = Optional.ofNullable(student1).filter(i -> i.getAge() > 18).orElse(getBackStudent());
    Student student4 = Optional.ofNullable(student2).filter(i -> i.getAge() > 18).orElse(getBackStudent());
    System.out.println(student3);
    System.out.println(student4);
}
复制代码

scss复制代码/**
 * 实战1
 * 针对原来的checkIsPublicV1进行改造
 */
public static boolean checkIsPublicV2(Student student) {
    return Optional.ofNullable(student).map(i -> i.getSchool()).map(i -> i.isPublicFlag()).orElseThrow(() -> new RuntimeException("参数异常"));
}

/**
 * 实战1
 * 针对原来的getAdultV1进行改造
 */
public static String getAdultV2(Student student) {
    return Optional.ofNullable(student).filter(i->i.getAge()>18).map(i->i.getName()).orElseGet(()->getDefaultStudent().getName());
}
复制代码

typescript复制代码public static void main(String[] args) {
    //逐个放开
    // 引入
//        System.out.println(checkIsPublicV1(stu2));
//        System.out.println(getAdultV1(stu2));
    // optional方法
//        testOptionalBuild();
//        testOptionalOrElse();
//        testOptionalIfPresent();
//        testOptionalMap();
//        testOptionalFilter();
    // 实战
//        System.out.println(getAdultV2(stu3));
//        System.out.println(checkIsPublicV2(stu3));
}

/**========模型数据=======**/
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
static class Student {
    private String name;
    private int age;
    private School school;
}

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
static class School {
    private String schoolName;
    private boolean publicFlag;
}

@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
static class StudentOpt {
    private String name;
    private int age;
    private Optional<School> school;
}

public static Student getDefaultStudent() {
    return null;
}

public static Student getBackStudent() {
    return Student.builder().name("小红").age(19).build();
}

public static Optional<StudentOpt> getOptionalStudent() {
    return Optional.ofNullable(StudentOpt.builder().name("小莫").age(18)
            .school(Optional.ofNullable(School.builder().schoolName("蓝鲸大学").publicFlag(true).build())).build());
}

public static void acceptStudent(Student stu, LocalDate date) {
    System.out.println("日期: " + date + " 新增一位学生: " + stu.getName());
}
复制代码

typescript复制代码while(number > 0)     
remainder = number % 62     
number = number / 62     
attach remainder to start of result collection

ini复制代码1st iteration: 
         number = 1000 
         remainder = 1000 % 62 = 8 
         number = 1000 / 62 = 16 
         result list = [8] 
2nd iteration: 
         number = 16 
         remainder = 16 % 62 = 16 
         number = 16 / 62 = 0 
         result list = [16,8] 
         There is no more iterations since number = 0 after 2nd iteration

ini复制代码i = 0     
while(i < inputString lenght) 
         counter = i + 1 
         mapped = base62alphabet.indexOf(inputString[i]) // map character to number based on its index in alphabet          
         result = result + mapped * 62^(inputString lenght - counter) 
         i++

ini复制代码inputString = g8     
inputString length = 2     
i = 0     
result = 0 
1st iteration 
        counter = 1 
        mapped = 16 // index of g in base62alphabet is 16 
        result = 0 + 16 * 62^1 = 992 
2nd iteration 
        counter = 2 
        mapped = 8 // index of 8 in base62alphabet is 8 
        result = 992 + 8 * 62^1 = 1000

ini复制代码private static final String allowedString = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"; 
private char[] allowedCharacters = allowedString.toCharArray(); 
private int base = allowedCharacters.length;

less复制代码@PostMapping("create-short") 
    public String convertToShortUrl(@RequestBody UrlLongRequest request) { 
        return urlService.convertToShortUrl(request); 
    } 
 
    @GetMapping(value = "{shortUrl}") 
    public ResponseEntity<Void> getAndRedirect(@PathVariable String shortUrl) { 
        var url = urlService.getOriginalUrl(shortUrl); 
        return ResponseEntity.status(HttpStatus.FOUND) 
        .location(URI.create(url)) 
        .build(); 
}

xml复制代码XML 
<dependency> 
  <groupId>io.springfox</groupId> 
  <artifactId>springfox-swagger2</artifactId> 
  <version>2.9.2</version> 
</dependency> 
<dependency> 
  <groupId>io.springfox</groupId> 
  <artifactId>springfox-swagger-ui</artifactId> 
  <version>2.9.2</version> 
</dependency>

less复制代码 @Configuration 
    @EnableSwagger2 
    public class SwaggerConfig { 
 
    @Bean     
    public Docket apiDocket() {    
        return new Docket(DocumentationType.SWAGGER_2)   
            .apiInfo(metadata())     
            .select()     
            .apis(RequestHandlerSelectors.basePackage("com.amarin"))     
            .build();     
    } 
               
    private ApiInfo metadata(){ 
        return new ApiInfoBuilder() 
        .title("Url shortener API")     
        .description("API reference for developers")     
        .version("1.0")     
        .build();     
        }   
}

bash复制代码FROM openjdk:13-jdk-alpine    
    COPY ./target/url-shortener-api-0.0.1-SNAPSHOT.jar /usr/src/app/url-shortener-api-0.0.1-SNAPSHOT.jar     
    EXPOSE 8080     
ENTRYPOINT ["java","-jar","/usr/src/app/url-shortener-api-0.0.1-SNAPSHOT.jar"]

xml复制代码<build>      
    <plugins>      
        <plugin>      
            <groupId>org.springframework.boot</groupId>      
            <artifactId>spring-boot-maven-plugin</artifactId>      
        </plugin>      
    </plugins>      
</build>

css复制代码$ docker run --name shortener -e MYSQL_ROOT_PASSWORD=my-secret-pw -d -p 3306:3306 mysql:8

arduino复制代码docker run -d –-name url-shortener-api -p 8080:8080 --link shortener url-shortener

java复制代码  //计算哈希次数
  @VisibleForTesting
  static int optimalNumOfHashFunctions(long n, long m) {
    // (m / n) * log(2), but avoid truncation due to division!
    return Math.max(1, (int) Math.round((double) m / n * Math.log(2)));
  }

//计算位数组长度
  @VisibleForTesting
  static long optimalNumOfBits(long n, double p) {
    if (p == 0) {
      p = Double.MIN_VALUE;
    }
    return (long) (-n * Math.log(p) / (Math.log(2) * Math.log(2)));
  }

go复制代码//表示经过多少散列函数计算
//固定14次
maps = 14

type (
	// 定义布隆过滤器结构体
	Filter struct {
		bits   uint
		bitSet bitSetProvider
	}
	//位数组操作接口定义
	bitSetProvider interface {
		check([]uint) (bool, error)
		set([]uint) error
	}
)

lua复制代码//ARGV:偏移量offset数组
//KYES[1]: setbit操作的key
//全部设置为1
setScript = `
	for _, offset in ipairs(ARGV) do
		redis.call("setbit", KEYS[1], offset, 1)
	end
	`
//ARGV:偏移量offset数组
//KYES[1]: setbit操作的key
//检查是否全部为1
testScript = `
	for _, offset in ipairs(ARGV) do
		if tonumber(redis.call("getbit", KEYS[1], offset)) == 0 then
			return false
		end
	end
	return true
	`

go复制代码//redis位数组
type redisBitSet struct {
	store *redis.Client
	key   string
	bits  uint
}
//检查偏移量offset数组是否全部为1
//是:元素可能存在
//否:元素一定不存在
func (r *redisBitSet) check(offsets []uint) (bool, error) {
	args, err := r.buildOffsetArgs(offsets)
	if err != nil {
		return false, err
	}
    //执行脚本
	resp, err := r.store.Eval(testScript, []string{r.key}, args)
    //这里需要注意一下,底层使用的go-redis
    //redis.Nil表示key不存在的情况需特殊判断
	if err == redis.Nil {
		return false, nil
	} else if err != nil {
		return false, err
	}

	exists, ok := resp.(int64)
	if !ok {
		return false, nil
	}

	return exists == 1, nil
}

//将k位点全部设置为1
func (r *redisBitSet) set(offsets []uint) error {
	args, err := r.buildOffsetArgs(offsets)
	if err != nil {
		return err
	}
	_, err = r.store.Eval(setScript, []string{r.key}, args)
	//底层使用的是go-redis,redis.Nil表示操作的key不存在
    //需要针对key不存在的情况特殊判断
    if err == redis.Nil {
		return nil
	} else if err != nil {
		return err
	}
	return nil
}

//构建偏移量offset字符串数组,因为go-redis执行lua脚本时参数定义为[]stringy
//因此需要转换一下
func (r *redisBitSet) buildOffsetArgs(offsets []uint) ([]string, error) {
	var args []string
	for _, offset := range offsets {
		if offset >= r.bits {
			return nil, ErrTooLargeOffset
		}
		args = append(args, strconv.FormatUint(uint64(offset), 10))
	}
	return args, nil
}

//删除
func (r *redisBitSet) del() error {
	_, err := r.store.Del(r.key)
	return err
}

//自动过期
func (r *redisBitSet) expire(seconds int) error {
	return r.store.Expire(r.key, seconds)
}

func newRedisBitSet(store *redis.Client, key string, bits uint) *redisBitSet {
	return &redisBitSet{
		store: store,
		key:   key,
		bits:  bits,
	}
}

lua复制代码//k次散列计算出k个offset
func (f *Filter) getLocations(data []byte) []uint {
	//创建指定容量的切片
	locations := make([]uint, maps)
	//maps表示k值,作者定义为了常量:14
	for i := uint(0); i < maps; i++ {
		//哈希计算,使用的是"MurmurHash3"算法,并每次追加一个固定的i字节进行计算
		hashValue := hash.Hash(append(data, byte(i)))
		//取下标offset
		locations[i] = uint(hashValue % uint64(f.bits))
	}
  
	return locations
}

lua复制代码//添加元素
func (f *Filter) Add(data []byte) error {
	locations := f.getLocations(data)
	return f.bitSet.set(locations)
}

//检查是否存在
func (f *Filter) Exists(data []byte) (bool, error) {
	locations := f.getLocations(data)
	isSet, err := f.bitSet.check(locations)
	if err != nil {
		return false, err
	}
	if !isSet {
		return false, nil
	}

	return true, nil
}

java复制代码// New create a Filter, store is the backed redis, key is the key for the bloom filter,
// bits is how many bits will be used, maps is how many hashes for each addition.
// best practices:
// elements - means how many actual elements
// when maps = 14, formula: 0.7*(bits/maps), bits = 20*elements, the error rate is 0.000067 < 1e-4
// for detailed error rate table, see http://pages.cs.wisc.edu/~cao/papers/summary-cache/node8.html
func New(store *redis.Redis, key string, bits uint) *Filter {
	return &Filter{
		bits:   bits,
		bitSet: newRedisBitSet(store, key, bits),
	}
}

//expectedInsertions - 预期总数量
//falseProbability - 预期误差
//这里也可以改为option模式不会破坏原有的兼容性
func NewFilter(store *redis.Redis, key string, expectedInsertions uint, falseProbability float64) *Filter {
	bits := optimalNumOfBits(expectedInsertions, falseProbability)
	k := optimalNumOfHashFunctions(bits, expectedInsertions)
	return &Filter{
		bits:   bits,
		bitSet: newRedisBitSet(store, key, bits),
		k:      k,
	}
}

//计算最优哈希次数
func optimalNumOfHashFunctions(m, n uint) uint {
	return uint(math.Round(float64(m) / float64(n) * math.Log(2)))
}

//计算最优数组长度
func optimalNumOfBits(n uint, p float64) uint {
	return uint(float64(-n) * math.Log(p) / (math.Log(2) * math.Log(2)))
}

ini复制代码unsigned int u = 1e9;
long signed int i = -1;
... i + u ...

csharp复制代码var u uint
var i int

csharp复制代码var i int = int(0)

字符串常量的类型是什么？string是错误的答案。


它是无类型字符串常量，即它没有固定的类型。没错，它是一个字符串，但它的类型不是Go里面的string。即便提供一个变量名，它仍然是无类型字符串常量：

这样声明之后，hello还是一个无类型字符串常量，一个无类型常量只有一个没有定义类型的值，所以它不受强制相同类型才可操作的限制。


正是无类型常量的概念让我们可以在Go中自由使用常量。


那么，有类型字符串常量是什么？下面是一个有类型的例子：

注意typedHello的声明，有一个显式string类型在等号前面。这意味着typedHell是string类型，它不可以被分配给其他类型。正确示例：

错误示例：

变量m是Mystring类型的，它不能被其他类型值赋值。它只能被MyString类型值赋值，像这样：

或者通过强制类型装换来解决：

回到我们的无类型字符串常量，因为它没有类型，所有把它赋值给一个有类型的变量不会引起类型错误。我们可以这样写：

或者

不像有类型常量typedHello和myStringHello，无类型常量"Hello, 世界"和hello没有类型，所有把他们赋值给任何类型兼容string的变量都不会出错。


这些无类型字符串常量当然是字符串，所以他们只能用在string允许的地方，但他们没有类型。


默认类型
----


做为一名Go程序员，你肯定见过这里的声明：

现在，你可能会问：“如果常量是无类型的，那比变量str是什么类型的？”答案是string，无类型常量会有一个默认类型，会在需要时自动将自己转换为该类型。对于无类型字符串常量，默认类型是string，所以

或者

意思都是

你可以把无类型常量当成一种在特殊空间的值，它们不会受到Go类型系统的大部分限制。但需要将它赋值给有类型的变量时，它们把自己的默认类型告诉变量。在这个例子中，str变成了一个string类型的值，因为无类型字符串常量提供它们的默认类型string用来声明。


在上面的声明中，一个变量会被声明并带着类型和初始值。有时当我们使用常量时，并没有明确的目标值，例如：

输出：

fmt.Printf的签名是

format之后的参数是接口类型（interface）。但调用fmt.Printf时，使用一个无类型常量作为参数传递时，参数的具体类型是常量的默认类型。这个过程类似于我们之前使用无类型的字符串常量声明初始化值时看到的过程。


你可以看到洗下面例子的结果，使用%v打印值，%T打印值的类型：

输出：

如果常量有类型，那么会传递到接口，像下面这样：

输出：

总结一下，一个有类型常量会遵循Go里所有的类型规则；一个无类型常量可以不用遵守，并且可以更自由地混合和匹配。无类型常量的默认类型只会在必要时且没有其他类型信息时被使用。


语法决定默认类型
--------


一个无类型常量的默认类型被它的语法所决定。对于字符串常量，默认类型只会是string。对于数字常量，默认类型有多种。整型常量默认是int，浮点型常量默认是float64，rune类型常量默认是rune(int32)，虚数类型常量默认是comlex128。例子：

输出：

Booleans
--------


无类型boolean常量和无类型字符串常量是一样的。true和false是无类型boolean常量，他们可以被赋值给任何boolean变量，一旦确定了类型，就不能和boolean变量混合操作了：

浮点类型
----


浮点常量和boolean常量有很多相同的地方：

唯一不同的地方是Go里面有两种浮点类型：float32和float64。浮点常量默认的类型是float64，但是可以把无类型浮点常量赋值给float32类型的变量：

我们来用浮点数介绍一下溢出的问题。


数字常量存储在一个任意精度的数字空间了，它们是常规的数字。但当他们被分配给一个变量时，大小必须在变量的类型所支持的范围内。我们可以给一个常量声明一个非常大的值：

虽然我们声明了Huge这个常量，但是我们不能把Huge分配给其他变量，甚至无法打印出来。下面语句甚至不会编译：

会报错："constant 1.00000e+1000 overflows float64"。但是Huge是可用的：我们可以在表达式里用它和其他常量进行运算，如果结果在存在float64的范围里，如下：

输出：

另外，浮点常量会有更高的精读，所以用他们计算更加准确。在math包中定义的常量比float64类型的变量拥有更多的精度位。下面是math.Pi的定义：

当Pi被分配给一个变量时，会有精读丢失；该变量会是float64或float32类型来尽可能接近原来的值。比如：

输出：

数字常量拥有更多的精度位，意味着在进入比如：Pi/2这样的计算中结果的精度很高，直到结果被分配给变量时精度才会丢失。并且在计算过程不会出现无穷大、溢出和NaN的问题。（如果表达式中有除以常量0的操作，在编译时会报错。


复数
--


复数常量也和浮点数常量类似。

复数常量的默认类型是complex128, 是由两个float64的值组成，有很大的精度。


声明一下，在例子中，我们写了完整的表达式(0.0+1.0i)，其实我们可以简写成0.0+1.0i、1.0i或者1i。


我们知道在Go中，数字常量只是一个数字，如果一个复数没有虚数部分，它会是什么？实数吗？

Two数一个无类型复数常量，即使它没有虚数部分，表达式的语法定义了它的默认类型是complex128。因此，如果我们用它去声明一个变量，默认类型将会是complex128。

输出：

在数值上，Two既可以被存储在float32空间里，也可以存储在float64空间里，不会发生精度丢失。我们在初始化或分配时把Two分配给float64是没问题的：

输出：

即使Two是复数常量，也可以将其分配给浮点类型变量。这种跨界操作是很有用的。


整型
--


最后我们来到了整型。他们的种类更多，不同的大小、有符号或无符号等等，他们遵循一样的规则：

上面的类型对所有的整数类型都适用，整数类型有：

（还有uint8也叫byte, int32也叫rune）。整数类型有很多，但是在整数常量的工作方式都是相似的，现在我们来具体看一看。


如上所述，整型有两种形式，每种形式都有自己的默认类型：对于像123、0xFF、-14这些简单的常量，默认类型是int；像'a'、'世'、'\r'这些单引号单字符，默认类型是rune。


没有哪种常量形式的默认类型无符号整型。但是我们可以利用无类型常量的灵活性，初始化出无符号整型变量。这就和我们可以用虚部为0的复数初始化出float64变量一样。下面有几中初始化uint的方式，每种方法都是明确指定了类型为uint：

整型也有类型浮点数那样数值范围的问题，不同整型之间的转换、分配可能会出现问题。可能会有两个问题发生：大范围的值转换为小范围的值；负数分配到无符号整型上。例如：int8的范围是-128到127，所以如果常量超出这个范围将不能被分配到一个int8类型的变量上：

同样，uint8（或者叫byte）的范围是0到255，不在这个范围中的常量也不能被分配到一个uint8变量上：

下面的代码也会被类型检查捕捉到错误：

如果编译器检查出常量的用法错误，真实太悲伤了。


练习：最大的无符号整型
-----------


这里有一个有意思的小练习。我们如何用常量表示uint中的最大值呢？如果我们是说uint32，我们可以这个样写：

但是我们要的是uint，而不是uint32。int和uint类型没有确定的bit位数，32位或者64位。因为具体的bit位数取决架构，我们不能写一个简单的值。


...省略...


最简单的uint值是有类型常量uint(0)，如果uint是32位，那么uint(32)就用32位0bit，反之uint是64位，那么uint(0)就有64位0bit。如果我们将这些bit位倒置成1，我们将会得到uint的最大值：

无论当前环境uint32的bit位是多少，这个常量都正确表示uint变量能承载的最大值。


数字
--


在Go中无类型常量的概念表示所有的数字常量，无论整型、浮点型、复数型还是字符值，都存储在一种统一的空间里。我们将它们作用在变量、复制和运算中时，类型才会有意义。只要我们在数字常量的世界里，我们就可以随意混合不同的类型进行运算，下面所有的常量的数值都是1：

因此，即使他们有不同的隐含默认类型，写做无类型的常量可以被分配任何整型变量：

输出：

你甚至可以这样写：

输出：

尽管在Go中同一个表达式中混合使用浮点数和整数变量或者int和int32变量是不合法的，但是这种灵活性让下面的写法可行，即不同类型的数字常量是可以混合的：

或者

或者

php复制代码<?php

namespace App\Render;

.
.
.

class CommonRender extends BaseRender
{
    public static function renderUserinfo($data, $hobbyInfo = [],$professionInfo = [])
    {
        $hobbyInfo = !empty($hobbyInfo) ? $hobbyInfo : HobbyInfo::getAllInfo();
        //特殊处理，因为职业用户可以自定义 数字一直增长 不全量查数据；$professionInfo为空时不是批量查询，只查单条记录
        $professionInfo = !empty($professionInfo) ? $professionInfo : (isset($data['profession']) ? ProfessionInfo::getByIds($data['profession']) : []);

        if (!is_array($data)) {
            return [];
        }

        $ret = [
            .
            .
            .
            
//优化之前
//          'hobby' => !isset($data['hobby']) ? [] : HobbyInfo::getByIds($data['hobby']),
//          'profession' => !isset($data['profession']) ? [] : ProfessionInfo::getByIds($data['profession']),


//优化之后
            'hobby' => !isset($data['hobby']) ? [] : self::_renderHobby($data['hobby'], $hobbyInfo),
            'profession' => !isset($data['profession']) ? [] : self::_renderProfession($data['profession'], $professionInfo),

            .
            .
            .

        return $ret;
    }
}

php复制代码protected static function _renderProfession($userProfession, $professionInfo)
{
    $ret = [];
    if ($userProfession) {
        $userProfessionIds = explode(',', $userProfession);
        foreach ($userProfessionIds as $key => $userProfessionId) {
            if (isset($professionInfo[$userProfessionId])) {
                $ret[$key] = $professionInfo[$userProfessionId];
            }
        }
    }
    return $ret;
}

php复制代码public static function getBatchUserIntro($userid, $userList)
{
    $retData = [];
    if (empty($userList)) {
        return $retData;
    }
    
    .
    .
    .
    
    $hobbyInfo = HobbyInfo::getAllInfo();
    
    //按需批量查职业，不全量查询职业
    $professionIds = array_column($batchUserInfo, 'profession');
    $professionIds = implode(',', $professionIds);
    $professionIds = array_unique(explode(',', $professionIds));
    $professionInfo = ProfessionInfo::batchGetByIds($professionIds);

    foreach ($batchUserInfo as $item) {
        $retData[$item['userid']] = CommonRender::renderUserinfo($item, $hobbyInfo, $professionInfo, $expectInfo);
    }
    
    return $retData;
}

php复制代码public static function batchGetByIds($ids = [])
{
    //兼容职业为空的情况
    foreach ($ids as $key => $id) {
        if (empty($id)) {
            unset($ids[$key]);
        }
    }

    if (empty($ids)) {
        return [];
    }

    return self::query()->selectRaw('id,name,pid')
        ->whereIn('id', $ids)
        ->get()
        ->keyBy('id')
        ->toArray();
}

java复制代码/**
 * @className: FormNoConstant
 * @description: 单号生成常量
 * @author: hanHang
 * @create: 2021/9/28 9:41
 **/
public class FormNoConstant {
    /**
     * 单号流水号缓存Key前缀
     */
    public static final String SERIAL_CACHE_PREFIX = "my-test:no:";
    /**
     * 单号流水号yyyyMMdd前缀
     */
    public static final String SERIAL_YYYY_MM_DD_PREFIX = "yyyyMMdd";
}

java复制代码/**
 * @className: FormNoTypeEnum
 * @description: 编号生成类型枚举
 * @author: hanHang
 * @create: 2021/9/28 9:40
 **/
@Getter
public enum FormNoTypeEnum {
    /**
     * 特别单据单号：
     */
    SPECIAL_ORDER("S", FormNoConstants.SERIAL_YYYY_MM_DD_PREFIX, 3 , 12),

    /**
     * 正常单据单号：
     */
    NORMAL_ORDER("N", FormNoConstants.SERIAL_YYYY_MM_DD_PREFIX, 3 , 12);

    /**
     * 单号前缀 为空时填""
     */
    private final String prefix;

    /**
     * 时间格式表达式
     * 例如：yyyyMMdd
     */
    private final String datePattern;

    /**
     * 流水号长度
     */
    private final Integer serialLength;

    /**
     * 总长度
     */
    private final Integer totalLength;


    FormNoTypeEnum(String prefix, String datePattern, Integer serialLength, Integer totalLength) {
        this.prefix = prefix;
        this.datePattern = datePattern;
        this.serialLength = serialLength;
        this.totalLength = totalLength;
    }
}

java复制代码/**
 * @className: FormNoSerialUtil
 * @description: 单据编号工具类
 * @author: hanHang
 * @create: 2021/9/28 9:45
 **/
public class FormNoSerialUtil {
    /**
     * 根据单据类型获取单号前缀
	 * @param formNoTypeEnum
	 * @return 单号前缀
     */
    public static String getFormNoPrefix(FormNoTypeEnum formNoTypeEnum) {
        //格式化时间
        DateTimeFormatter formatter = DateTimeFormatter.ofPattern(formNoTypeEnum.getDatePattern());
        return formNoTypeEnum.getPrefix() +
                formatter.format(LocalDateTime.now());
    }

    /**
     * 获取流水号缓存Key
     * @param serialPrefix 流水号前缀
     * @return 流水号缓存Key
     */
    public static String getCacheKey(String serialPrefix) {
        return FormNoConstants.SERIAL_CACHE_PREFIX.concat(serialPrefix);
    }

    /**
     * 补全流水号
     *
     * @param serialPrefix      单号前缀
     * @param incrementalSerial 当天自增流水号
	 * @param formNoTypeEnum    单据类型枚举
	 * @return 完整流水号
     */
    public static String completionSerial(String serialPrefix, Long incrementalSerial,
                                          FormNoTypeEnum formNoTypeEnum) {
        StringBuffer sb = new StringBuffer(serialPrefix);

        //需要补0的长度=流水号长度 -当日自增计数长度
        int length = formNoTypeEnum.getSerialLength() - String.valueOf(incrementalSerial).length();
        //补零
        for (int i = 0; i < length; i++) {
            sb.append("0");
        }
        //redis当日自增数
        sb.append(incrementalSerial);
        return sb.toString();
    }
}