GS1 医疗行业应用

什么是 UDI

唯一器械标识（Unique Device Identification，缩写UDI）是对医疗器械在其整个生命周期赋予的身份标识，是其在产品供应链中的唯一“身份证”。全球采用统一的、标准的UDI有利于提高供应链透明度和运作效率；有利于降低运营成本；有利于实现信息共享与交换；有利于不良事件的监控和问题产品召回，提高医疗服务质量，保障患者安全。

展开全文 >>

Spring Cloud Zuul 初识

Spring Boot: 1.5.10.RELEASE

Spring Cloud: Dalston.SR5

什么是 Zuul

Zuul 最主要的两大功能：请求路由和请求过滤

请求路由

请求路由是指将外部请求转发到具体的微服务实例上，实现外部访问统一入口的基础

请求过滤

请求过滤是指对外部请求进行干预，实现请求校验，服务聚合等功能的基础

Zuul 一般和 Eureka 集成使用

Zuul 初识

利用前期的相关工程实现环境搭建：

example-01 : eureka-server

example-01 : 服务提供者1

example-04 : 服务提供者2

example-05 : 服务提供者3

创建 zuul 工程，引入依赖：

1
2
3
4
5
6
7
8
<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-eureka</artifactId>
</dependency>
<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-zuul</artifactId>
</dependency>

spring-cloud-starter-zuul 是必须引入的依赖

spring-cloud-starter-eureka 是为了使 zuul 可以 eureka 进行无缝集成

启动类上添加 @EnableZuulProxy 注解：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.zuul.EnableZuulProxy;

@EnableZuulProxy
@SpringBootApplication
public class Application {
	
	public static void main(String[] args) {
		SpringApplication application = new SpringApplication(Application.class);
		application.run(args);
	}
	
}

配置文件集成 eureka 并配置路由规则：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
spring:
  application:
    name: zuul-server

server:
  port: 8888

eureka:
  instance:
    prefer-ip-address: false
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka

zuul:
  routes:
    api-a.path: /api-a/**
    api-a.serviceId: hello-world-service
    api-b.path: /api-b/*
    api-b.serviceId: hello-world-service-provide

路由配置规则： 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
格式：zuul.routes.<routh>.path 
格式：zuul.routes.<routh>.serviceId
``` 

这里定义了两个简单的转发规则：
拦截所有 api-a 开头的请求，将其转发到 hello-world-service 服务中
拦截所有 api-b 开头的请求，将其转发到 hello-world-service-provide 服务中

将服务运行以后，可以测试：<br>
http://localhost:8888/api-a/hello <br>
http://localhost:8888/api-b/hello <br>


上述路由配置可以简化为：

zuul:
routes:
hello-world-service: /api-a/
hello-world-service-provide: /api-b/

格式：zuul.routes.=
`

详细代码请参考 lxmuse-spring-cloud 下 example-zuul-01

展开全文 >>

Lambda表达式语法

Java 8 引入新操作符：->

  • 操作符左侧： Lambda 表达式的参数列表
  • 操作符右侧： Lambda 表达式所需执行的功能，即 Lambda 体

函数接口

函数接口是只有一个抽象方法的接口，Lambda 表达式使用函数接口。
多抽象方法的接口，并不能使用 Lambda 表达式。

Java 8 java.util.function 包下定义了一些函数接口：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
public interface Predicate<T> {
    boolean test(T t);
}

public interface Consumer<T> {
    void accept(T t);
}

public interface Function<T, R> {
    R apply(T t);
}

public interface Supplier<T> {
    T get();
}

而且很多原接口都继承了这些函数接口

函数接口可以使用 @FunctionalInterface 注解修饰
使用 @FunctionalInterface 修饰的接口必须是函数接口

Lambda 表达式语法格式

无参 无返回值

Lambda 表达式不包含参数，使用空括号 () 表示没有参数：

1
Runnable runnable = () -> System.out.println("Hello Lambda!");

一个参数 有返回值

1
2
Consumer<String> consumer = (x) -> System.out.println(x);
consumer.accept("Lambda 表达式");

Lambda 表达式包含且只包含一个参数，可以省略参数的括号

1
2
Consumer<String> consumer = x -> System.out.println(x);
consumer.accept("Lambda 表达式");

表达式是代码块

1
2
3
4
Runnable runnable = () -> {
	System.out.println("Hello Lambda!");
	System.out.println("Hello Lambda!");
};

如果 Lambda 表达式是一段代码块，则必须使用大括号包裹代码块

多参数，有返回值

1
2
3
4
Comparator<Integer> comparator = (x, y) -> {
	System.out.println("Hello Lambda!");
	return Integer.compare(x, y);
};

如果表达式只有一条语句，大括号和 return 可以省略

1
Comparator<Integer> comparator = (x, y) -> Integer.compare(x, y);

显式声明参数类型

1
Comparator<Integer> comparator = (Integer x, Integer y) -> Integer.compare(x, y);

引用值

在 Java 7 时，匿名内部类需要使用外部变量，外部变量需要 final 修饰。
在 Java 8 时，虽然无须显式声明为 final, 但默认还是 fianl 的。
同理 Lambda 表达式引用的也是事实上 final 修饰的变量

类型推断

Java 7 就引入了目录类型推断：

1
List<String> strList =  new ArrayList<>(8);

Java 8 中对类型推断进一步升级：编译器可以根据上下文进行推断

若推断不出，编辑期会报错。

代码可参考lxmuse-jdk8-new-feature-lambda-02

展开全文 >>

GS1 数据载体体系

数据载体承载编码信息，用于自动数据采集（Auto Data Capture，ADC）与电子数据交换（EDI&XML）。

条码符号

条码技术是20世纪中叶发展并广泛应用的集光、机、电和计算机技术为一体的高新技术。它解决了计算机应用中数据采集的“瓶颈”，实现了信息的快速、准确获取与传输，是信息管理系统和管理自动化的基础。条码符号具有操作简单、信息采集速度快、信息采集量大、可靠性高、成本低廉等特点。以商品条码为核心的GS1系统已经成为事实上的服务于全球供应链管理的国际标准。

EAN/UPC 条码

EAN（International）：国际物品编码协会

EAN/UPC条码包括EAN-13、EAN-8、UPC-A和UPC-E。通过零售渠道销售的贸易项目必须使用EAN/UPC条码进行标识。同时这些条码符号也可用于标识非零售的贸易项目。

EAN 条码

EAN条码是长度固定的连续型条码，其字符集是数字0~9。EAN条码有两种类型，即EAN-13条码和EAN-8条码。

UPC 条码

UPC条码是一种长度固定的连续型条码，其字符集为数字0~9。UPC码起源于美国，有UPC-A条码和UPC-E条码两种类型。

ITF-14 条码

ITF-14条码只用于标识非零售的商品。ITF-14条码对印刷精度要求不高，比较适合直接印制（热转印或喷墨）在表面不够光滑、受力后尺寸易变形的包装材料上。因为这种条码符号较适合直接印在瓦楞纸包装箱上，所以也称“箱码”。

提示：关于ITF-14条码的说明，请查阅GB/T 16830-2008 《商品条码 储运包装商品编码与条码表示》国家标准。

UCC/EAN-128 条码

UCC/EAN-128条码由起始符号、数据字符、校验符、终止符、左、右侧空白区及供人识读的字符组成，用以表示GS1系统应用标识符字符串。UCC/EAN-128条码可表示变长的数据，条码符号的长度依字符的数量、类型和放大系统的不同而变化，并且能将若干信息编码在一个条码符号中。该条码符号可编码的最大数据字数为48个，包括空白区在内的物理长度不能超过165㎜。UCC/EAN-128条码不用于POS零售结算，用于标识物流单元。

应用标识符（AI）是一个2-4位的代码，用于定义其后续数据的含义和格式。使用AI可以将不同内容的数据表示在一个UCC/EAN-128条码中。不同的数据间不需要分隔，既节省了空间，又为数据的自动采集创造了条件。图3-8 UCC/EAN-128条码符号示例中的（02）、（17）、（37）和（10）即为应用标识符。

提示：关于UCC/EAN-128条码的说明，请查阅GB/T 15425 《EAN•UCC系统 128条码》及GB/T 16986-2009 《商品条码 应用标识符》等国家标准。

射频标签

无线射频识别技术（RFID）是20世纪中叶进入实用阶段的一种非接触式自动识别技术。射频识别系统包括射频标签和读写器两部分。射频标签是承载识别信息的载体，读写器是获取信息的装置。射频识别的标签与读写器之间利用感应、无线电波或微波，进行双向通信，实现标签存储信息的识别和数据交换。

射频识别技术的特点：

  • 可非接触识读（识读距离可以从十厘米至几十米）；

  • 可识别快速运动物体；

  • 抗恶劣环境，防水、防磁、耐高温，使用寿命长；

  • 保密性强；

  • 可同时识别多个识别对象等。

射频识别技术应用领域广阔。多用于移动车辆的自动收费、资产跟踪、物流、动物跟踪、生产过程控制等。由于射频标签较条码标签成本偏高，目前很少像条码那样用于消费品标识，多用于人员、车辆、物流等管理，如证件、停车场、可回收托盘、包装箱的标识。

EPC标签是射频识别技术中应用于GS1系统EPC编码的电子标签，是按照GS1系统的EPC规则进行编码，并遵循EPCglobal制定的EPC标签与读写器的无接触空中通信规则设计的标签。EPC标签是产品电子代码的载体，当EPC标签贴在物品上或内嵌在物品中时，该物品与EPC标签中的编号则是一一对应的。

展开全文 >>

GS1 编码体系

编码体系是整个GS1系统的核心，是对流通领域中所有的产品与服务（包括贸易项目、物流单元、资产、位置和服务关系等）的标识代码及附加属性代码，附加属性代码不能脱离标识代码独立存在。

全球贸易项目代码（GTIN）

全球贸易项目代码（Global Trade Item Number,GTIN）是编码系统中应用最广泛的标识代码。贸易项目是指一项产品或服务。GTIN是为全球贸易项目提供唯一标识的一种代码（称代码结构）。GTIN有四种不同的编码结构：GTIN-13、GTIN-14、GTIN-8和GTIN-12。这四种结构可以对不同包装形态的商品进行唯一编码。标识代码无论应用在哪个领域的贸易项目上，每一个标识代码必须以整体方式使用。完整的标识代码可以保证在相关的应用领域内全球唯一。

对贸易项目进行编码和符号表示，能够实现商品零售（POS）、进货、存补货、销售分析及其他业务运作的自动化。

GTIN的四种代码结构：

系列货运包装箱代码（SSCC）

系列货运包装箱代码（Serial Shipping Container Code,SSCC）是为物流单元（运输和/或储藏）提供唯一标识的代码，具有全球唯一性。物流单元标识代码由扩展位、厂商识别代码、系列号和校验码四部分组成，是18位的数字代码。它采用UCC/EAN-128条码符号表示。

参与方位置代码（GLN）

参与方位置代码（Global Location Number，GLN）是对参与供应链等活动的法律实体、功能实体和物理实体进行唯一标识的代码。参与方位置代码由厂商识别代码、位置参考代码和校验码组成，用13位数字表示。

法律实体是指合法存在的机构，如：供应商、客户、银行、承运商等。

功能实体是指法律实体内的具体的部门，如：某公司的财务部。

物理实体是指具体的位置，如：建筑物的某个房间、仓库或仓库的某个门、交货地等。

GTIN 的编码规则

企业在对商品进行编码时，必须遵守编码唯一性、稳定性及无含义性原则。

唯一性

唯一性原则是商品编码的基本原则。是指相同的商品应分配相同的商品代码，基本特征相同的商品视为相同的商品；

不同的商品必须分配不同的商品代码。基本特征不同的商品视为不同的商品。

稳定性

稳定性原则是指商品标识代码一旦分配，只要商品的基本特征没有发生变化，就应保持不变。同一商品无论是长期连续生产、还是间断式生产，都必须采用相同的商品代码。即使该商品停止生产，其代码也应至少在4年之内不能用于其他商品上。

无含义性

无含义性原则是指商品代码中的每一位数字不表示任何与商品有关的特定信息。有含义的代码通常会导致编码容量的损失。厂商在编制商品代码时，最好使用无含义的流水号。

对于一些商品，在流通过程中可能需要了解它的附加信息，如生产日期、有效期、批号及数量等，此时可采用应用标识符（AI）来满足附加信息的标注要求。应用标识符由2～4位数字组成，用于标识其后数据的含义和格式。

展开全文 >>

Lambda表达式引子

有一个员工类：

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
public class Employee {
	
	private String name;
	private int age;
	private double salary;
	
	public Employee(String name, int age, double salary) {
		this.name = name;
		this.age = age;
		this.salary = salary;
	}
	
	public String getName() {
		return name;
	}
	
	public int getAge() {
		return age;
	}
	
	public double getSalary() {
		return salary;
	}
	
	@Override
	public String toString() {
		return "Employee{" +
			"name='" + name + '\'' +
			", age=" + age +
			", salary=" + salary +
			'}';
	}
}

准备初始数据：

1
2
3
4
5
6
7
List<Employee> employeeList = Arrays.asList(
	new Employee("张三", 18, 7777),
	new Employee("李四", 38, 22222),
	new Employee("王五", 50, 33333),
	new Employee("赵六", 24, 8888),
	new Employee("钱大", 28, 9999)
);

初始需求：获取年龄大于 35 的员工

1
2
3
4
5
6
7
8
9
10
11
publi List<Employee> filterEmployeeAgeOver35(List<Employee> employeeList) {
	List<Employee> employees = new ArrayList<>(8);
	if (employeeList != null && !employeeList.isEmpty()) {
		for(Employee employee : employeeList) {
			if (employee.getAge() >= 35) {
				employees.add(employee);
			}
		}
	}
	return employees;
}

当然了， 35 应该用常量代替

需求变更：获取年龄大于 20 的员工

1
2
3
4
5
6
7
8
9
10
11
publi List<Employee> filterEmployeeAgeOver20(List<Employee> employeeList) {
	List<Employee> employees = new ArrayList<>(8);
	if (employeeList != null && !employeeList.isEmpty()) {
		for(Employee employee : employeeList) {
			if (employee.getAge() >= 20) {
				employees.add(employee);
			}
		}
	}
	return employees;
}

对方法进行重构：

1
2
3
4
5
6
7
8
9
10
11
publi List<Employee> filterEmployeeByAge(List<Employee> employeeList, int overAge) {
	List<Employee> employees = new ArrayList<>(8);
	if (employeeList != null && !employeeList.isEmpty()) {
		for(Employee employee : employeeList) {
			if (employee.getAge() >= overAge) {
				employees.add(employee);
			}
		}
	}
	return employees;
}

此时需求再次发生变更：获取工资大于 10000 的员工

1
2
3
4
5
6
7
8
9
10
11
publi List<Employee> filterEmployeeBySalary(List<Employee> employeeList, double overSalary) {
	List<Employee> employees = new ArrayList<>(8);
	if (employeeList != null && !employeeList.isEmpty()) {
		for(Employee employee : employeeList) {
			if (employee.getSalary() >= overSalary) {
				employees.add(employee);
			}
		}
	}
	return employees;
}

此时发现两个方法非常相似，且如果需求变的更加灵活复杂，如：
获取员工工资大于8000小于2000的员工；获取员工年龄小于35但工资大于10000的员工等等

为了继续优化，此时需要引入策略设计模式：

定义比较策略方法：

1
2
3
4
5
public interface MyEmployeeFilter<T> {
	
	boolean test(T t);
	
}

通过策略方法实现比较：

1
2
3
4
5
6
7
8
9
10
11
public List<Employee> filterEmployee(List<Employee> employeeList, MyEmployeeFilter<Employee> employeeFilter) {
	List<Employee> employees = new ArrayList<>(8);
	if (employeeList != null && !employeeList.isEmpty()) {
		for(Employee employee : employeeList) {
			if (employeeFilter.test(employee)) {
				employees.add(employee);
			}
		}
	}
	return employees;
}

那么不管是什么比较的需求，只需要实现 MyEmployeeFilter 接口即可， 不能的需求，实现不同的比较。

比如：

1
2
3
4
5
6
7
8
public class FileterEmployeeByAgeOver35 implements MyEmployeeFilter<Employee> {
	
	@Override
	public boolean test(Employee employee) {
		return employee.getAge() >= 35;
	}
	
}

如果不想每次都创建一个新的实现类，可以使用匿名内部类的方式：

1
2
3
4
5
6
List<Employee> employeeList = filterEmployee(employees, new MyEmployeeFilter<Employee>() {
	@Override
	public boolean test(Employee employee) {
		return employee.getAge() >= 35;
	}
});

使用 Lambda 表达式：

1
List<Employee> employees = filterEmployee(employeeList, (e) -> (e).getAge() >= 35);

Lambda 表达式相对于匿名内部类，代码更加简洁，更加可读

代码可参考lxmuse-jdk8-new-feature-lambda-01

展开全文 >>

MySQL You can't specify target table 'x' for update in FROM clause

今天执行如下SQL时：

1
2
3
4

UPDATE materials_barcode_info SET del_flag = 1 WHERE barcode_id IN (
     SELECT barcode_id FROM materials_barcode_info WHERE barcode_length != LENGTH(barcode_example)
)

提示

1
[Err] 1093 - You can't specify target table 'materials_barcode_info' for update in FROM clause

本意是想将条码规则表中条码规则中样例实际长度和条码规则中长度不一致的条码规则进行逻辑删除

单独执行 SELECT barcode_id from materials_barcode_info where barcode_length != LENGTH(barcode_example) 运行正确

单独执行 update materials_barcode_info set del_flag = 1 where barcode_id in ('x','x') 运行正确

MySQL 对子查询的使用存在限制：

https://dev.mysql.com/doc/refman/5.7/en/subquery-restrictions.html

即不能在一个SQL中先查询同一张表中的某些记录然后再更新同一张表中的某些记录

修改一下SQL，再嵌套一层

1
2
3
4
5
UPDATE materials_barcode_info SET del_flag = 1 WHERE barcode_id IN (
     SELECT barcode_id FROM (
         SELECT barcode_id FROM materials_barcode_info WHERE barcode_length != LENGTH(barcode_example)
     ) a
)

展开全文 >>

MySQL 末尾空格的查询问题

MySQL 中如果字段类型是 char 或 varchar 类型，在字符串比较时 MySQL 使用 PADSPACE 校对规则，会忽略字段末尾的空格字符

比如有这样一个 SQL 语句 ：

1
select * from table where user = 'wxp    '；

但是可以查询到数据库中 user 为 wxp 的那一行

那么若想做到精确匹配，可以有如下解决方法：

第一种方法：使用 like 

1
select * from table where user like 'wxp     '；

第二种方法：使用 BINARY 

1
select * from table where user = BINARY'wxp    ';

第三种方法：添加 len 函数

1
slect * form table where user = 'wxp   ' and LENGTH(user) = LENGTH('wxp    ')

官方手册说明（5.0版本）：
http://dev.mysql.com/doc/refman/5.0/en/char.html

1
2
11.1.6.1. The CHAR and VARCHAR Types
 All MySQL collations are of type PADSPACE. This means that all CHAR, VARCHAR, and TEXT values in MySQL are compared without regard to any trailing spaces. “Comparison” in this context does not include the LIKE pattern-matching operator, for which trailing spaces are significant.

展开全文 >>

SpringBoot 启动源码解析系列六：执行启动方法 

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
public ConfigurableApplicationContext run(String... args) {
    StopWatch stopWatch = new StopWatch();
    stopWatch.start();
    ConfigurableApplicationContext context = null;
    FailureAnalyzers analyzers = null;
    this.configureHeadlessProperty();
    SpringApplicationRunListeners listeners = this.getRunListeners(args);
    listeners.starting();

    try {
        ApplicationArguments applicationArguments = new DefaultApplicationArguments(args);
        ConfigurableEnvironment environment = this.prepareEnvironment(listeners, applicationArguments);
        Banner printedBanner = this.printBanner(environment);
        context = this.createApplicationContext();
        new FailureAnalyzers(context);
        this.prepareContext(context, environment, listeners, applicationArguments, printedBanner);
        this.refreshContext(context);
        this.afterRefresh(context, applicationArguments);
        listeners.finished(context, (Throwable)null);
        stopWatch.stop();
        if (this.logStartupInfo) {
            (new StartupInfoLogger(this.mainApplicationClass)).logStarted(this.getApplicationLog(), stopWatch);
        }

        return context;
    } catch (Throwable var9) {
        this.handleRunFailure(context, listeners, (FailureAnalyzers)analyzers, var9);
        throw new IllegalStateException(var9);
    }
}

核心步骤一：

1
2
SpringApplicationRunListeners listeners = this.getRunListeners(args);
listeners.starting();

核心步骤二：

1
ConfigurableEnvironment environment = this.prepareEnvironment(listeners, applicationArguments);

核心步骤三：

1
context = this.createApplicationContext();

核心步骤四：

1
this.prepareContext(context, environment, listeners, applicationArguments, printedBanner);

核心步骤五：

1
this.refreshContext(context);

核心步骤六：

1
this.afterRefresh(context, applicationArguments);

核心步骤七：

1
listeners.finished(context, (Throwable)null);

展开全文 >>

tag:

    缺失模块。
    1、请确保node版本大于6.2
    2、在博客根目录（注意不是yilia根目录）执行以下命令：
    npm i hexo-generator-json-content --save

    3、在根目录_config.yml里添加配置： 

      jsonContent:
    meta: false
    pages: false
    posts:
      title: true
      date: true
      path: true
      text: false
      raw: false
      content: false
      slug: false
      updated: false
      comments: false
      link: false
      permalink: false
      excerpt: false
      categories: false
      tags: true

很惭愧<br><br>只做了一点微小的工作<br>谢谢大家